C++11 auto: what if it gets a constant reference?

by

Read this article: Appearing and Disappearing consts in C++

Type deduction for auto variables in C++0x is essentially the same as
for template parameters. (As far as I know, the only difference
between the two is that the type of auto variables may be deduced from
initializer lists, while the types of template parameters may not be.)
Each of the following declarations therefore declare variables of type
int (never const int):

auto a1 = i;
auto a2 = ci;
auto a3 = *pci;
auto a4 = pcs->i;

During type deduction for template parameters and auto variables, only
top-level consts are removed. Given a function template taking a
pointer or reference parameter, the constness of whatever is pointed
or referred to is retained:

template<typename T>
void f(T& p);

int i;
const int ci = 0;
const int *pci = &i;

f(i);               // as before, calls f<int>, i.e., T is int
f(ci);              // now calls f<const int>, i.e., T is const int
f(*pci);            // also calls f<const int>, i.e., T is const int

This behavior is old news, applying as it does to both C++98 and
C++03. The corresponding behavior for auto variables is, of course,
new to C++0x:

auto& a1 = i;       // a1 is of type int&
auto& a2 = ci;      // a2 is of type const int&
auto& a3 = *pci;    // a3 is also of type const int&
auto& a4 = pcs->i;  // a4 is of type const int&, too

Since you can retain the cv-qualifier if the type is a reference or pointer, you can do:

auto& my_foo2 = GetFoo();

Instead of having to specify it as const (same goes for volatile).

Edit: As for why auto deduces the return type of GetFoo() as a value instead of a reference (which was your main question, sorry), consider this:

const Foo my_foo = GetFoo();

The above will create a copy, since my_foo is a value. If auto were to return an lvalue reference, the above wouldn’t be possible.

More Related Contents:

  1. Why can I use auto on a private type?
  2. How much is too much with C++11 auto keyword?
  3. What is the type of lambda when deduced with “auto” in C++11?
  4. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  5. What does auto&& tell us?
  6. Arrow operator (->) in function heading
  7. Difference between pointer and reference as thread parameter
  8. Why does auto x{3} deduce an initializer_list?
  9. Range-for-loops and std::vector
  10. C++ auto keyword. Why is it magic?
  11. how to initialize a constexpr reference
  12. Can the use of C++11’s ‘auto’ improve performance?
  13. C++ auto vs auto&
  14. What is the difference between std::reference_wrapper and a simple pointer?
  15. C++11 – declaring non-static data members as ‘auto’
  16. The new keyword “auto”; When should it be used to declare a variable type? [duplicate]
  17. Why can’t I initialize a reference in an initializer list with uniform initialization?
  18. Advantage of using trailing return type in C++11 functions
  19. Why doesn’t the C++11 ‘auto’ keyword work for static members?
  20. C++11 Change `auto` Lambda to a different Lambda?
  21. Why does std::forward have two overloads?
  22. Rvalues, lvalues and formal definitions
  23. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  24. Convert std::tuple to std::array C++11
  25. If we seed c++11 mt19937 as the same on different machines, will we get the same sequence of random numbers
  26. How to directly bind a member function to an std::function in Visual Studio 11?
  27. How do static variables in lambda function objects work?
  28. Why is there no piecewise tuple construction?
  29. Constructor as a function try block – Exception aborts program
  30. map with incomplete value type

Leave a Comment