Why auto v {create()}; does not compile?

Question

i was doing some tests of the move semantics and I tried this :

class A{
public:
    A(){printf("A CTOR\n");}
    A(A&) {printf("A CTOR by copy\n");}
    A(A&&){printf("A CTOR by universal reverence\n");}
};

A&& create(){
    A v;
    return std::move(v);
}

auto x{ create() };//this does not compile

float d[]{1.2,1.3,5,6};//this does compile

I get the following error:

error C3086: cannot find 'std::initializer_list': you need to #include <initializer_list>

I don't understand as the initializer list feature has been added to VC11 with CTP2012 nov. Is this because we have to wait for an update of the stdlib ?

I think the code is correct as I copied it from a slide from Scott meyers: Move Semantics, Rvalue References, Perfect Forwarding.

Thank you for your help. For your information, the spurious copies occured because i did not add "const" in my CTOR by copy. Best

Answer 1

Braces with auto will always end up in std::initializer_list<T> type. So basically what happens here you try to create a std::initializer_list<A> here for x instead of A what probably was your intent here. However your code should compile fine and that may be a bug in the VS latest CTP compiler.

To make x be of A you have 2 options:

1. Do not use auto here:

   A x{ create() };
   

2. Do not use Uniform initialization here:

   auto x(create());
   

Beside that I see 2 other issues in you code. Firstly signature of proper copy-constructor should look like that:

A(const A &) {printf("A CTOR by copy\n");}

Moreover it is not encouraged to return RValue references from functions. Instead you should return by value like that:

A create(){
  A v;
  return v;   // std::move not needed here because C++11 compiler will put it for you here
}

or just:

A create(){
  return A();
}

EDIT:

Oh and just to be politically correct A(A&&) is not "A CTOR by universal reference". It is "A CTOR by move" or "A CTOR by rvalue reference" depending on which level of abstraction you want to operate. Universal reference is always about templates and that specific type type deduction.

Please also read an article of Scott Meyers I attached in a different comment http://scottmeyers.blogspot.com/2012/10/copying-constructors-in-c11.html where the same C++ guru that you refer in your notes exactly explains the problems you face. Hope that helps.

Answer 2

The line

auto x{ create() };//this does not compile

creates an initializer_list and not an instance of A, see for example std::initializer_list.

If you write

A x{ create() };

the code compiles and the type of x will be A.

---

I wouldn't return A&& from create(), see Move Semantics and Compiler Optimizations. I haven't seen this in Scott's slides either.

---

The following code prints only A CTOR, see here. That is the best you can get: The object has to be created. Apart from that there are no unnecessary copy constructor or assignment operator calls.

#include <cstdio>
#include <utility>
using namespace std;

class A{
public:
    A(){         printf("A CTOR\n");}
    A(const A&) {printf("A CTOR by copy\n");}
    A(A&&){      printf("A CTOR by universal reverence\n");}
    A& operator=(const A& ) = delete;
};

A create(){
    return A();
}

int main() {
    A x{ create() };
    return 0;
}

---

std::move is not the only way to get rid of the unnecessary copies. The compiler can do it for you, see for example What are copy elision and return value optimization? or Copy elision.