Der C++-Programmierer: C++ lernen - Professionell anwenden - Lösungen nutzen

Inhaltsverzeichnis

Vorwort

Teil I: Einführung in C++

  1 Es geht los!
      1.1 Historisches
      1.2 Objektorientierte Programmierung
      1.3 Compiler
      1.4 Das erste Programm
            o 1.4.1 Namenskonventionen
      1.5 Integrierte Entwicklungsumgebungen
            o 1.5.1 Code::Blocks
            o 1.5.2 Eclipse
      1.6 Einfache Datentypen und Operatoren
            o 1.6.1 Ausdruck
            o 1.6.2 Ganze Zahlen
            o 1.6.3 Reelle Zahlen
            o 1.6.4 Konstante
            o 1.6.5 Zeichen
            o 1.6.6 Logischer Datentyp bool
            o 1.6.7 Referenzen
            o 1.6.8 Regeln zum Bilden von Ausdrücken
            o 1.6.9 Standard-Typumwandlungen
      1.7 Gültigkeitsbereich und Sichtbarkeit
            o 1.7.1 Namespace std
      1.8 Kontrollstrukturen
            o 1.8.1 Anweisungen
            o 1.8.2 Sequenz (Reihung)
            o 1.8.3 Auswahl (Selektion, Verzweigung)
            o 1.8.4 Fallunterscheidungen mit switch
            o 1.8.5 Wiederholungen
            o 1.8.6 Kontrolle mit break und continue
      1.9 Benutzerdefinierte und zusammengesetzte Datentypen
            o 1.9.1 Aufzählungstypen
            o 1.9.2 Arrays: Der C++-Standardtyp vector
            o 1.9.3 Zeichenketten: Der C++-Standardtyp string
            o 1.9.4 Strukturen
            o 1.9.5 Typermittlung mit auto
            o 1.9.6 Unions und Bitfelder
  2 Einfache Ein- und Ausgabe
      2.1 Standardein- und -ausgabe
      2.2 Ein- und Ausgabe mit Dateien
  3 Programmstrukturierung
      3.1 Funktionen
            o 3.1.1 Aufbau und Prototypen
            o 3.1.2 Gültigkeitsbereiche und Sichtbarkeit in Funktionen
            o 3.1.3 Lokale static-Variable: Funktion mit Gedächtnis
      3.2 Schnittstellen zum Datentransfer
            o 3.2.1 Übergabe per Wert
            o 3.2.2 Übergabe per Referenz
            o 3.2.3 Gefahren bei der Rückgabe von Referenzen
            o 3.2.4 Vorgegebene Parameterwerte und variable Parameterzahl
            o 3.2.5 Überladen von Funktionen
            o 3.2.6 Funktion main()
            o 3.2.7 Beispiel Taschenrechnersimulation
            o 3.2.8 Spezifikation von Funktionen
      3.3 Modulare Programmgestaltung
            o 3.3.1 Steuerung der Übersetzung nur mit #include
            o 3.3.2 Einbinden vorübersetzter Programmteile
            o 3.3.3 Dateiübergreifende Gültigkeit und Sichtbarkeit
            o 3.3.4 Übersetzungseinheit, Deklaration, Definition
            o 3.3.5 Compilerdirektiven und Makros
      3.4 Funktions-Templates
            o 3.4.1 Spezialisierung von Templates
            o 3.4.2 Einbinden von Templates
      3.5 inline-Funktionen
      3.6 Namensräume
      3.7 C++-Header
            o 3.7.1 Einbinden von C-Funktionen
  4 Objektorientierung 1
      4.1 Abstrakte Datentypen
      4.2 Klassen und Objekte
            o 4.2.1 inline-Elementfunktionen
      4.3 Initialisierung und Konstruktoren
            o 4.3.1 Standardkonstruktor
            o 4.3.2 Allgemeine Konstruktoren
            o 4.3.3 Kopierkonstruktor
            o 4.3.4 Typumwandlungskonstruktor
      4.4 Beispiel: Rationale Zahlen
            o 4.4.1 Aufgabenstellung
            o 4.4.2 Entwurf
            o 4.4.3 Implementation
      4.5 const-Objekte und Methoden
      4.6 Destruktoren
      4.7 Wie kommt man zu Klassen und Objekten? Ein Beispiel
            o 4.7.1 Einige Analyse-Überlegungen
            o 4.7.2 Formulierung des Szenarios in C++
      4.8 Gegenseitige Abhängigkeit von Klassen
      4.9 Konstruktor und mehr vorgeben oder verbieten
      4.10 Delegierender Konstruktor
  5 Intermezzo: Zeiger
      5.1 Zeiger und Adressen
      5.2 C-Arrays
            o 5.2.1 C-Arrays und sizeof
            o 5.2.2 Indexoperator bei C-Arrays
            o 5.2.3 Initialisierung von C-Arrays
            o 5.2.4 Zeigerarithmetik
      5.3 C-Zeichenketten
      5.4 Dynamische Datenobjekte
            o 5.4.1 Freigeben dynamischer Objekte
      5.5 Zeiger und Funktionen
            o 5.5.1 Parameterübergabe mit Zeigern
            o 5.5.2 Parameter des main-Programms
            o 5.5.3 Gefahren bei der Rückgabe von Zeigern
      5.6 this-Zeiger
      5.7 Mehrdimensionale C-Arrays
            o 5.7.1 Statische mehrdimensionale C-Arrays
            o 5.7.2 Dynamisch erzeugte mehrdimensionale Arrays
            o 5.7.3 Klasse für dynamisches zweidimensionales Array
      5.8 Binäre Ein-/Ausgabe
      5.9 Zeiger auf Funktionen
      5.10 Komplexe Deklarationen lesen
      5.11 Standard-Typumwandlungen für Zeiger
      5.12 Zeiger auf Elementfunktionen und -daten
            o 5.12.1 Zeiger auf Elementfunktionen
            o 5.12.2 Zeiger auf Elementdaten
  6 Objektorientierung 2
      6.1 Eine String-Klasse
            o 6.1.1 Optimierung der Klasse MeinString
            o 6.1.2 friend-Funktionen
      6.2 Klassenspezifische Daten und Funktionen
            o 6.2.1 Klassenspezifische Konstante
      6.3 Klassen-Templates
            o 6.3.1 Ein Stack-Template
            o 6.3.2 Stack mit statisch festgelegter Größe
      6.4 Template-Metaprogrammierung
      6.5 Variadic Templates: Templates mit variabler Parameterzahl
  7 Vererbung
      7.1 Vererbung und Initialisierung
      7.2 Zugriffsschutz
      7.3 Typbeziehung zwischen Ober- und Unterklasse
      7.4 Code-Wiederverwendung
      7.5 Überschreiben von Funktionen in abgeleiteten Klassen
      Polymorphismus
            o Virtuelle Funktionen
            o Abstrakte Klassen
            o Virtueller Destruktor
      Probleme der Modellierung mit Vererbung
      Mehrfachvererbung
            o Namenskonflikte
            o Virtuelle Basisklassen
      Standard-Typumwandlungsoperatoren
      Typinformationen zur Laufzeit
      Using-Deklaration für Klassen
      Private- und Protected-Vererbung
  8 Fehlerbehandlung
      8.1 Ausnahmebehandlung
            o 8.1.1 Exception-Spezifikation in Deklarationen
            o 8.1.2 Exception-Hierarchie in C++
            o 8.1.3 Besondere Fehlerbehandlungsfunktionen
            o 8.1.4 Erkennen logischer Fehler
            o 8.1.5 Arithmetische Fehler / Division durch 0
      8.2 Speicherbeschaffung mit new
      8.3 Exception-Sicherheit
  9 Überladen von Operatoren
      9.1 Rationale Zahlen -- noch einmal
            o 9.1.1 Arithmetische Operatoren
            o 9.1.2 Ausgabeoperator <<
      9.2 Eine Klasse für Vektoren
            o 9.2.1 Index-Operator [ ]
            o 9.2.2 Zuweisungsoperator =
            o 9.2.3 Mathematische Vektoren
            o 9.2.4 Multiplikationsoperator
      9.3 Inkrement-Operator ++
      9.4 Typumwandlungsoperator
      9.5 Smart Pointer: Operatoren -> und *
            o 9.5.1 Smart Pointer und die C++-Standardbibliothek
      9.6 Objekt als Funktion
            o 9.6.1 Lambda-Funktionen
      9.7 new und delete überladen
            o 9.7.1 Speichermanagement mit malloc und free
            o 9.7.2 Unterscheidung zwischen Heap- und Stack-Objekten
            o 9.7.3 Fehlende delete-Anweisung entdecken
            o 9.7.4 Eigene Speicherverwaltung
            o 9.7.5 Empfehlungen im Umgang mit new und delete
      9.8 Mehrdimensionale Matrizen
            o 9.8.1 Zweidimensionale Matrix als Vektor von Vektoren
            o 9.8.2 Dreidimensionale Matrix
      9.9 Zuweisung bei Vererbung
  10 Dateien und Ströme
      10.1 Ausgabe
            o 10.1.1 Formatierung der Ausgabe
      10.2 Eingabe
      10.3 Manipulatoren
            o 10.3.1 Eigene Manipulatoren
      10.4 Fehlerbehandlung
      10.5 Typumwandlung von Dateiobjekten nach bool
      10.6 Arbeit mit Dateien
            o 10.6.1 Positionierung in Dateien
            o 10.6.2 Lesen und Schreiben in derselben Datei
      10.7 Umleitung auf Strings
      10.8 Ergänzungen
  11 Einführung in die Standard Template Library (STL)
      11.1 Container, Iteratoren, Algorithmen
      11.2 Iteratoren im Detail
      11.3 Beispiel verkettete Liste
  12 Reguläre Ausdrücke
      12.1 Elemente regulärer Ausdrücke
            o 12.1.1 Greedy oder lazy?
      12.2 Interaktive Auswertung
      12.3 Auszug des regex-APIs
      12.4 Anwendungen
  13 Threads
      13.1 Die Klasse thread
      13.2 Synchronisation
            o 13.2.1 Thread-Group
      13.3 Thread-Steuerung: pausieren, fortsetzen, beenden
      13.4 Interrupt
      13.5 Warten auf Ereignisse
      13.6 Reader/Writer-Problem
            o 13.6.1 Wenn Threads verhungern
            o 13.6.2 Reader/Writer-Varianten
      13.7 Thread-Sicherheit

