C++ mit Visual Studio 2019: C++17 für Studierende und erfahrene Programmierer [1. Aufl.] 9783662594759, 9783662594766

Table of contents :
Front Matter ....Pages i-xx
Die Entwicklungsumgebung (Richard Kaiser)....Pages 1-32
Elementare Datentypen und Anweisungen (Richard Kaiser)....Pages 33-199
Die Stringklassen: string, wstring usw. (Richard Kaiser)....Pages 201-242
Arrays und Container (Richard Kaiser)....Pages 243-265
Einfache selbstdefinierte Datentypen (Richard Kaiser)....Pages 267-277
Zeiger, dynamisch erzeugte Variablen und smart pointer (Richard Kaiser)....Pages 279-326
Überladene Funktionen und Operatoren (Richard Kaiser)....Pages 327-360
Objektorientierte Programmierung (Richard Kaiser)....Pages 361-540
Namensbereiche (Richard Kaiser)....Pages 541-554
Exception-Handling (Richard Kaiser)....Pages 555-589
Containerklassen der C++-Standardbibliothek (Richard Kaiser)....Pages 591-645
Dateibearbeitung mit den Stream-Klassen (Richard Kaiser)....Pages 647-676
Funktoren, Funktionsobjekte und Lambda-Ausdrücke (Richard Kaiser)....Pages 677-702
Templates (Richard Kaiser)....Pages 703-772
STL-Algorithmen und Lambda-Ausdrücke (Richard Kaiser)....Pages 773-828
Zeiten und Kalenderdaten mit chrono (Richard Kaiser)....Pages 829-839
Multithreading (Richard Kaiser)....Pages 841-902
Smart Pointer: shared_ptr, unique_ptr und weak_ptr (Richard Kaiser)....Pages 903-924
Back Matter ....Pages 925-947

Citation preview

Richard Kaiser

C++ mit Visual Studio 2019 C + +17 f ü r S t u d i e r e n d e u n d erfa hrene Programmierer

C++ mit Visual Studio 2019

Richard Kaiser

C++ mit Visual Studio 2019 C++17 für Studierende und erfahrene Programmierer

Prof. Richard Kaiser Tübingen, Deutschland

ISBN 978-3-662-59475-9 ISBN 978-3-662-59476-6  (eBook) https://doi.org/10.1007/978-3-662-59476-6 Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. © Springer-Verlag GmbH Deutschland, ein Teil von Springer Nature 2021 Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht ausdrücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags. Das gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen. Die Wiedergabe von allgemein beschreibenden Bezeichnungen, Marken, Unternehmensnamen etc. in diesem Werk bedeutet nicht, dass diese frei durch jedermann benutzt werden dürfen. Die Berechtigung zur Benutzung unterliegt, auch ohne gesonderten Hinweis hierzu, den Regeln des Markenrechts. Die Rechte des jeweiligen Zeicheninhabers sind zu beachten. Der Verlag, die Autoren und die Herausgeber gehen davon aus, dass die Angaben und Informationen in diesem Werk zum Zeitpunkt der Veröffentlichung vollständig und korrekt sind. Weder der Verlag, noch die Autoren oder die Herausgeber übernehmen, ausdrücklich oder implizit, Gewähr für den Inhalt des Werkes, etwaige Fehler oder Äußerungen. Der Verlag bleibt im Hinblick auf geografische Zuordnungen und Gebietsbezeichnungen in veröffentlichten Karten und Institutionsadressen neutral. Planung: Martin Börger Springer Vieweg ist ein Imprint der eingetragenen Gesellschaft Springer-Verlag GmbH, DE und ist ein Teil von Springer Nature. Die Anschrift der Gesellschaft ist: Heidelberger Platz 3, 14197 Berlin, Germany

Für Daniel, Alex, Kathy Emelie, Jonathan, Maximilian, Leonard und Matilda

Vorwort

