push_back vs emplace_back

Saya agak bingung tentang perbedaan antara push_backdan emplace_back.

void emplace_back(Type&& _Val);
void push_back(const Type& _Val);
void push_back(Type&& _Val);

Karena ada push_backkelebihan mengambil referensi nilai saya tidak cukup melihat apa tujuan emplace_backmenjadi?

Selain apa yang dikatakan pengunjung:

Fungsi yang void emplace_back(Type&& _Val)disediakan oleh MSCV10 tidak sesuai dan mubazir, karena seperti yang Anda catat, ini setara dengan push_back(Type&& _Val).

Tapi bentuk nyata C ++ 0x emplace_backsangat berguna void emplace_back(Args&&...):;

Alih-alih mengambil value_typeitu membutuhkan daftar argumen variadik, sehingga itu berarti bahwa Anda sekarang dapat dengan sempurna meneruskan argumen dan membangun langsung objek ke wadah tanpa sementara sama sekali.

Itu berguna karena tidak peduli seberapa banyak kepintaran RVO dan memindahkan semantik ke meja, masih ada kasus rumit di mana push_back cenderung membuat salinan yang tidak perlu (atau memindahkan). Misalnya, dengan insert()fungsi tradisional a std::map, Anda harus membuat sementara, yang kemudian akan disalin ke std::pair<Key, Value>, yang kemudian akan disalin ke peta:

std::map<int, Complicated> m;
int anInt = 4;
double aDouble = 5.0;
std::string aString = "C++";

// cross your finger so that the optimizer is really good
m.insert(std::make_pair(4, Complicated(anInt, aDouble, aString))); 

// should be easier for the optimizer
m.emplace(4, anInt, aDouble, aString);

Jadi mengapa mereka tidak mengimplementasikan versi emplace_back yang tepat di MSVC? Sebenarnya, itu menyadap saya beberapa waktu yang lalu, jadi saya mengajukan pertanyaan yang sama di blog Visual C ++ . Berikut adalah jawaban dari Stephan T Lavavej, pengelola resmi implementasi perpustakaan standar Visual C ++ di Microsoft.

T: Apakah fungsi beta 2 emplace hanya semacam placeholder sekarang?

A: Seperti yang Anda ketahui, template variadic tidak diimplementasikan dalam VC10. Kami mensimulasikan mereka dengan mesin preprocessor untuk hal-hal seperti make_shared<T>(), tuple, dan hal-hal baru di <functional>. Mesin preprosesor ini relatif sulit digunakan dan dirawat. Selain itu, ini secara signifikan memengaruhi kecepatan kompilasi, karena kami harus berulang kali menyertakan subpos. Karena kombinasi dari batasan waktu dan masalah kecepatan kompilasi kami, kami belum mensimulasikan templat variadic di fungsi emplace kami.

Ketika templat variadic diimplementasikan dalam kompiler, Anda dapat berharap bahwa kami akan memanfaatkannya di perpustakaan, termasuk di fungsi emplace kami. Kami menanggapi kesesuaian dengan sangat serius, tetapi sayangnya, kami tidak dapat melakukan semuanya sekaligus.

Itu keputusan yang bisa dimengerti. Setiap orang yang mencoba sekali saja untuk meniru template variadic dengan trik mengerikan preprocessor tahu betapa menjijikkannya hal ini.

emplace_backtidak boleh mengambil argumen tipe vector::value_type, melainkan argumen variadik yang diteruskan ke konstruktor item terlampir.

template <class... Args> void emplace_back(Args&&... args); 

Dimungkinkan untuk meneruskan value_typeyang akan diteruskan ke copy constructor.

Karena ini meneruskan argumen, ini berarti bahwa jika Anda tidak memiliki nilai, ini masih berarti bahwa wadah akan menyimpan salinan yang "disalin", bukan salinan yang dipindahkan.

 std::vector<std::string> vec;
 vec.emplace_back(std::string("Hello")); // moves
 std::string s;
 vec.emplace_back(s); //copies

