Std :: vector sta copiando gli oggetti con un push_back?

Dopo molte indagini con valgrind, ho concluso che std :: vector fa una copia di un oggetto che si desidera push_back.

È davvero vero? Un vettore non può conservare un riferimento o un puntatore di un oggetto senza una copia ?!

Grazie

Sì, std::vector<T>::push_back()crea una copia dell'argomento e lo memorizza nel vettore. Se si desidera memorizzare i puntatori agli oggetti nel vettore, creare un std::vector<whatever*>invece di std::vector<whatever>.

Tuttavia, è necessario assicurarsi che gli oggetti a cui fanno riferimento i puntatori rimangano validi mentre il vettore ne contiene un riferimento (i puntatori intelligenti che utilizzano il linguaggio RAII risolvono il problema).

Sì, std::vectorarchivia le copie. Come dovrebbe vectorsapere quali sono i tempi di vita previsti dei tuoi oggetti?

Se si desidera trasferire o condividere la proprietà degli oggetti utilizzare i puntatori, possibilmente i puntatori intelligenti come shared_ptr(presenti in Boost o TR1 ) per facilitare la gestione delle risorse.

Da C ++ 11 in poi, tutti i contenitori standard ( std::vector, std::map, ecc) semantica supporto mossa, il che significa che ora è possibile passare rvalues di contenitori standard e di evitare una copia:

// Example object class.
class object
{
private:
    int             m_val1;
    std::string     m_val2;

public:
    // Constructor for object class.
    object(int val1, std::string &&val2) :
        m_val1(val1),
        m_val2(std::move(val2))
    {

    }
};

std::vector<object> myList;

// #1 Copy into the vector.
object foo1(1, "foo");
myList.push_back(foo1);

// #2 Move into the vector (no copy).
object foo2(1024, "bar");
myList.push_back(std::move(foo2));

// #3 Move temporary into vector (no copy).
myList.push_back(object(453, "baz"));

// #4 Create instance of object directly inside the vector (no copy, no move).
myList.emplace_back(453, "qux");

In alternativa puoi utilizzare vari puntatori intelligenti per ottenere principalmente lo stesso effetto:

std::unique_ptr esempio

std::vector<std::unique_ptr<object>> myPtrList;

// #5a unique_ptr can only ever be moved.
auto pFoo = std::make_unique<object>(1, "foo");
myPtrList.push_back(std::move(pFoo));

// #5b unique_ptr can only ever be moved.
myPtrList.push_back(std::make_unique<object>(1, "foo"));

std::shared_ptr esempio

std::vector<std::shared_ptr<object>> objectPtrList2;

// #6 shared_ptr can be used to retain a copy of the pointer and update both the vector
// value and the local copy simultaneously.
auto pFooShared = std::make_shared<object>(1, "foo");
objectPtrList2.push_back(pFooShared);
// Pointer to object stored in the vector, but pFooShared is still valid.

std :: vector crea sempre una copia di tutto ciò che viene archiviato nel vettore.

Se si mantiene un vettore di puntatori, verrà creata una copia del puntatore, ma non l'istanza a cui punta il puntatore. Se hai a che fare con oggetti di grandi dimensioni, puoi (e probabilmente dovresti) usare sempre un vettore di puntatori. Spesso, utilizzare un vettore di puntatori intelligenti di un tipo appropriato è utile per motivi di sicurezza, poiché altrimenti la gestione della durata degli oggetti e la gestione della memoria possono essere complicate.

Non solo std :: vector crea una copia di ciò che stai respingendo, ma la definizione della raccolta afferma che lo farà e che non puoi usare oggetti senza la semantica della copia corretta all'interno di un vettore. Quindi, ad esempio, non usi auto_ptr in un vettore.

Rilevante in C ++ 11 è la emplacefamiglia di funzioni membro, che consente di trasferire la proprietà degli oggetti spostandoli in contenitori.

Il linguaggio dell'uso sarebbe simile

std::vector<Object> objs;

Object l_value_obj { /* initialize */ };
// use object here...

objs.emplace_back(std::move(l_value_obj));

Lo spostamento per l'oggetto lvalue è importante in quanto altrimenti verrebbe inoltrato come riferimento o riferimento const e il costruttore dello spostamento non verrebbe chiamato.

se non vuoi le copie; quindi il modo migliore è usare un vettore puntatore (o un'altra struttura che serve per lo stesso obiettivo). se vuoi le copie; usa direttamente push_back (). non hai altra scelta.

Perché ci sono volute molte indagini su Valgrind per scoprirlo! Provalo solo con un semplice codice, ad es

std::vector<std::string> vec;

{
      std::string obj("hello world");
      vec.push_pack(obj);
}

std::cout << vec[0] << std::endl;  

Se viene stampato "ciao mondo", l'oggetto deve essere stato copiato