-
Objektorientiertes Programmieren in C++ - V. 34 Seite 1 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Objektorientiertes Programmieren
in
C++
Detlef Wilkening www.wilkening-online.de
1996-2015
Dieses C++ Tutorial darf in unvernderter Form fr
Unterrichtszwecke weitergegeben und verwendet werden.
Der Autor freut sich aber ber Rckmeldungen zum Einsatz des
Tutorials.
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 2 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Objektorientiertes Programmieren in C++
1 Organisatorisches
.......................................................................................................
18
2 Allgemeines zu C++
....................................................................................................
21 2.1 Entwicklung
............................................................................................................
21 2.2 Paradigmen
............................................................................................................
21 2.3 Der ISO C++ Standard
...........................................................................................
22 2.4 Compiler
.................................................................................................................
23 2.5 Skript
......................................................................................................................
24 2.6 Bibliotheken
...........................................................................................................
24 2.7 Boost
......................................................................................................................
25 2.8 Praxis
.....................................................................................................................
27
3 Einfhrung
...................................................................................................................
28 3.1 Das erste C++ Programm
......................................................................................
28 3.2 Vereinfachung
........................................................................................................
31
4 Praktikum, Tools, Beispiele, Lsungen
.....................................................................
32 4.1 Microsoft Visual Studio 2003.NET unter Windows
................................................. 33 4.2 GCC unter
Linux
....................................................................................................
51 4.3 Editoren, Compiler, Make-Systeme und IDEs
........................................................ 54 4.4
Dokumentation
.......................................................................................................
65 4.5 Beispiele und Lsungen
.........................................................................................
65 4.6
Aufgaben................................................................................................................
66 4.7 Lsg. zu Aufgabe Hallo Welt Kap. 4.6.1
.............................................................
67
5 Typen, Variablen, Operatoren, uvm.
..........................................................................
67 5.1 Typen
.....................................................................................................................
67 5.2 Literale
...................................................................................................................
70 5.3 Internationalisierung
...............................................................................................
71 5.4 Variablen
................................................................................................................
74 5.5 Konstanten
.............................................................................................................
85 5.6 Operatoren
.............................................................................................................
89 5.7 Optimierungen und Sequenz-Punkte
...................................................................
101 5.8
Aufgaben..............................................................................................................
102 5.9 Lsg. zu Aufgabe Grundrechen-Arten Kap. 5.8.1
............................................. 102 5.10 Lsg. zu
Aufgabe Increment-Operator Kap. 5.8.2
............................................. 103
6 Kontrollstrukturen
.....................................................................................................
104 6.1 Bedingter-Kontrollfluss if & else
....................................................................
104 6.2 Mehrfach-Verzweigung switch
........................................................................
107 6.3 For-Schleife
..........................................................................................................
109 6.4 While-Schleife
......................................................................................................
110 6.5 Do-Schleife
..........................................................................................................
111 6.6 Break- und Continue-Anweisungen
......................................................................
111
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 3 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
6.7 Schleife mit Ausgang in der Mitte
.........................................................................
112 6.8 Labels und goto
.................................................................................................
113 6.9
Aufgaben..............................................................................................................
115 6.10 Lsg. zu Aufgabe Schleifen-Varianten Kap. 6.9.1
............................................. 117 6.11 Lsg. zu
Aufgabe Teilbar? Kap. 6.9.2
............................................................... 119
6.12 Lsg. zu Aufgabe Lesbare Zahlen Kap. 6.9.3
................................................... 122 6.13 Lsg.
zu Aufgabe Zahlen-Liste Kap. 6.9.4
........................................................ 123 6.14
Lsg. zu Aufgabe Multiplikatons-Matrix Kap. 6.9.5
........................................... 126
7 Ein- und Ausgabe
......................................................................................................
126 7.1 Ausgabe
...............................................................................................................
126 7.2 Eingabe
................................................................................................................
131 7.3 Weiteres
...............................................................................................................
136 7.4
Aufgaben..............................................................................................................
137 7.5 Lsg. zu Aufgabe Summe Kap. 7.4.1
............................................................... 139
7.6 Lsg. zu Aufgabe Lesbare Zahlen 2 Kap. 7.4.2
................................................ 139 7.7 Lsg. zu
Aufgabe Mittelwert und Varianz Kap. 7.4.3
......................................... 141 7.8 Lsg. zu Aufgabe
Multiplikat.-Matrix 2 Kap. 7.4.4
............................................. 142 7.9 Lsg. zu
Aufgabe Quadratwurzel Kap. 7.4.5
..................................................... 144
8 Texte und Textbearbeitung
.......................................................................................
147 8.1 Strings
..................................................................................................................
147 8.2 String-Streams
.....................................................................................................
157 8.3 Boost-Conversion- bzw. Boost-Lexical-Cast-Library
............................................. 160 8.4
Boost-String-Algorithm-Library
.............................................................................
161 8.5 Boost-Tokenizer-Library
.......................................................................................
164 8.6
Aufgaben..............................................................................................................
166 8.7 Lsg. zu Aufgabe Hallo Kap. 8.6.1
................................................... 168 8.8 Lsg. zu
Aufgabe Leerzeichen zhlen 1 Kap. 8.6.2
.......................................... 170 8.9 Lsg. zu Aufgabe
String-Analyse Kap. 8.6.3
..................................................... 171 8.10 Lsg.
zu Aufgabe Zahlen-Palindrom Kap. 8.6.4
................................................ 178
9 STL Container & Iteratoren
....................................................................................
178 9.1 Einfhrung
............................................................................................................
178 9.2
Vektoren...............................................................................................................
179 9.3 Listen
...................................................................................................................
183 9.4
Iteratoren..............................................................................................................
184 9.5
Arrays...................................................................................................................
189 9.6 Sets
......................................................................................................................
191 9.7 Maps
....................................................................................................................
198 9.8 Weitere Container
................................................................................................
203 9.9 Weiteres zu den STL Containern
.........................................................................
204 9.10 Initialisierungen & Boost-Assignment-Library
....................................................... 205 9.11
Container Kurz-Referenz
......................................................................................
209 9.12
Aufgaben..............................................................................................................
223 9.13 Lsg. zu Aufgabe Hallo Kap. 9.12.1
............................................. 226
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 4 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
9.14 Lsg. zu Aufgabe Lesbare Zahlen 3 Kap. 9.12.2
.............................................. 229 9.15 Lsg. zu
Aufgabe String-Analyse 2 Kap. 9.12.3
................................................ 231 9.16 Lsg. zu
Aufgabe Telefonbuch 1 Kap. 9.12.4
................................................... 239
10 Weiteres zum Typ-System
.....................................................................................
242 10.1 Typedefs
.............................................................................................................
242 10.2 Referenzen
..........................................................................................................
245 10.3 Aufzhlungs-Typen
..............................................................................................
252 10.4 Typ-Konvertierungen
............................................................................................
255 10.5
Aufgaben..............................................................................................................
259 10.6 Lsg. zu Aufgabe Referenzen Kap. 10.5.1
....................................................... 259
11 Funktionen
.............................................................................................................
259 11.1 Einfhrung
............................................................................................................
259 11.2 Parameter und Argumente
...................................................................................
263 11.3 Rckgaben
...........................................................................................................
267 11.4 Konvertierungen
...................................................................................................
273 11.5 Default-Argumente
...............................................................................................
275 11.6 berladen
............................................................................................................
277 11.7 Parameter und lokale Variablen
...........................................................................
282 11.8 Rekursion
.............................................................................................................
283 11.9
Aufgaben..............................................................................................................
284 11.10 Lsg. zu Aufgabe swap Kap. 11.9.1
.............................................................. 290
11.11 Lsg. zu Aufgabe Setze String-Lnge Kap. 11.9.2
....................................... 291 11.12 Lsg. zu Aufgabe
Fakultt Kap. 11.9.3
......................................................... 292 11.13
Lsg. zu Aufgabe Fibonacci Kap. 11.9.4
....................................................... 294 11.14
Lsg. zu Aufgabe Rek. Multiplikation Kap. 11.9.5
......................................... 300 11.15 Lsg. zu Aufgabe
Quadratwurzel-Fkt Kap. 11.9.6
......................................... 301 11.16 Lsg. zu Aufgabe
Zahlen-Wandlung Kap. 11.9.7
.......................................... 304 11.17 Lsg. zu
Aufgabe Formatierung Kap. 11.9.8
................................................. 313 11.18 Lsg. zu
Aufgabe Telefonbuch 2 Kap. 11.9.9
................................................ 314 11.19 Lsg. zu
Aufgabe Trme von Hanoi 1 Kap. 11.9.10
...................................... 324
12 Weiteres aus der Standard-Bibliothek und Boost
............................................... 335 12.1
File-Streams
.........................................................................................................
336 12.2 Filesystem-Library
................................................................................................
345 12.3 Exit
.......................................................................................................................
357 12.4 Datum und
Zeit.....................................................................................................
357 12.5 Zufallszahlen
........................................................................................................
359 12.6 Mathematische Funktionen
..................................................................................
364 12.7 Timer
....................................................................................................................
366 12.8 Swap-Funktion
.....................................................................................................
367 12.9 Pairs und Tuple
....................................................................................................
369 12.10 Numeric-Limits
..................................................................................................
374 12.11 Aufgaben
..........................................................................................................
377 12.12 Lsg. zu Aufgabe File-Stream Kap. 12.11.1
.................................................. 382
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 5 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
12.13 Lsg. zu Aufgabe String-Container Kap. 12.11.2
.......................................... 383 12.14 Lsg. zu
Aufgabe Telefonbuch 3 Kap. 12.11.3
.............................................. 389 12.15 Lsg. zu
Aufgabe Platten-Platz Kap. 12.11.4
................................................ 393 12.16 Lsg. zu
Aufgabe Datei-Suche Kap. 12.11.5
................................................. 394 12.17 Lsg. zu
Aufgabe Lotto-Programm Kap. 12.11.6
.......................................... 397 12.18 Lsg. zu
Aufgabe Pi simulieren Kap. 12.11.7
................................................ 399
13 Klassen
...................................................................................................................
399 13.1 Motivation
.............................................................................................................
399 13.2 Klassen-Definition
................................................................................................
401 13.3 Zugriffsbereiche
...................................................................................................
404 13.4 Klassen sind benutzerdefinierte Typen
.................................................................
405 13.5 Objekt-Orientierung
..............................................................................................
406 13.6 Erweiterung
..........................................................................................................
407 13.7 Objekt-Zustand
....................................................................................................
407 13.8 Konstruktoren
.......................................................................................................
409 13.9 Destruktoren
........................................................................................................
429 13.10 Const-Element-Funktionen
...............................................................................
431 13.11 this
....................................................................................................................
433 13.12 Was soll das alles?
...........................................................................................
434 13.13 Aufgaben
..........................................................................................................
437 13.14 Lsg. zu Aufgabe Klasse date Kap. 13.13.1
.................................................. 438 13.15 Lsg.
zu Aufgabe Ringzhler Kap. 13.13.2
................................................... 443 13.16 Lsg.
zu Aufgabe Trme von Hanoi 2 Kap. 13.13.3
...................................... 444
14 Prprozessor, Compiler, Linker, ...
.......................................................................
446 14.1 Quelltext-Aufteilung, Header, Sourcen
.................................................................
446 14.2 Prprozessor
........................................................................................................
448 14.3 Compiler
...............................................................................................................
449 14.4 Linker
...................................................................................................................
450 14.5 Fehler
...................................................................................................................
452 14.6 ODR und Header-Guards
.....................................................................................
452 14.7 Header und Using-Anweisungen
..........................................................................
453 14.8 Quelltext-Aufteilung
..............................................................................................
453 14.9 Bibliotheken
.........................................................................................................
454 14.10 Projekte und Make-Systeme
.............................................................................
456 14.11 Aufgaben
..........................................................................................................
456 14.12 Lsg. zu Aufgabe Datums-Bibliothek Kap. 14.11.1
....................................... 457
15 Inline
.......................................................................................................................
462 15.1 Thema Performance
..........................................................................................
462 15.2 Implizites Inline bei freien
Funktionen...................................................................
463
16 Klassen II
................................................................................................................
464 16.1 Klassen verwenden Klassen
................................................................................
464 16.2 Member-Initialisierungs-Listen
..............................................................................
465 16.3 Vorwrts-Deklarationen
........................................................................................
468
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 6 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
16.4 Klassen-Elemente
................................................................................................
469 16.5 friend
....................................................................................................................
472 16.6 Klassenbezogene Typen
......................................................................................
473 16.7
Aufgaben..............................................................................................................
474 16.8 Lsg. zu Aufgabe Gerchtekche Kap. 16.7.1
.................................................. 477 16.9 Lsg. zu
Aufgabe Tic-Tac-Toe 1 Kap. 16.7.2
................................................... 517 16.10 Lsg.
zu Aufgabe Telefonbuch 4 Kap. 16.7.3
................................................ 551
17 Operator-Funktionen
.............................................................................................
570 17.1 Einfhrung
............................................................................................................
571 17.2 Verstndnis Beispiel
.............................................................................................
574 17.3 Symmetrische Operatornutzung
...........................................................................
575 17.4 Ausgabe
...............................................................................................................
576 17.5 Kopier-Zuweisungs-Operator =
............................................................................
578 17.6 Move-Zuweisungs-Operator =
..............................................................................
582 17.7 Funktions-Aufruf Operator
....................................................................................
582 17.8 Spezialitten
.........................................................................................................
584 17.9 Fazit
.....................................................................................................................
585 17.10 Aufgaben
..........................................................................................................
586 17.11 Lsg. zu Aufgabe Bruch Kap. 17.10.1
........................................................... 587
17.12 Lsg. zu Aufgabe Datums-Bibliothek 2 Kap. 17.10.2
.................................... 588 17.13 Lsg. zu Aufgabe
Funktions-Objekte Kap. 17.10.3
....................................... 592 17.14 Lsg. zu Aufgabe
Fllzeichen-Reset Kap. 17.10.4
........................................ 593
18 STLAlgorithmen & Lambda-Ausdrcke
.............................................................. 594
18.1 Einfhrung in Algorithmen
....................................................................................
594 18.2 Lambda-Ausdrcke
..............................................................................................
605 18.3 Algorithmen
..........................................................................................................
618 18.4
Iteratoren..............................................................................................................
652 18.5 Fazit
.....................................................................................................................
664 18.6
Aufgaben..............................................................................................................
665 18.7 Lsg. zu Aufgabe Algorithmen Kap. 18.6.1
....................................................... 666 18.8
Lsg. zu Aufgabe Hallo 2 Kap. 18.6.2
.......................................... 670 18.9 Lsg. zu Aufgabe
Leerzeichen zhlen 2 Kap. 18.6.3
........................................ 672
19 Exceptions
.............................................................................................................
672 19.1 Motivation
.............................................................................................................
672 19.2 Konzept
................................................................................................................
673 19.3 Realisation
...........................................................................................................
673 19.4 Details
..................................................................................................................
678 19.5 Exception-Hierarchien
..........................................................................................
680 19.6 Exception-Sicherheit
............................................................................................
681 19.7 Exception-Sicherheit und Swap
............................................................................
684 19.8
Aufgaben..............................................................................................................
685 19.9 Lsg. zu Aufgabe Exception-Handling Kap. 19.8.1
........................................... 685 19.10 Lsg. zu
Aufgabe Date mit Exceptions Kap. 19.8.2
....................................... 686
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 7 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
19.11 Lsg. zu Aufgabe Fllzeichen-Reset 2 Kap. 19.8.3
....................................... 690
20 Adressen, Zeiger, uvm.
.........................................................................................
691 20.1 Adressen
..............................................................................................................
691 20.2 Zeiger
...................................................................................................................
692 20.3 Kurzer Einschub ber C-Strings
...........................................................................
694 20.4 Weiteres
...............................................................................................................
695
21 Dynamische Speicherverwaltung
.........................................................................
695 21.1 Allgemeines
.........................................................................................................
696 21.2 Die Operatoren new & delete
...............................................................................
696 21.3 Weiteres
...............................................................................................................
699 21.4 Roher Speicher
....................................................................................................
699 21.5 Exception-Sicherheit
............................................................................................
700 21.6 Ressourcen-Manager
...........................................................................................
702 21.7 Smart-Pointer
.......................................................................................................
704 21.8 Antwort
.................................................................................................................
707 21.9 Fazit
.....................................................................................................................
708 21.10 Aufgaben
..........................................................................................................
708 21.11 Lsg. zu Aufgabe Telefonbuch 5 Kap. 21.10.1
.............................................. 709
22 Ressourcen-Klassen & Move-Semantik
............................................................... 716
22.1 Klassen mit externen Ressourcen
........................................................................
716 22.2 Wert- und Referenz-Semantik
..............................................................................
730 22.3 Swap-Funktion
.....................................................................................................
731 22.4 Move-Semantik
....................................................................................................
733 22.5 Regel-der-Drei, -Vier, -Fnf, -Sechs oder -Null
.................................................... 735 22.6 Fazit
.....................................................................................................................
737 22.7
Aufgaben..............................................................................................................
738 22.8 Lsg. zu Aufgabe Liste Kap. 22.7.1
..................................................................
740
23 Vererbung & Polymorphie
.....................................................................................
740 23.1 Vererbung
............................................................................................................
740 23.2 Konsequenzen aus der ist-ein Beziehung
.......................................................... 751 23.3
Polymorphie
.........................................................................................................
754 23.4 Beispiel Obstkorb
...............................................................................................
757 23.5 Noch mal zusammengefat...
..............................................................................
763 23.6 Destruktoren
........................................................................................................
763 23.7 Abstrakte Basis-Klassen
......................................................................................
765 23.8 Dynamic-Cast
.......................................................................................................
767 23.9 Modul-Entkopplung
..............................................................................................
769 23.10 Vererbung & Polymorphie
.................................................................................
771 23.11 Aufgaben
..........................................................................................................
772 23.12 Lsg. zu Aufgabe Obstkorb Kap. 23.11.1
...................................................... 774 23.13
Lsg. zu Aufgabe Progress-Bar Kap. 23.11.2
............................................... 774 23.14 Lsg. zu
Aufgabe Tic-Tac-Toe 2 Kap. 23.11.3
.............................................. 774 23.15 Lsg. zu
Aufgabe Telefonbuch 6 Kap. 23.11.4
.............................................. 775
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 8 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
24 RTTI
........................................................................................................................
775 24.1
Aufgaben..............................................................................................................
777 24.2 Lsg. zu Aufgabe RTTI Kap. 24.1.1
..................................................................
777
25 Templates
...............................................................................................................
777 25.1 Motivation
.............................................................................................................
777 25.2 Grundlagen
..........................................................................................................
778 25.3 Praxis
...................................................................................................................
780 25.4 Funktions-Templates
............................................................................................
787 25.5 Klassen-Templates
..............................................................................................
789 25.6 Techniken
............................................................................................................
798 25.7 Fazit
.....................................................................................................................
804 25.8
Aufgaben..............................................................................................................
806 25.9 Lsg. zu Aufgabe swap Kap. 25.8.1
.................................................................
808 25.10 Lsg. zu Aufgabe Quadratwurzel-Fkt Kap. 25.8.2
......................................... 808 25.11 Lsg. zu Aufgabe
Complexe Zahlen Kap. 25.8.3
.......................................... 808 25.12 Lsg. zu
Aufgabe My lexical cast Kap. 25.8.4
............................................... 808 25.13 Lsg. zu
Aufgabe Stack Kap. 25.8.5
............................................................. 809
25.14 Lsg. zu Aufgabe Liste Kap. 25.8.6
............................................................... 809
25.15 Lsg. zu Aufgabe Date mit Policy Kap. 25.8.7
............................................... 809 25.16 Lsg. zu
Aufgabe Enum Check Kap. 25.8.8
.................................................. 809
26 Namespaces
...........................................................................................................
809 26.1 Problem
................................................................................................................
809 26.2 Prinzip
..................................................................................................................
810 26.3 Verschachtelung
..................................................................................................
810 26.4 Using- Deklarationen bzw. -Anweisungen
............................................................ 810
26.5 Unbenannte Namespaces
....................................................................................
811 26.6 Weiteres
...............................................................................................................
812 26.7
Aufgaben..............................................................................................................
812 26.8 Lsg. zu Aufgabe Tic-Tac-Toe 3 Kap. 26.7.1
................................................... 812
27 Fazit
........................................................................................................................
813 27.1 Reflektionen
.........................................................................................................
813 27.2 Schlussbetrachtung
..............................................................................................
816
28 Literatur
..................................................................................................................
817 28.1 Einsteiger-Literatur
...............................................................................................
817 28.2 Zur Vertiefung sehr zu empfehlen
........................................................................
817 28.3 Standards
.............................................................................................................
819 28.4 Web-Seiten
..........................................................................................................
820
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 9 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Abbildungen
Abb. 4-1 : MSV2003 Die IDE nach dem Start
....................................................................
34 Abb. 4-2 : MSV2003 Neues Projekt
...................................................................................
35 Abb. 4-3 : MSV2003 Programm-Assistent, berblick
........................................................ 36 Abb.
4-4 : MSV2003 Programm-Assistent, Seitenwechsel
................................................ 36 Abb. 4-5 :
MSV2003 Programm-Assistent, Programm-Optionen
....................................... 37 Abb. 4-6 : MSV2003 Neues
Projekt im Projektmappen-Explorer
....................................... 37 Abb. 4-7 : MSV2003
Leeres Projekt im Projektmappen-Explorer
...................................... 38 Abb. 4-8 : MSV2003
Projektmappe und Projekt speichern
................................................ 38 Abb. 4-9 :
MSV2003 Neue Datei erstellen
.........................................................................
39 Abb. 4-10 : MSV2003 Neuer Quelltext
...............................................................................
39 Abb. 4-11 : MSV2003 Quelltext speichern
.........................................................................
40 Abb. 4-12 : MSV2003 Fertiger Quelltext
............................................................................
40 Abb. 4-13 : MSV2003 Quelltext Kontext-Men
..................................................................
41 Abb. 4-14 : MSV2003 Projekt mit Quelltext
.......................................................................
41 Abb. 4-15 : MSV2003 Build Ausgaben
..............................................................................
42 Abb. 4-16 : MSV2003 Programmlauf
.................................................................................
42 Abb. 4-17 : MSV2003 Projektmappen-Verzeichnis
............................................................ 43
Abb. 4-18 : MSV2003 Projekt-Verzeichnis
.........................................................................
43 Abb. 4-19 : MSV2003 Debug-Verzeichnis
.........................................................................
44 Abb. 4-20 : MSV2003 Programmlauf in der Kommandozeile
............................................. 44 Abb. 4-21 :
MSV2003 Projekt Kontext-Men
.....................................................................
45 Abb. 4-22 : MSV2003 Projekt Eigenschaften Dialog, Sprache C++
................................... 46 Abb. 4-23 : MSV2003 Optionen
Dialog, Header Suchpfade
.............................................. 47 Abb. 4-24 :
MSV2003 Optionen Dialog, Bibliotheks Suchpfade
......................................... 48 Abb. 4-25 : MSV2003
Warnung
.........................................................................................
50 Abb. 4-26 : MSV2003 Projekt-Eigenschaften Dialog, Warnungen
..................................... 50 Abb. 4-27 : MSV2003 Keine
Warnung mehr
.....................................................................
51 Abb. 5-1 : Umlaute-Beispiel im Microsoft Visual Studio 2010
Editor unter Windows XP ....... 73 Abb. 5-2 : Umlaute-Beispiel in
der Windows XP Eingabeaufforderung
................................. 73 Abb. 9-1 : Speichermodell
eines Vektors
............................................................................
180 Abb. 9-2 : Hinten Einfgen und Lschen im Vektor
............................................................ 180
Abb. 9-3 : Vorne Einfgen und Lschen im Vektor
............................................................. 181
Abb. 9-4 : Speichermodell eines doppelt-verketteten Liste
................................................. 183 Abb. 9-5 :
Einfgen und Lschen in der doppelt-verketteten Liste
...................................... 183 Abb. 9-6 : Start- und
Ende-Iterator fr einen Vektor
........................................................... 185
Abb. 9-7 : Speichermodell eines Sets
.................................................................................
195 Abb. 9-8 : Einfgen im Set
.................................................................................................
196 Abb. 9-9 : Entstehung eines entarteten Baums
..................................................................
196 Abb. 9-10 : Suchen im sequentiellen Container
..................................................................
197 Abb. 9-11 : Suchen im Set
.................................................................................................
197 Abb. 9-12 : Speichermodell einer
Map................................................................................
199 Abb. 9-13 : Speichermodell eines Vektors
..........................................................................
211 Abb. 9-14 : Lschen und Einfgen im Vektor
.....................................................................
212
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 10 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Abb. 9-15 : Speichermodell einer Liste
...............................................................................
214 Abb. 9-16 : Speichermodell eines Sets
...............................................................................
217 Abb. 9-17 : Speichermodell einer
Map................................................................................
220 Abb. 11-1 : Die Trme von Hanoi
.......................................................................................
289 Abb. 12-1 : Datei, binr beschrieben - geffnet in einem Editor
......................................... 344 Abb. 12-2 : Eine
Kanone simuliert Pi
..................................................................................
382 Abb. 15-1 : Linker-Fehler bei Funktionen im Header ohne inline
...................................... 464 Abb. 18-1 : Trennung von
Containern und Algorithmen in der STL
.................................... 596 Abb. 18-2 : Menge nach
Anwendung von remove(it, eit, 2)
.............................................. 630 Abb. 18-3 :
Menge nach Anwendung von unique
............................................................. 633
Abb. 18-4 : Hierarchie der Iterator-Kategorien
....................................................................
659 Abb. 22-1 : Bild - Implementations-Konzept fr die Klasse
mystring ................................ 717 Abb. 22-2 : Fehler im
Destruktor
........................................................................................
719 Abb. 22-3 : Destruktor gibt Speicher frei
............................................................................
720 Abb. 22-4 : Fehler im Kopier-Konstruktor
...........................................................................
720 Abb. 22-5 : Kopier-Konstruktor arbeitet korrekt
..................................................................
722 Abb. 22-6 : Fehler im Kopier-Zuweisungs-Operator
........................................................... 722
Abb. 22-7 : Kopier-Zuweisungs-Operator V1
......................................................................
723 Abb. 22-8 : Fehler im Kopier-Zuweisungs-Operator
........................................................... 724
Abb. 22-9 : Fehler bei Exception
........................................................................................
725 Abb. 22-10 : Kopier-Zuweisungs-Operator V2
....................................................................
726 Abb. 22-11 : 2 Arten swap zu implementieren
..................................................................
732 Abb. 22-12 : Zeichenketten-Konstante in einen Vektor anhngen in
C++03 ...................... 734 Abb. 22-13 :
Zeichenketten-Konstante in einen Vektor moven in C++11
............................ 734 Abb. 23-1 : Eine ist-ein Beziehung
in der normalen Welt
................................................. 740 Abb. 23-2 :
Eine abstrakte ganz allgemeine ist-ein Beziehung
......................................... 740 Abb. 23-3 :
Klassen-Hierarchie des Beispiels
.....................................................................
742 Abb. 23-4 : Klassen-Hierarchie des erweiterten Beispiels
.................................................. 742 Abb. 23-5 :
Reihenfolge der Konstruktion eines abgeleiteten Objekts
................................ 745 Abb. 23-6 :
Objekt-Referenzierung ber verschiedene Typen
............................................ 752 Abb. 23-7 :
Klassen-Hierarchie des Beispiels fr virtuelle Funktionen
................................ 755 Abb. 23-8 : Klassen-Hierarchie
fr Probleme beim Dynamic-Cast
...................................... 767 Abb. 23-9 : 2
Schicht-Architektur eines Programms
........................................................... 769
Abb. 23-10 : Abhngigkeit in einer 2 Schicht-Architektur
.................................................... 769 Abb. 23-11
: Design der Modul-Entkopplung
......................................................................
770 Abb. 25-1 : Linkerfehler bei Templates
..............................................................................
782
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 11 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Versions-Historie
Version 34, 821 Seiten, Februar 2015 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - Das
Kapitel 2 ber die C++ Standards, die Compiler, Boost und andere
Bibliotheken
wurde auf den neusten Stand gebracht. Hierbei wurde das
bisherige Kapitel 2.3 ber die ISO Standards, Compiler und das
Skript auf drei Kapitel 2.3 - 2.5 verteilt Kapitel 2.4 beschreibt
nun die Compiler-Status bzgl. des Standards, und Kapitel 2.5 den
des Skripts. Durch die neuen Kapitel 2.4 & 2.5 haben sich die
Kapitel-Nummern der restlichen Kapitel von 2.4-2.6 auf 2.6-2.8
verndert.
- Kleine Erweiterungen in den Kapiteln 5.4.1.4 und 5.4.1.5 ber
die Initialisierungen von Variablen mit der neuen vereinheitlichten
Initialsierungs-Syntax.
- Kapitel 9.7 ber Maps um einige C++11 Erklrungen erweitert und
an die nderungen in den Kapiteln 11.4 und 13.8 angepat.
- In Kapitel 10.2.5 ber C++11 R-Value Referenzen diese
ausfhrlicher beschrieben. - Neues Kapitel 10.2.6 ber C++11
Forward-Referenzen. - Kapitel 10.4 ber Typ-Konvertierungen wurde
etwas berarbeitet vor allem was die
impliziten Typ-Konvertierungen angeht. Daher gibt es auch ein
neues Unter-Kapitel 10.4.1 ber impliziten Typ-Konvertierungen die
bisherigen Kapitel 10.4.1 10.4.3 wurden auf 10.4.2 10.4.4
umnummeriert.
- Kapitel 11.3.5 ber die neue C++11 Funktions-Syntax wurde um
die neue C++14 Syntax mit Auto-Rckgabe-Typ-Deduktion erweitet.
- Neues Kapitel 11.3.6 ber neue Objekte bei Funktions-Rckgaben.
- Neues Kapitel 11.4 ber Typ-Konvertierungen bei Funktions-Aufrufen
und Rckgaben.
Die bisherigen Kapitel 11.4 11.18 wurden auf 11.5 11.19
umnummeriert. - Kapitel 11.6 ber Funktions-berladung (vorher
Kapitel 11.5) wurde komplett neu
geschrieben und an die vernderten bzw. neuen Kapitel 10.4, 11.4
und 13.8 angepat. - Kapitel 12.5 ber Zufallszahlen ist komplett neu
geschrieben und wurde an C++11
angepat. - Kapitel 13.8 ber Konstruktoren wurde komplett neu
geschrieben und dabei stark
erweitert und an C++11 und C++14 angepat u.a. wurden Move-,
Konvertierungs- und Sequenz-Konstruktoren, temporre Objekte und
implizite Konvertierungen eingefhrt.
- Kurzes grob einfhrendes neues Kapitel 17.6 ber den C++11
Move-Zuweisungs-Operator . Damit haben sich die alten
Kapitel-Nummern der Kapitel 17.6-17.13 zu 17.7-17.14 verndert.
- In Kapitel 20.1 ber Zeiger und Adressen zustzlich den Begriff
shallow size eingefhrt.
Version 33, 792 Seiten, Mrz 2014 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - Kapitel
2.3 ber die ISO C++ Standards um Anmerkungen zu den kommenden
Standards C++14 und C++1y ergnzt. - Kapitel 2.4 wurde um
Hinweise auf einige subjektiv wichtige C++ Bibliotheken fr z.B.
GUI und Spiele-Programmierung erweitert.
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 12 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
- Kapitel 2.5 wurde bzgl. Boost auf die neuste Version 1.55
geupdatet, und auerdem wurde die Motivation fr Boost (gerade fr
C++03) berarbeitet.
- Kapitel 5.1.1 wurde um einen Verweis auf das neue Kapitel
12.10 ber die Klasse numeric_limits erweitert.
- Kapitel 5.4.1 ber Variablen-Definitionen wurde in groen Teilen
neu geschrieben, u.a. um mehr C++11 Features wie
Initialisierungs-Listen und decltype zu bercksichtigen.
- Kapitel 5.5.1 ber das Zusammenspiel von const und auto in
C++11 wurde erweitert und an das vernderte Kapitel 5.4.1
angepat.
- Kapitel 9.8 ber weitere STL Container um zustzliche
Informationen ber Hash-Container erweitert.
- Kapitel 9.15.2.3 wurde stark reduziert, indem die detailierten
Information ber std::numeric_limits in ein eigenes neues Kapitel
12.10 verschoben wurden, und dort nun detailierter dargestellt
werden.
- Kapitel 11.2.4 ber die Parameter-bergabe-Regel wurde ergnzt
und an das Optimierungs-Beispiel in Kapitel 22.4.4 und die
Move-Semantik angepat.
- Kapitel 11.8.1 (Aufgabe Swap-Funktion) und die dazugehrige
Musterlsung Kapitel 11.9 um Hinweis auf Move-Semantik und die
Standard Swap-Funktion erweitert.
- Kapitel 12.1.2 ber die File-Stream Erzeugung mit Zeichenketten
um Hinweise und Verweise auf das komplett vernderte Kapitel 22
angepat.
- Neues Kapitel 12.1.3 ber das ffnen von Dateien zum Schreiben,
ohne die Datei dabei zu lschen sondern den neuen Inhalt an den
Alten anzuhngen. Achtung, die bisherigen Kapitel 12.1.3 12.1.5
muten daher zu den Kapiteln 12.1.4 12.1.6 umnummeriert werden.
- Die Lsung 11.12 fr die Aufgabe 11.8.4 (Fibonacci-Reihe) wurde
um einige Anmerkungen bzgl. der Performance und Zeit-Komplexitt der
rekursiven Lsung erweitert u.a. auch durch einen Link auf einen
Artikel im Internet, der die rekursive Lsung mit Caching
bespricht.
- Kapitel 12.1.4 (neue Nummerierung, frher Kapitel 12.1.3) ber
das binres ffnen von Dateien wurde um mehr Informationen und ein
Beispiel erweitert.
- Neues Kapitel 12.8 ber die Funktion std::swap aus der
Standard-Bibliothek. - Neues Kapitel 12.9. ber Pairs und Tuple in
der C++ Standard-Bibliothek und Boost. - Neues Kapitel 12.10. ber
Numeric-Limits in der C++ Standard-Bibliothek. - Die bisherigen
Kapitel 12.8 12.15 muten aufgrund der neuen Kapitel 12.8, 12.9
und
12.10 zu den Kapiteln 12.11 12.18 umnummeriert werden. - Kapitel
13.10.1 ber die Zugehrigkeit von const zur Signatur bei
Const-Element-
Funktionen erweitert. - Kapitel 19.4.5 ber
Exception-Spezifikationen wurde an C++11 angepat. - Neues Kapitel
19.4.6 ber die neue C++11 Exception-Spezifikation noexcept. - Neues
Kapitel 19.7 ber das Zusammenspiel von Exception-Sicherheit und der
Swap-
Funktion. - Die bisherigen Kapitel 19.7 19.10 haben sich durch
das neue Kapitel 19.7 zu den
Kapiteln 19.8 19.11 umnummeriert. - Kapitel 22 ist komplett neu
geschrieben worden. Es wurden zwar auch alte Teile
bernommen, aber alle Kapitel wurden verndert, viele neue sind
hinzugekommen, und auch die gesamte Struktur wurde verndert.
Zustzlich zu dem bislang
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 13 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
vorhandenen Thema Klassen mit externen Ressourcen wird jetzt in
Kapitel 22 auch Swapping und zumindest einfhrend Move-Semantik in
C++11 abgehandelt.
Version 32, 757 Seiten, Feb. 2013 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - Kapitel
2.6 wurde komplett neu geschrieben, und gibt nun einen kurzen
berblick,
welche Tools man bentigt, um ein C++ Programm zu erzeugen und zu
bersetzen. - Es gibt ein neues kleines Kapitel 4.4, das einige
Hinweise auf C++ Dokumentation
enthlt, die Sie vielleicht hilfreich finden. Achtung dadurch hat
sich die Numerierung der bisherigen Kapitel 4.4, 4.5 und 4.6 zu
4.5, 4.6 und 4.7 verndert.
- In Kapitel 9.2 eine neue Abbildung (Abb. 9.3) ber das Einfgen
und Lschen von Elementen vorne im Vektor hinzugefgt.
- Kapitel 9.11 (Container Referenz) um zwei Internet-Links zu
C++ Referenz-Seiten erweitert.
- Im Kapitel 17 ber Operator-berladung gibt es viele kleine und
einige grere Erweiterungen und nderungen u.a. Umbenennung der
Bruch-Klasse auf rational, Vervollstndigung der Beispiele,
Erweiterung des Vergleichs zwischen bisherigen Funktionen und neuen
Operatoren. Insbesondere betroffen davon waren die Kapitel 17.1,
17.4 und 17.10.
- Kleine nderungen und Erweiterungen in Kapitel 18.1.1. -
Kapitel 18.2 ber Lambda-Ausdrcke ist fertig gestellt. Komplett neu
ist dabei das
Kapitel 18.2.2 ber die C++11 Lambdas. Und das Kapitel 18.2.3 ber
funktionale Bibliotheken wie die BLL wurde endlich an die
Vernderungen im Tutorial angepat und dabei komplett
berarbeitet.
- Auch Kapitel 18.5 (Fazit zu Algorithmen, Lambdas und
Iteratoren) wurde komplett neu geschrieben und an die neuen Inhalte
und die neue Kapitel-Struktur angepat.
- Aufgabe 18.6.1 und die zugehrige Musterlsung 18.7 wurden an
die neuen Inhalte wie z.B. die C++11 Lambdas angepat.
- Viele kleine nderungen in Kapitel 23, wie Umformatierungen,
korrektes Syntax-Highlighting oder explizitere Auszeichnung der
Compiler-Fehler.
- Neues Kapitel 23.2.5, in dem noch mal an einem komplexeren
Beispiel der Sinn von dynamischen Typen erklrt wird.
- Neues Kapitel 28.4 mit den allerwichtigsten Web-Seiten zu
C++
Version 31, 738 Seiten, Dez. 2012 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - In
Kapitel 8.1.8 ber Suchen und Ersetzen in Strings die
Funktions-Erklrungen
verbessert. - In Kapitel 9.7.1 den zustzlichen Hinweis mit
Begrndung eingefgt, da der Operator
[ ] nicht fr konstante Maps genutzt werden kann. - Neue Aufgabe
11.8.8 ber die Formatierung eines Strings mit Eintrgen aus
einem
Wrterbuch, und Musterlsung 11.16. Die Musterlsung besteht
bislang nur aus Quelltext ohne Erklrung. Achtung durch diese
Aufgabe und Lsung haben sich die Kapitel-Nummern hinter 11.8.8 und
11.16 entsprechend verndert.
- In Kapitel 12.2.1 die Gren aller Dateien in die
Beispiel-Datei-Struktur fr die Aufgabe
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 14 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
12.8.4 eingetragen. - In der Aufgabe 12.8.4 die
Benutzer-Eingaben der Beispiele korrekt blau eingefrbt. -
Quelltexte der Musterlsung 12.12 fr die Aufgabe 12.8.4
(Platten-Platz) hinzugefgt,
einmal mit eigener Rekursion, und einmal mit rekursivem
File-System Iterator. Zur Zeit ist die Musterlsung noch ohne
Erklrung, nur Quelltexte.
- Quelltexte der Musterlsung 12.13 fr die Aufgabe 12.8.5
(Datei-Suche) hinzugefgt, einmal mit eigener Rekursion, und einmal
mit rekursivem File-System Iterator. Zur Zeit ist die Musterlsung
noch ohne Erklrung, nur Quelltexte.
- In der Musterlsung 12.15 (Simulation von Pi) die berflssige
Wurzel-Berechnung und den zugehrigen Header cmath entfernt.
- Kapitel 17.6 ber den Funktions-Aufruf-Operator um den Hinweis
auf die typische Nutzung von Funktions-Objekten in den STL
Algorithmen erweitert.
- Kapitel 18.1 ber den Einstieg in die STL Algorithmen umgebaut
und erweitert. U.a. hat das Einfhrungs-Kapitel 18.1.2 drei neue
Beispiele und weitere Informationen ber Funktions-Objekte bekommen.
Es gibt ein neues Kapitel 18.1.3 ber Callables, die Nutzung von
Callables zusammen mit STL Algorithmen, und einen Vergleich von
Funktionen und Funktions-Objekten. Auerdem wurde das bisherige
Kapitel 18.1.4 verschoben und zu Kapitel 18.3.
- Das bisherige Kapitel 18.3 ber Lambdas wurde zum Kapitel 18.2.
Achtung, das Kapitel ist weiterhin nur in einem Rohzustand.
- Es gibt ein neues Kapitel 18.3 (vorher Kapitel 18.1.4), das
einige STL Algorithmen detailierter beschreibt, und viele neue
Beispiele mit Funktions-Objekten und Lambda-Ausdrcken enthlt, und
auch an die nderungen in den Kapiteln Kapitel 17.6 und 18.1.3
angepat wurde.
- Das bisherige Kapitel 18.2 ber Iteratoren wurde zu Kapitel
18.4. - Die restlichen Unter-Kapitel (nach bisher 18.3) in Kapitel
18 haben sich um ein
Unterkapitel nach hinten verschoben, z.B. Kapitel 18.4 wurde zu
18.5, usw.
Version 30, 709 Seiten, Nov. 2012 - Versions-Historie von einer
Tabelle auf eine Auflistung umgestellt, da die Tabellen-
Zellen ber eine Seite gingen und die Seitenumbrche dadurch
unschn wurden. - In vielen Kapiteln wurden Rechtschreibfehler und
kleine Ausdrucksfehler beseitigt. - Und weiter fehlendes
Syntax-Highlighting in vielen Beispielen nachgezogen, vor allem
in den Kapiteln 18.2 und 18.3, aber auch in vielen anderen
Kapiteln. - Alle fehlenden Verweise ergnzt und weitere eingefgt. -
Tutorial an die neuste Boost-Version 1.52.0 vom 6.11.2012 angepat.
- Kapitel 5.7 ber Ausdrucks-Optimierungen und Sequenz-Punkte
eingefgt. Eigentlich
wollte ich in diesem Tutorial nie so tief in die dunklen Seiten
von C++ einsteigen, aber die aktuellen Erfahrungen aus dem
Praktikum haben mich eines Besseren belehrt.
- Kapitel 6.3.1 ber die neue C++11 For-Schleife fr Container an
das neue Kapitel 9.4.2.1 angepat.
- Abbildungen 9.1 und 9.2 fertig gestellt und eingefgt Vektor
Speichermodell und beim Vektor hinten einfgen und lschen.
- Die Lsungs-Variante 9.13.2 mit expliziter Sortierung bei der
Aufgabe 9.12.1 Hallo Personen wurde ins Kapitel 18 verschoben, da
erst dort die entspechenden
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 15 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Informationen ber STL-Algorithmen zur Verfgung stehen. - Kapitel
9.4.2 ber bisher nur Boost.For-Each komplett erneuert, und um
eine
Beschreibung der neuen C++11 For-Schleife fr Container
erweitert. - Neues Kapitel 9.10 ber C++11 Container
Initialisierungen und die Boost-Assignment
Library. Dies ist kein neues Kapitel, sondern wurde von Kapitel
18.1 hierhin verschoben, da dieses Wissen in vielen Musterlsungen
benutzt wird. Auerdem wurden einige Ergnzungen und
Fehlerbeseitigungen vorgenommen. Achtung, durch die Kapitel
Verschiebung haben sich die Kapitel-Nummerierungen in Kapitel 9 ab
9.10 und auch in Kapitel 18 verndert.
- Neues Kapitel 10.2.4 ber die Relevanz von Referenzen, mit
Beispielen fr den Unterschied zwischen Kopie und Referenz.
- Neues sehr kleines Kapitel 10.2.5, das auf die neuen R-Value
Referenzen von C++11 hinweist.
- Kapitel 10.4 ber Typ-Konvertierungen erweitert und
berarbeitet. - Kapitel 11.3.4 ber const Funktions-Rckgaben
erweitert, gerade auch um die C++11
Regel fr Move-Semantik - Neues Kapitel 11.3.5 ber die neue C++11
Funktions-Rckgabe-Typ Syntax. - nderungen an der Musterlsung 11.10
fr die Aufgabe 11.8.2 bzgl. String-Lnge. - Neues Unterkapitel
12.1.4 mit Hinweis auf die quivalenten File-Streams der
Boost.Filesystem Library - Kapitel 12.2 ber die Boost.Filesystem
Library, das bisher nur aus einem Quelltext
bestand komplett erstellt inkl. Kurz-Referenz und mehrerer
Beispiele. - Kapitel 12.3 ber exit um mehr Informationen ber das
Argument ergnzt. - Kapitel 12.6 ber mathematische Funktionen um die
Wurzel-Funktion sqrt erweitert,
und einige zustzliche Infos ber die Funktion log10 hinzugefgt. -
Neue Aufgabe 12.8.4 zur Feststellung des Platten-Platz-Verbrauchs
von Dateien,
bislang ohne Lsung die dazugehrige Musterlsung 12.12 ist noch
leer. Achtung durch diese und die nchste neue Aufgabe haben sich
die Kapitel-Nummerierungen in 12.8 und ab 12.12 verndert.
- Neue Aufgabe 12.8.5 zur Suche von Dateien bestimmter
Extensions, bislang ohne Lsung die dazugehrige Musterlsung 12.13
ist noch leer. Achtung durch diese und die vorherige neue Aufgabe
haben sich die Kapitel-Nummerierungen in 12.8 und ab 12.12
verndert.
- Neue Aufgabe 12.8.7 zur Simulation von Pi, und die dazugehrige
neue Musterlsung 12.15. Die Musterlsung besteht bislang nur aus dem
Quelltext und enthlt noch keine Erluterung.
- Kapitel 18.1 wurde verschoben ins Kapitel 9 und ist nun
Kapitel 9.10. Achtung dadurch haben sich die Kapitel-Nummerierungen
in Kapitel 9 (ab 9.10) und in Kapitel 18 verndert.
- Neue Aufgabe 18.5.2 mit zugehriger fertiger Musterlsung 18.7.
Eigentlich ist dies keine neue Aufgabe, sondern nur eine weitere
Lsungs-Variante fr die Aufgabe 9.12.1 nun mit expliziter
Sortierung. Achtung auch hierdurch hat sich die restliche
Kapitel-Nummerierung in Kapitel 18 verndert.
- Kapitel 19.4.5 ber Exception-Spezifikationen verbessert und
auf den neusten C++11 Stand gebracht.
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 16 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Version 29, 684 Seiten, Okt. 2012 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. -
Fehlendes Syntax-Highlighting in vielen Beispielen nachgezogen. -
Im gesamten Tutorial einheitlich auf const typ& und const typ*
umgestellt, und
angefangen auf const typ umzustellen. - Anpassungen in Kapitel
2.3 und 2.5 an die aktuellen Versionen der aufgefhrten
Compiler und der Boost Bibliothek. - Kapitel 3.2 ber
Using-Anweisungen und Using-Deklarationen um einen Abschnitt
ber
die praktischen Vorteile von Using-Deklarationen, z.B. bei
einigen Musterlsungen, erweitert.
- Kapitel 4.3 (Editoren, Compiler, IDEs,) aktualisiert und um
das Unter-Kapitel 4.3.2.2 ber den C++ Compiler CLANG erweitert.
- Viele nderungen in den Kapitel 5.4 und 5.5 ber Variablen und
Konstanten, so u.a. die Einfhrung des C++11 Features auto und
erweiterte Beschreibungen.
- Kapitel 5.6 ber Operatoren erweitert, u.a. um viele neue
Unter-Kapitel, die einige nicht intuitive Operatoren im Detail
erklren.
- Neue Aufgabe 5.7.1 und neue zugehrige Musterlsung in Kapitel
5.8. Achtung die bisherige Aufgabe 5.7.1 und ihre Musterlsung 5.8
haben sich dadurch in die Kapitel 5.7.2 und 5.9 verschoben.
- Kleine nderungen in Kapitel 6.2 ber die Switch-Anweisung. -
Neues Kapitel 6.3.1 ber die neue C++11 For-Schleife fr Container. -
Neues Kapitel 7.1.2 ber die Manipulatoren boolalpha und
noboolalpha. - Kleines neues Kapitel 8.1.2 ber String-Iteratoren
und Algorithmen. - Zwei neue Aufgaben 8.6.2 und 8.6.4 im
String-Kapitel mit ihren Musterlsungen 8.8
und 8.10 (nur Quelltext, noch keine Erklrung). Die alte Aufgabe
8.6.2 und ihre Musterlsung 8.8 wurden nach 8.6.3 bzw. 8.9
verschoben.
- In Kapitel 10.1.1 einen Hinweis auf C++11 eingebaut. - Neues
Unterkapitel 10.2.2 ber die Kombination von Referenzen und dem
C++11
Schlsselwort auto. - Kapitel 10.3 ber Enums wurde vollstndig
berarbeitet, und auch um Hinweise fr
einige neue C++11 Features erweitert. - Mehrere Verbesserungen
und Erweiterungen in Kapitel 17 ber Operator-berladung,
u.a. ein neues Unter-Kapitel 17.6 ber das berladen des
Funktions-Aufruf-Operators. - Neue Aufgabe 18.6.2 im Kapitel ber
Algorithmen mit Musterlsung 18.8 nur
Quelltext, keine Erklrung.
Version 28, 664 Seiten, Jan. 2012 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - Kapitel
12.1.2 wurde umformuliert und an C++11 angepat. - Neues Kapitel
12.2 ber Datei-System Handling mit der Boost-Filesystem-Library
angefangen bislang besteht es nur aus einem Quelltext. Durch
dieses neue Kapitel haben sich die Kapitelnummern der restlichen
12er Unterkapitel natrlich erhht.
Version 27, 662 Seiten, Dez. 2011
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 17 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
- In vielen Kapiteln wurden Rechtschreibfehler und kleine
Ausdrucksfehler beseitigt. - Kapitel 2.5 an die neuste Boost
Version 1.48.0 vom 15.11.2011 angepat. - In Kapitel 8 wurde ein
Kapitel (8.5) ber die Boost-Tokenizer-Library hinzugefgt, und
die gesamte Struktur der weiterfhrenden Kapitel ber z.B.
String-Streams, Wandlungen oder die Boost-String-Algorithm-Library
komplett neu organisiert.
- In Kapitel 9.4 wurde der Hinweis aufgenommen, dass das
Iterator-Paar (Start- und Ende-Iterator) nicht zwingend einem
Container entsprechen mu.
- In Kaptitel 9.7 wurden mehrere Beispiele leicht verndert und
erweitert. - In Kapitel 9.10 kleine Fehler beseitigt,
Beschreibungen konkretisiert, und einige
weitere Funktionen hinzugefgt. - Und wieder eine grundlegende
nderung. Ich habe das neue Kapitel 12, das erst mit
Version 25 eingefhrt wurde, noch weiter nach hinten verschoben.
Nun ist es zu Kapitel 18 geworden. Hintergrund: in Kapitel 17
werden Funktions-Klassen bzw. Funktions-Objekte eingefhrt, und die
wollte ich gerne zur Verfgung haben.
- Kapitel 13.16 wurde nach vorne vor die Aufgaben geschoben und
ist nun zu Kapitel 13.12 geworden. Auerdem habe ich das Kapitel im
Detail leicht verndert und an neue Entwicklungen angepat.
- An Kapitel 18 (vorher Kapitel 12) wurde weiter geschrieben.
Sowohl Kapitel 18.2 als auch Kapitel 18.3 sind nun bis auf die noch
fehlenden Abbildungen fertig.
Version 26, 645 Seiten, Nov. 2011 - In vielen Kapiteln wurden
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - Und mal
wieder Kapitel 5.3 erweitert und verbessert das Thema Zeichenstze
und
Internationalisierung macht mir immer wieder Probleme.
Eigentlich will ich das Thema nicht gro besprechen da es den Rahmen
sprengt und nicht das Haupt-Thema ist aber ignorieren kann ich es
auch nicht.
- Minimale Erweiterungen im Kapitel 5.6. - Kapitel 8.1.5 wurde
um ein Beispiel fr den fehlerhaften Vergleich von
Zeichenketten-
Konstanten erweitert. - Kapitel 8.4 um ein paar Infos und ein
Beispiel erweitert. - Kapitel 9 wurde weiter bearbeitet und ist nun
erstmal fertig besonders die
Unterkapitel 9.4, 9.5, 9.6 und 9.7 sind komplett neu geschrieben
worden aber auch alle anderen Kapitel wurden verndert. Es fehlen
noch alle Abbildungen und die Aufgaben mssen noch an die neue
Kapitel-Struktur angepat werden.
- Kapitel 12 wurde angefangen neu zu schreiben bis Kapitel
12.2.3.4 ist es halbwegs fertig.
- Kapitel 17.2 wurde aufgrund des Kapitel 12.1.1 umbenannt und
exakter formuliert.
Version 25, 610 Seiten, Okt. 2011 - Kapitel 1 wurde auf die
aktuelle Vorlesung & Praktikum angepat. - Kapitel 2 wurde an
den neuen C++ ISO Standard C++11 und die Situation rund um
den Standard herum angepat Kapitel 2.5 auch an die neuste Boost
Version. Hier hat sich also einiges gendert.
- Kapitel 3.2 wurde um eine Kurzeinfhrung von
Using-Deklarationen erweitert. - Viel kleine nderungen in Kapitel 4
an die neusten Versionen von Editoren, Compilern
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 18 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
und natrlich auch den neuen ISO Standard C++11. - Das Kapitel 5
ist an vielen Stellen verbessert und umformuliert worden,
auerdem
wurden neue Beispiele eingefhrt und mehrere Stellen stark an den
neuen Standard C++11 angepat besonders die Unter-Kapitel 5.1 und
5.4.1.
- Kapitel 6.1 wurde komplett neu geschrieben viel ausfhrlicher
und mehr Beispiele. - Kleine nderungen in Kapitel 6.8 u.a.
Beispiele erweitert. - Viele kleine nderungen in Kapitel 7
Rechtschreibfehler, Beispiele erweitert und
Erklrungen verbessert. - Auch Kapitel 8 hat einige Erweiterungen
erfahren, besonders die Unter-Kapitel 8.1.1,
Kapitel 8.4 und Kapitel 8.2.1. - Es wurde angefangen Kapitel 9
in vielen Teilen komplett neu zu scheiben und Teile in
ein neues Kapitel 12 auszulagern, um die Container &
Iteratoren auf der einen Seite (Kapitel 9) und die
Fortgeschrittenen-Themen wie z.B. Algorithmen (Kapitel 12) zu
trennen.
Version 24, 592 Seiten, Mrz 2011 - Titelblatt eingefhrt mit
Copyright und Hinweis auf die freie Verfgbarkeit des
unvernderten Skripts fr Unterrichtszwecke. - Fuzeile um Link auf
meine Homepage erweitert - Kapitel 1 um Copyright und Hinweis auf
die freie Verfgbarkeit des unvernderten
Skripts fr Unterrichtszwecke erweitert. - In vielen Kapiteln
Rechtschreibfehler und kleine Ausdrucksfehler beseitigt. - Kapitel
11.17.1 um Hinweis zur Vermeidung globaler Variablen ergnzt. -
Kapitel 14.2.1 ergnzt um Verweise auf gebruchliche C++ Style Guides
inkl. Links
ins Internet.
Offene Punkte - Kapitel 6 enthlt noch viele offene Punkte, da es
an einigen Stellen noch zu knapp ist. - Erklrungen zu Pair und zur
Boost Tuple Library in Kapitel 16.8.6.5 aus der Lsung
der Aufgabe Gerchtekche heraus ins Kapitel 12 verschieben.
Erklrung ist verschoben nun mu noch Kapitel Kapitel 16.8.6.5
entsprechend umgebaut werden.
- Die Kapitel ber Time in Kapitel 12 um die neusten C++11 (und
Boost) Libs erweitern. - Lsung in Kapitel 12.10.5.2 vollstndig
transaktions-sicher machen, d.h. alten Vektor
erst berschreiben, wenn alle Strings fehlerfrei eingelesen
werden konnten.
1 Organisatorisches Dozent
Name: Detlef Wilkening mailto:[email protected]
Termine
Vorlesung Mo. 16:25 ca. 18:45 Raum 01 2 10
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 19 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Praktikum Mo. ca. 18:50 - 20:10 Raum 01 2 11 Auerdem 4 weitere
Termine in November, Dezember und Januar Die aktuellste
Terminplanung finden Sie im Internet unter:
http://www.wilkening-online.de . Voraussetzungen
Fr die Vorlesung
Allgemeine Computer-Kenntnisse s.u. Kenntnisse der
Programmiersprache C Fr das Praktikum
Benutzer fr das FH Netz vorhanden Das Praktikum kann unter
Windows oder Linux durchgefhrt werden:
unter Linux mit GCC 4.6 oder hoffentlich neuer unter Windows mit
dem Microsoft Visual Studio 2008 oder hoffentlich neuer Aufgaben fr
das Praktikum finden Sie am Ende der meisten Kapitel. Hinweise zur
Benutzung der Compiler finden Sie in den Kapiteln 4.1 und 4.2. Was
meint allgemeine Computer-Kenntnisse?
Windows wenn Sie unter Windows arbeiten wollen, erwarte ich,
dass Sie problemlos mit fensterorientierten Programmen umgehen
knnen. Auerdem sollten ihnen das Konzept und der Aufbau des
Dateisystems bekannt sein, und sie sollten mit dem Datei-Explorer
jederzeit Verzeichnisse aufsuchen und Dateien finden knnen. Schn
wre es, wenn sie zustzlich schon mal mit der Windows-Kommandozeile
(Eingabeaufforderung) gearbeitet haben, und hier die wichtigsten
Kommandos (z.B. dir, cd, usw.) kennen.
Linux wenn Sie unter Linux arbeiten wollen, so sollten Sie
problemlos mit der Linux-Kommandozeile (oder auch Terminal bzw.
Console genannt) arbeiten knnen. Sie sollten die wichtigsten
Befehle beherrschen, und das Konzept der Programm-Parameter kennen
und anwenden knnen unter Linux werden Sie den Compiler auf der
Kommandozeile mit den entsprechenden Parametern aufrufen mssen.
Auerdem sollten Sie einen der installierten Editoren beherrschen,
z.B. vi, Emacs oder Joe. Auf Dauer hilfreich wre es es ist aber
nicht notwendig wenn Sie aus Ihrer C-Erfahrung unter Linux schon
Make-Systeme kennen und in kleinem Umfang anwenden knnen. In diesem
Fall knnten Sie sich solche auch fr C++ erstellen. Make-Systeme
werden in Kapitel 4.3.3 zwar kurz vorgestellt, sind aber nicht Teil
der C++ Vorlesung und werden fr die Umfnge der Beispiele und
bungs-Aufgaben in der Vorlesung nicht zwingend bentigt.
Prfung
Anmelden im Prfungsamt bzw. im Campus-System Termin mit mir
ausmachen (z.B. per Mail) Mndlich, 20-30 Minuten
- es geht mehr um Verstndniss der Konzepte - weniger um
syntaktische Feinheiten
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 20 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Skript
Das Skript wird jedes Semester stndig erweitert und berarbeitet,
aber es enthlt noch immer Lcken, und sicher auch noch Fehler.
Das Skript wird im Laufe der Vorlesung immer wieder aktualisiert
die aktuellste Version finden Sie im Internet unter
http://www.wilkening-online.de . Siehe auch die Versions-Nummer in
der Kopf-Zeile.
Copyright
Dieses Skript darf in unvernderter Form fr Unterrichtszwecke
weitergegeben und verwendet werden. Ich freue mich aber ber
Rckmeldungen zum Einsatz des Skriptes, ber eine Information, wie
Sie von dem Skript erfahren haben, und natrlich ber Fehlerhinweise
und Erweiterungs-Vorschlge. Noch ein wichtiger Hinweis zum
Skript
Im PDF sind in den Quelltexten die Underscores _ zum Teil nur
schlecht bis gar nicht zu sehen gerade in der ausgedruckten Form.
In folgendem Beispiel sind die Namensteile der Symbole durch
Underscores _ getrennt zum Teil ist das nicht lesbar.
const_iterator value_type _1_2_3
Achtung auch wenn Sie hier die Underscores sehen knnen so heit
das leider nichts fr andere Stellen im Skript. Seien Sie im
Einzelfall beim Durcharbeiten der Quelltexte aufmerksam, und wenden
Sie Ihren gesunden Menschenverstand an. Inhalt der Vorlesung
Trotz C Vorkenntnissen macht die Vorlesung einen vollen
Neueinstieg mit C++. Damit lernen Sie direkt, Programme in C++ zu
schreiben und Probleme in C++ Art zu lsen (und nicht weiter C
Programme zu schreiben, die nur um C++ Elemente erweitert worden
sind).
Wozu brauchen Sie dann noch C Kenntnisse? Damit wir ber die
Grundlagen der Programmierung und viele Sytnax-Feinheiten sehr
schnell hinweg fliegen knnen.
C++ ist extrem umfangreich von daher wird nur ein Teil der
Sprache, der Bibliotheken und der Techniken gelehrt werden knnen.
Der Lehrstoff wird daher motiviert durch drei Anforderungen: -
unbedingt notwendige Elemente von C++ - C++ Elemente zum Lsen von
Aufgaben - Programmieren lernen Es wird immer Hinweise auf weitere
Details geben, die Vorlesung wird sich aus Zeitmangel aber
beschrnken mssen. Wenn Sie wirklich ordentlich C++ programmieren
lernen wollen, werden Sie sich diese Details und weitergehendes
Wissen in Form von Bchern, Artikeln und Erfahrung aneignen
mssen.
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 21 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Praktikum
In den meisten Kapiteln im Skript findet sich am Ende Aufgaben,
die sie im Praktikum lsen sollen. Manche der Aufgaben sind einfach
und in wenigen Zeilen zu lsen, andere sind schon ganz schn
anspruchsvoll, und stellen richtige kleine sinnvolle Programme dar,
an denen Sie mglicherweise mehrere Praktika hindurch knabbern
mssen. Ein Ziel der Vorlesung ist auch programmiern lernen von
daher werden wir fr einen Teil der Aufgaben die Lsungen in der
Vorlesung besprechen. Sie finden diese Lsungen auch im Skript. Aber
damit Sie vom Praktikum etwas haben, sollten Sie trotzdem
versuchen, die Aufgaben selbstndig zu lsen, und am Schlu ihre Lsung
mit der Musterlsung des Skripts vergleichen. Sie lernen C++ nicht
vom Abtippen, sondern nur wenn Sie sich aktiv mit Problemen
herumschlagen. Viele Beispiele und Musterlsungen aus dem Skript
knnen Sie als Zip-Archiv im Internet unter
http://www.wilkening-online.de herunterladen weitere Informationen
hierzu finden Sie auch in Kapitel 4.5.
2 Allgemeines zu C++
2.1 Entwicklung Entwickelt von Bjarne Stroustrup
Start der Entwicklung Mai 1979 Erster ISO Standard Juli 1998 -
ISO/IEC 14882:1998 Zweiter ISO Standard 2003 - ISO/IEC 14882:2003
Dritter ISO Standard August 2011 - ISO/IEC 14882:2011 Aktueller ISO
Standard Januar 2015 - ISO/IEC 14882:2015
Entstanden aus C C++ basiert auf ISO C von 1990 D.h. (fast)
jedes C Programm ist (syntaktisch) ein C++ Programm
2.2 Paradigmen Sprachparadigmen in C
imperativ prozuderal Sprachparadigmen in C++
imperativ prozuderal objekt-orientiert generativ funktional C
ist sehr klein und maschinennah, mit allen Vorteilen:
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 22 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
kleiner Sprachkern => problemloser Compiler effizient Aber C
hat wenig Sprachmittel fr hhere Abstraktionslevel. Auerdem gibt es
in C viele Probleme und Fallen (z.B. im Kontext von Typsicherheit,
Zeigern, dynamischer Speicherverwaltung, Stringhandling,
printf/scanf, Bufferoverflows, usw...). D.h. fr viele C
Sprachmittel bzw. Vorgehensweisen gibt es in C++ neue Sprachmittel
bzw. neue Verfahren. Viele dunkle und graue Seiten der Macht sind
durch hellere Elemente ersetzt worden.
2.3 Der ISO C++ Standard Mittlerweile gibt es die vierte
Generation des ISO C++ Standards:
Erster ISO Standard C++98 vom Juli 1998 - ISO/IEC 14882:1998
Zweiter ISO Standard C++03 von 2003 - ISO/IEC 14882:2003 Dritter
ISO Standard C++11 vom August 2011 - ISO/IEC 14882:2011. Der neue
aktuelle ISO Standard C++14 vom Januar 2015 - ISO/IEC 14882:2015.
Hinweis der Standard C++11 wurde lange gerne mit C++0x bezeichnet.
Man wollte damit andeuten, dass er noch im letzten Jahrzehnt
erscheinen sollte, das exakte Jahr aber noch unbekannt war. Im
nachhinein ist klar, dass daraus nichts wurde. Daher wird heute
hufig gesagt, dass im Computer-Bereich ja gerne Hexadezimal
gearbeitet wird, und daher mit C++0x in Wirklichkeit C++0B gemeint
war. Hinweis eigentlich mte der aktuelle C++ Standard C++15 heien,
da er am 14. Januar 2015 von der ISO offiziell verffentlicht wurde.
Aber jeder hatte mit einer Verffentlichung in 2014 gerechnet, und
so wurde schon lange von C++14 geredet der Name hat sich nun
eingebrgert. Leider haben sich die Prozesse in der ISO so sehr
verzgert, dass der offizielle Standard erst 2015 erschienen ist.
Der erste C++ Standard von 1998 definierte den Umfang von C++ und
das genaue Verhalten. Vorher war C++ mehr beschreibend durch das
Buch The Annotated C++ Reference Manual von Margaret Ellis und
Bjarne Stroustrup festgelegt und in vielen Details unterschieden
sich die Implementierungen der Compiler sehr. Mit dem Standard gab
es eine klare Referenz fr das Verhalten der Sprache und den
Mindest-Umfang der Bibliotheken, so da sich die Programmierer
hierauf verlassen konnten. Der zweite Standard von 2003 hatte
gegenber dem Standard von 1998 den Charakter eines Technical
Corrigendums (TCs). Er hat eine Menge Fehler, Mehrdeutigkeiten und
ungenaue Aussagen des ersten Standards korrigiert, aber keine neuen
Features eingefhrt. Der Standard vom August 2011 war ein sehr
wichtiger und groer Schritt fr C++, da er die Sprache und vor allem
die Bibliotheken stark erweitert hat und er das Ende des langen
Stillstands in der Entwicklung von C++ bedeutet hat. Die finale
Abstimmung der ISO wurde
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 23 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
am 8. August 2011 beendet und der Final-Release wurde einstimmig
angenommen. Details dazu finden Sie z.B. im Blog von Herb Sutter:
http://herbsutter.com/2011/08/12/we-have-an-international-standard-c0x-is-unanimously-approved/
Offiziell seit dem Januar 2015 gibt es den zur Zeit aktuellen
Standard C++14, der den bisherigen Standard C++11 nur moderat
erweitert hat. Er enthlt keine groen neuen Features, sondern viele
kleine Korrekturen, Berichtigungen und Erweiterungen die die neuen
C++11 Features an vielen Stellen abrunden und Lcken stopfen.
z.B. wurden in C++11 u.a. die freien Funktionen cbegin(),
cend(), crbegin() und crend() vergessen, whrend an begin(), end(),
rbegin() und rend() gedacht wurde. Oder es gibt z.B. die
Smart-Pointer Factory-Funktion make_shared, aber nicht make_unique.
Oder bei den Lambda-Ausdrcken wurden die Move-Semantik
vergessen.
Aber es gibt auch einige echte kleine Neuerungen so hat optional
als neue Klasse Einzug in die Standard-Bibliothek gehalten, oder
die automatische Funktions-Typ-Deduktion von Lambdas wurde auf
Funktionen ausgeweitet, und Lambdas untersttzen nun polymorphe
Parameter.
Mittlerweile kndigt sich schon der nchste C++ Standard an: fr
2017 oder 2018 ist der Standard C++1y geplant (das y soll andeuten,
dass der genaue Termin noch unklar ist). Das ist zwar noch in
weiter Zukunft, trotzdem ist klar, dass hier mehr passieren wird.
Heie Kandidaten fr C++1y sind in der Sprache z.B. Concepts-Light,
aber auch grere Bibliotheks-Erweiterungen wie File-System und mehr
Untersttzung fr Concurrent-Programmierung und mit etwas Glck auch
eine Erweiterung fr 2D-Grafik-Objekte (Proposal n3888
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3888.pdf
). Lassen wir uns berraschen. Wer mehr wissen will auf meiner
Web-Seite findet sich ein kurzer Bericht vom C++ User-Treffen in
Dsseldorf vom 17.04.2013 Thema waren an dem Tag die damals
kommenden Standards C++14 und C++1y. Neben dem Bericht finden sich
dort auch viele Links zum damaligen Stand der Standardisierung:
http://www.wilkening-online.de/programmieren/c++-treffen-duesseldorf.html#Treffen_2013_04
.
2.4 Compiler Ein schner Standard ist die eine Seite vorhande
Compiler die andere. Sie bentigen zum bersetzen Ihrer C++
Quelltexte immer einen C++ Compiler und die entsprechen leider
nicht immer dem Standard. Und was hilft einem der schnste Standard,
wenn man ihn nicht nutzen kann weil einem ein entsprechender
Compiler fehlt? Der aktuellste GCC (Version 4.9.2) und der
aktuellste CLang (Version 3.5.1) untersttzen C++14 komplett
vielleicht von kleinen Fehlern abgesehen. Der Intel-Compiler icc
hinkt etwas hinterher, setzt aber mittlerweile C++11 komplett und
C++14 fast vollstndig um. Nur das Microsoft Visual Studio (aktuelle
Version 2013) hngt doch um einiges hinterher hier
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 24 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
sind viele C++11 Features noch nicht umgesetzt, von C++14 keine
Spur. Fr 2015 ist aber das neue Visual Studio 2015 angekndigt, das
voraussichtlich C++11 fast komplett und zumindest schon mal Teile
von C++14 umsetzen wird. Im Internet finden Sie viele
bersichtsseiten, die die aktuelle Umsetzung der C++11 und C++14
Features in den Compilern detailiert aufschlsseln, z.B.:
http://wiki.apache.org/stdcxx/C++0xCompilerSupport
http://brnz.org/hbr/?p=1404 Wenn Sie irgendwie knnen, nutzen Sie
einen mglichst modernen Compiler, da die neuen Features das
Programmierer-Leben stark vereinfachen und erleichtern. Aber
Achtung in manchen Firmen werden noch sehr alte Compiler
eingesetzt. Einige Compiler, die noch im praktischen Einsatz sind
(z.B. GCC 2.9.5 oder Microsoft Visual Studio 6 von ~1996), sind auf
einem Vor-Standard-Stand (und hier ist wirklich der erste Standard
von 1998 gemeint). Machen Sie sich daher immer klar, mit
welchem/(n) Compiler(n) Sie arbeiten (mssen).
2.5 Skript Das Skript bezieht sich natrlich prinzipiell auf den
neusten C++ Standard von 2015. Aber ich trage noch der Realitt
Rechnung, indem ich alle Beispiele, die C++11 bzw. C++14
voraussetzen, entsprechend kennzeichne. Leider enthlt das Skript
noch viele Kapitel, die ich bislang nicht auf C++11 bzw. C++14
aktualisieren konnte. Diese beziehen sich dann leider noch auf
C++03.
2.6 Bibliotheken Neben der eigentlichen Sprache bringt ISO C++
auch noch eine Standard-Bibliothek mit. Diese wird nur zu einem
kleinen Teil in der Vorlesung besprochen, da der Umfang fr die
Vorlesung zu gro ist. Obwohl die ISO C++ Standard-Bibliothek viel
umfangreicher als die von ISO C ist, enthlt sie doch einige
schmerzhafte Lcken. So fehlen z.B. die wichtigen Themen: Unicode,
GUI, Netzwerk, Datenbank-Anbindungen, XML, uvm. Natrlich gibt es fr
alle diese Themen C++ Bibliotheken: kleine, groe, gute, schlechte,
Open-Source, kommerzielle und auch abhngig von Compiler und
Plattform. Aber eben keine im ISO Standard. Zum Teil ist dies eine
bewute Entscheidung des Standardisierungs-Komitees zum grten Teil
ist es aber eine Folge mangelnder Man-Power. Mit den Standards
C++11 & C++14 wurde die Situation besser, da die C++ Bibliothek
nun auch u.a. folgende Bereiche abdeckt:
Hash-Container Regular-Expressions
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 25 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
Bind und Reference-Wrapper Tuple Optional Polymorphe
Funktions-Wrapper Multithreading Untersttzung Erste Unicode
Untersttzung Da die Vorlesung ISO C++ unterrichten will, und keine
Prferenz bzgl. einer Plattform, eines Compilers oder einer
Bibliothek machen will, werden wir keine Beispiele mit z.B. GUIs
machen. Wir werden uns bei dem Stoff und den Beispielen bis auf
eine Ausnahme (Boost siehe nchstes Kapitel) auf reines ISO C++
beschrnken. Neben Boost gibt es natrlich viele weitere wichtige C++
Bibliotheken. Einige subjektiv wichtige sind die Folgenden, aber es
gibt natrlich viel viel mehr:
Qt fr u.a. grafische Oberflchen http://qt-project.org/
wxWindows fr grafische Oberflchen https://www.wxwidgets.org/
Poco Basis-Libs fr XML, Zip, Netzwerke, Kryptografie,
Datenbanken, uvm. http://pocoproject.org/
DLib fr u.a. grafische Oberflchen, aber auch Maschinen-Lernen
http://dlib.net/
Cinder, fr z.B. Spiele, Open-GL und andere multi-mediale
Aufgaben http://libcinder.org/
Open-Framework, fr multi-mediale Aufgaben
http://www.openframeworks.cc/
Cairo bzw. CarioMM fr 2D-Grafiken http://cairographics.org/
http://cairographics.org/cairomm/
2.7 Boost Boost ist eine Sammlung "freier, portabler,
begutachteter" C++ Bibliotheken. Der Zweck von Boost ist die Strken
von C++ durch qualitativ hochwertige und in die C++ Philosophie
passende Bibliotheken zu erweitern, ohne dass diese gleich einen
ISO Standardisierungs-Proze durchlaufen mssen. Viele Leute sagen:
Boost ist die Spielwiese der C++ Standardisierer. Das ist nicht
ganz falsch, denn:
Boost wurde von Mitgliedern des C++ Standardisierungs-Komitees
gegrndet Viele Mitglieder des C++ Standardisierungs-Komitees sind
aktiv im Boost Umfeld ttig Viele Boost-Bibliotheken sind
Bestandteil des Standards C++11 & C++14 geworden, und
weitere werden wohl in die nchsten C++ Standards Einzug finden.
Mit Boost besitzen die Standardisierer eine Mglichkeit, neue
Bibliotheken zu testen und ausreifen zu lassen
-
Objektorientiertes Programmieren in C++ - V. 34 Seite 26 /
821
Detlef Wilkening 1996-2015 www.wilkening-online.de
bevor sie in den Standard bernommen werden. In C++03 lieen sich
viele Probleme (z.B. Exceptions-Sicherheit siehe Kapitel 19.6) nur
mit Hilfe der C++03 Standard-Bibliothek nicht zeitgem lsen. Von
daher war Boost (oder eine vergleichbare Bibliothek) lange Zeit ein
Muss in der Nutzung von C++. Mit C++11 sind u.a. alle diese
fehlenden Elemente in die Standard-Bibliothek bernommen worden.
Noch immer enthlt Boost sehr viele hilfreiche Dinge, aber fr die
wichtigsten Aufgaben stehen jetzt auch alle Mittel in C++11 selber
zur Verfgung. Trotzdem kann ich den Einsatz von Boost oder
vergleichbarer Bibliotheken nur empfehlen. Schauen wir uns Boost
einmal etwas detailierter an:
Homepage: http://www.boost.org Die aktuelle Version ist 1.57.0
(vom 3.11.2014). Boost umfat mehr als 100 C++ Bibliotheken von sehr
kleinen bis zu sehr groen.
Weitere Bibliotheken sind in Arbeit.
Einige Boost-Bibliotheken sind Bestandteil des neuen ISO C++11
Standards geworden, und stehen uns damit sowohl in Boost als auch
in C++11 zur Verfgung. Damit knnen Sie diese Elemente auch dann
nutzen, wenn Sie noch kein C++11 Compiler haben, z.B. das Array
(siehe Kapitel 9.5) oder die Shared-Pointer (siehe Kapitel
21.7.3).
Es gibt eine sehr grozgige Boost Software Lizenz (BSL), die
keine Einschrnkung bzgl. der Verwendung der Bibliotheken sowohl in
kommerziellen als auch freien Programmen enthlt.
Die Boost-Bibliotheken haben u.a. aufgrund ihrer Nhe zur C++
Standardisierung und einer groen Community eine sehr hohe Qualitt.
Dies betrifft sowohl die uere als auch die innere Qualitt. Die uere
Qualitt meint hier die Themen API, Schnittstellen, Konventionen,
Dokumentation, vielfltige, offene und erweiterbare Einsetzbarkeit,
Design und so. Whrend die innere Qualitt die Implementierung
meint.
Die meisten Boost-Bibliotheken sind reines ISO C++, und sollten
von jedem standard-konformen Compiler problemlos bersetzt und
benutzt werden knnen. Die restlichen Boost-Bibliotheken kapseln in
einem ISO C++ Wrapper plattform-spezifische APIs (z.B. die Boost
Filesystem-Library) ihre Implementierung ist daher natrlich
plattform spezifisch. Daher liegen sie leider nicht fr jede
Compiler- und Plattform-Kombination vor.
Viele Unix Distributionen wie z.B. Fedora, Debian oder NetBSD
enthalten die Boost Bibliotheken in fertiger Form (leider selten in
aktueller Version).
Jeder kann neue Bibliotheken einreichen vor ihrer Annahme
durchlaufen sie aber eine