initializer_list und Verschiebungssemantik

Darf ich Elemente aus einem verschieben std::initializer_list<T>?

#include <initializer_list>
#include <utility>

template<typename T>
void foo(std::initializer_list<T> list)
{
    for (auto it = list.begin(); it != list.end(); ++it)
    {
        bar(std::move(*it));   // kosher?
    }
}

Schon seit std::intializer_list<T> besondere Aufmerksamkeit des Compilers erfordert und keine Wertesemantik wie bei normalen Containern der C ++ - Standardbibliothek aufweist, möchte ich lieber auf Nummer sicher gehen und fragen.

Nein, das wird nicht wie beabsichtigt funktionieren. Sie erhalten weiterhin Kopien. Ich bin ziemlich überrascht darüber, da ich gedacht hatte, dass initializer_listes eine Reihe von Provisorien gibt, bis sie movefertig sind.

beginund endfür die initializer_listRückgabe const T *ist das Ergebnis movein Ihrem Code T const &&- eine unveränderliche Wertreferenz. Ein solcher Ausdruck kann nicht sinnvoll verschoben werden. Es wird an einen Funktionsparameter vom Typ T const &gebunden, da rWerte an konstante Wertreferenzen gebunden sind und Sie weiterhin die Kopiersemantik sehen.

Wahrscheinlich liegt der Grund dafür darin, dass der Compiler das wählen kann initializer_list statisch initialisierte Konstante festlegen kann, aber es scheint sauberer zu sein, den Typ initializer_listoder const initializer_listnach Ermessen des Compilers festzulegen, sodass der Benutzer nicht weiß, ob er eine constoder eine veränderbare Konstante erwarten soll Ergebnis von beginund end. Aber das ist nur mein Bauchgefühl, wahrscheinlich gibt es einen guten Grund, warum ich falsch liege.

Update: Ich habe einen ISO-Vorschlag zur initializer_listUnterstützung von Nur-Verschieben-Typen geschrieben. Es ist nur ein erster Entwurf, und er ist noch nirgendwo implementiert, aber Sie können ihn zur weiteren Analyse des Problems sehen.

bar(std::move(*it));   // kosher?

Nicht so, wie Sie es beabsichtigen. Sie können ein constObjekt nicht verschieben . Und std::initializer_listbietet nur constZugriff auf seine Elemente. So die Art der itheißt const T *.

Ihr Anrufversuch std::move(*it)führt nur zu einem l-Wert. IE: eine Kopie.

std::initializer_listverweist auf statischen Speicher. Dafür ist die Klasse da. Sie können nicht bewegen aus statischen Speicher, da die Bewegung es ändert sich bringt. Sie können nur davon kopieren.

Dies funktioniert nicht wie angegeben, da list.begin()Typ hatconst T * ist und Sie sich nicht von einem konstanten Objekt entfernen können. Die Sprachdesigner haben dies wahrscheinlich gemacht, damit Initialisierungslisten beispielsweise Zeichenfolgenkonstanten enthalten können, von denen es unangemessen wäre, sie zu verschieben.

Wenn Sie sich jedoch in einer Situation befinden, in der Sie wissen, dass die Initialisierungsliste rWert-Ausdrücke enthält (oder Sie den Benutzer zwingen möchten, diese zu schreiben), gibt es einen Trick, mit dem dies funktioniert (ich wurde von der Antwort von Sumant für inspiriert dies, aber die Lösung ist viel einfacher als diese). Die in der Initialisiererliste gespeicherten Elemente müssen keine TWerte sein, sondern Werte, die kapseln T&&. Selbst wenn diese Werte selbst constqualifiziert sind, können sie dennoch einen veränderbaren Wert abrufen.

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

Anstatt ein initializer_list<T>Argument zu deklarieren, deklarieren Sie jetzt ein initializer_list<rref_capture<T> >Argument. Hier ist ein konkretes Beispiel mit einem Vektor von std::unique_ptr<int>intelligenten Zeigern, für die nur die Bewegungssemantik definiert ist (daher können diese Objekte selbst niemals in einer Initialisierungsliste gespeichert werden). Die unten stehende Initialisierungsliste lässt sich jedoch problemlos kompilieren.

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

Eine Frage muss beantwortet werden: Wenn die Elemente der Initialisierungsliste echte Werte sein sollen (im Beispiel sind es x-Werte), stellt die Sprache dann sicher, dass sich die Lebensdauer der entsprechenden Provisorien bis zu dem Punkt erstreckt, an dem sie verwendet werden? Ehrlich gesagt glaube ich nicht, dass der relevante Abschnitt 8.5 des Standards dieses Problem überhaupt behandelt. Wenn man jedoch 1,9: 10 liest, scheint es, dass der relevante vollständige Ausdruck in allen Fällen die Verwendung der Initialisiererliste umfasst, so dass ich denke, dass keine Gefahr besteht, dass rvalue-Referenzen baumeln.

Ich dachte, es könnte lehrreich sein, einen vernünftigen Ausgangspunkt für eine Problemumgehung anzubieten.

Kommentare inline.

#include <memory>
#include <vector>
#include <array>
#include <type_traits>
#include <algorithm>
#include <iterator>

template<class Array> struct maker;

