C++11. Der Leitfaden für Programmierer zum neuen Standard. Rainer Grimm. An imprint of Pearson

Transkript

1

2 Rainer Grimm C++11 Der Leitfaden für Programmierer zum neuen Standard An imprint of Pearson München Boston San Francisco Harlow, England Don Mills, Ontario Sydney Mexico City Madrid Amsterdam

3 Kapitel 7 Entwurf von Klassen // well-formed: f override Base::f 27 virtual void f() override; // well-formed: a new (final) virtual method 30 virtual void g(long) final; // ill-formed: base method declared final 33 virtual void h(int); // well-formed: a new virtual function 36 virtual void h(double); }; int main(){ Base base; 43 Derived derived; } Listing 7.18: Die Identifier override und final Kernsprache: virtualfunctionsoverride.cpp Genaueres Studium des Listing 7.18 zeigt, dass das beabsichtigte, aber falsche Erklären neuer virtueller Methoden oder auch das unbeabsichtigte Überschreiben von Methoden der Klassenhierarchie, die als final deklariert wurden, deutlich schwieriger ist. Denn der Compiler prüft nicht nur den Namen, sondern auch die Parameter (Zeile 18), den Rückgabetyp (Zeile 24) und die const-zusicherung der Methode (Zeile 21). Genau dies moniert der GCC 4.7. Abbildung 7.5: Irrtümliches Überschreiben von virtuell erklärten Methoden 166

4 Explizite Klassendefinitionen Die Geschichte mit final ist noch nicht zu Ende. Durch den Identifier final kann eine Klasse als final wie auch unter Java ausgezeichnet werden. Dadurch ist es nicht mehr möglich, von dieser abzuleiten. final class struct Base final { }; struct Derived : Base { }; Listing 7.19: final-klasse Das Übersetzen des kleinen Codeschnipsels in final-klasse quittiert der Compiler mit einer eindeutigen Fehlermeldung in Abbildung 7.6. Abbildung 7.6: Ableiten einer als final deklarierten Klasse 1. Verwenden Sie für die Implementierung der Template-Methode die Identifier final und override. AUFGABE Die Schablonenmethode (template method) gibt eine Ablaufstruktur für eine Familie von Algorithmen vor, die aus mehreren Einzelschritten besteht. Während die Reihenfolge der Einzelschritte feststeht, hängt die Logik der Einzelschritte von dem konkreten Algorithmus ab. Die Details zur Schablonenmethode lassen sich unter Wikipedia (Schablonenmethode, 2011) nachlesen. Entwerfen Sie eine abstrakte Basisklasse Sort, die eine Methode process- Data besitzt. Es soll verhindert werden, dass die Methode überschrieben wird, und die Methode soll die virtuellen Methoden readdata, sortdata und writedata in dieser Reihenfolge aufrufen. Während die Basisklasse Sort einfache Implementierungen für readdata und writedata vorhält, soll die Methode sortdata rein virtuell sein. Implementieren und instanziieren Sie eine Dummyklasse QuickSort, um Ihren Entwurf zu testen. Implementieren Sie dazu auch die zwei Methoden readdata und writedata. Stellen Sie sicher, dass die Methoden die Methoden der Basisklasse Sort überschreiben. Kernsprache: Aufgaben: sort.cpp Expliziter Konvertierungsoperator Beim Entwurf der Klasse MyClass stehen dem C++-Entwickler zwei Wege offen, die Konvertierung seines Datentyps MyClass in einen fremden Datentyp anzubieten. Über einen Konvertierungskonstruktor wird der fremde Datentyp zu MyClass konvertiert. Über einen Konvertierungsoperator wird Konvertierungskonstruktor und Konviertierungsoperator 167

