c++ should I use const to method of parameter value type?

Question

I have for example this:

void SetWidth(double width);

Should it be:

void SetWidth(const double width);

Since *double* is a value type (i.e. call-by-copy), as far as your *caller* is concerned there is no difference. Either way is fine. — jelford, Sep 02 '13 at 16:07
It's up to you. It's just for your own checking. No difference to the code's final behavior. — Neil Kirk, Sep 02 '13 at 16:12

score 4 · Answer 1 · answered Sep 02 '13 at 16:08

No, you shouldn't.

The compiler treats the two function signatures as identical, so about all you can accomplish by adding const in a case like this is mislead the reader. For one obvious example, a reader who doesn't know C++ quite so well might believe that having both:

void SetWidth(double) {}
void SetWdith(const double) {}

...would be legitimate function overloading. This, of course, is wrong -- as already noted, the compiler treats the two as identical, so this would simply violate the one definition rule.

The const does prevent you from modifying the parameter inside the function, but if your function is large enough that you think you need this (i.e., you're having difficulty keeping track of what's being modified and what isn't), then chances are pretty good that you need to rewrite the function.

score 3 · Answer 2 · answered Sep 02 '13 at 16:08

From the caller's viewpoint, both are equivalent. You can (and, to reduce noise, should) leave that const out of a declaration, and only include it in the definition.

From the implementor's viewpoint, you might want to do it for the same reason you might want any local variable to be constant: to be sure that it won't change by accident.

LihO · Answer 3 · 2013-09-02T16:16:10.037

1

Short answer: implement a function that takes a const argument by value when it makes sense to ensure (or explicitly express) that: "This argument will not change inside the body of this function."

and implement a function that will take const argument by reference, when you want to explicitly tell the caller: "This function will not change the argument you're passing to it."

(In case of the "setter" taking an argument by value - such as SetWidth - it doesn't make much of a sense to use const)

edited Sep 02 '13 at 16:16

answered Sep 02 '13 at 16:06

LihO

41,190
11
99
167

It makes perfect sense. You're setting the width of _something else_, and this is the width you're setting it to. It's an input parameter, not a reference or pointer parameter. – Barmar Sep 02 '13 at 16:10
@Barmar: I've edited my answer regarding the difference between passing by value and passing by reference. But still, I don't agree that using `const` for an argument of a "setter" that takes it by value makes sense. – LihO Sep 02 '13 at 16:17
Why would a setter need to modify the input? If all it's going to do is something like `myWidth = width`, it makes perfect sense for `width` to be `const`. – Barmar Sep 02 '13 at 16:19
@Barmar: Not using of `const` keyword doesn't necessarily mean that the value will change. `const` seems to be rather obsolete here. – LihO Sep 02 '13 at 16:20
Read my answer: `const` allows the compiler to let you know if you mistakenly assign to a variable that you shouldn't. For instance, if you get the assignment backwards `width = myWidth`, you'll get an error. It's a safety check. – Barmar Sep 02 '13 at 16:22

score 1 · Answer 4 · answered Sep 02 '13 at 16:06

1

They are almost equivalent.

The only difference is that you tell to the compiler that the variable width cannot be modified inside the function scope when you use const.

answered Sep 02 '13 at 16:06

Pierre Fourgeaud

14,290
1
38
62

score 1 · Accepted Answer · answered Sep 02 '13 at 16:20

For, Void SetWidth(double width);

We can change the value of the variable width with in the function SetWidth(). But, the changed value will not reflect back to the called function. Say,

 class A_Class
 {
   public:
   void SetWidth(double width) {  
      width=width+10; 
      this._width=width; 
      std::cout<<"IN SetWidth:"<<width; 
   }
   private:
   double _width;
 };

 int main()
 {
    A_Class aObj;
    double twidth=20.9;
    aObj.SetWidth(twidth);
    std::cout<<"twidth:"<<twidth;
    return 0;
 } 

 O/P: IN SetWidth:30.9
      twidth:20.9

So, it doesn't matter if make it as const, which you have mentioned in the other proto-type [void SetWidth(const double width);].

Internally compiler allocates memory for 'width' variable in the stack and copies the value to that variable. If you use the second proto-type[void SetWidth(const double width);] it ensures that variable width is constant can not be changed inside the function.

Hope this helps.

score 0 · Answer 6 · answered Sep 02 '13 at 16:09

If the function is not expected to modify the local variable width, you should declare it const. This way, if you inadvertently try to assign to the variable, or assign its address to a non-const pointer (since that could allow it to be modified), the compiler will issue a warning.

There's no difference in the generated code in either case, it just enables these additional safety checks.

c++ should I use const to method of parameter value type?

6 Answers6