Mengapa saya menggunakan push_back alih-alih emplace_back?

C ++ 11 vektor memiliki fungsi baru emplace_back. Tidak seperti push_back, yang bergantung pada optimisasi kompiler untuk menghindari salinan, emplace_backmenggunakan penerusan yang sempurna untuk mengirim argumen langsung ke konstruktor untuk membuat objek di tempat. Sepertinya saya yang emplace_backmelakukan segalanya push_backdapat melakukan, tetapi beberapa waktu itu akan melakukannya dengan lebih baik (tetapi tidak pernah lebih buruk).

Alasan apa yang harus saya gunakan push_back?

Saya telah memikirkan pertanyaan ini sedikit selama empat tahun terakhir. Saya sampai pada kesimpulan bahwa sebagian besar penjelasan tentang push_backvs. emplace_backmelewatkan gambaran lengkap.

Tahun lalu, saya memberikan presentasi di C ++ Now on Type Deduction in C ++ 14 . Saya mulai berbicara tentang push_backvs. emplace_backpada 13:49, tetapi ada informasi berguna yang menyediakan beberapa bukti pendukung sebelum itu.

Perbedaan utama sebenarnya berkaitan dengan konstruktor implisit vs eksplisit. Pertimbangkan kasus di mana kita memiliki satu argumen yang ingin kita sampaikan push_backatau emplace_back.

std::vector<T> v;
v.push_back(x);
v.emplace_back(x);

Setelah kompiler pengoptimalisasi Anda berhasil, tidak ada perbedaan antara kedua pernyataan ini dalam hal kode yang dihasilkan. Kearifan tradisional adalah bahwa push_backakan membangun objek sementara, yang kemudian akan pindah ke vsedangkan emplace_backakan meneruskan argumen bersama dan membangunnya langsung di tempat tanpa salinan atau bergerak. Ini mungkin benar berdasarkan kode seperti yang ditulis di perpustakaan standar, tetapi itu membuat asumsi yang salah bahwa tugas kompiler mengoptimalkan adalah untuk menghasilkan kode yang Anda tulis. Pekerjaan kompiler pengoptimal sebenarnya untuk menghasilkan kode yang Anda tulis jika Anda seorang ahli optimasi platform spesifik dan tidak peduli tentang rawatan, hanya kinerja.

Perbedaan aktual antara kedua pernyataan ini adalah bahwa semakin kuat emplace_backakan memanggil semua jenis konstruktor di luar sana, sedangkan yang lebih berhati push_back- hati akan memanggil hanya konstruktor yang implisit. Konstruktor implisit seharusnya aman. Jika Anda dapat secara implisit membangun Udari T, Anda mengatakan bahwa Udapat menyimpan semua informasi Ttanpa kehilangan. Aman dalam hampir semua situasi untuk dilewati Tdan tidak ada yang keberatan jika Anda menjadikannya sebagai Ugantinya. Contoh bagus konstruktor implisit adalah konversi dari std::uint32_tke std::uint64_t. Contoh buruk konversi implisit adalah doubleuntuk std::uint8_t.

Kami ingin berhati-hati dalam pemrograman kami. Kami tidak ingin menggunakan fitur yang kuat karena semakin kuat fitur, semakin mudah untuk melakukan sesuatu yang tidak benar atau tidak terduga. Jika Anda bermaksud memanggil konstruktor eksplisit, maka Anda memerlukan kekuatan emplace_back. Jika Anda ingin memanggil konstruktor implisit saja, tetap dengan keamanan push_back.

Sebuah contoh

std::vector<std::unique_ptr<T>> v;
T a;
v.emplace_back(std::addressof(a)); // compiles
v.push_back(std::addressof(a)); // fails to compile

std::unique_ptr<T>memiliki konstruktor eksplisit dari T *. Karena emplace_backdapat memanggil konstruktor eksplisit, melewatkan pointer yang tidak memiliki mengkompilasi dengan baik. Namun, ketika vkeluar dari ruang lingkup, destruktor akan berusaha memanggil deletepointer itu, yang tidak dialokasikan oleh newkarena itu hanya objek tumpukan. Ini mengarah pada perilaku yang tidak terdefinisi.

Ini bukan hanya kode yang ditemukan. Ini adalah bug produksi nyata yang saya temui. Kode itu std::vector<T *>, tetapi memiliki isinya. Sebagai bagian dari migrasi ke C ++ 11, saya benar berubah T *untuk std::unique_ptr<T>menunjukkan bahwa vektor dimiliki memori. Namun, saya mendasarkan perubahan ini dari pemahaman saya pada tahun 2012, di mana saya berpikir "emplace_back melakukan semua yang bisa dilakukan push_back dan banyak lagi, jadi mengapa saya menggunakan push_back?", Jadi saya juga mengubah push_backke emplace_back.

Seandainya saya meninggalkan kode sebagai menggunakan yang lebih aman push_back, saya akan langsung menangkap bug lama ini dan itu akan dilihat sebagai keberhasilan meningkatkan ke C ++ 11. Sebagai gantinya, saya menutupi bug dan tidak menemukannya sampai berbulan-bulan kemudian.

push_backselalu memungkinkan penggunaan inisialisasi seragam, yang sangat saya sukai. Misalnya:

struct aggregate {
    int foo;
    int bar;
};

std::vector<aggregate> v;
v.push_back({ 42, 121 });

Di sisi lain, v.emplace_back({ 42, 121 });tidak akan berfungsi.

Kompatibilitas mundur dengan kompiler pra-C ++ 11.

Beberapa implementasi pustaka emplace_back tidak berlaku seperti yang ditentukan dalam standar C ++ termasuk versi yang dikirimkan dengan Visual Studio 2012, 2013 dan 2015.

Untuk mengakomodasi bug kompiler yang diketahui, lebih baik menggunakan std::vector::push_back()jika parameter merujuk iterator atau objek lain yang akan tidak valid setelah panggilan.

std::vector<int> v;
v.emplace_back(123);
v.emplace_back(v[0]); // Produces incorrect results in some compilers

Pada satu kompiler, v berisi nilai-nilai 123 dan 21 bukannya 123 dan 123 yang diharapkan. Hal ini disebabkan oleh fakta bahwa panggilan ke-2 emplace_backmenghasilkan perubahan ukuran di mana titik v[0]menjadi tidak valid.

Implementasi kerja dari kode di atas akan digunakan push_back()sebagai ganti emplace_back()sebagai berikut:

std::vector<int> v;
v.emplace_back(123);
v.push_back(v[0]);

Catatan: Penggunaan vektor int adalah untuk tujuan demonstrasi. Saya menemukan masalah ini dengan kelas yang jauh lebih kompleks yang mencakup variabel anggota yang dialokasikan secara dinamis dan panggilan untuk emplace_back()menghasilkan crash keras.