push_back vs emplace_back

Biraz arasındaki fark ile ilgili karıştı değilim push_backve emplace_back.

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

push_backBir rvalue referansı alan bir aşırı yük olduğundan , amacının ne olduğunu tam olarak göremiyorum emplace_back?

Ziyaretçilerin söylediklerine ek olarak:

void emplace_back(Type&& _Val)MSCV10 tarafından sağlanan işlev uyumsuz ve gereksizdir, çünkü belirttiğiniz gibi kesinlikle buna eşdeğerdir push_back(Type&& _Val).

Ancak gerçek C ++ 0x formu emplace_backgerçekten yararlıdır void emplace_back(Args&&...):;

value_typeBunu almak yerine değişken bir argüman listesi alır, böylece artık argümanları mükemmel bir şekilde iletebilir ve geçici olarak hiç bir nesneyi doğrudan bir kaba inşa edebilirsiniz.

Ne kadar zekice RVO ve semantik hareket tabloya getirmek olursa olsun, bir push_back'in gereksiz kopyalar oluşturması (veya taşıması) hala karmaşık durumlar vardır. Örneğin, a'nın geleneksel insert()işleviyle, std::mapdaha sonra a'ya kopyalanacak ve std::pair<Key, Value>daha sonra haritaya kopyalanacak bir geçici oluşturmanız gerekir:

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

Peki neden MSVC'de emplace_back'in doğru sürümünü uygulamadılar? Aslında, bir süre önce beni rahatsız etti, bu yüzden aynı soruyu Visual C ++ blogunda sordum . İşte Microsoft'un Visual C ++ standart kütüphane uygulamasının resmi sürdürücüsü Stephan T Lavavej'in cevabı.

S: Beta 2 emplace fonksiyonları şu anda sadece bir çeşit yer tutucu mu?

C: Bildiğiniz gibi VC10'da varyasyon şablonları uygulanmaz. Onları make_shared<T>(), tuple ve içindeki yeni şeyler için önişlemci makineleri ile simüle ediyoruz <functional>. Bu önişlemci makinesinin kullanımı ve bakımı nispeten zordur. Ayrıca, alt başlıkları tekrar tekrar eklememiz gerektiğinden derleme hızını önemli ölçüde etkiler. Zaman kısıtlamaları ve derleme hızı endişelerimizin bir kombinasyonu nedeniyle, emplace fonksiyonlarımızda varyasyon şablonları simüle etmedik.

Derleyiciye varyasyon şablonları uygulandığında, emplace fonksiyonlarımız da dahil olmak üzere kütüphanelerden bunlardan faydalanmamızı bekleyebilirsiniz. Uyumu çok ciddiye alıyoruz, ancak ne yazık ki, her şeyi aynı anda yapamayız.

Bu anlaşılabilir bir karardır. Önişlemci korkunç hileleri ile varyasyon şablonu taklit etmeye sadece bir kez deneyen herkes, bu şeylerin ne kadar iğrenç olduğunu bilir.

emplace_backtür argümanı almamalı vector::value_type, bunun yerine ekteki öğenin yapıcısına iletilen varyasyonlu bağımsız değişkenler almalıdır .

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

value_typeKopya yapıcıya iletilecek olanı geçmek mümkündür .

Argümanları ilettiği için, bu, eğer rvalue'nuz yoksa, konteynerin taşınan bir kopyayı değil, "kopyalanmış" bir kopya saklayacağı anlamına gelir.

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

Ancak yukarıdakiler ne ile aynı olmalıdır push_back. Muhtemelen aşağıdaki gibi kullanım durumları içindir:

 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

İçin optimizasyon bir emplace_backsonraki örnekte gösterilebilir.

İçin emplace_backyapıcı A (int x_arg)çağrılır. Ve push_back A (int x_arg)ilk move A (A &&rhs)olarak çağrılır ve daha sonra çağrılır.

Tabii ki, kurucu olarak işaretlenmelidir explicit, ancak mevcut örnek için açıklığı kaldırmak iyidir.

#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;
}

çıktı:

call emplace_back:
A (x_arg)

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

Burada push_back ve emplace_back için güzel bir kod gösterilir.

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

Taşıma işlemini emplace_back üzerinde değil push_back üzerinde görebilirsiniz.

emplace_backUYGULAMA UYGULAMASI vector<Object>::value_type, vektöre eklendiğinde argümanları yapıcıya iletir . Visual Studio'nun varyasyonlu şablonları desteklemediğini hatırlıyorum, ancak varyasyonlu şablonlar ile Visual Studio 2013 RC'de desteklenecek, bu yüzden uygun bir imza eklenecek.

İle emplace_backdoğrudan argümanlar ileri eğer vector<Object>::value_typeyapıcı, bir tür gerekmez için hareketli veya copyable olmak emplace_backaçıkçası, işlevi. Bu vector<NonCopyableNonMovableObject>durumda, vector<Object>::value_type büyümek için kopyalanabilir veya taşınabilir bir türe ihtiyaç duyduğundan , bu yararlı değildir .

Ama not Bunun için yararlı olabileceğini std::map<Key, NonCopyableNonMovableObject>haritanın bir girdiyi tahsis kez taşınması veya farklı olarak, artık hiç kopyalanması gerekmediğinden, vectorkullanabileceğiniz anlamınastd::map ne de haritalanmış bir türle etkili bir hareket edebilir.

Listelerde bir tane daha:

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

Özel kullanım örneği emplace_back: Daha sonra bir kaba aktarılacak geçici bir nesne oluşturmanız gerekirse emplace_back,push_back . Nesneyi konteyner içinde yerinde oluşturacaktır.

Notlar:

1. push_backYukarıdaki durumda geçici bir nesne oluşturacak ve onu kaba taşıyacaktır. Bununla birlikte, kullanılan yerinde yapı emplace_back, nesneyi inşa etmekten ve sonra hareket etmekten daha performanslıdır (genellikle bir miktar kopyalamayı içerir).
2. Genel olarak, tüm durumlar emplace_backyerine push_backçok fazla sorun olmadan kullanabilirsiniz . ( İstisnalara bakın )