Est-ce que std :: vector copie les objets avec un push_back?

Après de nombreuses recherches avec valgrind, j'ai conclu que std :: vector fait une copie d'un objet que vous voulez push_back.

Est-ce vraiment vrai? Un vecteur ne peut pas garder une référence ou un pointeur d'un objet sans copie?!

Merci

Oui, std::vector<T>::push_back()crée une copie de l'argument et le stocke dans le vecteur. Si vous souhaitez stocker des pointeurs vers des objets dans votre vecteur, créez un à la std::vector<whatever*>place de std::vector<whatever>.

Cependant, vous devez vous assurer que les objets référencés par les pointeurs restent valides tant que le vecteur contient une référence à eux (les pointeurs intelligents utilisant l'idiome RAII résolvent le problème).

Oui, std::vectorstocke des copies. Comment vectorsavoir quelles sont les durées de vie attendues de vos objets?

Si vous souhaitez transférer ou partager la propriété des objets, utilisez des pointeurs, éventuellement des pointeurs intelligents comme shared_ptr(trouvés dans Boost ou TR1 ) pour faciliter la gestion des ressources.

A partir de C ++ 11 partir, tous les conteneurs standard ( std::vector, std::map, etc.) , supportent la sémantique de mouvement, ce qui signifie que vous pouvez maintenant passer rvalues aux conteneurs standards et éviter une copie:

// 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");

Vous pouvez également utiliser divers pointeurs intelligents pour obtenir le même effet:

std::unique_ptr exemple

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 exemple

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 fait toujours une copie de tout ce qui est stocké dans le vecteur.

Si vous conservez un vecteur de pointeurs, alors il fera une copie du pointeur, mais pas l'instance vers laquelle le pointeur pointe. Si vous avez affaire à de gros objets, vous pouvez (et devriez probablement) toujours utiliser un vecteur de pointeurs. Souvent, l'utilisation d'un vecteur de pointeurs intelligents d'un type approprié est bonne pour des raisons de sécurité, car la gestion de la durée de vie des objets et de la gestion de la mémoire peut être délicate dans le cas contraire.

Non seulement std :: vector fait une copie de tout ce que vous repoussez, mais la définition de la collection déclare qu'elle le fera et que vous ne pouvez pas utiliser d'objets sans la sémantique de copie correcte dans un vecteur. Ainsi, par exemple, vous n'utilisez pas auto_ptr dans un vecteur.

La emplacefamille de fonctions membres, qui vous permet de transférer la propriété des objets en les déplaçant dans des conteneurs, est pertinente dans C ++ 11 .

L'idiome d'utilisation ressemblerait à

std::vector<Object> objs;

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

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

Le déplacement de l'objet lvalue est important car sinon il serait transféré en tant que référence ou référence const et le constructeur de déplacement ne serait pas appelé.

si vous ne voulez pas les copies; alors la meilleure façon est d'utiliser un vecteur de pointeur (ou une autre structure qui sert au même but). si vous voulez les copies; utilisez directement push_back (). vous n'avez pas d'autre choix.

Pourquoi a-t-il fallu beaucoup d'investigations valgrind pour le découvrir! Prouvez-le vous-même avec un code simple, par exemple

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

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

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

Si "hello world" est imprimé, l'objet doit avoir été copié