Einführung 21

Teil 1: Ein schneller Überblick über C + + 23

Kapitel 1: Der C+ +-Compiler (Version 7) von Visual Studio .NET 23
Was gibt es Neues in Version 7.0 von Visual C++? 23
Professional Edition 24
Enterprise Edition (wurde für dieses Buch benutzt) 25
Empfohlene Hardware und Software 26
Eine typische Windows-Installation 26
Verzeichnisse 27
Dokumentation 27
Das Entwicklungssystem 28
Projektmappen-Explorer 28
Der integrierte Debugger 28
Die integrierten Ressourcen-Editoren 28
Tools und Utilities 29
Automation und Makros 29
Klassenansicht 30
Anpassbare Symbolleisten und Menüs 30
Internet-Connectivity 30
Projektmappen und Dateien 30
Assistenten 31
Wichtige Compiler-Funktionen 31
Vorkompilierte Header und Typen 31
Die Microsoft Foundation Classes-Bibliothek 32
Inline-Funktionen 33
Compiler-Optionen 33
Allgemein 34
Debuggen 34
C/C++ 35
Linker 36
Ressourcen 37
Webverweise 37
Wie geht es weiter? 37

Kapitel 2: Eine Schnelleinführung in den Gebrauch der MDE 39
Die Visual-C++-MDE starten 39
Auf kontextsensitive Hilfe zugreifen 40
Was sind Menüs? 41
Symbolleisten andocken oder unverankert anzeigen 41
Automatisch im Hintergrund 42
Rückwärts navigieren und vorwärts navigieren 42
Das Datei-Menü 42
Neu 42
Offnen 43
Schließen 44
Neues Element/Vorhandenes Element/Projekt hinzufügen 44
Projektmappe öffnen/schließen 44
Ausgewählte Komponente(n) speichern 44
Ausgewählte Komponente(n) speichern unter 45
Alle speichern 45
Quellcodeverwaltung 45
Seite einrichten 46
Drucken 46
Zuletzt geöffnete Dateien 46
Zuletzt geöffnete Projekte 46
Beenden 46
Das Bearbeiten-Menü 47
Rückgängig 47
Wiederholen 47
Ausschneiden 48
Kopieren 48
Einfügen 49
Zwischenablagering durchlaufen 49
Löschen 49
Alle auswählen 49
Suchen und Ersetzen 49
Gehe zu 51
Datei als Text einfügen 51
Erweitert 51
Textmarken 51
Gliedern 51
IntelliSense 52
Das Ansicht-Menü 52
Öffnen/Öffnen mit 53
Projektmappen-Explorer 53
Server-Explorer 53
Ressourcenansicht 53
Eigenschaftenfenster 54
Toolbox 54
Anstehende Eincheckvorgänge 54
Webbrowser 54
Andere Fenster 54
Aufgaben anzeigen 55
Symbolleisten 55
Ganzer Bildschirm 55
Rückwärts/Vorwärts navigieren 55
Eigenschaftenseiten 55
Das Projekt-Menü 56
Klasse/Ressource/Neues Element/Vorhandenes Element hinzufügen 56
Visio UML 56
Webverweis hinzufügen 57
Als Startprojekt festlegen 57
Das Erstellen-Menü 57
Projektmappe erstellen 57
Projektmappe neu erstellen 58
Projektmappe bereinigen 59
Batch erstellen 59
Konfigurations-Manager 59
Kompilieren 59
Das Debuggen-Menü 60
Fenster 60
Starten 60
Starten ohne Debuggen 60
Prozesse 61
Ausnahmen 61
Einzelschritt/Prozedurschritt 61
Neuer Haltepunkt 61
Alle Haltepunkte löschen 61
Das Extras-Menü 61
Debugprozesse 62
Mit Datenbank verbinden 62
Toolbox anpassen 62
Add-In-Manager 63
Erstellen von Kommentarwebseiten 63
Makros 63
Externe Tools 63
Anpassen 63
Optionen 64
Das Fenster-Menü 64
Neues Fenster 64
Teilen 64
Andockbar, Ausblenden, Unverankert, Automatisch im Hintergrund, Alle automatisch ausblenden 64
Liste der zuletzt geöffneten Fenster 65
Fenster 65
Das Hilfe-Menü 65
Dynamische Hilfe 65
Inhalt, Index, Suchen 66
Vorheriges/Nächstes Thema und Inhalt synchronisieren 66
Startseite anzeigen 66
Auf Aktualisierungen überprüfen 66
Technischer Support 66
Hilfe zur Hilfe 66
Info über Microsoft Visual C++ 66
Wie geht es weiter? 66