// a maker which makes a std::vector
template<class T, class A>
struct maker<std::vector<T, A>>
{
  using result_type = std::vector<T, A>;

  template<class...Ts>
  auto operator()(Ts&&...ts) const -> result_type
  {
    result_type result;
    result.reserve(sizeof...(Ts));
    using expand = int[];
    void(expand {
      0,
      (result.push_back(std::forward<Ts>(ts)),0)...
    });

    return result;
  }
};

// a maker which makes std::array
template<class T, std::size_t N>
struct maker<std::array<T, N>>
{
  using result_type = std::array<T, N>;

  template<class...Ts>
  auto operator()(Ts&&...ts) const
  {
    return result_type { std::forward<Ts>(ts)... };
  }

};

//
// delegation function which selects the correct maker
//
template<class Array, class...Ts>
auto make(Ts&&...ts)
{
  auto m = maker<Array>();
  return m(std::forward<Ts>(ts)...);
}

// vectors and arrays of non-copyable types
using vt = std::vector<std::unique_ptr<int>>;
using at = std::array<std::unique_ptr<int>,2>;


int main(){
    // build an array, using make<> for consistency
    auto a = make<at>(std::make_unique<int>(10), std::make_unique<int>(20));

    // build a vector, using make<> because an initializer_list requires a copyable type  
    auto v = make<vt>(std::make_unique<int>(10), std::make_unique<int>(20));
}

Es scheint im aktuellen Standard nicht erlaubt zu sein, wie bereits beantwortet . Hier ist eine weitere Problemumgehung, um etwas Ähnliches zu erreichen, indem Sie die Funktion als variadisch definieren, anstatt eine Initialisierungsliste zu erstellen.

#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 können im Gegensatz zu initializer_list R-Wert-Referenzen angemessen verarbeiten.

In diesem Beispielcode habe ich eine Reihe kleiner Hilfsfunktionen verwendet, um die variadischen Argumente in einen Vektor zu konvertieren und sie dem ursprünglichen Code ähnlich zu machen. Natürlich können Sie stattdessen direkt eine rekursive Funktion mit variablen Vorlagen schreiben.

Ich habe eine viel einfachere Implementierung, die eine Wrapper-Klasse verwendet, die als Tag fungiert, um die Absicht zu markieren, die Elemente zu verschieben. Dies sind Kosten für die Kompilierung.

Die Wrapper - Klasse ist so konzipiert , in der Art und Weise verwendet werden , std::moveverwendet wird, ersetzen Sie einfach std::movemit move_wrapper, aber dies erfordert C ++ 17. Für ältere Spezifikationen können Sie eine zusätzliche Builder-Methode verwenden.

Sie müssen Builder-Methoden / Konstruktoren schreiben, die Wrapper-Klassen akzeptieren, initializer_listund die Elemente entsprechend verschieben.

Wenn Sie möchten, dass einige Elemente kopiert werden, anstatt verschoben zu werden, erstellen Sie eine Kopie, bevor Sie sie an übergeben initializer_list.

Der Code sollte selbst dokumentiert sein.

#include <iostream>
#include <vector>
#include <initializer_list>

using namespace std;

template <typename T>
struct move_wrapper {
    T && t;

    move_wrapper(T && t) : t(move(t)) { // since it's just a wrapper for rvalues
    }

    explicit move_wrapper(T & t) : t(move(t)) { // acts as std::move
    }
};

struct Foo {
    int x;

    Foo(int x) : x(x) {
        cout << "Foo(" << x << ")\n";
    }

    Foo(Foo const & other) : x(other.x) {
        cout << "copy Foo(" << x << ")\n";
    }

    Foo(Foo && other) : x(other.x) {
        cout << "move Foo(" << x << ")\n";
    }
};

template <typename T>
struct Vec {
    vector<T> v;

    Vec(initializer_list<T> il) : v(il) {
    }

    Vec(initializer_list<move_wrapper<T>> il) {
        v.reserve(il.size());
        for (move_wrapper<T> const & w : il) {
            v.emplace_back(move(w.t));
        }
    }
};

int main() {
    Foo x{1}; // Foo(1)
    Foo y{2}; // Foo(2)

    Vec<Foo> v{Foo{3}, move_wrapper(x), Foo{y}}; // I want y to be copied
    // Foo(3)
    // copy Foo(2)
    // move Foo(3)
    // move Foo(1)
    // move Foo(2)
}

Anstatt a zu verwenden std::initializer_list<T>, können Sie Ihr Argument als Array-Wertreferenz deklarieren:

template <typename T>
void bar(T &&value);

template <typename T, size_t N>
void foo(T (&&list)[N] ) {
   std::for_each(std::make_move_iterator(std::begin(list)),
                 std::make_move_iterator(std::end(list)),
                 &bar);
}

void baz() {
   foo({std::make_unique<int>(0), std::make_unique<int>(1)});
}

Siehe Beispiel unter Verwendung von std::unique_ptr<int>: https://gcc.godbolt.org/z/2uNxv6

Betrachten Sie die in<T>auf cpptruths beschriebene Redewendung . Die Idee ist, lvalue / rvalue zur Laufzeit zu bestimmen und dann move oder copy-building aufzurufen. in<T>erkennt rvalue / lvalue, obwohl die von initializer_list bereitgestellte Standardschnittstelle eine konstante Referenz ist.