Meeting C++ C++11 R-Value Referenzen

Transkript

1 Meeting C++ Detlef Wilkening Inhalt Motivation L-Values und R-Values R-Value Referenzen Move Semantik std::move Funktionen mit R-Value-Referenz Parametern Fazit Fragen 1

2 Motivation Einer der Haupt-Performance Probleme in C++ sind Kopien Überflüssige Kopien An vielen Stellen werden Kopien erzeugt Auch viele Stellen, an denen es der Einsteiger nicht erwartet Und Kopien können teuer sein Beispiele: Zeichenketten-Literal in Vektor rein pushen Vektor Reallokation Swap Funktion String Addition 2

3 Zeichenketten-Literal in Vektor rein pushen vector<string> v; v.push_back("c++"); Vektor Reallokation 3

4 Swap Funktion 1/6 Typische alte Implementierung Bilder siehe folgende 5 Folien void swap(t& lhs, T& rhs) T temp(lhs); lhs = rhs; rhs = temp; Swap Funktion 2/6 4

5 Swap Funktion 3/6 Swap Funktion 4/6 5

6 Swap Funktion 5/6 Swap Funktion 6/6 C + + B o o s t B o o s t string string C + + swap( string& lhs, string& rhs ) C + + string temp 6

7 String Addition 1/2 Bild siehe nächste Folie string operator + (const string&, const string&); string operator + (const string&, const char*); string s1("s1"); string s2("s2"); string s = s1 + "und" + s2; String Addition 2/2 7

8 Alle diese Beispiele zeichnen sich dadurch aus: Das Kopien angelegt werden Und die Kopien unter Umständen sehr teuer sind Z.B. bei Containern, Strings, Und die Kopien eigentlich gar nicht notwendig sind Warum sind die Kopien nicht notwendig? Die Originale werden danach gelöscht Effizienter wäre es, wenn man ihren Inhalt einfach "weiterverwenden" und/oder "moven" hätte können Siehe Bilder auf den nächsten Folien Zeichenketten-Literal in Vektor rein pushen Der Performance-Traum vom Moven vector<string> v; v.push_back("c++"); 8

9 Vektor Reallokation Der Performance-Traum vom Moven Swap Funktion 1/5 Bilder vom Move Performance-Traum auch auf den nächsten Folien 9

10 Swap Funktion 2/5 Swap Funktion 3/5 10

11 Swap Funktion 4/5 Swap Funktion 5/5 11

12 String Addition Der Performance-Traum vom Moven string s = s1 + "und" + s2; Wann macht moven Sinn? Die logischen Objekte haben Daten ausserhalb liegen Ausserhalb dem primären Speicherbereichs des Objektes Diese Daten müssen synchron zum Objekt gehandelt werden Typische Anzeichen für diese Objekte: Destruktor Kopier-Konstruktor Kopier-Zuweisungs-Operator Also: Regel der 3 Bei Objekten, die z.b. nur aus int bestehen, ist moven wie kopieren 12

13 L- und R-Values Was sind L-Values und R-Values? Es gibt eine einfache und eine exaktere Erklärung Zuerst die einfache Erklärung Sie reicht für viele Dinge quasi als Pi*Daumen Regel Alles was auf der linken Seite einer Zuweisung stehen kann, ist ein L-Value, der Rest ist ein R-Value. int n, n1, n2; n = n1 + n2; // Okay, n ist ein L-Value 3 = n1 + n2; // Fehler 3 ist R-Value 13

14 L-Values sind Objekte, die nach dem Anweisungs-Ende noch existieren Variablen, aber auch z.b. dereferenzierte Zeiger Elemente in Arrays oder Containern Funktions-Aufrufe, die eine Referenz zurückgeben, z.b. vector[idx], ++n R-Values sind Objekte, die nach dem Anweisungs-Ende (Semikolon) nicht mehr da sind Literale, z.b. 42 Funktions-Aufrufe, die eine Kopie zurückgeben, z.b. s1+s2, n++ Temporäre Objekte, z.b. string("temp") Hilfsregeln Hat es einen Namen? Wenn ja, dann ist es ein L-Value Wenn nein, dann ist es vielleicht ein R-Value Kann man die Adresse davon bekommen? Wenn ja, dann ist es ein L-Value Wenn nein, dann ist es ein R-Value Der Standard sagt: Die Adresse eines persistenten Objekts ist sinnvoll Die eines temporären Objekts ist gefährlich Achtung dies heißt nicht, dass man nicht über Tricks an die Adresse kommen kann. Aber eben nicht durch direkte Anwendung von & Oder temporäre Objekte nicht explizit ändern kann 14