Kapitel 3: Einfache Programme schreiben, kompilieren und debuggen 67
Das Developer Studio starten 67
Ihr erstes Programm erstellen 68
Quellcode editieren 72
Dateien speichern 73
Die ausführbare Datei erstellen 75
Projektmappe erstellen oder Projektmappe neu erstellen 75
Programme debuggen 75
Die Unterschiede zwischen Warnungen und Fehlermeldungen 76
Ihr erster unerwarteter Fehler 77
Ausgabe- und Quellcode-Fenster anzeigen 77
Mit Suchen und Ersetzen arbeiten 77
Mit Shortcuts die Ansichten wechseln 79
Nützliche Warnungen und Fehlermeldungen 80
Weiteres Arbeiten mit dem Debugger 81
Ihr erstes Programm ausführen 83
Mit dem integrierten Debugger arbeiten 84
Fortgeschrittene Debugging-Methoden 87
Mit Haltepunkten arbeiten 88
Eine Einführung in die Schnellüberwachung 89
Wie geht es weiter? 91

Kapitel 4: Fortgeschrittene Visual C++-Funktionen 93
Was ist die Standard Template Library? 93
Die Komplexität von Mehrplattform-Zielumgebungen 93
Unabsichtlicher Missbrauch oder Unkenntnis von C/C++-Funktionen 94
Datenstrukturen: Worin sich Hacker und Profis unterscheiden 95
Was genau ist die Standard Template Library? 95
Die Ursprünge der STL 95
Was muss ich wissen, um die STL nutzen zu können? 95
Ein Überblick über die STL 96
Ein Lob des ANSI/ISO-C- und C++-Komitees 96
Die drei Komponenten der STL 97
STL-Zusammenfassung 100
Wie geht es weiter? 103

Teil II: Grundlagen der Programmierung 105

Kapitel 5: Die Grundlagen von C++ 105
Am Anfang war C 105
Eine kleine Geschichte von C 105
C im Vergleich zu älteren Hochsprachen 107
Die Vorteile von C 108
Nachteile von C 110
C ist kein Spielzeug! 111
American National Standards Institute: ANSI C 111
Von C nach C++ und zur objektorientierten Programmierung 113
Eine kurze Geschichte von C++ 113
Effizienter Objektcode 114
Feine Unterschiede zwischen C und C++ 114
Hauptunterschiede zwischen C und C++ 117
Grundkomponenten eines C/C++-Programms 118
Die fünf Elemente eines guten C/C++-Programmentwurfs 119
Ein einfaches C-Programm 119
Ein einfaches C++-Programm 121
Von main nach _tmain und von char* nach _TCHAR 122
Die neuesten Aktualisierungen von ANSI/ISO-C++ 122
Eine Benutzerschnittstelle zu einem C-Programm hinzufügen 125
Eine Benutzerschnittstelle zu einem C++-Programm hinzufügen 129
Datei-Eingabe/Ausgabe hinzufügen 130
Wie geht es weiter? 133

Kapitel 6: Mit Daten arbeiten 135
Bezeichner 135
Schlüsselwörter 137
Microsoft-spezifische Schlüsselwörter 138
Standard-Datentypen von C und C++ 139
Zeichen 139
Drei Ganzzahlen 141
Der Modifizierer unsigned 141
Fließkommatypen 143
Enumerierte Typen 144
Der neue C++-Typ bool 146
Zugriffsmodifizierer 147
Der Modifizierer const 147
#define-Konstanten 148
Der Modifizierer volatile 148
const und volatile zusammen verwenden 149
Die Modifizierer pascal, cdecl, near, far und huge 149
pascal 149
cdecl 150
near, far und huge 151
Datentypumwandlungen 152
Explizite Typumwandlungen mit dem Cast-Operator 153
Neue Cast-Operationen 153
Speicherklassen 155
Variablendeklarationen auf externer Ebene 156
Variablendeklarationen auf interner Ebene 157
Zusammenfassung zum Gültigkeitsbereich von Variablen 159
Funktionsdeklarationen auf externer Ebene 159
Operatoren 159
Bitweise Operatoren 160
Links-Shift und Rechts-Shift 161
Inkrement und Dekrement 162
Arithmetische Operatoren 163
Zuweisungsoperator 163
Zusammengesetzte Zuweisungsoperatoren 164
Relationale und logische Operatoren 166
Bedingungsoperator 167
Komma-Operator 168
Die Rangfolge der Operatoren 168
Standard-Bibliotheken von C und C++ 169
Wie geht es weiter? 170