5 Kapitel 7 Entwurf von Klassen MyClass in einen fremden Datentyp konvertiert. Abbildung 7.7 stellt diese beiden Richtungen exemplarisch dar. Abbildung 7.7: Konvertierungskonstruktor und Konvertierungsoperator Listing 7.20 zeigt die zwei Richtungen in Anwendung. convertimplicit.cpp 01 class A{}; class B{}; class MyClass{ 06 public: 07 MyClass(){} 08 MyClass(A){} 09 operator B(){ return B(); } 10 }; void needmyclass(myclass){}; 13 void needb(b){}; int main(){ // A -> MyClass 18 A a; // explicit invocation 21 MyClass myclass1(a); 22 // implicit conversion from A to MyClass 23 MyClass myclass2= a; 24 needmyclass(a); // MyClass -> B 27 MyClass mycl; // explicit invocation 30 B b1(mycl); 31 // implicit conversion from MyClass to B 32 B b2= mycl; 33 needb(mycl); } Listing 7.20: Implizite Konvertierung erlaubt 168

6 Explizite Klassendefinitionen Kernsprache: convertimplicit.cpp Da die heimliche Konvertierung nicht immer erwünscht ist, lässt sich durch die Angabe des Schlüsselworts explicit die implizite Konvertierung nach MyClass in den Zeilen 23 und 24 unterbinden. Leider ist die Angabe des Schlüsselworts explicit im aktuellen C++-Standard nur für den Konvertierungskonstruktor möglich, aber nicht für den Konvertierungsoperator. Damit lassen sich die Aufrufe in Zeile 32 und 33 nicht verhindern. Mit C++11 wurde diese Asymmetrie beseitigt. Sowohl der Konvertierungskonstruktor als auch der Konvertierungsoperator von MyClass sind explicit deklariert (Listing 7.21). 01 class A{}; class B{}; class MyClass{ 06 public: 07 MyClass(){} 08 explicit MyClass(A){} // since C explicit operator B(){} // new with C }; void needmyclass(myclass){}; 13 void needb(b){}; int main(){ // A -> MyClass 18 A a; // explicit invocation 21 MyClass myclass1(a); 22 // implicit conversion from A to MyClass 23 MyClass myclass2= a; 24 needmyclass(a); // MyClass -> B 27 MyClass mycl; // explicit invocation 30 B b1(mycl); 31 // implicit conversion from MyClass to B 32 B b2= mycl; 33 needb(mycl); } Listing 7.21: Implizite Konvertierung nicht erlaubt convertexplicit.cpp 169

7 Kapitel 7 Entwurf von Klassen Kernsprache: convertexplicit.cpp Die entscheidenden Zeilen im Listing 7.21 sind die Schlüsselwörter explicit in Zeile 8 und 9. Sie führen dazu, dass das Programm nicht mehr kompiliert. Abbildung 7.8: Fehlerhafte Übersetzung bei Verwendung des Schlüsselworts explicit bool Die Konvertierung nach bool mit dem expliziten Konvertierungsoperator verhält sich besonders. So ignoriert der Compiler das Schlüsselwort explicit, damit der Datentyp in Ausdrücken verwendet werden kann, die zu den Wahrheitswerten true oder false evaluiert werden. Eine implizite Konvertierung nach int führt der C++-Compiler hingegen nicht durch (Listing 7.22). 01 struct MyBool{ 02 explicit operator bool(){return true;} 03 }; int main(){ MyBool myb; if (myb){}; 10 int a= (myb)? 3: 4; 11 int b= myb + a; } Listing 7.22: Sonderfall Datentyp bool 170

8 Explizite Klassendefinitionen Kernsprache: bool.cpp explicit operator bool() in Zeile 2 bewirkt, dass der arithmetische Ausdruck in Zeile 11 nicht gültig ist. Der Bezeichner explicit besitzt keinen Einfluss auf die implizite Konvertierung in den Zeilen 9 und 10 nach bool. Abbildung 7.9: Keine implizite Arithmetik mit dem Datentyp bool 1. Überprüfen Sie Ihren Sourcecode auf implizite Konvertierungen. Durchsuchen Sie Ihren Sourcecode auf die Definition nicht expliziter Konvertierungskonstruktoren und Konvertierungsoperatoren. Entscheiden Sie für jede dieser impliziten Konvertierungsfunktionen, ob diese Eigenschaft beabsichtigt ist. Falls die implizite Konvertierung nicht unterstützt werden soll, verwenden Sie das Schlüsselwort explicit. Übersetzen Sie das Programm, so dass der Compiler implizite Konvertierungen im Sourcecode entdeckt. 2. Wie erreichen Sie, dass der Code in Listing 2.22 gültig ist, obwohl Sie den Konvertierungsoperator nach bool als explicit erklärt haben. Kernsprache: Aufgaben: explicitconvertoperator.cpp AUFGABE 171

9

10 8 Rvalue-Referenzen Rvalue-Referenzen, in Tour de C++11 eingeführt, sind die Grundlage für zwei mächtige Features: Move-Semantik und Perfect Forwarding. Während die Move-Semantik es dem C++11-Autor erlaubt, an der Performance- Schraube seiner Anwendung massiv zu drehen, löst Perfect Forwarding das bekannte Problem in C++, Argumente generisch an eine Funktion durchzureichen, ohne ihre Lvalue- und Rvalue-Eigenschaften zu verändern. Lvalue versus Rvalue EXKURS Die klassische Definition von Lvalue und Rvalue als Werte, die auf der linken bzw. der rechten Seite einer Zuweisung stehen dürfen, ist nicht besonders hilfreich, denn konstante Objekte sind auch Lvalues. Diese können aber nicht auf der linken Seiten einer Zuweisung stehen. Besser ist es da schon, Lvalue als Ausdruck zu interpretieren, von dem die Adresse bestimmt werden kann. Damit lässt er sich potenziell zuweisen. Ein Rvalue hingegen kann nur gelesen werden.

11 Kapitel 8 Rvalue-Referenzen EXKURS Gerne werden Rvalues auch als temporäre Objekte bezeichnet. Ein paar Beispiele für Lvalue und Rvalue: Zuerst definiere ich zwei Funktionen int& getthree() und int getfour(). int three= 3; int& getthree(){ return three;} int getfour(){return 4;}»» Lvalue int i= 1; int& lvalueref= i; getthree()= 4; // three == 4»» Rvalue int rvalue= getfour(); rvalue= 5; auto func= []{std::cout << 2011 << std::endl;}; Sowohl i, lvalueref als auch getthree() sind Lvalues. Hingegen sind get- Four(), 5 und die Lambda-Funktion Rvalues. Lvalue- und Rvalue-Referenz Lvalue- und Rvalue-Referenzen sind Referenzen auf Lvalues bzw. Rvalues. Eine Lvalue-Referenz wird dadurch erzeugt, dass ein & hinter dem Datentyp platziert wird. Zwei && hingegen definieren eine Rvalue-Referenz (Listing 8.1). MyData mydata; MyData& mydatalvalue= mydata; MyData&& mydatarvalue(mydata()); Listing 8.1: Definition einer Lvalue- und Rvalue-Referenz PRAXISTIPP Rvalue-Referenzen sind spezielle Referenzen. Rvalue-Referenzen verhalten sich wie die bekannten Lvalue-Referenzen. Sie müssen initialisiert werden und können nicht nachträglich auf ein anderes Objekt verweisen. Wird eine Funktion definiert, die ihre Argumente per Lvalue- und Rvalue- Referenz annimmt, entscheidet der Compiler, welche Funktion verwendet wird. Das Entscheidungskriterium für den Compiler ist, ob das Argument ein Lvalue oder Rvalue ist (Listing 8.2). Da das Argument in Zeile 21 ein Lvalue ist und das in den Zeilen 22 und 23 jeweils ein Rvalue, wird die entsprechende Funktion function in Listing 8.2 aufgerufen, die das Argument als Lvalue- oder Rvalue-Referenz bindet. rvaluereference.cpp 01 #include <algorithm> 02 #include <iostream> 03 #include <string>

12 Rvalue-Referenzen 05 struct MyData{}; std::string function( MyData & ) { 08 return "lvalue reference"; 09 } std::string function( MyData && ) { 12 return "rvalue reference"; 13 } int main(){ std::cout << std::endl; MyData myd; std::cout << "function(myd): " << function(myd) << std::endl; 22 std::cout << "function(mydata()): " << function(mydata()) << std::endl; 23 std::cout << "function(std::move(myd)): " << function(std::move(myd)) << std::endl; std::cout << std::endl; } Listing 8.2: Lvalue- und Rvalue-Referenz Kernsprache: rvaluereference.cpp Der Aufruf in Zeile 23 function(std::move(myd)) ist der interessanteste, denn durch das neue C++11-Funktions-Template std::move wird aus dem Lvalue ein Rvalue. Dies zeigt die Ausgabe. Abbildung 8.1: Binden einer Lvalue- und Rvalue-Referenz std::move ist eine wichtige Funktion, wenn es darum geht, die Move- Semantik in C++11 umzusetzen. Dazu bald mehr. 175

13 Copyright Daten, Texte, Design und Grafiken dieses ebooks, sowie die eventuell angebotenen ebook-zusatzdaten sind urheberrechtlich geschützt. Dieses ebook stellen wir lediglich als persönliche Einzelplatz-Lizenz zur Verfügung! Jede andere Verwendung dieses ebooks oder zugehöriger Materialien und Informationen, einschließlich der Reproduktion, der Weitergabe, des Weitervertriebs, der Platzierung im Internet, in Intranets, in Extranets, der Veränderung, des Weiterverkaufs und der Veröffentlichung bedarf der schriftlichen Genehmigung des Verlags. Insbesondere ist die Entfernung oder Änderung des vom Verlag vergebenen Passwortschutzes ausdrücklich untersagt! Bei Fragen zu diesem Thema wenden Sie sich bitte an: Zusatzdaten Möglicherweise liegt dem gedruckten Buch eine CD-ROM mit Zusatzdaten bei. Die Zurverfügungstellung dieser Daten auf unseren Websites ist eine freiwillige Leistung des Verlags. Der Rechtsweg ist ausgeschlossen. Hinweis Dieses und viele weitere ebooks können Sie rund um die Uhr und legal auf unserer Website herunterladen: