Breymann. C++ Einführung und professionelle Programmierung
Breymann. C++ Einführung und professionelle Programmierung Breymann. C++ Einführung und professionelle Programmierung
6 Intermezzo: Zeiger 205 6.1 Zeiger und Adressen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 6.2 C-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 6.2.1 C-Arrays und sizeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 6.2.2 Indexoperator bei C-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 6.2.3 Initialisierung von C-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 6.3 C-Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 6.4 Dynamische Datenobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 6.4.1 Freigeben dynamischer Objekte . . . . . . . . . . . . . . . . . . . . . . . . . 233 6.5 Mehrdimensionale C-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 6.5.1 Statische mehrdimensionale C-Arrays . . . . . . . . . . . . . . . . . . . . . . 237 6.5.2 Dynamisch erzeugte mehrdimensionale Arrays . . . . . . . . . . . . . . . . 247 6.6 Binäre Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 6.7 Zeiger und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256 6.7.1 Parameterübergabe mit Zeigern . . . . . . . . . . . . . . . . . . . . . . . . . 256 6.7.2 Gefahren bei der Rückgabe von Zeigern . . . . . . . . . . . . . . . . . . . . . 259 6.8 Zeiger auf Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 6.9 this-Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 7 Objektorientierung 2 267 7.1 Eine String-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 7.1.1 friend-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 7.2 Klassenspezifische Daten und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . 274 7.2.1 Klassenspezifische Konstante . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 7.3 Klassentemplates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 7.3.1 Ein Stack-Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Breymann C++, c○ Hanser Verlag München Inhalt ◭◭ ◭ ◮ ◮◮ 6 zurück Ende
7.3.2 Stack mit statisch festgelegter Größe . . . . . . . . . . . . . . . . . . . . . . . 293 8 Vererbung 297 8.1 Vererbung und Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 8.2 Zugriffsschutz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 8.3 Code-Wiederverwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 8.4 Überschreiben von Funktionen in abgeleiteten Klassen . . . . . . . . . . . . . . . . 315 8.5 Polymorphismus in abgeleiteten Klassen . . . . . . . . . . . . . . . . . . . . . . . . 318 8.5.1 Virtuelle Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 8.5.2 Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326 8.5.3 Virtuelle Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 8.6 Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 8.6.1 Namenskonflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346 8.6.2 Virtuelle Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 8.6.3 Virtuelle Basisklassen und Initialisierung . . . . . . . . . . . . . . . . . . . . 352 8.7 Vererbung und andere Beziehungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 8.7.1 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 8.7.2 Der Teil und das Ganze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 8.7.3 Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 8.7.4 „Benutzt“-Beziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 9 Überladen von Operatoren 367 9.1 Rationale Zahlen - noch einmal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 9.1.1 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 9.1.2 Ausgabeoperator
- Seite 1 und 2: Objektorientierte Programmierung mi
- Seite 3 und 4: Inhalt 1 Einführung 9 2 Grundlegen
- Seite 5: 4.3.2 Einbinden vorübersetzter Pro
- Seite 9 und 10: 1. Einführung Aufgaben eines Rechn
- Seite 11 und 12: Klassen Klasse = Beschreibung von O
- Seite 13 und 14: Kursaufbau • Daten Datentypen, -s
- Seite 15 und 16: 2. Grundlegende Begriffe - das erst
- Seite 17 und 18: C++ C PASCAL #include #include int
- Seite 19 und 20: 2.2 Einfache Datentypen und Operato
- Seite 21 und 22: 2.2.2 Ganze Zahlen Typische Werte f
- Seite 23 und 24: Operator Beispiel Bedeutung Kurzfor
- Seite 25 und 26: Operator Beispiel Bedeutung Bit-Ope
- Seite 27 und 28: Syntax: Vorzeichen (optional) Vorko
- Seite 29 und 30: #include #include // math. Biblioth
- Seite 31 und 32: Strukturierung mit Klammern (). Kla
- Seite 33 und 34: 2.2.5 Zeichen 3 verschiedene Typen:
- Seite 35 und 36: i = 66; c = static_cast(i); // Typu
- Seite 37 und 38: 2.2.6 Logischer Datentyp Datentyp:
- Seite 39 und 40: 2.2.7 Referenzen Referenz = Verweis
- Seite 41 und 42: { // Blockbeginn int a = 1; { // Bl
- Seite 43 und 44: 2.4.2 Auswahl (Selektion, Verzweigu
- Seite 45 und 46: Auswertung des Bedingungsausdrucks
- Seite 47 und 48: Bedingungsoperator ?: Bedingung ? A
- Seite 49 und 50: #include using namespace std; int m
- Seite 51 und 52: nein ✛ ❄ ❅ ❅ ❅ Bedingun
- Seite 53 und 54: Schleifen mit do while Wirkung: ✛
- Seite 55 und 56: typische Anwendung: Eingabe mit Pla
7.3.2 Stack mit statisch festgelegter Größe . . . . . . . . . . . . . . . . . . . . . . . 293<br />
8 Vererbung 297<br />
8.1 Vererbung <strong>und</strong> Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307<br />
8.2 Zugriffsschutz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308<br />
8.3 Code-Wiederverwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313<br />
8.4 Überschreiben von Funktionen in abgeleiteten Klassen . . . . . . . . . . . . . . . . 315<br />
8.5 Polymorphismus in abgeleiteten Klassen . . . . . . . . . . . . . . . . . . . . . . . . 318<br />
8.5.1 Virtuelle Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319<br />
8.5.2 Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326<br />
8.5.3 Virtuelle Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337<br />
8.6 Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341<br />
8.6.1 Namenskonflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346<br />
8.6.2 Virtuelle Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349<br />
8.6.3 Virtuelle Basisklassen <strong>und</strong> Initialisierung . . . . . . . . . . . . . . . . . . . . 352<br />
8.7 Vererbung <strong>und</strong> andere Beziehungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 357<br />
8.7.1 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357<br />
8.7.2 Der Teil <strong>und</strong> das Ganze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362<br />
8.7.3 Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363<br />
8.7.4 „Benutzt“-Beziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366<br />
9 Überladen von Operatoren 367<br />
9.1 Rationale Zahlen - noch einmal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371<br />
9.1.1 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371<br />
9.1.2 Ausgabeoperator
Change language