Ist es sinnvoll, Operatoren mit Ref-Qualifier zu überladen, um Provisorien zu vermeiden?

Question

Es fiel mir gerade ein, dass operator+ & co auf this für rvalues ​​arbeiten kann; das heißt, eine Klasse gegeben C, dann ist es möglich, dies zu tun:

class C { 
    // ... 
    C operator-(const C& rhs) const & { 
     C result = *this; 
     result -= rhs; 
     return result; 
    } 
    C&& operator-(const C& rhs) && { 
     *this -= rhs; 
     return std::move(*this); 
    } 
}; 

Diese Kopien durch einfaches Modifizieren temporäre Werte an Ort und Stelle verhindern würde.

Würde das so funktionieren, wie ich es erwarte? Ist es eine vernünftige Optimierung oder würde der Compiler genauso schnellen Code erstellen?

Answer 1

Lassen Sie uns sagen, dass wir std::string nur wickeln und eine vereinfachte Version von operator+ tun:

struct C { 
    std::string val; 

    C&& operator+(const C& rhs) && { 
     val += rhs.val; 
     return std::move(*this); 
    } 

    std::string::iterator begin() { return val.begin(); } 
    std::string::iterator end() { return val.end(); } 
}; 

Damit das funktioniert gut:

for (char c : C{"hello"}) { .. } 

der Bereich-für-Expression wird die Lebensdauer des verlängern vorübergehend, also sind wir in Ordnung. Aber bedenken Sie:

for (char c : C{"hello"} + C{"goodbye"}) { .. } 

Wir haben effektiv:

auto&& __range = C{"hello"}.operator+(C{"goodbye"}); 

Hier wir keine temporäre auf eine Referenzbindung. Wir binden eine Referenz. Das Objekt wird nicht verlängert, weil ... es kein Objekt ist. Wir haben also eine freie Referenz und ein undefiniertes Verhalten. Dies wäre sehr überraschend für Benutzer, die diese Arbeit erwarten:

for (char c : std::string{"hello"} + std::string{"goodbye"}) { .. } 

Sie würden einen Wert zurückgeben haben:

C operator+(const C& rhs) && { 
    val += rhs.val; 
    return std::move(*this); 
} 

, das dieses Problem löst (wie jetzt wir temporäre Erweiterung haben), und wenn das Verschieben Ihrer Objekte billiger ist als das Kopieren, ist das ein Gewinn.