initializer_list und move-Semantik

Nein, das wird nicht so funktionieren wie Sie sollen; Sie werden immer noch kopiert. Ich bin ziemlich überrascht, da ich dachte, dass initializer_list Bestand zu halten, eine Reihe von Provisorien, bis Sie move'd....

begin und end für initializer_list zurück const T *, so das Ergebnis der move im code ist T const && — eine unveränderliche rvalue-Referenz. Ein solcher Ausdruck kann nicht sinnvoll verschoben werden. Es wird eine Bindung an eine Funktion parameter vom Typ T const & weil rvalues tun binden const lvalue Referenzen, und Sie werden noch sehen, copy-Semantik.

Wohl der Grund für dieses ist, also kann der compiler entscheiden, um die initializer_list eine statisch initialisierte Konstanten, aber es scheint, wäre es sauberer zu machen, seine Art initializer_list oder const initializer_list bei der compiler nach eigenem Ermessen, so dass die Benutzer nicht wissen, ob zu erwarten const oder veränderlich Ergebnis von begin und end. Aber das ist nur mein Bauchgefühl, wahrscheinlich gibt es einen guten Grund, ich bin falsch.

Update: ich geschrieben habe ein ISO-Vorschlag für initializer_list Unterstützung von move-only-Typen. Es ist nur ein Erster Entwurf, und es ist nicht überall implementiert, aber Sie können sehen, dass es für die weitere Analyse des Problems.

InformationsquelleAutor Potatoswatter

Diese nicht so funktionieren, wie angegeben, da list.begin() Typ const T *, und es gibt keine Weise, die Sie verschieben können, von einem Konstanten Objekt. Die Sprache, die Designer wahrscheinlich gemacht, dass, damit, um zu ermöglichen, Initialisierer-Listen enthalten, zum Beispiel string-Konstanten, aus denen es unangemessen wäre, sich zu bewegen.

Jedoch, wenn Sie in einer situation, wo Sie wissen, dass die Initialisierungsliste enthält rvalue-Ausdrücke (oder Sie wollen erzwingen, dass der Benutzer schreiben diese), dann gibt es einen trick, damit es funktioniert (ich wurde inspiriert durch die Antwort von Sumant für diese, aber die Lösung ist viel einfacher als das). Sie müssen die Elemente gespeichert, die in der initialiser Liste nicht T Werte, sondern Werte, die Kapseln T&&. Wenn dann auch noch diejenigen, die Werte selbst sind const qualifiziert, können Sie noch immer abrufen einer modifizierbaren rvalue.

template<typename T>
  class rref_capture
{
  T* ptr;
public:
  rref_capture(T&& x) : ptr(&x) {}
  operator T&& () const { return std::move(*ptr); } //restitute rvalue ref
};

Nun, anstatt zu erklären, eine initializer_list<T> argument, Sie deklarieren eineinitializer_list<rref_capture<T> > argument. Hier ist ein konkretes Beispiel, mit einem Vektor, der std::unique_ptr<int> smart pointers, für die nur move-Semantik eindeutig definiert ist (also diese Objekte selbst können nie abgelegt werden, die in einer Initialisierer-Liste); aber der Initialisierungsliste unten kompiliert ohne Probleme.

#include <memory>
#include <initializer_list>
class uptr_vec
{
  typedef std::unique_ptr<int> uptr; //move only type
  std::vector<uptr> data;
public:
  uptr_vec(uptr_vec&& v) : data(std::move(v.data)) {}
  uptr_vec(std::initializer_list<rref_capture<uptr> > l)
    : data(l.begin(),l.end())
  {}
  uptr_vec& operator=(const uptr_vec&) = delete;
  int operator[] (size_t index) const { return *data[index]; }
};

int main()
{
  std::unique_ptr<int> a(new int(3)), b(new int(1)),c(new int(4));
  uptr_vec v { std::move(a), std::move(b), std::move(c) };
  std::cout << v[0] << "," << v[1] << "," << v[2] << std::endl;
}

Einer Frage braucht eine Antwort: wenn die Elemente der Initialisierungsliste sein sollte, true prvalues (im Beispiel sind Sie xvalues), hat die Sprache sicher, dass die Lebensdauer der entsprechenden Provisorien erstreckt sich bis zu dem Punkt, wo Sie verwendet werden? Ehrlich gesagt, ich glaube nicht, dass der entsprechende Abschnitt 8.5 der Norm beschäftigt sich mit diesem Problem überhaupt. Jedoch, Lesen 1.9:10, es scheint, dass die relevanten full-Ausdruck in allen Fällen umfasst die Verwendung der Initialisierungsliste, so denke ich, dass es keine Gefahr von dangling rvalue-Referenzen.

InformationsquelleAutor Marc van Leeuwen

Scheint es nicht erlaubt, in den aktuellen standard als schon beantwortet. Hier ist eine andere Möglichkeit, etwas zu erreichen, ähnlich der, durch die Definition der Funktion als Variable statt einer Initialisierungsliste.

#include <vector>
#include <utility>

//begin helper functions

template <typename T>
void add_to_vector(std::vector<T>* vec) {}

template <typename T, typename... Args>
void add_to_vector(std::vector<T>* vec, T&& car, Args&&... cdr) {
  vec->push_back(std::forward<T>(car));
  add_to_vector(vec, std::forward<Args>(cdr)...);
}

template <typename T, typename... Args>
std::vector<T> make_vector(Args&&... args) {
  std::vector<T> result;
  add_to_vector(&result, std::forward<Args>(args)...);
  return result;
}

//end helper functions

struct S {
  S(int) {}
  S(S&&) {}
};

void bar(S&& s) {}

template <typename T, typename... Args>
void foo(Args&&... args) {
  std::vector<T> args_vec = make_vector<T>(std::forward<Args>(args)...);
  for (auto& arg : args_vec) {
    bar(std::move(arg));
  }
}

int main() {
  foo<S>(S(1), S(2), S(3));
  return 0;
}

Variadic-Vorlagen verarbeiten kann r-Wert-Referenzen angemessen, im Gegensatz zu initializer_list.

In diesem Beispiel-code, den ich verwendet eine Reihe von kleinen Hilfsfunktionen zum konvertieren der Variable Argumente in einen Vektor, um zu machen es ähnlich wie das original-code. Aber natürlich, Sie können schreiben Sie eine rekursive Funktion mit variadic templates direkt statt.

InformationsquelleAutor Hiroshi Ichikawa