C++ hat sich in den letzten Jahren rasant entwickelt: Die Neuerungen von C++11, C++14, C++17 und C++20 haben viele Verbesserungen und neue Möglichkeiten gebracht. Vieles, was 2010 noch gut und empfehlenswert war, kann heute besser und sicherer gemacht werden. Das merkt man als Buchautor und Trainer, der diese ganze Entwicklung begleitet hat, besonders deutlich: Vieles, was man früher einmal geschrieben hat, sollte man heute anders machen. Zwar würde es immer noch kompiliert werden. Aber es ist kein modernes C++ mehr, das dem aktuellen Stand der Technik entspricht und alle Vorteile nutzt. Dieses Buch stellt C++ auf dem Stand von Visual Studio 2019 im Mai 2020 vor. Das ist nicht nur der Umfang von C++17, sondern auch schon ein Teil von C++20. Auch wenn Module, concepts, std::span und der dreifache Vergleichsoperator noch nicht vollständig verfügbar sind, kann man die wichtigsten Vorteile schon jetzt zeigen. Wenn der Leser dieses Buch dann in einem oder zwei Jahren in der Hand oder am Bildschirm hat, sieht er schon, wie man sie einsetzen kann. Dieses Buch entstand einerseits aus meinen Vorlesungen an der Dualen Hochschule Lörrach und andererseits aus zahlreichen Seminaren für Firmen, die sich an Software-Entwickler richten, die C++ professionell einsetzen. Dementsprechend richtet es sich einerseits an Studierende ohne Vorkenntnisse. Die Lernziele für diese Gruppe sind: – Modernes C++ auf dem Stand von 2020 zu lernen. C++ ist nach wie vor eine der am häufigsten eingesetzten Programmiersprachen. – Programmieren zu lernen, d.h. Programme zu schreiben, die konkrete, vorgegebene Aufgaben lösen. Das ist nur mit viel Übung möglich. Programmieren lernt man nur, indem man es tut. Deshalb enthält dieses Buch auch viele Übungsaufgaben. Es ist unerlässlich, zahlreiche Aufgaben selbständig zu lösen (das müssen nicht die aus diesem Buch sein). Der Schwierigkeitsgrad der Aufgaben reicht von einfachen Wiederholungen des Textes bis zu kleinen Projektchen, die ein gewisses Maß an selbständiger Arbeit erfordern. Die Lösungen der Aufgaben findet man auf https://www.rkaiser.de. – Eine moderne Entwicklungsumgebung kennen- und einsetzen lernen. Visual Studio ist das in der Industrie wohl am häufigsten eingesetzte Werkzeug zur Software-Entwicklung. – Man hört immer wieder, dass C++ zu schwierig ist, um damit das Programmieren zu lernen. Dieses Buch soll ein in vielen Jahren erprobtes Gegenargument zu dieser Meinung sein. Damit will ich die Komplexität von C++ nicht abstreiten. Aber wer C++ kann, findet sich leicht mit C#, Java usw. zurecht. Der umgekehrte Weg ist meist schwieriger.

viii Dieses Buch richtet sich aber ebenso an professionelle Software-Entwickler mit einer jahrelangen C++-Praxis. Viele C++-Neuerungen machen elementare Sprachkonzepte einfacher und sicherer. Dazu kommen anspruchsvollere Neuerungen, die bessere und effizientere Lösungen ermöglichen, die so vor einigen Jahren noch nicht möglich waren. Sowohl die einfachen als auch die anspruchsvolleren Möglichkeiten haben sich in der industriellen Praxis oft noch nicht herumgesprochen. Oft wird mit C++ noch wie vor 30 Jahren mit C programmiert. Das ist fehleranfällig, unnötig aufwendig und verschenkt Vorteile und Möglichkeiten. – Für professionelle Entwickler soll dieses Buch einen nahezu vollständigen Überblick über C++17 geben und die Sprachelemente so vorstellen, dass sie in der praktischen Arbeit eingesetzt werden können. Die Erfahrungen aus meinen Firmenseminaren geben mir die Hoffnung, dass die allermeisten Themen abgedeckt sind, die im industriellen Einsatz notwendig sind. – Da ausschließlich Standard-C++ behandelt wird, ist dieses Buch nicht auf Visual Studio beschränkt. Praktisch alle Ausführungen gelten für jeden standardkonformen C++Compiler (gcc, Intel, Embarcadero usw.). – Das moderne C++ bietet auch Programmierern von eingebetteten Anwendungen viele Vorteile gegenüber dem in diesem Anwendungsbereich verbreiteten C. Mit dem modernen C++ gibt es noch weniger Gründe als vorher, solche Anwendungen in C zu schreiben. – Professionelle Entwickler sollen sich nicht an den Übungsaufgaben stören. Sie haben schon genügend Aufgaben gemacht, sonst wären sie keine Profis geworden. Und außerdem bietet das Tagesgeschäft genügend Übungsaufgaben. Ich habe nicht nur versucht, die Sprachelemente anschaulich zu beschreiben, sondern auch Kriterien dafür anzugeben, wann und wie man sie sinnvoll einsetzen kann. Viele Empfehlungen aus style guides (z.B. der C++ Core Guidelines, siehe Abschnitt 2.13) sind in den Text eingearbeitet, ohne dass explizit darauf hingewiesen wird. Dieses Buch erscheint in zwei weitgehend identischen Ausgaben: – In der vorliegenden Ausgabe werden reine Standard-C++-Programme geschrieben, d.h. ohne graphische Benutzeroberfläche. Alle Ein- und Ausgaben erfolgen über die Konsole. – In der anderen Ausgabe „C++ mit Visual Studio 2019 und Windows-Forms-Anwendungen“ werden Programme mit einer grafischen Benutzeroberfläche geschrieben. Alle Ein- und Ausgaben erfolgen über eine Windows-Benutzeroberfläche. Der Unterschied zwischen den beiden Ausgaben ist meist nur, dass in „C++ mit Visual Studio 2019 und Windows Forms Anwendungen“ Ein- und Ausgaben über ein Windows-Steuerelement (meist eine TextBox) erfolgen textBox1->AppendText("Hello World");

