`auto` specifier type deduction for references

Question

Let\'s consider the following code snippet

void Test()
  {
  int x = 0;

  int& rx = x;
  int* px = &x;

  auto apx = px;    // deduced type is int*
         


        

Answer 1

The simplest way to think about it is comparing it to template argument deduction.

Given:

template
void deduce(T) { }

If you call:

deduce(px);

then the template argument T will be deduced as int* and if you call

deduce(rx);

then T will be deduced as int, not int&

You get the same types deduced when using auto.

One could draw an analogy from pointer types expecting that the deduced type of arx is int&

You'd have to have a fairly confused model of the C++ language to make that analogy. Just because they are declared in syntactically similar ways, as Type@ with a type and a modifier doesn't make them work the same way. A pointer is a value, an object, and it can be copied and have its value altered by assignment. A reference is not an object, it's a reference to some object. A reference can't be copied (copying it copies the referent) or altered (assigning to it alters the referent). A function that returns a pointer returns an object by value (the object in question being a pointer object), but a function that returns a reference (like your GetBigClass()) returns an object by reference. They're completely different semantics, trying to draw analogies between pointers and references is doomed to failure.