Kapitel 7: Programmablaufkontrolle 171
Bedingungsanweisungen 171
if 172
if-else 173
Verschachtelte if-else-Anweisungen 175
if-else-if 176
Der Bedingungsoperator ?: 177
switch-case 179
if-else-if und switch kombinieren 185
Schleifenanweisungen 187
for 187
while 192
do-while 195
break 196
continue 197
break und continue kombinieren 198
exit() 200
atexit() 203
Wie geht es weiter? 204

Kapitel 8: Funktionen schreiben und einsetzen 205
Was ist ein Funktionsprototyp? 205
Die Syntax von Prototypen 206
Methoden zur Übergabe tatsächlicher Argumente 207
Listen von Standardargumenten 209
Speicherklassen 210
Sichtbarkeitsregeln für Bezeichner 211
Rekursion 211
Funktionsargumente 212
Tatsächliche und formelle Parameter 212
void-Parameter 213
char-Parameter 214
int-Parameter 215
float-Parameter 216
double-Parameter 219
Array-Parameter 220
Funktionsrückgabetypen 222
void-Rückgabetyp 222
char-Rückgabetyp 224
bool-Rückgabetyp 224
int-Rückgabetyp 225
long-Rückgabetyp 226
float-Rückgabetyp 227
double-Rückgabetyp 228
Befehlszeilenargumente 229
Alphanumerische Argumente 230
Ganzzahlige Argumente 230
Fließkomma-Argumente 232
Funktionen in C und in C++ 233
Wann ist eine Funktion ein Makro? 233
Prototypen für mehrere Funktionen mit demselben Namen 234
Funktionen mit einer variablen Anzahl von Argumenten 236
Was Sie mit Funktionen nicht tun sollten 237
Versuchen Sie nicht, auf Bezeichner außerhalb des Gültigkeitsbereiches zuzugreifen 238
Zugriff auf externe vs. interne Bezeichner 239
Zugriff auf interne und externe Bezeichner 240
Es ist zwar zulässig, doch vom Gebrauch ist abzuraten! 241
Missachten Sie nicht den internen Vorrang 242
Wie geht es weiter? 243

Kapitel 9: Mit Arrays arbeiten 245
Was sind Arrays? 245
Array-Eigenschaften 245
Arrays deklarieren 246
Arrays initialisieren 247
Standardinitialisierung 247
Explizite Initialisierung 248
Initialisierung ohne Größenangabe 248
Auf Array-Elemente zugreifen 249
Array-Dimensionen berechnen 251
Array-Indizes außerhalb der Array-Grenzen 253
Strings ein- und ausgeben 254
Mehrdimensionale Arrays 256
Arrays als Funktionsargumente 260
Arrays an C++-Funktionen übergeben 260
String-Funktionen und Zeichen-Arrays 267
gets(), puts(), fgets(), fputs() und sprintf() 267
strcpy(), strcat(), strncmp() und strlen() 269
Wie geht es weiter? 271

Kapitel 10: Mit Zeigern arbeiten 273
Zeigervariablen 273
Zeiger deklarieren 275
Mit Zeigervariablen arbeiten 276
Zeiger initialisieren 279
Was man mit dem Adressoperator nicht tun sollte 280
Zeiger auf Arrays 281
Zeiger auf Zeiger 282
Zeiger auf Strings 284
Zeigerarithmetik 285
Zeigerarithmetik und Arrays 288
Probleme mit den Operatoren ++ und - 289
const mit Zeigern verwenden 290
Zeiger vergleichen 291
Zeigerportabilität 291
sizeof() mit Zeigern unter 16-Bit-DOS-Umgebungen verwenden 292
Zeiger auf Funktionen 294
Dynamischer Speicher 296
Mit void-Zeigern arbeiten 299
Zeiger und Arrays näher betrachtet 302
Strings (Arrays vom Typ char) 302
Arrays von Zeigern 303
Mehr über Zeiger auf Zeiger 306
Arrays von String-Zeigern 312
Der C++-Referenztyp 314
Funktionen, die Adressen zurückgeben 315
Wann sollten Sie Referenztypen verwenden? 316
Wie geht es weiter? 316

