Gibt es irgendeinen Fall, wo eine Rückkehr von einer RValue-Referenz (&&) ist sinnvoll?

Gibt es einen Grund, wenn eine Funktion zurückgeben sollte eine RValue-Referenz? Eine Technik, oder trick, oder ein idiom oder Muster?

MyClass&& func( ... );

Ich bin mir der Gefahr bewusst Rückgabe Referenzen im Allgemeinen, aber manchmal tun wir es sowieso nicht wir (T& T::operator=(T) ist nur eine idiomatische Beispiel). Aber wie wäre es T&& func(...)? Gibt es irgendeine Allgemeine Stelle, wo wir gewinnen würden, machen die das? Wahrscheinlich anders, wenn man schreibt-Bibliothek oder API-code, im Vergleich zu nur-client-code?

InformationsquelleAutor towi | 2011-04-24

  1. 53

    Gibt es ein paar Gelegenheiten, wenn es angemessen ist, aber Sie sind relativ selten. Der Fall kommt in einem Beispiel, wenn Sie zulassen möchten, dass der client, um von einer Daten-Mitglied. Zum Beispiel:

    template <class Iter>
class move_iterator
{
private:
    Iter i_;
public:
    ...
    value_type&& operator*() const {return std::move(*i_);}
    ...
};
    Ein ausgezeichnetes Beispiel. Das Muster ist, Sie wollen Kunden-code move etwas -- was es erlaubt ihn zu "stehlen". Ja, natürlich.
    Letztes mal habe ich überprüft, es war undefiniert, Zugang nach dem Umzug aus.
    Im Allgemeinen hat eine bewegte Objekt, wenn verwendet, in die die std::lib, müssen alle Anforderungen erfüllen, angegeben, welchen Teil der std::lib ist es. std-Typen muss zusätzlich garantieren, dass Ihre zog von Staat gültig ist. Kunden können, rufen Sie eine Funktion mit diesem Objekt, solange es keine Voraussetzungen, die auf dessen Wert für diese Funktion-Anruf.
    Schließlich, wie im obigen Beispiel, es sind keine bewegten-Objekten. std::move bewegt sich nicht. Es wirft nur um rvalue. Es ist Sache des Kunden, sich zu bewegen (oder auch nicht) aus, dass rvalue. Dieser client erhält nur Zugriff auf eine bewegt-von Wert, wenn er dereferenziert den move_iterator zweimal, ohne einzugreifen iterator-traversal.
    Wäre es nicht sicherer, zu verwenden value_type statt value_type&& als Rückgabetyp?

    InformationsquelleAutor Howard Hinnant

  2. 16

    Diese folgt bis auf towi ' s Kommentar. Sie will nie wieder Referenzen auf lokale Variablen. Aber haben Sie vielleicht dieses:

    vector<N> operator+(const vector<N>& x1, const vector<N>& x2) { vector<N> x3 = x1; x3 += x2; return x3; }
