C++ programmieren

Ralf Schneeweiß ist als IT Seminarleiter, Trainer, Coach in Projekten und als Systementwickler tätig.

1. Installation der Compiler [00:17 Std.]


. 1.1. Einleitung [00:43 Min.]

. 1.2. Der Borland-Compiler unter Windows [00:35 Min.]

. 1.3. Der MinGW-Compiler unter Windows [01:51 Min.]

. 1.4. Microsoft Visual C++ 2010 Express [01:18 Min.]

. 1.5. Der C++-Compiler für Linux [02:13 Min.]

. 1.6. Der C++-Compiler für Mac OS X [01:48 Min.]

. 1.7. Ausflug in die Kommandozeile [08:41 Min.]



2. Mein erstes C++-Programm [00:12 Std.]


. 2.1. Einleitung [00:16 Min.]

. 2.2. Der Editor [01:09 Min.]

. 2.3. Pfade setzen [06:12 Min.]

. 2.4. Hallo Welt! [04:34 Min.]



3. Grundlegende Werkzeuge [00:19 Std.]


. 3.1. Einleitung [00:15 Min.]

. 3.2. Compiler und Linker kennen lernen [02:35 Min.]

. 3.3. Compile- und Linkvorgang trennen [03:46 Min.]

. 3.4. Besonderheiten verschiedener Compiler [03:24 Min.]

. 3.5. Verwendung des Compilers unter Mac [02:19 Min.]

. 3.6. Verwendung des Compilers unter Linux [06:34 Min.]



4. Grundlegende Konzepte [01:06 Std.]


. 4.1. Einleitung [00:20 Min.]

. 4.2. Kommentare verwenden [02:07 Min.]

. 4.3. Eine erste Berechnung programmieren [04:43 Min.]

. 4.4. Primitive Datentypen [10:10 Min.]

. 4.5. Präprozessor-Anweisungen [04:13 Min.]

. 4.6. Eine erste Schleife programmieren [12:32 Min.]

. 4.7. Regeln für Bezeichner [02:03 Min.]

. 4.8. Funktionen definieren und verwenden [06:47 Min.]

. 4.9. Das Blockkonzept [04:06 Min.]

. 4.10. Funktionsprototypen definieren [04:20 Min.]

. 4.11. Header-Dateien [14:60 Min.]



5. Kontrollstrukturen und Operatoren [00:47 Std.]


. 5.1. Einleitung [00:13 Min.]

. 5.2. Kontrollstrukturen definieren [06:05 Min.]

. 5.3. Logische Operatoren und Bedingungen [10:06 Min.]

. 5.4. Arithmetische Operatoren [13:04 Min.]

. 5.5. Bitoperationen durchführen [10:11 Min.]

. 5.6. Der Komplement-Operator [04:35 Min.]

. 5.7. Bedingte Ausdrücke [02:23 Min.]



6. Tools für das C++-Projekt [00:33 Std.]


. 6.1. Einleitung [00:34 Min.]

. 6.2. Das Tool 'make' [12:52 Min.]

. 6.3. Libraries erstellen [09:13 Min.]

. 6.4. Die IDE 'Code:Blocks' [04:49 Min.]

. 6.5. Der Debugger [05:14 Min.]



7. Zeiger und Arrays [01:14 Std.]


. 7.1. Einleitung [00:26 Min.]

. 7.2. Arrays innerhalb des Stacks [10:10 Min.]

. 7.3. Globale Arrays und Zeiger [08:14 Min.]

. 7.4. Speicher allokieren im Heap [13:36 Min.]

. 7.5. Mit Zeigern programmieren [11:42 Min.]

. 7.6. Mit Strings umgehen [13:51 Min.]

. 7.7. Die Speicherklassen von C++ [15:47 Min.]



8. Komplexe Datentypen [00:34 Std.]


. 8.1. Einleitung [00:21 Min.]

. 8.2. Die Struktur [13:14 Min.]