Teil II: Bausteine komplexer Anwendungen

  14 Grafische Benutzungsschnittstellen
      14.1 Ereignisgesteuerte Programmierung
      14.2 GUI-Programmierung mit Qt
            o 14.2.1 Meta-Objektsystem
            o 14.2.2 Der Programmablauf
            o 14.2.3 Speicher sparen und lokal Daten sichern
      14.3 Signale, Slots und Widgets
      14.4 Dialog
      14.5 Qt oder Boost?
            o 14.5.1 Threads
            o 14.5.2 Verzeichnisbaum durchwandern
  15 Internet-Anbindung
      15.1 Protokolle
      15.2 Adressen
      15.3 Socket
            o 15.3.1 Bidirektionale Kommunikation
            o 15.3.2 UDP-Sockets
            o 15.3.3 Atomuhr mit UDP abfragen
      15.4 HTTP
            o 15.4.1 Verbindung mit GET
            o 15.4.2 Verbindung mit POST
      15.5 Mini-Webserver
  16 Datenbankanbindung
      16.1 C++-Interface
      16.2 Anwendungsbeispiel

Teil III: Praktische Methoden und Werkzeuge der Softwareentwicklung

  17 Abläufe automatisieren mit make
      17.1 Quellen
      17.2 Wirkungsweise
      17.3 Variablen und Muster
      17.4 Universelles Makefile für einfache Projekte
  18 Unit-Test
      18.1 Werkzeuge
      18.2 Test Driven Development
      18.3 Boost Unit Test Framework
            o 18.3.1 Beispiel: Testgetriebene Entwicklung einer Operatorfunktion
            o 18.3.2 Fixture
            o 18.3.3 Testprotokoll und Log-Level
            o 18.3.4 Prüf-Makros
            o 18.3.5 Kommandozeilen-Optionen
  19 Werkzeuge zur Verwaltung von Projekten
      19.1 Dokumentation und Strukturanalyse mit doxygen
            o 19.1.1 Strukturanalyse
      19.2 Versionskontrolle
            o 19.2.1 Einrichtung des Servers
            o 19.2.2 Exemplarische Benutzung
      19.3 Projektverwaltung
            o 19.3.1 Projektmanagement
            o 19.3.2 Wiki für Software-Entwicklungsprojekte