Tetapi hal di atas harus identik dengan apa yang push_backdilakukannya. Ini mungkin lebih dimaksudkan untuk kasus penggunaan seperti:

 std::vector<std::pair<std::string, std::string> > vec;
 vec.emplace_back(std::string("Hello"), std::string("world")); 
 // should end up invoking this constructor:
 //template<class U, class V> pair(U&& x, V&& y);
 //without making any copies of the strings

Optimasi untuk emplace_backdapat ditunjukkan dalam contoh berikut.

Untuk emplace_backkonstruktor A (int x_arg)akan dipanggil. Dan untuk push_back A (int x_arg)disebut pertama dan move A (A &&rhs)sesudahnya disebut.

Tentu saja, konstruktor harus ditandai sebagai explicit, tetapi untuk contoh saat ini baik untuk menghilangkan kesaksian.

#include <iostream>
#include <vector>
class A
{
public:
  A (int x_arg) : x (x_arg) { std::cout << "A (x_arg)\n"; }
  A () { x = 0; std::cout << "A ()\n"; }
  A (const A &rhs) noexcept { x = rhs.x; std::cout << "A (A &)\n"; }
  A (A &&rhs) noexcept { x = rhs.x; std::cout << "A (A &&)\n"; }

private:
  int x;
};

int main ()
{
  {
    std::vector<A> a;
    std::cout << "call emplace_back:\n";
    a.emplace_back (0);
  }
  {
    std::vector<A> a;
    std::cout << "call push_back:\n";
    a.push_back (1);
  }
  return 0;
}

keluaran:

call emplace_back:
A (x_arg)

call push_back:
A (x_arg)
A (A &&)

Kode yang bagus untuk push_back dan emplace_back ditampilkan di sini.

http://en.cppreference.com/w/cpp/container/vector/emplace_back

Anda dapat melihat operasi pemindahan pada push_back dan bukan pada emplace_back.

emplace_backimplementasi yang sesuai akan meneruskan argumen ke vector<Object>::value_typekonstruktor ketika ditambahkan ke vektor. Saya ingat Visual Studio tidak mendukung templat variadic, tetapi dengan templat variadic akan didukung di Visual Studio 2013 RC, jadi saya kira tanda tangan yang sesuai akan ditambahkan.

Dengan emplace_back, jika Anda meneruskan argumen secara langsung ke vector<Object>::value_typekonstruktor, Anda tidak perlu tipe yang dapat dipindahkan atau disalin untuk emplace_backfungsi, secara tegas. Dalam vector<NonCopyableNonMovableObject>hal ini, ini tidak berguna, karena vector<Object>::value_type perlu jenis yang dapat disalin atau bergerak untuk tumbuh.

Tetapi perhatikan bahwa ini bisa berguna untuk std::map<Key, NonCopyableNonMovableObject>, karena begitu Anda mengalokasikan entri di peta, itu tidak perlu dipindahkan atau disalin lagi, tidak seperti dengan vector, yang berarti bahwa Anda dapat menggunakan std::mapsecara efektif dengan tipe yang dipetakan yang tidak dapat disalin maupun bergerak.

Satu lagi dalam hal daftar:

// constructs the elements in place.                                                
emplace_back("element");


//It will create new object and then copy(or move) its value of arguments.
push_back(explicitDataType{"element"});

Kasus penggunaan khusus untuk emplace_back: Jika Anda perlu membuat objek sementara yang kemudian akan didorong ke dalam wadah, gunakan emplace_backsebagai ganti push_back. Ini akan membuat objek di tempat di dalam wadah.

Catatan:

1. push_backdalam kasus di atas akan membuat objek sementara dan memindahkannya ke wadah. Namun, konstruksi di tempat yang digunakan emplace_backakan lebih berkinerja daripada membangun dan kemudian memindahkan objek (yang umumnya melibatkan penyalinan).
2. Secara umum, Anda dapat menggunakan emplace_backalih-alih push_backdalam semua kasus tanpa banyak masalah. (Lihat pengecualian )