15 Hinweis schon mal für später (Perfect Forwarding): Objekte mit Namen sind L-Values Also sind auch R-Value Referenz Variablen L-Values, denn sie haben einen Namen! R-Value Referenzen 15

16 R-Value Referenzen sind Referenzen, die an R-Values binden können Werden mit && definiert Es sind weiterhin normale Referenzen Müssen initialisiert werden Sind abhängig, dass die referenzierten Objekte lange genug leben Es kann const R-Value Referenzen geben Sind aber sehr ungewöhnlich Aber sie binden eben an R-Values Die alten C++03 Referenzen heißen nun L-Value Referenzen Non-Const L-Value Referenzen können nicht an R-Values binden void fct(string&); fct("c++"); // Fehler, da R-Value void fct(const string&); fct("c++"); // okay void fct(string&&); fct("c++"); // okay 16

17 L- und R-Values haben ein unterschiedliches Verhalten bei Der Initialisierung Beim Überladen Initialisierung Welche Referenz bindet an welche Values? & const & && const && L-Value x x x x const L-Value x x R-Value x x x const R-Value x x Zwei einfache Regeln Const muß respektiert werden Kein versehentliches Ändern von temporären Objekten 17

18 string mod_lval("c++"); const string const_lval("boost"); string mod_rval() return "STL"; const string const_rval() return "R-Value"; string& lr1 = mod_lval; string& lr2 = const_lval; string& lr3 = mod_rval(); string& lr4 = const_rval(); // Okay // Fehler // Fehler // Fehler const string& clr1 = mod_lval; const string& clr2 = const_lval; const string& clr3 = mod_rval(); const string& clr4 = const_rval(); // Okay // Okay // Okay // Okay 18

19 string&& rr1 = mod_lval; string&& rr2 = const_lval; string&& rr3 = mod_rval(); string&& rr4 = const_rval(); // Okay // Fehler // Okay // Fehler const string&& crr1 = mod_lval; const string&& crr2 = const_lval; const string&& crr3 = mod_rval(); const string&& crr4 = const_rval(); // Okay // Okay // Okay // Okay Überladen Welche Funktion wird von welchem Wert aufgerufen 2 Situationen Alle 4 Varianten überladen Diese Situation hat mehr theoretischen Wert Nur 2 Varianten überladen (const L-Value und R-Value Referenz) Dies ist die typische Situation in der Praxis 3 Regeln: L-Values binden lieber an L-Value Referenzen R-Values binden lieber an R-Value Referenzen Const muß respektiert werden 19

20 string mod_lval("c++"); const string const_lval("boost"); string mod_rval() return "STL"; const string const_rval() return "R-Value"; void overload(string& s)... void overload(const string& s)... void overload(string&& s)... void overload(const string&& s)... overload(mod_lval); overload(const_lval); overload(mod_rval); overload(const_rval); // => overload(string&) // => overload(const string&) // => overload(string&&) // => overload(const string&&) 20

21 void overload(const string& s)... void overload(string&& s)... overload(mod_lval); overload(const_lval); overload(mod_rval); overload(const_rval); // => overload(const string&) // => overload(const string&) // => overload(string&&) // => overload(const string&) Praktische Variante überladen auf const & && Nur modifizierbare R-Values binden an R-Value Referenzen Alles anderen Argumente binden an L-Value Referenzen Aber die modifizierbaren R-Values sind ja auch die, die überflüssige Kopien sind Die Regeln erlauben das Erkennen überflüssige Kopien durch den Compiler (zumindest zum Teil z.b. swap nicht) Dies ist die Grundlage der Move-Semantik 21

22 Noch eine Regel, bevor es weitergeht... Wenn Funktionen Wert-Rückgaben (Kopien) machen Dann sind dies überflüssige Kopien Wenn die Funktionen "const Typ" zurückgeben, dann bindet das nicht an R-Value Referenzen Dann kann keine Move-Semantik zuschlagen => Also sollten Funktionen nie Const-Wert-Rückgaben machen Move Semantik 22