vector<N>&& operator+(const vector<N>& x1, vector<N>&& x2)    { x2 += x1; return std::move(x2); }
vector<N>&& operator+(vector<N>&& x1, const vector<N>& x2)    { x1 += x2; return std::move(x1); }
vector<N>&& operator+(vector<N>&& x1, vector<N>&& x2)         { x1 += x2; return std::move(x1); }

    Dieser soll verhindern, dass jegliche Kopien (und die möglichen Zuordnungen) in allen Fällen, außer denen beide Parameter sind lvalues.

    Es ist zwar möglich, dies ist in der Regel verpönt, weil dieser Ansatz hat seine eigenen Probleme neben der Einsparung der Provisorien. Siehe stackoverflow.com/questions/6006527
    Nicht diejenigen, die zurück ruft, müssen die Verwendung von std::move()?
    Gute Frage, aber ich denke nicht so. std::move funktioniert ohne Verwendung von std::move. Ich denke, die Besetzung zu && funktioniert der trick hier.
    es gibt kein cast in Ihrem code, müssen Sie return std::move(x2); etc. Oder man könnte schreiben, eine Besetzung zu rvalue-Referenz geben, aber das ist genau das, was move ohnehin tut.
    Ich habe in der moves. Matt ist korrekt. Ich habe es getestet

    InformationsquelleAutor Clinton

  3. 7

    Nicht. Nur den Rückgabewert. Die Rückgabe von Referenzen im Allgemeinen ist überhaupt nicht gefährlich - es ist die Rückkehr Verweise auf lokalen Variablen, die gefährlich ist. Rückkehr eine rvalue-Referenz, jedoch, ist ziemlich wertlos in fast allen Situationen (ich denke, wenn Sie schreiben std::move oder so).

    Ich denke, dass während der frühen design des C++0x-es gab eine Zeit, wenn es wurde vorgeschlagen, dass Dinge wie die bewegen-weisen und T&& operator+(const T&,T&&) zurückgeben sollte eine &&. Aber das ist jetzt vorbei, in den endgültigen Entwurf. Das ist, warum ich Frage.

    InformationsquelleAutor Puppy

  4. 0

    Können Sie die Rückgabe durch Referenz, wenn Sie sicher sind, dass das referenzierte Objekt nicht mehr gültig, nachdem die Funktion beendet wird, z.B. es ist ein global-Objekt die Referenz-oder member-Funktion zurückgeben Bezug auf die Klasse Felder, etc.

    Diese Rückkehr-Referenz-Regel ist nur für beide lvalue und rvalue-Referenz. Der Unterschied ist, wie Sie wollen, verwenden Sie die zurückgegebene Referenz. Wie ich sehen kann, die Rückkehr von rvalue-Referenz ist selten. Wenn Sie die Funktion:

    Type&& func();

    Werden Sie nicht, wie ein solcher code:

    Type&& ref_a = func();

    weil es effektiv definiert ref_a als Typ& da benannt rvalue-Referenz ist ein lvalue, und keine tatsächliche Bewegung wird hier durchgeführt. Es ist ganz wie:

    const Type& ref_a = func();

    außer, dass die tatsächlichen ref_a ist eine non-const lvalue reference.

    Und es ist auch nicht sehr hilfreich, für die Sie selbst direkt übergeben func() zu einer anderen Funktion, die eine Art&& argument, weil es immer noch eine benannte Referenz innerhalb der Funktion.

    void anotherFunc(Type&& t) {
  //t is a named reference
}
anotherFunc(func());

    Die Beziehung von func( ) und anotherFunc( ) ist mehr wie eine "Autorisierung" , func() stimmt anotherFunc( ) könnte in Besitz nehmen (oder kann man sagen "stehlen") das zurückgegebene Objekt von func( ). Aber diese Vereinbarung ist sehr Locker. Eine nicht-const lvalue-Referenz kann immer noch "gestohlen" von Anrufern. Funktioniert eigentlich nur selten definiert, rvalue-Referenz-Argumente. Der häufigste Fall ist, dass "anotherFunc" ist ein Klasse name und anotherFunc( ) ist eigentlich ein move-Konstruktor.

    InformationsquelleAutor hangyuan

  5. 0

    Noch eine mögliche Falle: wenn Sie brauchen, um zu packen ein Tupel und übergibt die Werte an eine Funktion.

    Könnte es nützlich sein, in diesem Fall, wenn Sie sich nicht sicher über copy-elision.

    So ein Beispiel:

    template<typename ... Args>
class store_args{
    public:
        std::tuple<Args...> args;

        template<typename Functor, size_t ... Indices>
        decltype(auto) apply_helper(Functor &&f, std::integer_sequence<size_t, Indices...>&&){
            return std::move(f(std::forward<Args>(std::get<Indices>(args))...));
        }

        template<typename Functor>
        auto apply(Functor &&f){
            return apply_helper(std::move(f), std::make_index_sequence<sizeof...(Args)>{});
        }
};

    ziemlich seltener Fall, es sei denn Sie schreiben eine form von std::bind oder std::thread Ersatz obwohl.

    InformationsquelleAutor CoffeeandCode

Schreibe einen Kommentar