std :: vector :: erase() non si desidera spostare

Question

Ho uno std::vector<Foo> dove Foo è una classe contenente Foo(Foo&&) noexcept.

L'aggiunta di oggetti al contenitore funziona in modo impeccabile, tuttavia non cancellandoli utilizzando std::vector::erase(iterator), GCC 4.7 tenta di chiamare l'operatore di assegnazione che ho eliminato. Il messaggio di errore esatto è:

errore: uso della funzione cancellato 'Foobar & Foobar :: operator = (const Foobar &)

Edit: Naturalmente std::vector chiama l'operatore di assegnazione, non la copia costruttore (lo puoi vedere anche nel messaggio di errore). Risolto problema nella descrizione, mi dispiace.

Ecco esempio di codice sorgente come richiesto:

#include <vector> 

class Foo { 
    public: 
     Foo() {} 
     Foo(Foo&& other) noexcept {} 

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

int main() { 
    std::vector<Foo> v; 

    v.push_back(Foo{}); 
    v.erase(v.begin()); 
} 

Answer 1

Il problema è che non è stato fornito un operatore di assegnazione mossa. Questo fa parte del vettore Requisiti mobili per alcune funzioni.

Answer 2

non ho potuto riprodurla. Risulta che le buone abitudini sono molto importanti: ho definito l'operatore di spostamento dell'asse.

Live GCC 4.7.2: http://liveworkspace.org/code/36c600c285f2c91649fd4f73784c2c00

#include <iostream> 
#include <vector> 

struct Foo 
{ 
    Foo() {} 

    Foo(Foo const&) = delete; 
    Foo(Foo&&) throw() { } 

    Foo& operator=(Foo const&) = delete; 
    Foo& operator=(Foo&&) throw() { return *this; } 
}; 

int main(int argc, char* args[]) 
{ 
    std::vector<Foo> v; 
    v.emplace_back(); 
    v.emplace_back(); 
    v.emplace_back(); 
    v.emplace_back(); 

    auto it = v.begin(); 
    it++; 
    v.erase(it); 
} 

Answer 3

risposta di DeadMG è eccellente, però mi piacerebbe promuovere un altro modo di scrivere l'operatore di assegnazione:

struct Foo { 
    Foo() {} 

    Foo(Foo const&) = delete; 
    Foo(Foo&&) throw() { } 

    Foo& operator=(Foo) throw() { return *this; } 
}; 

Dal momento che hai bisogno di una nuova temporanea all'inizio del metodo, il compilatore scegliere sia la copia o sposta costruttore per creare questo temporaneo da solo, e non devi scrivere sia un operatore di assegnazione delle copie AND un operatore di assegnazione dello spostamento :)