Why copy constructor is called in std::vector'

Question

I have the following very simple class:

class Foo 
{
public:
  Foo() {}
  Foo(const Foo&) = delete;
  Foo(Foo&&) {}

  void operator=(const Foo&) = delete;
  void operator=(Foo&&) {}

  void dump() const {}
};

The class is move constructible and assignable but isn't copy constructible and assignable.

I'd like to initialize a vector of Foo elements using vector's initializer list.

std::vector<Foo> vf = { Foo() };

The compiler complains because code has to use the deleted copy constructor. Could anybody explain, why the move construct is not used in this case, and why copy of the object is needed?

The following also requires the copy constructor and does not work either:

std::vector<Foo> vf = { std::move(Foo()) };

On the other hand, this works fine (the move constructor is called):

std::vector<Foo> vf;
vf.push_back(Foo());

Thanks for the explanation... :)

Update:

A suggested this post explains my question.

Furthermore let's consider the following code (together with class Foo above):

class Bar {
public:
    Bar(std::initializer_list<Foo> _l) {
        std::cout << "Bar::Bar()" << std::endl;
        for (auto& e : _l)
            e.dump();
    }
};

int main() {
    Bar b { Foo() };
    return 0;
}

This produces the following output (compiled with C++11):

Foo::Foo()
Bar::Bar()
Foo::dump()
Foo::~Foo()

It can be seen, that the initializer list is not actually filled with the 'copy of the objects' stated between the braces. This might be not true from C++14.

Answer 1

std::initializer_list doesn't work for move-only types. See this question for more details.

Fortunately, there's a dead easy fix for you:

std::vector<foo> vf (1);

This will initialize the vector with 1 default-constructed foo.

Answer 2

On general the requirements that are imposed on the elements of a std::vector is that the element type is a complete type and meets the requirements of Erasable. As such there's no problem with your object.

However, initializing with an initializer list as such:

std::vector<Foo> vf = { Foo() };

Requires that the temporary object Foo() in the list be copied into the vector. Consequently, the compiler complains because you've already made your object non-copyable.

You can accomplish what you want in the following way;

std::vector<Foo> vf(1);

Answer 3

It's specifically because you use an initializer list that the copy-constructor is used. The initializer list is initialized with a copy of the object, and then passed to the vector.

If you read the linked reference, from C++14 it even explicitly say

... each element is copy-initialized ... from the corresponding element of the original initializer list

_{Emphasis mine}