1

I do not understand what is going on. I am just learning C++ and I see something like this a lot:

double some_function(const Struct_Name& s) { ... }

Why the const if we are passing by reference?

Improve this question
2
  • 2
    What book are you learning C++ from that doesn't exhaustively cover const-correctness? Commented Dec 31, 2011 at 0:01
  • 1
    const-correctness is heavy and confusing in C++, but you really have to learn and understand this stuff. Doing it wrong means your code won't compile and you'll have trouble understanding why. Commented Dec 31, 2011 at 0:04

7 Answers 7

Reset to default
5

You pass by const reference when you don't want to(or can't) modify the argument being passed in, and you don't want the performance hit that you might get from copying the object.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

@ildjarn : you pass the argument by copy in your case
@eharvest : My point was that taking by non-const reference doesn't allow one to pass a temporary while taking by const reference does. (After the all, the OP is specifically wondering what benefit const offers when one is already passing by reference -- allowing temporaries is one of those benefits.)
4

A const reference prevents the object from being modified, as const would anywhere else, but also avoids the potential cost of copying.

Improve this answer

3 Comments

but making a reference non-changable is silly - it's just an address. what you are saying is that when this particular bit of memory is accessed and read that no writes are allowed to this particular section of memory while within the scope of this function?
Something along those lines. Passing by reference is similar in speed to passing a pointer, but the syntax for passing a const reference is the same as any other argument (among other things). As far as writing, the same coercion can be applied as to a copied const object, but without subverting the system, only const methods may be called and you can't write to the object. The purpose is to pass large objects without performing a copy (which could be many deep copies in the case of collections), but use regular syntax and enforce standard const-ness.
@lollercoaster: It's not the reference that the const is applied to, it's the referent. References cannot be reassigned anyway, so there would be no sense to making them const. If you could, it would look like this: (Struct_Name & const s) not like this: (const Struct_Name& s)
3

You are telling the compiler you're not going to change s, ever.

This enables it to make some optimizations it wouldn't have been able to do otherwise. Basically, it gives you the same semantics as passing by value, but doesn't incur the performance penalty of calling the copy constructor.

Improve this answer

1 Comment

The semantics of passing by value and passing by const-reference are not the same -- in a multithreaded environment the latter offers no guarantees regarding object lifetime while the former does.
3

Call by const-reference avoids a copy of the Struct_Name while promising not to modify it.

There is both a performance reason for this, and a semantics reason.

If Struct_Name is large, copying it is expensive in both time and memory.

If Struct_Name is uncopyable (or becomes invalid when copied) calling by value is impossible or introduces undesirable complexity. For example: std::unique_ptr and std::auto_ptr.

Improve this answer

Comments

2

By using const we can signal both the user of the function and the compiler that the object passed as the argument s will not be changed inside the function (which would actually be possible, because we pass it by reference!). The compiler can than give us an error if we modify the object by accident and it can do some optimizations it couldn't do otherwise.

An additional advantage is, that if the caller of the function only owns a const pointer to an object, it can still provide that object as an argument without casting.

Improve this answer

Comments

1

const here promisses that some_function will not modify s parameter, 

double some_function(const Struct_Name& s) { ... }

you can try modifying it but compiler will return errors. Actually constness requires you to carefully write Struct_Name internal methods, ie. you will not be able to call inside some_function non-const functions on s object. You can try, but you will get error. ie:

struct Struct_Name { void myfun() const { } // can be called from some_function void myfun2() { } // will show error if called from some_function };

Using const parameter is good from design point of view, if you know some function is not supposed to change your object then you add const. This means that no other programmer can do changes in some deeply hidden in classes hierarchy code, that will modify your object. It really makes debugging easy.

Improve this answer

Comments

1

Another reason that noone has mentioned yet - passing by a const reference allows the compiler to create and pass a temporary object, without generating a warning, if the input value is not the exact type declared in the parameter, but the type has a constructor that supports the type being passed in.

For example:

void foo(const std::string &s) { ... } foo("hello"); // OK

foo() is expecting a std::string but receives a const char* instead. Since std::string has a constructor that accept a const char*, the compiler generates code that is effectively doing this:

std::string temp("hello"); foo(temp);

The compiler knows the parameter is const, the temporary will not be altered by foo(), and the temporary will be discarded after foo() exits, so it does not complain about having to create a temporary.

The same thing happens if the parameter is passed by value (const or non-const, it does not matter) instead of by reference:

void foo(const std::string s) { ... } void bar(std::string s) { ... } foo("hello"); // OK bar("world"); // OK

This is effectively the same as this:

{ std::string temp1("hello"); foo(temp1); } { std::string temp2("world"); bar(temp2); }

Again, the compiler does not complain, as it knows the temporary does not affect the calling code, and any alterations made to the temporary in bar() will be safely discarded.

If the parameter were a non-const reference instead, passing a const char* would generate a warning about the temporary that has to be created to satisfy the reference binding. The warning is to let you know that any changes the function makes to the temporary (since it is not const) will be lost when the function exits, which may or may not have an effect on the calling code. This is usually an indication that a temporary should not be used in that situation:

void foo(std::string &s) { ... } foo("hello"); // warning!
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.