push back vs emplace back

emplace_back nie powinien przyjmować argumentu typu vector::value_type, lecz zmiennych argumentów, które są przekazywane do konstruktora dołączonego elementu.

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

Możliwe jest przekazanie value_type, które zostanie przekazane do konstruktora kopiującego.

Ponieważ przekazuje argumenty, oznacza to, że jeśli nie masz wartości rvalue, to nadal oznacza, że kontener będzie przechowywał "skopiowaną" kopię, a nie przeniesioną kopię.

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

Ale powyższe powinno być identyczne z tym, co robi push_back. On prawdopodobnie raczej przeznaczone do takich przypadków użycia jak:

 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

Optymalizację dla emplace_back można zademonstrować w następnym przykładzie.

Dla emplace_back konstruktor A (int x_arg) zostanie wywołany. Oraz dla push_back A (int x_arg) nazywa się pierwszy i move A (A &&rhs) nazywa się później.

Oczywiście konstruktor musi być oznaczony jako explicit, ale dla obecnego przykładu dobrze jest usunąć explicitness.

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

Wyjście:

call emplace_back:
A (x_arg)

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

emplace_back zgodna implementacja przekaże argumenty do konstruktora vector<Object>::value_typepo dodaniu do wektora. Przypominam sobie, że Visual Studio nie obsługiwało różnych szablonów, ale z różnymi szablonami będą obsługiwane w Visual Studio 2013 RC, więc domyślam się, że zostanie dodany zgodny podpis.

Z emplace_back, jeśli przekazujesz argumenty bezpośrednio do konstruktora vector<Object>::value_type, nie potrzebujesz typu, aby był ruchomy lub kopiowalny dla funkcji emplace_back, ściśle mówiąc. W przypadku vector<NonCopyableNonMovableObject> nie jest to przydatne, ponieważ vector<Object>::value_type potrzebuje typu kopiowalnego lub ruchomego do wzrostu.

Ale zauważ , że może to być przydatne dla std::map<Key, NonCopyableNonMovableObject>, ponieważ po przydzieleniu wpisu na mapie nie trzeba go już przenosić ani kopiować, w przeciwieństwie do vector, co oznacza, że możesz efektywnie używać std::map z odwzorowanym typem, który nie jest ani kopiowalny, ani ruchomy.

Jeszcze jeden w przypadku List:

/ / konstruuje elementy w miejscu.
emplace_back ("element");

/ / utworzy nowy obiekt, a następnie skopiuje (lub przeniesie) jego wartość argumentów. push_back (explicitDataType {"element"});

Ładny kod dla push_back i emplace_back jest pokazany tutaj.

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

Możesz zobaczyć operację przenoszenia na push_back, a nie na emplace_back.