während in „C++ mit Visual Studio 2019“ die Konsole verwendet wird: cout >“ definiert. Damit kann man einen Ausdruck (z.B. einen Text oder den Wert einer Variablen) an der Konsole ausgegeben. Mit endl wird ein Zeilenvorschub eingefügt, so dass die nächste Ausgabe in der nächsten Zeile beginnt. Fügt man die Anweisung cout y; cout -1" von links nach rechts.

8 Objektorientierte Programmierung

Bis ca. 1975 waren vordefinierte Datentypen wie int und double die überwiegend verwendeten Datentypen. Im Lauf der Zeit hat sich dann aber die Überzeugung durchgesetzt, dass bei komplexeren Aufgaben problemangemessene Datentypen besser sind. Da der Datentyp einer Variablen festlegt, welche Operationen mit dieser Variablen möglich sind, bietet ein problemangemessener Datentyp im Idealfall genau die Operationen, die für die Lösung des anstehenden Problems hilfreich sind. Bei der objektorientierten Programmierung werden Datentypen definiert, die Daten mit Funktionen für diese Daten zusammenfassen. Diese Funktionen sind dann die einzigen Operationen, die mit den Daten der Variablen möglich sind. Dadurch können unzulässige Operationen mit den Daten unterbunden werden. Objektorientierte Programmierung beruht vor allem auf den Konzepten Klasse, Objekt, Vererbung und Polymorphie. Diese finden sich in vielen modernen Programmiersprachen. – Eine Klasse definiert einen Datentyp. Meist fasst eine Klasse Daten und Funktionen zusammen und bringt so explizit zum Ausdruck, dass diese zusammengehören. Eine solche Zusammenfassung ist in nicht objektorientierten Sprachen in der Regel nicht möglich. – Vererbung ermöglicht die Konstruktion von neuen Klassen aus vorhandenen. Die neuen Klassen übernehmen die Elemente der Basisklassen und können zusätzliche Elemente haben. Auf diese Weise kann man eine Basisklasse als Baustein wiederverwenden. – Vererbung ist außerdem die Grundlage für Polymorphie. Dabei wird beim Aufruf einer Funktion aus einer Klassenhierarchie erst zur Laufzeit (und nicht schon bei der Kompilation) entschieden, welche Funktion aufgerufen wird. Nahezu alle anspruchsvollen und komplexen Programme (z.B. mit grafischen Benutzeroberflächen), Apps usw. verwenden heute die objektorientierte Programmierung. Ohne diese hätten sie kaum mit vertretbarem Aufwand realisiert werden. Damit Klassen hilfreich sind, müssen sie allerdings richtig entworfen sein. Es ist meist einfach, Klassen zu schreiben, die der Compiler ohne Fehlermeldung übersetzen kann. Schwieriger ist es dagegen, sie so zu gestalten, dass sie sich auch in späteren Phasen eines Projekts bewähren. Deshalb werden auch die Grundbegriffe der objektorientierten Analyse und des objektorientierten Designs behandelt. Dabei zeigt sich, dass man oft nur mit den erst in Abschnitt 8.4.9 behandelten abstrakten Basisklassen ein tragfähiges Konzept erhält. Die Dramaturgie vieler Beispiele und Aufgaben soll verschiedene Design-Alternativen und die Schwierigkeiten bei der Auswahl der richtigen zeigen. In Abschnitt 8.4.9 zeigt sich dann, dass alles doch nicht so schwierig ist, wie es zunächst gelegentlich ausgesehen haben mag. © Springer-Verlag GmbH Deutschland, ein Teil von Springer Nature 2021 R. Kaiser, C++ mit Visual Studio 2019, https://doi.org/10.1007/978-3-662-59476-6_8

362

Objektorientierte Programmierung

8.1 Klassen In der objektorientierten Programmierung ist ein Objekt eine Zusammenfassung von Daten und Funktionen. Dieser Begriff hat der objektorientierten Programmierung den Namen gegeben. In C++ ist ein Objekt eine Variable, deren Datentyp eine Klasse ist. Anstelle von Objekt sind auch die Bezeichnungen Klassenobjekt, Klasseninstanz oder Instanz verbreitet, die aber im Folgenden nicht verwendet werden. Zur Vermeidung von umständlichen Formulierungen werden Objekte auch als Variablen bezeichnet und umgekehrt, falls es nicht darauf ankommt, ob ein Datentyp eine Klasse ist. Die Syntax einer Klassendefinition ergibt sich aus den folgenden Regeln. Diese sind gegenüber dem C++-Standard stark vereinfacht, decken aber praktisch alle im Folgenden behandelten Fälle ab: class-specifier: class-head { member-specificationopt } class-head: class-key class-name class-virt-specifieropt base-clauseopt class-virt-specifier: final class-key: class struct union

