mir ist gerade eine Idee gekommen:
Mithilfe von variadic template könnte man analog zu make_shared dem std::vector eine methode hinzufügen, der man konstrutorargumente übergibt und die dann ein neues objekt direkt im vector konstruiert.
Gibt es sowas vielleicht sogar mit dem neuen Standard?
Was haltet ihr davon?

Nochmal als Beispiel:

struct Point
{
  int x, y;
  Point(int x, int y)
  {
     this->x = x;
     this->y = y;
  }
};

void some_func()
{
   vector<Point> vec;
   //früher:
   vec.push_back(Point(5,3));
   //mit variadic templates
   vec.construct_inplace_and_push_back(5,3); //natürlich sollte man sich einen besseren namen dafür ausdenken :-)
}

Dadurch kann man kopien vermeiden.
Bei Point bringts vll nicht soviel und es gibt ja jetzt auch move-semantik, aber ich fänds schon gut.

Gibt es sowas vielleicht sogar mit dem neuen Standard?

Wäre das im neuen Standard (wegen Move-Semantik) überhaupt sinnvoll?

Q schrieb:

Gibt es sowas vielleicht sogar mit dem neuen Standard?

Wäre das im neuen Standard (wegen Move-Semantik) überhaupt sinnvoll?

Klar ...

struct OmgHuge
{
int huge[1000];
};

std::vector<OmgHuge> huge;
huge.push_back( { { 0, 1, 2, 3, /* ... */ } } );

Da müssten ja rein technisch 1000 ints vom temporären Objekt in den Storage kopiert werden.

Man könnte es z.B. intern für eine Datenstruktor als new-Ersatz verwenden:

class node {
  :::
};

class graph : boost::noncopyable {
  list<node> nodes_;
  :::
public:
  :::
  template<class...Args>
  node* new_node(Args&&...args)
  {
    nodes_.emplace_back(std::forward<Args>(args)...);
    return &nodes_.back();
  }
  :::
};

nette sache.
Gibts denn compiler, die sowas schon können?

Der GCC kann zumindest schonmal variadische Templates verarbeiten. Damit müssten die emplace-Funktionen eigentlich relativ leicht implementierbar werden. Ob libstdc++ das schon kann, weiß ich nicht mit Sicherheit. Es würde mich nicht überaschen, wenn das da schon funktionierte.