Why should I use const T& instead of const T or T&

Question

I always use const T& to pass a class to a function. Like this:

void foo(const MyType& p)
{
  //...
}

But now I'm confused, why not pass a const T or a T& to a function?

By the way, for built-in types, like int, long long, double, why const T is better than const T& (I remember I've read in Effective C++)

Thanks for answering my questions.

Answer 1

You could pass any of the three (const T, T&, or const T&). They all have different meanings. Up to you whether you want to pass a copy of the object that cannot be modified, a non-const reference to the object, or a const reference to the object. What you choose depends on the semantics of your code. Overall, you would want to choose const T& over const T in order to refrain from having to copy the value over from the caller to this function (save time and memory). Moreover (according to this helpful link), you would want to use const T& over T& whenever you want to refrain from changing neither the value nor the state of the passed reference. This can prevent silly and overlooked coding errors, such as changing a field for testing purposes.

For your question about passing as a parameter a reference to a const primitive type, see this: C++ and QT4.5 - is passing a const int& overkill? Does pass by reference helps in signals/slots?

Answer 2

const T is passed by value (copy is needed), which may be too much for a class while should be ok for built-in types.

T& is passed by reference, which could be modified in the function while const T& can't, so it depends on what you need to do.

Answer 3

(I remember I've read in Effective C++)

No, you don't, because Scott Meyers wouldn't make such a mistake.

const T& is the best option because it never involves a copy but can still take rvalues. Consider

void foo(int& p);
void foo(const std::string s);
int main() { 
    foo(1); // illegal!
    foo("A reaaaaaaaallllllllllllllllllllllllllllllllllllllllllly long string");
    // Nasty copy
}

If you need a copy of an item, make one in the parameter list (take by value) but there's little reason for this value to be const. Else, use const T&. For some cheap types there's little point not taking by value because you know in advance that copying is cheap.

Answer 4

Your rule to always pass by const reference is overly general.

Passing by const reference generally indicates that

• the method is not going to modify the argument
• that the method may not claim ownership of the argument
• that the caller guarantees the argument's lifetime will be longer than the call

If you need something different, then you should choose something other than passing by const reference.