Klassen werden meist mit dem Schlüsselwort class oder struct definiert. Anstelle von class oder struct kann man auch union verwenden. Bei mit union definierten Klassen sind allerdings zahlreiche Einschränkungen zu beachten. Deshalb werden solche Klassen im Rahmen der objektorientierten Programmierung nur selten verwendet und im Folgenden auch nicht weiter berücksichtigt. Auf class oder struct folgt dann der Name der Klasse (ein Bezeichner), eventuell final und eine Basisklasse. Danach werden in geschweiften Klammern die Elemente der Klasse angegeben. 8.1.1 Datenelemente und Elementfunktionen Die Elemente einer Klasse werden durch geschweifte Klammern zusammengefasst. class-specifier: class-head { member-specificationopt }

Zwischen den geschweiften Klammern können Elementdeklarationen und Zugriffsrechte (access-specifier) stehen:

8.1 Klassen

363

member-specification: member-declaration member-specificationopt access-specifier : member-specificationopt

Elemente können Funktionen, Datenelemente sowie weitere Deklarationen angegeben werden. member-declaration: decl-specifier-seqopt member-declarator-listopt ; function-definition

In der Programmiersprache C können mit struct (siehe Abschnitt 5.1) nur Datenelemente zusammengefasst werden. Da objektorientierte Programmierung aber durch die Zusammenfassung von Daten und Funktionen gekennzeichnet ist, werden hier vor allem Klassen definiert, die auch Funktionen enthalten. Eine Funktion, die zu einer Klasse gehört, wird als Elementfunktion (member function) bezeichnet. Beispiel: Die Klasse C2DPunkt soll einen zweidimensionalen Punkt darstellen. Sie fasst dessen Koordinaten x und y (Datenelemente) sowie die Funktionen Init, toStr und anzeigen zusammen. class C2DPunkt{ double x,y; void Init(double x_, double y_); string toStr(); void anzeigen(); }; // Semikolon am Ende einer Klasse notwendig

Anstelle von class kann bei einer Klassendefinition auch struct verwendet werden: struct C2DPunkt{ double x,y; void Init(double x_, double y_); string toStr(); void anzeigen(); }; // Semikolon am Ende einer Klasse notwendig

Die Unterschiede zwischen einer Klassendefinition mit struct und class werden in Abschnitt 8.1.3 beschrieben. Eine Klasse muss durch eine Semikolon abgeschlossen. Wie bei einer gewöhnlichen Funktion ist ein solches Semikolon am Ende einer Elementfunktion zulässig, aber nicht notwendig. Eine Elementfunktion kann innerhalb oder außerhalb der Klasse definiert werden. Wenn sie außerhalb der Klasse definiert wird, muss sie zuvor in der Klasse durch die Angabe ihres Prototyps deklariert werden. Bei der Definition gibt man vor ihrem Namen den Namen der Klasse und den Bereichsoperator „::“ an.

364

Objektorientierte Programmierung

Beispiele: Nach den Deklarationen des letzten Beispiels können die Funktionen für die Klasse C2DPunkt folgendermaßen definiert werden: void C2DPunkt::Init(double x_, double y_) { x = x_; y = y_; }; // Semikolon zulässig, aber nicht notwendig string C2DPunkt::toStr() { return "(" + std::to_string(x) + "|" + std::to_string(y) + ")"; } // z.B. (2,345|3,45678) void C2DPunkt::anzeigen() { cout y Solange eine Klasse keine virtuellen Elementfunktionen oder statischen Elemente (mehr darüber später) enthält, ergibt sich der Speicherplatzbedarf für ein Objekt nur aus dem für seine Datenelemente. Die Elementfunktionen tragen nicht dazu bei. Falls der Compiler für die Elemente eines Objekts nicht mehr Platz als notwendig reserviert, belegt ein Objekt genauso viel Speicherplatz wie alle Datenelemente seiner Klasse zusammen: sizeof(C2DPunkt) = sizeof(double) + sizeof(double) = 16 Mit den Zugriffsrechten private, protected und public kann man für jedes Klassenelement explizit festlegen, ob man von außerhalb einer Elementfunktion (d.h. über ein Objekt oder aus einer abgeleiteten Klasse) darauf zugreifen kann. Auf den Zugriff aus einer Elementfunktion hat ein solches Zugriffsrecht keinen Einfluss: Wie schon im letzten Abschnitt gesagt wurde, kann man in einer Elementfunktion auf jedes Klassenelement zugreifen. access-specifier: private protected public

