How to add elements to vector without invoking copy-constructor?

Question

For some reason my temporary local object is always copy-constructed/destroyed when added to a vector which is causing problems due to nested std::reference_wrapper which are getting invalid because of the copy-construction and destruction afterwards (std::reference_wrapper targets are inside the object which gets destroyed -> so they are invalid in the copy-constructed object, if the source object is destroyed). But if possible I want to avoid the additional copying / destroying completely - that seems impossible, because whatever I tried always it wants to invoke the copy constructor (even using std::vector::emplace_back).

Considering this simple example (for easier understanding without std::reference_wrapper involved), it always tries to invoke the copy-constructor - I don't get why.

#include <vector>

class A{
public:
  A(int a) : a(a){ }
  int getInt() const{ return a; }
  A(const A&) = delete; /* to deny copy-construction */
private:
  int a;
};

int main(int argc, char* argv[]){
  std::vector<A> vec;
  vec.emplace_back(3);              /* tries to call copy constructor */
  vec.push_back(A(3));              /* tries to call copy constructor */
  vec.push_back(std::move(A(3)));   /* tries to call copy constructor */
  return 0;
}

Any ideas what I'm missing here?

Answer 1

Per the Visual Studio 2013 documentation, emphasis mine:

"Rvalue references v3.0" adds new rules to automatically generate move constructors and move assignment operators under certain conditions. However, this is not implemented in Visual C++ in Visual Studio 2013, due to time and resource constraints.

Visual Studio 2013 is specified as using Rvalue references v2.1.

Note: As T.C. notes in the comments there is also an issue with explicitly disabling the copy constructor in your example. Per cppreference.com.

If no user-defined move constructors are provided for a class type (struct, class, or union), and all of the following is true:

• there are no user-declared copy constructors
• there are no user-declared copy assignment operators
• there are no user-declared move assignment operators
• there are no user-declared destructors
• (until C++14) the implicitly-declared move constructor is not defined as deleted due to conditions detailed in the next section

then the compiler will declare a move constructor as an inline public member of its class with the signature T::T(T&&).

A class can have multiple move constructors, e.g. both T::T(const T&&) and T::T(T&&). If some user-defined move constructors are present, the user may still force the generation of the implicitly declared move constructor with the keyword default.

Which means your example code also prevents auto generation of the move constructor (i.e., it has a user-declared copy constructor).

You need to explicitly declare your move constructor and/or move assignment operator. The following works for your example.

class A
{
public:
    A(int a) : a(a) {}

    A(const A&) = delete;

    A(A&& other) : a(other.a) {}

    int getInt() const { return a; }

private:
    int a;
};

int main(int argc, char* argv[])
{
    std::vector<A> vec;
    vec.emplace_back(3);
    vec.push_back(A(3));
    vec.push_back(std::move(A(3)));

    return 0;
}