Kopiert std :: vector die Objekte mit einem push_back?

Nach vielen Untersuchungen mit valgrind bin ich zu dem Schluss gekommen, dass std :: vector eine Kopie eines Objekts erstellt, das Sie push_back möchten.

Stimmt das wirklich ? Ein Vektor kann ohne Referenz keine Referenz oder einen Zeiger eines Objekts behalten ?!

Vielen Dank

Ja, std::vector<T>::push_back()erstellt eine Kopie des Arguments und speichert es im Vektor. Wenn Sie Zeiger auf Objekte in Ihrem Vektor speichern möchten, erstellen Sie eine std::vector<whatever*>anstelle von std::vector<whatever>.

Sie müssen jedoch sicherstellen, dass die Objekte, auf die die Zeiger verweisen, gültig bleiben, während der Vektor einen Verweis auf sie enthält (intelligente Zeiger, die die RAII-Sprache verwenden, lösen das Problem).

Ja, std::vectorspeichert Kopien. Woher sollten Sie vectordie erwarteten Lebensdauern Ihrer Objekte wissen?

Wenn Sie das Eigentum an den Objekten übertragen oder teilen möchten, verwenden Sie Zeiger, möglicherweise intelligente Zeiger wie shared_ptr(in Boost oder TR1 ), um die Ressourcenverwaltung zu vereinfachen.

Von C ++ 11 ab, alle Standardcontainer ( std::vector, std::mapusw.) convoy Semantik, was bedeutet , dass Sie jetzt rvalues zu Standardcontainer und vermeiden eine Kopie passieren kann:

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

Alternativ können Sie verschiedene intelligente Zeiger verwenden, um größtenteils den gleichen Effekt zu erzielen:

std::unique_ptr Beispiel

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 Beispiel

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 erstellt immer eine Kopie von allem, was im Vektor gespeichert ist.

Wenn Sie einen Zeigervektor beibehalten, wird eine Kopie des Zeigers erstellt, nicht jedoch die Instanz, auf die der Zeiger zeigt. Wenn Sie mit großen Objekten arbeiten, können (und sollten) Sie immer einen Zeigervektor verwenden. Die Verwendung eines Vektors von intelligenten Zeigern eines geeigneten Typs ist häufig aus Sicherheitsgründen gut, da die Handhabung der Objektlebensdauer und der Speicherverwaltung ansonsten schwierig sein kann.

Std :: vector erstellt nicht nur eine Kopie von allem, was Sie zurückschieben, sondern die Definition der Auflistung besagt auch, dass dies der Fall ist und dass Sie möglicherweise keine Objekte ohne die korrekte Kopiersemantik innerhalb eines Vektors verwenden. So verwenden Sie beispielsweise nicht auto_ptr in einem Vektor.

Relevant in C ++ 11 ist die emplaceFamilie der Elementfunktionen, mit denen Sie das Eigentum an Objekten übertragen können, indem Sie sie in Container verschieben.

Die Gebrauchssprache würde so aussehen

std::vector<Object> objs;

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

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

Die Verschiebung für das lvalue-Objekt ist wichtig, da es sonst als Referenz oder const-Referenz weitergeleitet würde und der Verschiebungskonstruktor nicht aufgerufen würde.

wenn Sie nicht die Kopien wollen; Dann ist es am besten, einen Zeigervektor (oder eine andere Struktur, die für dasselbe Ziel dient) zu verwenden. wenn Sie die Kopien wollen; benutze direkt push_back (). Sie haben keine andere Wahl.

Warum waren viele Valgrind-Untersuchungen erforderlich, um dies herauszufinden? Beweisen Sie es sich einfach mit einem einfachen Code, z

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

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

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

Wenn "Hallo Welt" gedruckt wird, muss das Objekt kopiert worden sein