Mögliche Duplikate:
Wie wird die Bewegungssemantik erzwungen, wenn ein Vektor wächst?

insert, push_back undemplace(_back) kann eine Umverteilung von astd::vector. Ich war verblüfft, als ich den folgenden Code sahKopien die Elemente stattziehen um sie beim Umverteilen des Containers.

<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>

Auf meinem speziellen Computer mit meinem speziellen Compiler (GCC 4.7) wird Folgendes ausgegeben:

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

Beim Löschen des Kopierkonstruktors (foo(foo const&) = delete;) wird die folgende (erwartete) Ausgabe generiert:

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

Warum das? Wäre das Verschieben im Allgemeinen nicht effizienter oder zumindest nicht viel weniger effizient als das Kopieren?

Es ist erwähnenswert, dassGCC 4.5.1 macht das erwartete - Handelt es sich um eine Regression in GCC 4.7 oder handelt es sich um eine äußerst clevere Optimierung, da der Compiler feststellt, dass mein Objekt billig zu kopieren ist (aber wie ?!)?

Beachten Sie auch, dass ich dafür gesorgt habeist verursacht durch Umverteilung, durch experimentelles Setzen von afoos.reserve(2); vor den Einfügungen; Dadurch werden weder das Kopieren noch das Verschieben ausgeführt.