Posible duplicado:
¿Cómo hacer cumplir la semántica de movimiento cuando un vector crece?

insert, push_back yemplace(_back) puede causar una reasignación de unstd::vector. Me desconcertó ver que el siguiente códigocopias los elementos en lugar deemocionante Ellos mientras reasignan el contenedor.

<code>#include <iostream>
#include <vector>

struct foo {
    int value;

    explicit foo(int value) : value(value) {
        std::cout << "foo(" << value << ")\n";
    }

    foo(foo const& other) noexcept : value(other.value) {
        std::cout << "foo(foo(" << value << "))\n";
    }

    foo(foo&& other) noexcept : value(std::move(other.value)) {
        other.value = -1;
        std::cout << "foo(move(foo(" << value << "))\n";
    }

    ~foo() {
        if (value != -1)
            std::cout << "~foo(" << value << ")\n";
    }
};

int main() {
    std::vector<foo> foos;
    foos.emplace_back(1);
    foos.emplace_back(2);
}
</code>

En mi máquina específica que usa mi compilador específico (GCC 4.7) esto imprime lo siguiente:

<code>foo(1)
foo(2)
foo(foo(1))
~foo(1)
~foo(1)
~foo(2)
</code>

Sin embargo, al eliminar el constructor de copia (foo(foo const&) = delete;), se genera la siguiente salida (esperada):

<code>foo(1)
foo(2)
foo(move(foo(1))
~foo(1)
~foo(2)
</code>

¿Porqué es eso? ¿El movimiento en general sería más eficiente, o al menos no mucho menos eficiente, que copiar?

Vale la pena señalar queGCC 4.5.1 hace lo esperado - ¿Es esto una regresión en GCC 4.7 o es una optimización astutamente inteligente porque el compilador ve que mi objeto es barato de copiar (pero, ¿cómo?).

También tenga en cuenta que me aseguré de que estoes causada por la reasignación, poniendo experimentalmentefoos.reserve(2); delante de las inserciones; esto hace que ni la copia ni el movimiento se ejecuten.