23 Wie implementiert man nun eine Move-Semantik? Erkennen können wir Moveable Objekte durch R-Value Referenzen Implementiert werden muß: Move-Konstruktor Move-Zuweisungs-Operator = Beispiel Klasse mit einem dynamisch allokierten Integer Nicht sehr realistisch, aber schön einfach Realistisch wäre z.b. eine String-Klasse Auf den folgenden Folien: Erstmal die normale Implementierung Ohne Smart-Pointer, schön einfach Dann die Move-Semantik class DynamicInteger public: explicit DynamicInteger(int arg=0); DynamicInteger(const DynamicInteger& other); DynamicInteger& operator=(const DynamicInteger& other); ~DynamicInteger(); private: ; int* p; 23

24 DynamicInteger::DynamicInteger(int arg) p = new int(arg); DynamicInteger::DynamicInteger(const DynamicInteger& other) if (other.p) p = new int(*other.p); else p = 0; 24

25 DynamicInteger& DynamicInteger::operator=(const DynamicInteger& other) if (this==&other) return *this; delete p; // Hier könnte man p weiterverenden... // aber es geht um s Prinzip if (other.p) p = new int(*other.p); else p = 0; return *this; DynamicInteger::~DynamicInteger() delete p; 25

26 DynamicInteger create(int arg) return DynamicInteger(arg); // Mit RVO int main() // Int-Konstruktor mit 0 // Int-Konstruktor mit 42 DynamicInteger d1; // Kopier-Zuweisungs-Operator 42 d1 = create(42); // Destruktor: 42 // Destruktor: 42 Und nun zusätzlich mit Move-Semantik 26

27 class DynamicInteger public: explicit DynamicInteger(int arg=0); DynamicInteger(const DynamicInteger& other); DynamicInteger(DynamicInteger&& other); DynamicInteger& operator=(const DynamicInteger& other); DynamicInteger& operator=(dynamicinteger&& other); ~DynamicInteger(); private: int* p; ; DynamicInteger::DynamicInteger(DynamicInteger&& other) p = other.p; other.p = 0; 27

28 DynamicInteger& DynamicInteger::operator=(DynamicInteger&& other) if (this == &other) return *this; delete p; p = other.p; other.p = 0; return *this; DynamicInteger create(int arg) return DynamicInteger(arg); // Mit RVO int main() // Int-Konstruktor mit 0 // Int-Konstruktor mit 42 DynamicInteger d1; // Move-Zuweisungs-Operator 42 d1 = create(42); // Destruktor: null // Destruktor: 42 28

29 Move-Semantik Das Ziel-Objekt stiehlt beim moven die Daten vom Quell-Objekt und nullt sie Der Destruktor des Quell-Objektes hat dann nichts mehr zu tun. Achtung Der Move-Zuweisungs-Operator benötigt wie auch der Kopier-Konstruktor Überprüfung auf Zuweisung auf sich selbst Move-Konstruktoren und Move-Zuweisungs-Operatoren sollen keine Exceptions werfen Dies ist machbar, da man ja nur elementare und Zeiger-Typen verschiebt Nutzen Sie in C++11 das neue Schlüsselwort noexcept Automatische Erzeugung von Funktionen Die Regeln für die automatische Erzeugung von Funktionen (implizite Funktionen) werden vom Move-Konstruktor und dem Move-Zuweisungs- Operator nur bzgl. implizitem Standard-Konstruktor beeinflußt: Move-Konstruktor und Move-Zuweisungs-Operatoren werden niemals implizit erzeugt Jeder manuelle Konstruktor verbietet den automatischen Standard- Konstruktor auch der Move-Konstruktor. Der implizite Kopier-Konstruktor wird nicht vom Move-Konstruktor beeinflußt Sondern weiterhin nur durch manuelle Kopier-Konstruktoren Der implizite Kopier-Zuweisungs-Operator wird nicht vom Move- Zuweisungs-Operatore beeinflußt Sondern weiterhin nur durch den manuellen Kopier-Zuweisungs-Operator 29

30 std::move Okay, Literal per push_back in den Vektor ist jetzt effizient Aber was ist mit swap? Die überflüssige Kopie ist nicht weg! void swap(t& lhs, T& rhs) T temp(lhs); lhs = rhs; rhs = temp; 30

