Is it guaranteed that a container will destruct existing objects during std::move?

Question

Consider the following example:

#include <iostream>
#include <vector>

class A {
public:
    A(const A&) = default;
    A(A&&) = default;
    A& operator=(const A&) = default;
    A& operator=(A&&) = default;

    A() = default;
    ~A() {
        std::cout << "~A()\n";
    }
};

int main() {
    std::vector<A> v1;
    std::vector<A> v2;

    v1.emplace_back();
    v1 = std::move(v2);
    std::cout << "moved\n";
}

The output is:

~A()
moved

My question is: Can I rely on std::move to destruct elements inside v1? Or, in other words, is the output above guaranteed, or can I get:

moved
~A()

It would be surprising if the latter is possible, but I didn't find a definite answer, and didn't find anything explicit in the standard. That could happen if the move assignment operator is implemented with std::swap or similar, but I didn't find a solid answer regarding whether that's valid or not.

q.v. [`std::vector operator=`](https://en.cppreference.com/w/cpp/container/vector/operator%3D) for the move assignment. — Eljay, May 04 '23 at 13:10
`std::move` is not moving anything. The actual move is happening in `=` — 463035818_is_not_an_ai, May 04 '23 at 13:11

score 2 · Accepted Answer · answered May 04 '23 at 13:17

While swapping would be a valid implementation for move assignment in general, standard library containers have extra requirements. Table 73:

Expression: a = rv
Return type: X&
Operational semantics: All existing elements of a are either move assigned to or destroyed
Assertion/Note pre-/post-condition: Postconditions: a is equal to the value that rv had before this assignment
Complexity: linear

So a swap wouldn't suffice, since that wouldn't move-assign to or destroy the original v1[0]

Is it guaranteed that a container will destruct existing objects during std::move?

1 Answers1