Std :: vector nesneleri bir push_back ile kopyalıyor mu?

Valgrind ile çok fazla araştırma yapıldıktan sonra, std :: vector'un push_back yapmak istediğiniz bir nesnenin bir kopyasını oluşturduğu sonucuna vardım.

Bu gerçekten doğru mu? Vektör, kopya olmadan bir nesnenin referansını veya işaretçisini tutamaz mı ?!

Teşekkürler

Evet, std::vector<T>::push_back()argümanın bir kopyasını oluşturur ve vektörde saklar. İşaretçileri vektörünüzdeki nesnelere depolamak istiyorsanız, std::vector<whatever*>yerine bir tane oluşturun std::vector<whatever>.

Ancak, işaretçi tarafından başvurulan nesnelerin, vektör bunlara referans tutarken geçerli kaldığından emin olmanız gerekir (RAII deyimini kullanan akıllı işaretçiler sorunu çözer).

Evet, std::vectorkopyaları saklar. vectorNesnelerinizin beklenen yaşam sürelerinin ne olduğunu nasıl bilebilirsiniz?

Nesnelerin sahipliğini aktarmak veya paylaşmak istiyorsanız, kaynak yönetimini kolaylaştırmak için muhtemelen shared_ptr( Boost veya TR1'de bulunan ) gibi akıllı işaretçiler kullanın .

C ++ 11'den itibaren, tüm standart kaplar ( std::vector, std::mapvb.) Taşıma semantiğini destekler, yani artık değerleri standart kaplara geçirebilir ve bir kopyadan kaçınabilirsiniz:

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

Alternatif olarak, çoğunlukla aynı etkiyi elde etmek için çeşitli akıllı işaretçiler kullanabilirsiniz:

std::unique_ptr misal

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 misal

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 her zaman vektörde depolanan her şeyin bir kopyasını oluşturur.

Bir işaretçi vektörü tutuyorsanız, işaretçinin bir kopyasını oluşturur, ancak işaretçinin işaret ettiği örneği oluşturmaz. Büyük nesnelerle uğraşıyorsanız, her zaman bir işaretçi vektörü kullanabilirsiniz (ve muhtemelen kullanmalısınız). Genellikle, uygun tipte bir akıllı işaretçi vektörü kullanmak, güvenlik amaçları için iyidir, çünkü nesne ömrü ve bellek yönetimi işlemek zor olabilir.

Std :: vector, geri ittiğiniz her şeyin bir kopyasını oluşturmakla kalmaz, koleksiyonun tanımı, bunu yapacağını ve bir vektör içinde doğru kopya semantiği olmadan nesneleri kullanamayacağınızı belirtir. Örneğin, bir vektörde auto_ptr kullanmıyorsunuz.

C ++ 11 ile ilgili emplaceolan, nesnelerin sahipliğini kaplara taşıyarak aktarmanıza olanak tanıyan üye işlevleri ailesidir.

Kullanım deyimi

std::vector<Object> objs;

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

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

Lvalue nesnesinin taşınması önemlidir, aksi takdirde bir başvuru veya sabit başvuru olarak iletilir ve taşıma yapıcısı çağrılmaz.

kopyaları istemiyorsanız; en iyi yol bir işaretçi vektörü (veya aynı amaca hizmet eden başka bir yapı) kullanmaktır. kopyaları istiyorsanız; doğrudan push_back () kullanın. başka seçeneğin yok.

Bunu bulmak için neden çok fazla valgrind soruşturması gerekiyor? Sadece basit bir kodla kendinize kanıtlayın, örn.

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

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

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

"Merhaba dünya" basılırsa, nesne kopyalanmış olmalıdır