Kapitel 11: Eine Einführung in die Ein- und Ausgabe in C++ 317
Die Eingabe/Ausgabe mit C++ beschleunigen 317
cin, cout und cerr 318
Der Extraktionsoperator » und der Einfügeoperator « 318
Von stream.h nach iostream 325
Operatoren und Elementfunktionen 326
Wie geht es weiter? 338

Kapitel 12: Strukturen, Unions und diverse Themen 339
Strukturen 339
Syntax und Regeln 339
C++-Strukturen: Zusätzliche Syntax- und Regelerweiterungen 341
Auf Elemente einer Struktur zugreifen 342
Eine einfache Struktur konstruieren 342
Strukturen an Funktionen übergeben 344
Ein Array von Strukturen konstruieren 346
Mit Zeigern auf Strukturen arbeiten 349
Ein Array von Strukturen an eine Funktion übergeben 351
Strukturen in C++ verwenden 354
Weitere Manipulationen von Strukturen 356
Unions 358
Syntax und Regeln 359
Eine einfache Union konstruieren 359
Verschiedene Elemente 361
Mit typedef arbeiten 361
Mit enum arbeiten 363
Wie geht es weiter? 365

Kapitel 13: Fortgeschrittene Programmierthemen 367
Typenkompatibilität 367
ANSI-C-Definition für Typenkompatibilität 367
Was ist ein identischer Typ? 368
Enumerierte Typen 369
Array-Typen 369
Funktionstypen 369
Struktur- und Union-Typen 369
Zeiger-Typen 370
Kompatibilität mit mehreren Quelldateien 370
Makros 370
Was ist ein Makro? 371
Makros und Parameter 372
Probleme mit Makro-Erweiterungen 372
Eigene Makros erstellen und nutzen 374
Makros, die mit dem Compiler geliefert werden 374
Fortgeschrittene Präprozessor-Anweisungen 375
Die #ifdef- und die #endif-Direktive 375
Die #undef-Direktive 376
Die #ifndef-Direktive 376
Die #if-Direktive 377
Die #else-Direktive 377
Die #elif-Direktive 377
Die #line-Direktive 378
Die #error-Direktive 378
Die #pragma-Direktive 379
Bedingtes Kompilieren 379
Präprozessor-Operatoren 380
Der Stringize-Operator # 381
Der Verkettungsoperator ## 381
Der Charizing-Operator #@ 382
Der richtige Gebrauch von Header-Dateien 382
Effizientere Header-Dateien 383
Vorkompilierte Header-Dateien 384
Vorkompilierte Header verwenden 384
Mit vorkompilierten Headern arbeiten 384
climits und cfloat 385
Fehler mit perror() behandeln 386
Verkettete Listen und dynamische Speicherallozierung 387
Überlegungen beim Arbeiten mit verketteten Listen 388
Eine einfache verkettete Liste 389
Wie geht es weiter? 392

Kapitel 14: Power-Programmierung: Wichtige C- und C++-Bibliotheken nutzen 393
Wichtige C- und C++-Header-Dateien 393
Funktionen der Standardbibliothek (cstdlib) 394
Datenumwandlungen durchführen 395
Suchen und Sortieren 397
Verschiedene Operationen 400
Die Zeichenfunktionen (cctype) 402
Auf alphanumerische Zeichen, Buchstaben und ASCII-Werte prüfen 403
Auf Steuerzeichen, Whitespace-Zeichen und Satzzeichen prüfen 405
Umwandlungen in ASCII, Kleinbuchstaben und Großbuchstaben 407
Die String-Funktionen (cstring) 408
Mit Speicherfunktionen arbeiten 410
Mit String-Funktionen arbeiten 412
Die mathematischen Funktionen (cmath) 417
Eine Tabelle trigonometrischer Werte erstellen 418
Die zeitbezogenen Funktionen (ctime) 419
Datums- und Zeit-Strukturen und -Syntax 420
Wie geht es weiter? 425

Teil III: Grundlagen der objektorientierten Programmierung 427