Teil IV: Das C++-Rezeptbuch: Tipps und Lösungen für typische Aufgaben

  20 Sichere Programmentwicklung
      20.1 Regeln zum Design von Methoden
      20.2 Defensive Programmierung
            o 20.2.1 double- und float-Werte richtig vergleichen
            o 20.2.2 const verwenden
            o 20.2.3 Anweisungen nach for/if/while einklammern
            o 20.2.4 int und unsigned/size_t nicht mischen
            o 20.2.5 size_t oder auto statt unsigned int verwenden
            o 20.2.6 Postfix++ mit Präfix++ implementieren
            o 20.2.7 Ein Destruktor darf keine Exception werfen
            o 20.2.8 Typumwandlungsoperatoren vermeiden
            o 20.2.9 explicit-Konstruktoren bevorzugen
            o 20.2.10 Leere Standardkonstruktoren vermeiden
            o 20.2.11 Kopieren und Zuweisung verbieten
            o 20.2.12 Vererbung verbieten
            o 20.2.13 Defensiv Objekte löschen
      20.3 Exception-sichere Beschaffung von Ressourcen
            o 20.3.1 Sichere Verwendung von shared_ptr
            o 20.3.2 shared_ptr für Arrays korrekt verwenden
            o 20.3.3 unique_ptr für Arrays korrekt verwenden
            o 20.3.4 Exception-sichere Funktion
            o 20.3.5 Exception-sicherer Konstruktor
            o 20.3.6 Exception-sichere Zuweisung
      20.4 Aussagefähige Fehlermeldung ohne neuen String erzeugen
      20.5 Empfehlungen zur Thread-Programmierung
            o 20.5.1 Warten auf die Freigabe von Ressourcen
            o 20.5.2 Deadlock-Vermeidung
            o 20.5.3 notify_all oder notify_one?
            o 20.5.4 Performance mit Threads verbessern?
  21 Von der UML nach C++
      21.1 Vererbung
      21.2 Interface anbieten und nutzen
      21.3 Assoziation
            o 21.3.1 Aggregation
            o 21.3.2 Komposition
  22 Performance, Wert- und Referenzsemantik
      22.1 Performanceproblem Wertsemantik
            o 22.1.1 Auslassen der Kopie
            o 22.1.2 Temporäre Objekte bei der Zuweisung
      22.2 Optimierung durch Referenzsemantik für R-Werte
            o 22.2.1 Bewegender Konstruktor
            o 22.2.2 Bewegender Zuweisungsoperator
      22.3 Ein effizienter binärer Plusoperator
            o 22.3.1 Kopien temporärer Objekte eliminieren
            o 22.3.2 Verbesserung durch verzögerte Auswertung
  23 Effektive Programmerzeugung
      23.1 Automatische Ermittlung von Abhängigkeiten
            o 23.1.1 Getrennte Verzeichnisse: src, obj, bin
      23.2 Makefile für Verzeichnisbäume
            o 23.2.1 Rekursive Make-Aufrufe
            o 23.2.2 Ein Makefile für alles
      23.3 Automatische Erzeugung von Makefiles
            o 23.3.1 Makefile für rekursive Aufrufe erzeugen
      23.4 Erzeugen von Bibliotheken
            o 23.4.1 Statische Bibliotheksmodule
            o 23.4.2 Dynamische Bibliotheksmodule
      23.5 GNU Autotools
      23.6 CMake
      23.7 Code Bloat bei der Instanziierung von Templates vermeiden
            o 23.7.1 extern-Template
            o 23.7.2 Aufspaltung in Schnittstelle und Implementation
  24 Algorithmen für verschiedene Aufgaben
      24.1 Algorithmen mit Strings
            o 24.1.1 String splitten
            o 24.1.2 String in Zahl umwandeln
            o 24.1.3 Zahl in String umwandeln
            o 24.1.4 Strings sprachlich richtig sortieren
            o 24.1.5 Umwandlung in Klein- bzw. Großschreibung
            o 24.1.6 Strings sprachlich richtig vergleichen
            o 24.1.7 Von der Groß-/Kleinschreibung unabhängiger Zeichenvergleich
            o 24.1.8 Von der Groß-/Kleinschreibung unabhängige Suche
      24.2 Textverarbeitung
            o 24.2.1 Datei durchsuchen
            o 24.2.2 Ersetzungen in einer Datei
            o 24.2.3 Code-Formatierer
            o 24.2.4 Lines of Code (LOC) ermitteln
            o 24.2.5 Zeilen, Wörter und Zeichen einer Datei zählen
            o 24.2.6 CSV-Datei lesen
            o 24.2.7 Kreuzreferenzliste
      24.3 Operationen auf Folgen
            o 24.3.1 Container anzeigen
            o 24.3.2 Folge mit gleichen Werten initialisieren
            o 24.3.3 Folge mit Werten eines Generators initialisieren
            o 24.3.4 Folge mit fortlaufenden Werten initialisieren
            o 24.3.5 Summe und Produkt
            o 24.3.6 Mittelwert und Standardabweichung
            o 24.3.7 Skalarprodukt
            o 24.3.8 Folge der Teilsummen oder -produkte
            o 24.3.9 Folge der Differenzen
            o 24.3.10 Minimum und Maximum
            o 24.3.11 Elemente rotieren
            o 24.3.12 Elemente verwürfeln
            o 24.3.13 Dubletten entfernen
            o 24.3.14 Reihenfolge umdrehen
            o 24.3.15 Anzahl der Elemente, die einer Bedingung genügen
            o 24.3.16 Gilt X für alle, keins oder wenigstens ein Element einer Folge?
            o 24.3.17 Permutationen
            o 24.3.18 Lexikografischer Vergleich
      24.4. Sortieren und Verwandtes
            o 24.4.1 Partitionieren
            o 24.4.2 Sortieren
            o 24.4.3 Stabiles Sortieren
            o 24.4.4 Partielles Sortieren
            o 24.4.5 Das n.-größte oder n.-kleinste Element finden
            o 24.4.6 Verschmelzen (merge)
      24.5 Suchen und Finden
            o 24.5.1 Element finden
            o 24.5.2 Element einer Menge in der Folge finden
            o 24.5.3 Teilfolge finden
            o 24.5.4 Bestimmte benachbarte Elemente finden
            o 2.5.5 Bestimmte aufeinanderfolgende Werte finden
            o 24.5.6 Binäre Suche
      24.6 Mengenoperationen auf sortierten Strukturen
            o 24.6.1 Teilmengenrelation
            o 24.6.2 Vereinigung
            o 24.6.3 Schnittmenge
            o 24.6.4 Differenz
            o 24.6.5 Symmetrische Differenz
      24.7 Heap-Algorithmen
            o 24.7.1 pop_heap
            o 24.7.2 push_heap
            o 24.7.3 make_heap
            o 24.7.4 sort_heap
            o 24.7.5 is_heap
      24.8 Vergleich von Containern auch ungleichen Typs
            o 24.8.1 Unterschiedliche Elemente finden
            o 24.8.1 Prüfung auf gleiche Inhalte
      24.9 Rechnen mit komplexen Zahlen: Der C++-Standardtyp complex
      24.10 Schnelle zweidimensionale Matrix
            o 24.10.1 Optimierung mathematischer Array-Operationen
      24.11 Singleton
            o 24.11.1 Implementierung mit einem Zeiger
            o 24.11.2 Implementierung mit einer Referenz
            o 24.11.3 Meyers' Singleton
      24.12 Vermischtes
            o 24.12.1 Erkennung eines Datums
            o 24.12.2 Erkennung einer IP-Adresse
            o 24.12.3 Erzeugen von Zufallszahlen
            o 24.12.4 for_each -- Auf jedem Element eine Funktion ausführen
            o 24.12.5 Verschiedene Möglichkeiten, Container-Bereiche zu kopieren
            o 24.12.6 Vertauschen von Elementen, Bereichen und Containern
            o 24.12.7 Elemente transformieren
            o 24.12.8 Ersetzen und Varianten
            o 24.12.9 Elemente herausfiltern
            o 24.12.10 Grenzwerte von Zahltypen
            o 24.12.11 Minimum und Maximum
  25 Ein- und Ausgabe
      25.1 Datei- und Verzeichnisoperationen
            o 25.1.1 Datei oder Verzeichnis löschen
            o 25.1.2 Datei oder Verzeichnis umbenennen
            o 25.1.3 Verzeichnis anlegen
            o 25.1.4 Verzeichnis anzeigen
            o 25.1.5 Verzeichnisbaum anzeigen
      25.2 Tabelle formatiert ausgeben
      25.3 Formatierte Daten lesen
            o 25.3.1 Eingabe benutzerdefinierter Typen
      25.4 Array als Block lesen oder schreiben

