Why does resize() cause a copy, rather than a move, of a vector's content when capacity is exceeded?
c++, c++11, copy-constructor, move-semantics
Solution
Paragraph 23.3.6.3/14 of the C++11 Standard specifies (about the `resize()` member function of the `vector<>` class template):
Remarks: If an exception is thrown other than by the move constructor of a non-`CopyInsertable T` there are no effects.
In other words, this means that for `X` (which is `CopyInsertable`), `resize()` offers the strong guarantee: it either succeeds or leaves the state of the vector unchanged.
In order to satisfy this guarantee, implementations usally adopt the copy-and-swap idiom: if the copy constructor of `X` throws, we haven't altered the content of the original vector yet, so the promise is kept.
However, if the previous content of the vector were moved into the new storage rather than being copied and the move constructor threw, then we would have irreversibly changed the original content of the vector.
Therefore, implementations will use the copy constructor of `X` to safely transfer the content of the vector into a new storage unless the move constructor is known not to throw, in which case it is safe to move from the previous elements.
With a small change to the definition of `X`'s move constructor (marking it as `noexcept`), in fact, the output of the program is now the expected one.:
struct X
{
X() { }
X(int) { }
X(X const&) { std::cout << "X(X const&)" << std::endl; }
X(X&&) noexcept { std::cout << "X(X&&)" << std::endl; }
// ^^^^^^^^
};
Problem
Given class `X` below (special member functions other than the one explicitly defined are not relevant for this experiment): ``` struct X { X() { } X(int) { } X(X const&) { std::cout << "X(X const&)" << std::endl; } X(X&&) { std::cout << "X(X&&)" << std::endl; } }; ``` The following program creates a vector of objects of type `X` and resizes it so that its capacity is exceeded and reallocation is forced: ``` #include <iostream> #include <vector> int main() { std::vector<X> v(5); v.resize(v.capacity() + 1); } ``` Since class `X` provides a move constructor, I would expect the previous content of the vector to be moved into the new storage after reallocation. Quite surprisingly, that does not seem to be the case, and the output I get is: ``` X(X const&) X(X const&) X(X const&) X(X const&) X(X const&) ``` Why?