. 8.3. Die Union [07:30 Min.]

. 8.4. Der Aufzählungstyp 'enum' [04:50 Min.]

. 8.5. Eine erste Klasse [03:03 Min.]

. 8.6. Statische Elemente [04:47 Min.]



9. Syntaktische Grundlagen der Objektorientierung [01:59 Std.]


. 9.1. Einleitung [00:24 Min.]

. 9.2. Die Referenzen [06:39 Min.]

. 9.3. Funktionsüberladung [05:57 Min.]

. 9.4. Typenkonvertierungen [13:01 Min.]

. 9.5. Methoden [15:54 Min.]

. 9.6. Konstruktoren [19:32 Min.]

. 9.7. Der Destruktor [05:35 Min.]

. 9.8. Operatoren überladen [06:53 Min.]

. 9.9. Das Schlüsselwort 'const' [04:29 Min.]

. 9.10. Namensräume [11:55 Min.]

. 9.11. Das Funktions-Inlining [09:57 Min.]

. 9.12. Ein integriertes Beispiel [08:00 Min.]

. 9.13. Dynamische Allokation mit 'new' und 'delete' [11:05 Min.]



10. Exkurs: Theorie der Objektorientierung [00:33 Std.]


. 10.1. Einleitung [00:17 Min.]

. 10.2. Theoretische Grundlagen der Objektorientierung [06:49 Min.]

. 10.3. UML-Klassendiagramme [11:31 Min.]

. 10.4. Prinzipien des Objektorientierten Designs [14:02 Min.]



11. Fortgeschrittene Konzepte der Objektorientierung [02:21 Std.]


. 11.1. Einleitung [00:21 Min.]

. 11.2. Datenkapselung und Sichtbarkeit [13:16 Min.]

. 11.3. Sicherung des Kopierkonstruktors [12:21 Min.]

. 11.4. Das Konzept der Vererbung [17:40 Min.]

. 11.5. Virtuelle Methoden [24:27 Min.]

. 11.6. Rein virtuelle Methoden und abstrakte Klassen [17:35 Min.]

. 11.7. Elemente der C-Bibliothek im Namensraum 'std' [03:30 Min.]

. 11.8. Typenkonvertierung bei Klassen [15:26 Min.]

. 11.9. Der explizite Konstruktor [02:36 Min.]

. 11.10. Der Zuweisungsoperator [06:52 Min.]

. 11.11. Die Cast-Operatoren [18:48 Min.]

. 11.12. Der dynamische Cast [08:00 Min.]



12. Klassen der Standardbibliothek [01:37 Std.]


. 12.1. Einleitung [00:18 Min.]

. 12.2. Die Stream-Klassen [13:35 Min.]

. 12.3. Manipulatoren [13:29 Min.]

. 12.4. Der Eingabeoperator [12:17 Min.]

. 12.5. Container der STL [24:23 Min.]

. 12.6. Mit Listen arbeiten [07:13 Min.]

. 12.7. Algorithmen verwenden [03:10 Min.]

. 12.8. Listen sortieren [04:07 Min.]

. 12.9. Vektoren sortieren [03:40 Min.]

. 12.10. Iteratoren verwenden [05:52 Min.]

. 12.11. Weitere Container der STL [04:00 Min.]

. 12.12. Der String der Standardbibliothek [05:18 Min.]



13. Fehler- und Ausnahmebehandlung [00:50 Std.]


. 13.1. Einleitung [00:53 Min.]

. 13.2. Ein erstes Beispiel [11:25 Min.]

. 13.3. Ausnahmen deklarieren [04:42 Min.]

. 13.4. Das Stack-Unwinding-Prinzip [05:11 Min.]

. 13.5. Ausnahmen werfen mit 'throw' [10:56 Min.]

. 13.6. Eigene Ausnahmen definieren [07:42 Min.]

. 13.7. Der Einsatz von Exceptions [09:15 Min.]