Teil V: Die C++-Standardbibliothek

  26 Aufbau und Übersicht
      26.1 Auslassungen
      26.2 Beispiele des Buchs und die C++-Standardbibliothek
  27 Hilfsfunktionen und -klassen
      27.1 Relationale Operatoren
      27.2 Unterstützung der Referenzsemantik für R-Werte
      27.3 Paare
      27.4 Tupel
      Funktionsobjekte
            o Arithmetische, vergleichende und logische Operationen
            o Funktionsobjekte zum Negieren logischer Prädikate
            o Binden von Argumentwerten
            o Funktionen in Objekte umwandeln
      Templates für rationale Zahlen
      Zeit und Dauer
      Hüllklasse für Referenzen
  28 Container
      28.1 Gemeinsame Eigenschaften
            o 28.1.1 Initialisierungslisten
            o 28.1.2 Konstruktion an Ort und Stelle
            o 28.1.3 Reversible Container
      28.2 Sequenzen
            o 28.2.1 vector
            o 28.2.2 vector
            o 28.2.3 list
            o 28.2.4 deque
            o 28.2.5 stack
            o 28.2.5 queue
            o 28.2.7 priority_queue
            o 28.2.8 array
      28.3 Sortierte assoziative Container
            o 28.3.1 map
            o 28.3.2 multimap
            o 28.3.3 set
            o 28.3.4 multiset
      28.4 Hash-Container
            o 28.4.1 unordered_map
            o 28.4.2 unordered_multimap
            o 28.4.3 unordered_set
            o 28.4.4 unordered_multiset
      28.5 bitset
  29 Iteratoren
      29.1 Iterator-Kategorien
            o 29.1.1 Anwendung von Traits
      29.2 distance() und advance()
      29.3 Reverse-Iteratoren
      29.4 Insert-Iteratoren
      29.5 Stream-Iteratoren
  30 Algorithmen
      30.1 Algorithmen mit Prädikat
            o 30.1.1 Algorithmen mit binärem Prädikat
      30.2 Übersicht
  31 Nationale Besonderheiten
      31.1 Sprachumgebungen festlegen und ändern
            o 31.1.1 Die locale-Funktionen
      31.2 Zeichensätze und -codierung
      31.3 Zeichenklassifizierung und -umwandlung
      31.4 Kategorien
            o 31.4.1 collate
            o 31.4.2 ctype
            o 31.4.3 numeric
            o 31.4.4 monetary
            o 31.4.5 time
            o 31.4.6 messages
      31.5 Konstruktion eigener Facetten
  32 String
  Speichermanagement
      33.1 Smart Pointer unique_ptr, shared_ptr, weak_ptr
      33.2 new mit vorgegebenem Speicherort
      33.3 Hilfsfunktionen
  34 Optimierte numerische Arrays (valarray)
      34.1 Konstruktoren
      34.2 Elementfunktionen
      34.3 Binäre Valarray-Operatoren
      34.4 Mathematische Funktionen
      34.5 slice und slice_array
      34.6 gslice und gslice_array
      34.7 mask_array
      34.8 indirect_array
  35 C-Header
      35.1 
      35.2 
      35.3 
      35.4 
      35.5 
      35.6 
      35.7 
      35.8 
      35.9 
      35.10 

A Anhang

  A.1 Programmierhinweise
  A.2 C++-Schlüsselwörter
  A.3 ASCII-Tabelle
  A.4 Rangfolge der Operatoren
  A.5 Compilerbefehle
  A.6 Lösungen zu den Übungsaufgaben
  A.7 Installation der DVD-Software für Windows
      A.7.1 Installation des Compilers und der Entwicklungsumgebung
      A.7.2 Installation der Boost-Bibliothek
      A.7.3 Installation von Qt
      A.7.4 Codeblocks einrichten
      A.7.5 Integration von Qt in ein Code::Blocks-Projekt
      A.7.6 Bei Verzicht auf die automatische Installation
  A.8 Installation der DVD-Software für Linux
      A.8.1 Installation des Compilers
      A.8.2 Installation von Boost
      A.8.3 Installation von Code::Blocks
      A.8.4 Code::Blocks einrichten
      A.8.5 Beispieldateien entpacken
      A.8.6 Installation von Qt4
      A.8.7 Integration von Qt in ein Code::Blocks-Projekt

Glossar

Literaturverzeichnis

Register