Kapitel 15: Grundbegriffe der objektorientierten Programmierung 427
Es gibt nichts Neues unter der Sonne 428
Traditionelle strukturierte Programmierung 429
Objektorientierte Programmierung 429
C++ und die objektorientierte Programmierung 430
Die objektorientierte Terminologie 431
Einkapselung 432
Klassenhierarchie 432
Ein erster Blick auf die C++-Klasse 434
Eine Struktur als einfache Klasse 434
Syntax und Regeln für C++-Klassen 439
Eine einfache C++-Klasse 440
Wie geht es weiter? 443

Kapitel 16: Mit C++-Klassen arbeiten 445
Klassenspezifische Funktionen 445
Mit einer einfachen Klasse arbeiten 446
Klassen verschachteln 446
Mit Konstruktoren und Destruktoren arbeiten 450
Memberfunktionen einer Klasse überladen 453
Friend-Funktionen 458
Der Zeiger this 461
Operatoren überladen 461
Operatoren und Funktionsausfrufe überladen 462
Die Syntax für das Überladen 462
Abgeleitete Klassen 465
Die Syntax abgeleiteter Klassen 465
Mit abgeleiteten Klassen arbeiten 466
Wie geht es weiter? 470

Kapitel 17: Die komplette Eingabe/Ausgabe in C++ 471
Mit enum-Typen in C++ arbeiten 471
Referenzvariablen 472
Standardargumente 475
Die memset()-Funktion 476
Output formatieren 477
I/O-Optionen 481
Die iostream-Klassenliste 482
Input-Stream-Klassen 485
Output-Stream-Klassen 487
Buffered-Stream-Klassen 489
String-Stream-Klassen 491
Binärdateien 493
C- und C++-Code kombinieren 495
Eindeutige Manipulatoren entwerfen 497
Manipulatoren ohne Parameter 498
Manipulatoren mit einem Parameter 499
Manipulatoren mit mehreren Parametern 500
Wie geht es weiter? 503

Kapitel 18: In einer objektorientierten Umgebung arbeiten 505
Ein objektorientierter Stack 505
Eine objektorientierte verkettete Liste in C++ 508
Eine übergeordnete Klasse erstellen 508
Eine abgeleitete Klasse 509
Mit einer befreundeten Klasse arbeiten 511
Das komplette Programm untersuchen 514
Die Ausgabe der verketteten Liste 523
Wie geht es weiter? 525

Kapitel 19: Templates und die Standard Template Library 527
Die jüngste Vergangenheit der STL 527
Die STL nutzen 527
Die ANSI-C/C++-Komitees 528
Der Aufbau der STL 528
Container 529
Container-Adapter 530
Algorithmen 530
Iteratoren 531
Weitere STL-Elemente 531
Templates auf der Basis von Strukturen 532
Das Schlüsselwort template 532
Die Syntax von template 533
Template-Funktionen 533
Template-Klassen 534
STL: Sogar noch besser als Templates 534
Die -Template 535
Vektor-Templates 536
Vektoren instanziieren 536
Vektor-Template-Funktionen verstehen 536
Auf -Elemente zugreifen 537
-Elemente einfügen und entfernen 537
Zwei verschiedene Deskriptoren für die Vektorgröße 537
Andere -Operationen 538
-Template-Syntax 539
-Template-Typdefinitionen 542
Überladene -Operatoren 543
-Template-Methoden 544
Beispielcode 546
Wie geht es weiter? 551

Teil IV: Windows und Assistenten 553

Kapitel 20: Konzepte und Werkzeuge für Windows-Anwendungen 553
Die Grundlagen von Windows 553
Die Windows-Umgebung 554
Die Vorteile von Windows 554
Das »Executable Format« von Windows 561
Konzepte und Fachbegriffe der Windows-Programmierung 562
Was ist ein Windows-Fenster? 562
Das Layout eines Fensters 562
Eine prozedurorientierte Windows-Klasse 564
OOP und Windows 565
Windows-Meldungen 568
Auf Windows-Funktionen zugreifen 572
Die Windows-Header-Datei: windows.h 572
Komponenten einer Windows-Anwendung 573
Windows-Entwicklungswerkzeuge von Visual C++ 573
Projektdateien 574
Die Ressourcen im Einzelnen 574
Wie geht es weiter? 588