Diese Spezifizierer definieren ab ihrer Angabe einen Abschnitt mit Zugriffsrechten, die für alle folgenden Elemente bis zum nächsten solchen Spezifizierer oder bis zum Ende der Klasse gelten. Ohne die Angabe eines Zugriffsrechts ist das Zugriffsrecht private. Ein Element aus einem private, protected oder public Abschnitt heißt auch private, protected oder public Element. – Ein public Element kann über ein Objekt angesprochen werden. – Ein private oder protected Element kann nicht über ein Objekt angesprochen werden. Eine Ausnahme sind friend-Funktionen (siehe Abschnitt 8.2.3) der Klasse. – Der Unterschied zwischen private und protected wirkt sich nur in abgeleiteten Klassen aus: Ein protected Element kann in einer abgeleiteten Klasse (siehe Abschnitt 8.3.2) angesprochen werden. public private protected

Zugriff über ein Objekt ja nein nein

372

Objektorientierte Programmierung

Ohne die Angabe eines Zugriffsrechts sind alle Elemente einer mit class definierten Klasse private, während alle Elemente einer mit struct definierten Klasse public sind. Dieses voreingestellte Zugriffsrecht ist der einzige Unterschied zwischen einer mit class und einer mit struct definierten Klasse. Beispiel: Alle Elemente der Klassen C0 und C1 haben das Zugriffsrecht private: class C0 { int x; int f() { return x; } }; struct C1 { private: int x; int f() { return x; } };

Jeder Zugriff auf diese Elemente über ein Objekt führt zu einer Fehlermeldung: void test(C0 a, C1 b) { a.x = 1; //Fehler: Kein a.f(); //Fehler: Kein b.x = 1; //Fehler: Kein b.f(); //Fehler: Kein

Zugriff Zugriff Zugriff Zugriff

auf auf auf auf

private private private private

Member Member Member Member

} Mit dem Zugriffsrecht public sind alle diese Zugriffe zulässig: class C0 { public: int x; int f() { return x; }

}; struct C1 { int x; int f() { return x; }

}; Eine Klasse kann eine beliebige Anzahl von Abschnitten mit verschiedenen Zugriffsrechten in einer beliebigen Reihenfolge enthalten. Die Reihenfolge der Abschnitte ist dabei ohne Bedeutung. Es wird aber gelegentlich empfohlen, sie in der Reihenfolge public, protected und private aufzuführen. Dann kommen die Elemente zuerst, die für einen Anwender der Klasse von Bedeutung sind, und dieser muss dann den Rest der Klasse überhaupt nicht mehr anschauen, der nur für einen Entwickler von abgeleiteten Klassen (protected Elemente) oder dieser Klasse (private Elemente) von Bedeutung ist. Beispiel: Die beiden Klassen C1 und C2 sind gleichwertig. Oft werden die verschiedenen Abschnitte wie bei C1 in der Reihenfolge private, protected und public aufgeführt.

8.1 Klassen

373

Wenn man sie aber wie bei C2 in der umgekehrten Reihenfolge anordnet, kommen die Elemente, die für einen Benutzer wichtig sind, am Anfang: class C1 { int x; public: int f(C p); };

class C2 { public: int f(C p); private: int x; };

