Apakah std :: vector menyalin objek dengan push_back?

Setelah banyak penyelidikan dengan valgrind, saya telah membuat kesimpulan bahwa std :: vector membuat salinan dari objek yang ingin Anda push_back.

Benarkah itu benar? Vektor tidak dapat menyimpan referensi atau penunjuk objek tanpa salinan ?!

Terima kasih

Ya, std::vector<T>::push_back()buat salinan argumen dan simpan dalam vektor. Jika Anda ingin menyimpan pointer ke objek di vektor Anda, buat std::vector<whatever*>bukan std::vector<whatever>.

Namun, Anda perlu memastikan bahwa objek yang direferensikan oleh pointer tetap valid sementara vektor memegang referensi untuk mereka (pointer pintar menggunakan idiom RAII memecahkan masalah).

Ya, std::vectorsimpan salinannya. Bagaimana seharusnya vectortahu masa hidup yang diharapkan dari objek Anda?

Jika Anda ingin mentransfer atau berbagi kepemilikan objek menggunakan pointer, mungkin pointer cerdas seperti shared_ptr(ditemukan dalam Boost atau TR1 ) untuk memudahkan manajemen sumber daya.

Dari C ++ 11 dan seterusnya, semua kontainer standar ( std::vector,, std::mapdll) mendukung pemindahan semantik, yang berarti bahwa Anda sekarang dapat meneruskan nilai ke kontainer standar dan menghindari salinan:

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

Atau Anda dapat menggunakan berbagai pointer cerdas untuk mendapatkan sebagian besar efek yang sama:

std::unique_ptr contoh

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 contoh

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 selalu membuat salinan dari apa pun yang disimpan dalam vektor.

Jika Anda menyimpan vektor pointer, maka itu akan membuat salinan dari pointer, tetapi bukan instance yang menunjuk pointer. Jika Anda berurusan dengan objek besar, Anda bisa (dan mungkin harus) selalu menggunakan vektor pointer. Seringkali, menggunakan vektor smart pointer dari tipe yang sesuai adalah baik untuk tujuan keselamatan, karena menangani masa pakai objek dan manajemen memori bisa rumit sebaliknya.

Std :: vector tidak hanya membuat salinan dari apa pun yang Anda tekan kembali, tetapi definisi dari koleksi menyatakan bahwa ia akan melakukannya, dan bahwa Anda tidak dapat menggunakan objek tanpa semantik salinan yang benar dalam vektor. Jadi, misalnya, Anda tidak menggunakan auto_ptr dalam vektor.

Relevan dalam C ++ 11 adalah emplacekeluarga fungsi anggota, yang memungkinkan Anda mentransfer kepemilikan objek dengan memindahkannya ke dalam wadah.

Ungkapan penggunaan akan terlihat seperti

std::vector<Object> objs;

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

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

Langkah untuk objek nilai adalah penting karena jika tidak maka akan diteruskan sebagai referensi atau referensi const dan langkah konstruktor tidak akan dipanggil.

jika Anda ingin bukan salinannya; maka cara terbaik adalah dengan menggunakan vektor pointer (atau struktur lain yang berfungsi untuk tujuan yang sama). jika Anda ingin salinannya; gunakan langsung push_back (). Anda tidak punya pilihan lain.

Mengapa butuh banyak penyelidikan valgrind untuk mengetahui hal ini! Buktikan saja kepada diri Anda dengan beberapa kode sederhana misalnya

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

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

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

Jika "hello world" dicetak, objek harus disalin