Kapitel 21: Assistenten und prozedurorientierte Windows-Anwendungen 589
Ein Anwendungs-Framework 589
Komponenten einer Windows-Anwendung 590
Ein prozedurorientiertes Projekt mit dem Anwendungs-Assistenten erstellen 601
Ein komplettes Windows-Programm 604
Eine Ellipse zeichnen 606
Ein Bogensegment zeichnen 607
Ein Kreissegment zeichnen 609
Ein Rechteck zeichnen 610
Ein weiteres praktisches Projekt 611
Eine Kuchendiagramm-Anwendung erstellen 617
Die Quelldatei pie.cpp 628
Wie geht es weiter? 632

Kapitel 22: Die Grundlagen der Microsoft-Foundation-Classes-Bibliothek 633
Warum wird eine Foundation-Classes-Bibliothek benötigt? 633
Überlegungen zur Entwicklung der MFC 634
Schlüsselfunktionen der MFC-Bibliothek 635
Am Anfang steht das CObject 635
MFC-Schlüsselklassen 639
Eine MFC-Textverarbeitungsanwendung 643
Die Anwendung erstellen 649
Wie geht es weiter? 661

Kapitel 23: Assistenten und MFC-Windows-Anwendungen 663
Im Arbeitsbereich zeichnen 663
Mit dem Anwendungs-Assistenten arbeiten 663
Den Template-Code ändern 668
Den geänderten Code untersuchen 672
Weitere Projektdetails 674
Eine Anwendung von Fourierschen Reihen mit Ressourcen 678
Den Code für das Fourier-Template erstellen 678
Eine Dialogfeld-Ressource hinzufügen 679
Die Menü-Ressource ändern 683
Fourier-Titelleiste und InfoBox 684
Code zum Zeichnen der Fourierschen Reihe 684
Code für die Änderung der Größe der Grafik 687
Dialogfeld-Schnittstelle 690
Das Fourier-Projekt testen 696
Ein Balkendiagramm mit Ressourcen 697
Titelleisten-String 698
Menü 699
Infofeld-Symbol 700
Infofeld 701
Dialogfeld zur Dateneingabe 702
Grundlegender Code zum Zeichnen eines Balkendiagramms 702
Code für die Änderung der Größe der Grafik 712
Die Dialogfeld-Schnittstelle 713
Das BarChart-Projekt testen 720
Wie geht es weiter? 722

Teil V: Fortgeschrittene Programmierkonzepte 723

Kapitel 24: Die STL und Windows 723
Komplexe Zahlen 723
Die Template-Syntax von 724
Die Klasse complex 729
Die Klasse complex 729
Die Klasse complex 730
Eine einfache -Anwendung 730
Eine Windows-Anwendung mit der STL und der MFC 731
Code für die Änderung der Größe der Grafik 735
Die Complex2-Anwendung testen 738
Zusammenfassung 738

Kapitel 25: Ein Einstieg in das Arbeiten mit OLE 739
OLE-Funktionen und -Spezifikationen 739
Objekte 740
Dateien 740
Daten 740
Einbetten 740
Linking 746
Eine Container-Anwendung entwickeln 746
Mit dem Assistenten arbeiten 746
Ein Blick auf Projektdateien 750
Die Container-Anwendung testen 760
Wie geht es weiter? 762

Kapitel 26: Ein Einstieg in das Arbeiten mit ActiveX-Controls 763
ActiveX-Controls 764
Ein Kriterium für den Entwurf von Controls 764
Die COleControl-Klasse 764
Container, die ActiveX-Controls speichern 773
Ein einfaches ActiveX-Steuerelement entwerfen 773
Ein Standard-Steuerelement 774
Wichtigen Code untersuchen 778
Das Standard-Steuerelement anpassen 784
Form, Größe und Farben von TDCtrl ändern 785
Mausereignisse 787
Das fertige Steuerelement testen 797
Zusammenfassung 798

Kapitel 27: Dynamic Link Libraries 799
Eine MFC-basierte Dynamic Link Library 799
Die Header-Datei Framer.h 802
Die Quelldatei Framer.cpp 803
Die Framer.dll erstellen 805
Eine Anwendung, die eine DLL aufruft 805
Die Header-Datei DLLDemoView.h 807
Die Quelldatei DLLDemoView.cpp 807
Zusammenfassung 810

Stichwortverzeichnis 811