Ein Benutzer einer Klasse ist dadurch charakterisiert, dass er eine Variable des Klassentyps definiert (ein Objekt) und dann auf ihre Elemente zugreift (z.B. Elementfunktionen aufruft). Da man über ein Objekt nur auf die public Elemente zugreifen kann, werden diese auch als Schnittstelle der Klasse bezeichnet. Beispiel: Die Schnittstelle der Klasse Datum_1 besteht aus den Datenelementen Tag, Monat und Jahr, und die der Klasse Datum_2 aus den Funktionen setze, Tag, Monat und Jahr. Über ein Objekt der Klasse Datum_2 ist kein Zugriff auf die Elemente Tag_, Monat_ und Jahr_ möglich. class Datum_1 { public: int Tag, Monat, Jahr; }; class Datum_2 { public: bool gueltigesDatum(int Tag, int Monat, int Jahr) { int MaxTag = 31; if ((Monat == 4) || (Monat == 6) || (Monat == 9) || (Monat == 11)) MaxTag = 30; else if (Monat == 2) { bool Schaltjahr = ((Jahr % 4 == 0) && (Jahr % 100 != 0)) || (Jahr % 400 == 0); if (Schaltjahr) MaxTag = 29; else MaxTag = 28; } return ((1 x = x; this->y = y; };

8.1.5 Konstruktoren und Destruktoren In den bisherigen Beispielen wurde die Elementfunktion Init dazu verwendet, die Datenelemente eines Objekts zu initialisieren. Damit man den Aufruf einer solchen Initialisierungsfunktion nicht versehentlich vergisst, kann man in C++ sogenannte Konstruktoren definieren. Der Compiler akzeptiert dann die Definition eines Objekts nur, wenn dabei ein Konstruktor aufgerufen wird.

378

Objektorientierte Programmierung

Ein Konstruktor ist eine Elementfunktion der Klasse, die dadurch charakterisiert ist, dass sie denselben Namen wie die Klasse hat. Er darf keinen Rückgabetyp haben (auch nicht void) und nicht virtual oder static sein (siehe Abschnitt 8.4.2 und 8.2.11). Eine Klasse kann mehrere Konstruktoren haben. Diese müssen sich dann wie alle anderen überladenen Funktionen durch hinreichend verschiedene Parameter unterscheiden. Die Parameter können auch Default-Argumente haben. Ein Konstruktor wird in den folgenden Situationen automatisch aufgerufen: 1. Wenn man ein Objekt durch eine Definition erzeugt. Dabei muss nach dem Namen des Objekts eine Liste von Argumenten angeben werden, die zur Parameterliste des Konstruktors passt. Bei der Definition des Objekts wird dann der Konstruktor mit diesen Argumenten aufgerufen. Beispiel: Mit der Klassendefinition class C2DPunkt { double x, y; public: C2DPunkt(double x_) { // ein Parameter: x-Wert x = x_; y = 0; } C2DPunkt(double x_, double y_) { x = x_; y = y_; } };

können folgendermaßen Objekte dieser Klasse definiert werden: C2DPunkt p(3); // p=(3,0) C2DPunkt q(5, 6); // q=(5,6)

Dagegen wird diese Definition vom Compiler nicht akzeptiert: C2DPunkt p; // error: Kein Standardkonstruktor verfügbar

Die beiden Konstruktoren von C2DPunkt können auch durch einen einzigen mit einem Default-Argument ersetzt werden: class C2DPunkt { double x, y; public:

8.1 Klassen

379

C2DPunkt(double x_, double y_ = 0) { x = x_; y = y_; } };

Die Argumente für einen Konstruktor kann man auch in einer Initialisierungsliste übergeben: C2DPunkt p{ 3 }; // p=(3,0) C2DPunkt q{ 5, 6 }; // q=(5,6)

Der Zeitpunkt des Konstruktoraufrufs hängt von der Art der Definition ab: – Bei einer globalen Definition wird der Konstruktor ein einziges Mal beim Start des Programms aufgerufen. – Bei einer lokalen nicht statischen Definition wird er bei jeder Ausführung der Deklarationsanweisung aufgerufen. – Bei einer lokalen statischen Definition wird er bei der ersten Ausführung der Definition aufgerufen. 2. Wenn ein Objekt mit new erzeugt wird. Dabei muss man nach new den Namen der Klasse und anschließend eine Liste von Argumenten für einen Konstruktor angeben. Bei der Ausführung der new-Anweisung wird dann der Konstruktor aufgerufen, der zu den Argumenten passt. Beispiel: Mit der Klasse C2DPunkt aus dem letzten Beispiel sind die ersten beiden Definitionen möglich. Die dritte wird dagegen vom Compiler abgelehnt: C2DPunkt* pp = new C2DPunkt(3); // *pp=(3,0) C2DPunkt* pq = new C2DPunkt(5, 6); // *pq=(5,6) C2DPunkt* p = new C2DPunkt; // Fehler

3. Ein Konstruktor kann explizit mit seinem Namen (also dem Namen der Klasse) aufgerufen werden. Dabei wird ein temporäres Objekt erzeugt, das keinen Namen hat. Solche Ausdrücke werden oft in einer Zuweisung, bei einer return-Anweisung, als Argument oder als Default-Argument verwendet. Beispiel: In den mit 1, 2, 3 und 4 gekennzeichneten Anweisungen werden temporäre Objekte erzeugt: C2DPunkt Nullpunkt() { return C2DPunkt(0, 0); }

// 1

void f(const C2DPunkt& r = C2DPunkt(0, 0)) {}

380

Objektorientierte Programmierung

C2DPunkt p(1, 2); p = C2DPunkt(3, 4); f(C2DPunkt(5, 6)); f();

// 2 // 3 // 4

Die temporären Objekte in diesem Beispiel existieren nur während der Ausführung des Ausdrucks, in dem sie erzeugt werden. Ein temporäres Objekt, das eine Referenz initialisiert, existiert während der gesamten Lebensdauer des initialisierten Objekts. Deshalb existiert das beim Aufruf f() erzeugte temporäre Objekt bis zum Ende des Blocks der Funktion f. Ein Konstruktor, der mit einem einzigen Argument aufgerufen werden kann, heißt konvertierender Konstruktor (siehe auch Abschnitt 8.2.9), da sein Aufruf wie eine Typkonversion aussieht. Dabei wird ein temporäres Objekt erzeugt. Solche Konstruktoren gehören zu den benutzerdefinierten Konversionen und werden oft dazu verwendet, einem Ausdruck einen bestimmten Datentyp zu geben: const char* s = "12"; const char* t = "abc"; string u = s + t;//error: Zeiger können nicht addiert werden string u = string(s) + t; // das geht - konvertierender Konstruktor

Ein temporäres Objekt wird außerdem durch einen throw-Ausdruck erzeugt. 4. Wenn eine Funktion einen Parameter hat, dessen Datentyp eine Klasse mit einem konvertierenden Konstruktor ist, dann kann die Funktion auch mit einem Argument für diesen Konstruktor aufgerufen werden. Der Compiler erzeugt dabei aus dem Argument mit dem konvertierenden Konstruktor ein temporäres Objekt, das der Funktion als Argument übergeben wird. Beispiel: Die Klasse C2DPunkt von oben hat einen konvertierenden Konstruktor, der mit einem Ganzzahlargument aufgerufen werden kann. Deshalb kann man die Funktion void f(C2DPunkt x) {}

auch mit einem Ganzzahlargument aufrufen. Dieser Aufruf führt dann zum Aufruf des Konstruktors, der aus dem Argument y ein temporäres Objekt C2DPunkt(y) erzeugt: f(1); // f(C2DPunkt(1));

Solche Konversionen kann man mit explicit (siehe Abschnitt 8.2.9) unterbinden. 5. Bei der Definition eines Arrays von Objekten wird für jedes Arrayelement in der Reihenfolge der Indizes ein Konstruktor aufgerufen. Die Konstruktoren kann man in einer Initialisierungsliste angeben. Für Konstruktoren mit einem Parameter genügt ein Argument für den Konstruktor. Beispiel: Mit der Klasse C2DPunkt erzeugt die folgende Definition die als Kommentar angegebenen Arrayelemente:

8.1 Klassen

381

std::array a{ C2DPunkt(1,2),3 }; // bzw. C2DPunkt a[2] = { C2DPunkt(1,2),3 }; // a[0]=(1,2), a[1]=(3,0)

Enthält diese Liste weniger Elemente als das Array, werden die restlichen Elemente durch den sogenannten Standardkonstruktor initialisiert. Das ist ein Konstruktor, der ohne Argumente aufgerufen werden kann (siehe Abschnitt 8.2.1). Bei einem Array ohne eine Initialisierungsliste werden alle Elemente mit dem Standardkonstruktor initialisiert. Falls die Klasse keinen Standardkonstruktor hat, bringt der Compiler eine Fehlermeldung. Beispiel: Die folgende Definition führt zum zweifachen Aufruf des Standardkonstruktors von C2DPunkt, falls dieser definiert ist, bzw. zu einer Fehlermeldung: C2DPunkt* pa = new C2DPunkt[2];

6. Wenn eine Klasse Datenelemente eines Klassentyps enthält, wird beim Erzeugen eines Objekts der umgebenden Klasse ein Konstruktor für jedes enthaltene Objekt aufgerufen (siehe Abschnitt 8.2.2). 7. Kennzeichnet man einen Konstruktor mit constexpr, kann man mit diesem Konstruktor eine Compilezeit-Konstante (siehe Abschnitt 2.7.2) definieren: Beispiel: Da die Klasse class C { public: constexpr C() {}; };

einen constexpr-Konstruktor hat, kann man eine Compilezeit-Konstante von C anlegen: constexpr C c;

Auch die Klasse std::array (siehe Abschnitt 4.2.6) hat einen constexpr-Konstruktor. Deswegen kann ein std::array-Objekt mit constexpr definiert werden: constexpr std::array a = { 1,2 };

Die Klasse string (siehe Kapitel 3) hat dagegen hat dagegen erst ab C++20 einen constexpr-Konstruktor: constexpr std::string s=""; // Fehler in C++17, ok in C++20

Normalerweise ist es die Aufgabe eines Konstruktors, alle Datenelemente eines Objekts der Klasse so zu initialisieren, dass sie beim Aufruf einer beliebigen Elementfunktion konsistent sind. Falls die Klasse keine Konsistenzbedingung hat, sollten sie zumindest in einem definierten Zustand sein. Wenn eine Elementfunktion der Klasse Datenelemente

382

Objektorientierte Programmierung

verwendet, die nach dem Aufruf eines Konstruktors nicht initialisiert sind, ist das meist ein Fehler. Beispiel: Nach der Definition class C2DPunkt{ double x,y; public: C2DPunkt(double x_, double y_=0) { x=x_; // Initialisierung von y wurde vergessen } string toStr() { return "(" + std::to_string(x) + "|" + std::to_string(y) + ")"; } // z.B. (2,345|3,45678) };

wird beim Aufruf von toStr ein undefinierter Wert von y verwendet. Bei einer Codeanalyse mit den C++ Core Guidelines (siehe Abschnitt 2.13) wird darauf hingewiesen, wenn ein Datenelement nicht initialisiert wird: class AlleVariablenInitialisieren { int i, j; public: AlleVariablenInitialisieren(int x, int y) : j(y) { } // warning C26495: Die Variable "i" ist nicht initialisiert. Eine Membervariable muss immer initialisiert werden (type.6). AlleVariablenInitialisieren() : i(0) { } // warning C26495 : Die Variable "j" ist nicht initialisiert. };

Die von einem Objekt reservierten Ressourcen (z.B. Speicher) müssen am Ende seiner Existenz auch wieder freigegeben werden. Damit das nicht versehentlich vergessen wird, kann man diese Freigabe in einem Destruktor durchführen. Ein Destruktor ist dadurch charakterisiert, dass sein Name mit dem Zeichen „~“ (Tilde) beginnt, auf das der Name der Klasse folgt. Ein Destruktor muss public sein und darf weder eine Parameterliste noch einen Rückgabetyp (auch nicht void) haben. Während eine Klasse also mehrere verschiedene Konstruktoren haben kann, kann sie nur einen einzigen Destruktor haben. Ein Destruktor wird in den folgenden Situationen automatisch aufgerufen: 1. Beim Verlassen des Blocks, in dem ein lokales, nicht statisches Objekt durch eine Definition erzeugt wurde. Das gilt auch, wenn der Block verlassen wird, weil eine

8.1 Klassen

2. 3. 4. 5. 6. 7.

383

Exception ausgelöst wird. Für ein Array von Objekten wird der Destruktor für jedes Element des Arrays aufgerufen. Wird während der Ausführung eines Konstruktors eine Exception ausgelöst, dann wird für alle bisher konstruierten Objekte ihr Destruktor aufgerufen. Am Ende des Programms für ein Objekt, das durch eine globale oder eine lokale statische Definition erzeugt wurde. Wenn für ein mit new erzeugtes Objekt delete aufgerufen wird. Für ein mit new[] erzeugtes Array von Objekten wird durch den Aufruf von delete[] der Destruktor für jedes Objekt des Arrays aufgerufen. Wenn ein Objekt Element eines anderen Objekts ist, ruft der Destruktor des umgebenden Objekts die Destruktoren aller Elemente auf. Bei einem temporären Objekt mit dem Ende der Ausdrucksanweisung, in der es erzeugt wurde. Falls das temporäre Objekt eine Referenz initialisiert, wird der Destruktor am Ende der Lebensdauer der Referenz aufgerufen.

Beim Aufruf eines Destruktors werden zuerst die Anweisungen in seinem Anweisungsteil ausgeführt. Danach werden die Destruktoren aller Datenelemente in der umgekehrten Reihenfolge ihrer Definition aufgerufen und danach die Destruktoren aller Basisklassen in der umgekehrten Reihenfolge ihrer Definition. Beispiel: Beim Aufruf der Funktion test class C { public: ~C() // Destruktor { cout x eine Fehlermeldung zur Folge hat. Eine solche Funktion wird als konstante Elementfunktionen bezeichnet. Durch die Kennzeichnung einer Elementfunktion mit const dokumentiert man explizit, dass sie keine Datenelemente verändert. Da eine konstante Elementfunktion keine Daten eines Objekts verändern kann, kann sie auch die Klasseninvariante (siehe Abschnitt 8.1.7) nicht verändern. Deshalb wird empfohlen, alle solchen Elementfunktionen immer als const zu kennzeichnen. – Da eine statische Elementfunktion keine Datenelemente eines Objekts verändern kann, kann eine statische Elementfunktion auch mit einem konstanten Objekt aufgerufen werden. Beispiel: Ergänzt man die Funktion setze aus dem letzten Beispiel um const, akzeptiert der Compiler den Aufruf. Er erzeugt aber eine Fehlermeldung, da das Element x verändert wird: void setze (int v) const { x = v; }

Entfernt man die Zuweisung aus setze, akzeptiert der Compiler die Funktion. In der Klasse class C2DPunkt { double x, y; public: C2DPunkt(double x_ = 0, double y_ = 0) :x(x_), y(y_) {} double X() const { return x; } double Y() const { return y; } string toStr() const { return "(" + std::to_string(X()) + "|" + std::to_string(Y()) + ")"; } // z.B. (2,345|3,45678)

}; können X, Y und toStr mit const definiert werden, da sie keine Klassenelemente verändern. Dann können diese Funktionen auch in einer Funktion mit einem konstanten Referenzparameter aufgerufen werden: void show2(const C2DPunkt& p) { cout