Objektorientiertes Programmieren in C++ - Wilkening-Online+/c++.pdf · Objektorientiertes Programmieren in C++ - V. 34 Seite 3 / 821 © Detlef Wilkening 1996-2015 6.7 Schleife mit

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++

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



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



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



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



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



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



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



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



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



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.



- 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



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



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



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.



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



- 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



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



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



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.



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:



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



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



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



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



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

Documents

Objektorientiertes Programmieren in C++ - Wilkening-Online+/c++.pdf · Objektorientiertes Programmieren in C++ - V. 34 Seite 3 / 821 © Detlef Wilkening 1996-2015 6.7 Schleife mit