31 Problem lhs und rhs sind L-Values L-Values werden kopiert Move-Semantik kann nicht zuschlagen Lösung Mache L-Value explizit zu R-Value Wenn Move-Semantik vorhanden => dann wird gemovt Wenn keine Move-Semantik => dann wird kopiert R-Values binden auch an Const L-Value-Referenzen void swap(t& lhs, T& rhs) T temp(lhs); lhs = rhs; rhs = temp; Explizit L-Values zu R-Values machen std::move Aber Achtung das Quell-Objekt wird genullt Es ist hinterher also leer Hinweis statt move geht auch static_cast<src&&>(src); void swap(t& lhs, T& rhs) T tmp(std::move(lhs)); lhs = std::move(rhs); rhs = std::move(tmp); 31

32 std::move ist die Lösung für explizites Moven Immer wenn Sie moven könnten, falls Move-Semantik implementiert ist und sie ein L-Value haben Nutzen Sie std::move Aus dem Header <utility> Jetzt wissen wir auch, wie man Move-Semantik für Klassen mit Move-Semantik Attributen implementiert Der Compiler erzeugt nie Move-Funktionen Move-Konstruktor Move-Zuweisungs-Operator Move-Semantik muß immer manuell programmiert werden Klasse mit Movable-Member sollten selber movable sein Move-Semantik manuell implementieren 32

33 class DynamicPoint public: DynamicPoint(int xarg, int yarg) : x(xarg), y(yarg) DynamicPoint(DynamicPoint&& other); DynamicPoint& operator=(dynamicpoint&& other); // Weiteres... private: DynamicInteger x; DynamicInteger y; ; DynamicPoint::DynamicPoint(DynamicPoint && other) : x(std::move(other.x)), y(std::move(other.y)) DynamicPoint& DynamicPoint::operator=(DynamicPoint && other) x = std::move(other.x); y = std::move(other.y); return *this; 33

34 R-Value-Referenz Parameter Benötigt man R-Value Referenzen für Funktions-Parameter? Eher selten Meist reicht es, sich auf auf die Move-Semantik der Klassen zu verlassen Außer Ihre Funktion kann einen Vorteil aus dem expliziten Gebrauch von modifizierbaren R-Values ziehen. Beispiel: String-Addition Hier z.b. die Addition von temp(sl+ und ) und sr. string s, sl, sr; s = sl + "und" + sr; 34

35 string operator+(const string&, const string&); string operator+(const string&, const char*); string operator+(string&& lhs, const string& rhs) lhs += rhs; return lhs; // Nutzt lhs statt neuen String anzulegen string s, sl, sr; s = sl + "und" + sr; 35

36 Und R-Value-Referenzen als Funktions-Rückgaben? Tendenziell eher nicht sinnvoll Auch R-Value-Referenzen sind Referenzen Probleme mit der Lebensdauer sind vorprogrammiert Eher auf RVO, NRVO und Move-Semantik verlassen Aber prinzipiell möglich ist es Vielleicht gibt es wirklich Sonder-Sonder-Sonderfälle, wo das sinnvoll ist Fazit 36

37 Was fehlte? Viele Details Vor allem aber Perfect Forwarding Perfect Forwarding Ermöglicht in Funktions-Template die optimale Weiterleitung von Argumenten Const L-Value Referenz L-Value Referenz R-Value Referenz Der Compiler sucht nach Regeln die richtige Referenz aus Ermöglicht perfekte Factory Funktionen R-Value Referenzen sind nicht ganz trivial, aber R-Value Referenzen sind ein großer Schritt Kopien zu vermeiden Die C++11 Standard-Bibliothek nutzt sie überall Ein Umstieg auf C++11 bringt häufig schon einen Performance-Boost Spezielle Programme bringen es locker auf einen Faktor 10 Normale reale Programme von mir liegen zwischen Faktor 1 bis 1,8 37

38 Bibliotheks-Entwickler sollten R-Value Referenzen beherrschen und nutzen Move-Semantik in Bibliotheks-Klassen ermöglicht transparente Nutzung Für Einsteiger gibt es sicher wichtigere Themen C++ ist groß und hat viele wichtige Themen Aber schon der professionelle Programmierer sollte sie kennen Move-Semantik in eigene Klassen einbringen std::move nutzen Perfect-Forwarding in Factory-Funktionen Fragen? 38