André Willms
Visual C++ 2010 Das umfassende Handbuch
Liebe Leserin, lieber Leser, ich freue mich, Ihnen dieses Kompendium zu Visual C++ 2010 vorstellen zu dürfen. Eine solche umfassende Behandlung des Themas, wie es dieses Buch bietet, ist einfach notwendig, denn dank Visual C++ 2010 können Sie die Vorteile von C++ auch unter .NET nutzen. Einer davon springt besonders ins Auge: C++ ist nicht an .NET gebunden. Es können auch C++-Programme auf anderen Systemen geschrieben werden. Der erste Teil des Buches, ANSI C++, richtet sich vor allem an Programmierer ohne C++-Kenntnisse: Sie erhalten eine Einführung in die Sprache, angefangen bei den Variablen über Klassen und Vererbung bis hin zu den Templates. Aber auch wenn Sie schon Erfahrung mit C++ haben, möchten Sie vielleicht das ein oder andere zu den Grundlagen noch einmal nachlesen. Wenn Sie schon mit C++ programmiert haben, werden Sie sich vor allem für die Erweiterungen und Änderungen der Sprache interessieren, die unter .NET notwendig sind. Dieses Thema wird im zweiten Teil des Buches, C++/CLI, behandelt. Hier wird auf die Auswirkungen auf die Klassen und die Vererbung eingegangen und es werden u.a. die Dateiverwaltung, Delegaten und Ereignisse sowie Collections behandelt. Im dritten Teil wird ausführlich auf die Programmierung grafischer Oberflächen eingegangen. Hier finden Sie alles Wichtige zu Windows Forms, zur Entwicklung von Steuerelementen, Menüleisten und Kontextmenüs und zum Zeichnen mit GDI+. Außerdem wird gezeigt, wie Sie eine oder mehrere Seiten drucken, und auch die Datenbankanbindung kommt nicht zu kurz. Dieses Buch wurde mit großer Sorgfalt begutachtet, lektoriert und produziert. Sollten sich dennoch Fehler eingeschlichen haben oder Fragen auftreten, zögern Sie nicht, mit uns Kontakt aufzunehmen. Sagen Sie uns, was wir noch besser machen können. Ihre Anregungen und Fragen sind uns jederzeit willkommen.
Ihre Christine Siedle Lektorat Galileo Computing
[email protected] www.galileocomputing.de Galileo Press · Rheinwerkallee 4 · 53227 Bonn
Auf einen Blick TEIL I ANSI C++ 1
Grundlagen von ANSI C++ ...................................................
29
2
Kontrollstrukturen ................................................................
77
3
Komplexere Datentypen ......................................................
117
4
Klassen ................................................................................
143
5
Fortgeschrittene Sprachelemente .........................................
193
6
Die STL ................................................................................
227
7
Praxis – Adressbuch ..............................................................
375
TEIL II C++/CLI 8
Grundlagen von C++/CLI ......................................................
409
9
Klassendefinition unter .NET ................................................
433
10 Nützliche .NET-Klassen ........................................................
485
11 Dateiverwaltung ...................................................................
541
12 Praxis – objektorientiertes Telefonbuch ................................
567
TEIL III .NET-Klassenbibliothek 13 Einführung in Windows Forms .............................................
591
14 Nützliche Windows-Forms-Klassen ......................................
639
15 Steuerelemente I ..................................................................
677
16 Steuerelemente II .................................................................
715
17 Menüs & Leisten ..................................................................
751
18 GDI+ ....................................................................................
765
19 Drucken ...............................................................................
785
20 Datenbankanbindung ...........................................................
809
Der Name Galileo Press geht auf den italienischen Mathematiker und Philosophen Galileo Galilei (1564–1642) zurück. Er gilt als Gründungsfigur der neuzeitlichen Wissenschaft und wurde berühmt als Verfechter des modernen, heliozentrischen Weltbilds. Legendär ist sein Ausspruch Eppur si muove (Und sie bewegt sich doch). Das Emblem von Galileo Press ist der Jupiter, umkreist von den vier Galileischen Monden. Galilei entdeckte die nach ihm benannten Monde 1610. Lektorat Christine Siedle, Anne Scheibe Korrektorat Annette Lennartz, Bonn Einbandgestaltung Barbara Thoben, Köln Titelbilder oben links: © fuxart, fotolia.com, oben rechts: © Jorge Figueiredo, fotolia.com, unten rechts: © Galileo Press Typografie und Layout Vera Brauner Herstellung Maxi Beithe Satz Typographie & Computer, Krefeld Druck und Bindung Bercker Graphischer Betrieb, Kevelaer Dieses Buch wurde gesetzt aus der Linotype Syntax Serif (9,75/14 pt) in FrameMaker.
Gerne stehen wir Ihnen mit Rat und Tat zur Seite:
[email protected] bei Fragen und Anmerkungen zum Inhalt des Buches
[email protected] für versandkostenfreie Bestellungen und Reklamationen
[email protected] für Rezensions- und Schulungsexemplare
Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. ISBN
978-3-8362-1639-5
© Galileo Press, Bonn 2011 1. Auflage 2011 Das vorliegende Werk ist in all seinen Teilen urheberrechtlich geschützt. Alle Rechte vorbehalten, insbesondere das Recht der Übersetzung, des Vortrags, der Reproduktion, der Vervielfältigung auf fotomechanischem oder anderen Wegen und der Speicherung in elektronischen Medien. Ungeachtet der Sorgfalt, die auf die Erstellung von Text, Abbildungen und Programmen verwendet wurde, können weder Verlag noch Autor, Herausgeber oder Übersetzer für mögliche Fehler und deren Folgen eine juristische Verantwortung oder irgendeine Haftung übernehmen. Die in diesem Werk wiedergegebenen Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. können auch ohne besondere Kennzeichnung Marken sein und als solche den gesetzlichen Bestimmungen unterliegen.
Inhalt Vorwort ..........................................................................................................
23
TEIL I ANSI C++ 1
Grundlagen von ANSI C++ ....................................................... 29 1.1
1.2 1.3
1.4 1.5 1.6
1.7
1.8
1.9
Die Win32-Konsolenanwendung ................................................. 1.1.1 Eine C++-Datei hinzufügen ............................................. 1.1.2 Das Projekt kompilieren ................................................. 1.1.3 Das Programm starten .................................................... 1.1.4 Die Fehlerkorrektur ........................................................ Die Hauptfunktion ....................................................................... 1.2.1 Der Funktionskopf ......................................................... Die Ausgabe ................................................................................ 1.3.1 cout ............................................................................... 1.3.2 endl ............................................................................... 1.3.3 Escape-Sequenzen ......................................................... 1.3.4 Manipulatoren ............................................................... Die include-Direktive ................................................................... using ........................................................................................... 1.5.1 Bezugsrahmenoperator .................................................. Kommentare ................................................................................ 1.6.1 Einzeilige Kommentare .................................................. 1.6.2 Mehrzeilige Kommentare ............................................... 1.6.3 Kommentare verschachteln ............................................ 1.6.4 Kommentare in der Entwicklungsumgebung .................. Variablen ..................................................................................... 1.7.1 Bezeichner ..................................................................... 1.7.2 Eingabe .......................................................................... 1.7.3 Literale .......................................................................... 1.7.4 Konstanten .................................................................... Datentypen ................................................................................. 1.8.1 Elementare Datentypen .................................................. 1.8.2 Zusammengesetzte Datentypen ...................................... Operatoren .................................................................................. 1.9.1 Zuweisungsoperatoren ................................................... 1.9.2 Arithmetische Operatoren .............................................. 1.9.3 Inkrement und Dekrement .............................................
29 30 32 33 33 34 35 36 37 37 38 38 40 40 41 41 42 42 42 43 43 45 46 47 48 49 50 53 54 54 56 57
5
Inhalt
1.10
2
2.2
2.3
2.4
Verzweigungen ............................................................................ 2.1.1 Bedingungen & bool ...................................................... 2.1.2 if .................................................................................... 2.1.3 else ................................................................................ 2.1.4 Einsatz logischer Operatoren .......................................... 2.1.5 ?:-Operator .................................................................... 2.1.6 switch & case ................................................................. Schleifen ...................................................................................... 2.2.1 while .............................................................................. 2.2.2 do while ......................................................................... 2.2.3 for .................................................................................. 2.2.4 Wann welche Schleife? ................................................... 2.2.5 break ............................................................................. 2.2.6 continue ........................................................................ Funktionen .................................................................................. 2.3.1 Lokale Variablen ............................................................ 2.3.2 Funktionen mit Parametern ............................................ 2.3.3 Mehrere Parameter ........................................................ 2.3.4 Rückgabewerte .............................................................. 2.3.5 Standardwerte für Parameter ......................................... 2.3.6 Funktionsdeklarationen .................................................. Module ....................................................................................... 2.4.1 Definition auslagern ....................................................... 2.4.2 Deklaration auslagern .................................................... 2.4.3 Kompilationsvorgang ..................................................... 2.4.4 Mehrfachdeklarationen vermeiden .................................
77 78 78 80 83 84 85 91 92 94 96 98 98 99 100 102 104 106 107 109 110 111 111 112 113 115
Komplexere Datentypen .......................................................... 117 3.1
6
58 62 63 66 66 69 71
Kontrollstrukturen ................................................................... 77 2.1
3
1.9.4 Bitweise Operatoren ...................................................... 1.9.5 Vergleichsoperatoren ..................................................... 1.9.6 Logische Operatoren ...................................................... 1.9.7 Spezielle Operatoren ...................................................... 1.9.8 Operanden unterschiedlichen Datentyps ........................ 1.9.9 Bindungsstärke ............................................................... Die cmath-Funktionen .................................................................
Arrays .......................................................................................... 117 3.1.1 Variabler Index ............................................................... 118 3.1.2 Mehrdimensionale Arrays ............................................... 119
Inhalt
3.2
3.3
3.4
3.5
4
3.1.3 Einschränkungen von Arrays ........................................... C-Strings ...................................................................................... 3.2.1 char ............................................................................... 3.2.2 cctype-Funktionen ......................................................... 3.2.3 Aufbau von C-Strings ..................................................... 3.2.4 Texteingabe ................................................................... 3.2.5 cstring-Funktionen ......................................................... Strukturen ................................................................................... 3.3.1 Definition einer Struktur ................................................ 3.3.2 Definition der Strukturelemente ..................................... 3.3.3 Zugriff auf die Struktur-Elemente ................................... 3.3.4 Strukturobjekt als Einheit ............................................... Zeiger .......................................................................................... 3.4.1 Adressoperator .............................................................. 3.4.2 Definition eines Zeigers .................................................. 3.4.3 Dereferenzierungsoperator ............................................. 3.4.4 Zeiger als Funktionsparameter ........................................ 3.4.5 Zeiger auf Struktur- und Klassenobjekte ......................... 3.4.6 Zeiger auf Arrays ............................................................ 3.4.7 Zeigerarithmetik ............................................................. Referenzen ..................................................................................
120 120 120 121 122 123 125 130 130 131 132 132 133 133 134 135 136 138 139 140 141
Klassen ..................................................................................... 143 4.1 4.2 4.3 4.4
4.5
4.6 4.7 4.8
Definition einer Klasse ................................................................. 4.1.1 Erstellen einer Klasse mit Visual C++ .............................. Attribute ...................................................................................... Zugriffsrechte ............................................................................... Methoden ................................................................................... 4.4.1 Externe Definition .......................................................... 4.4.2 this ................................................................................ Konstruktoren ............................................................................. 4.5.1 Externe Definition .......................................................... 4.5.2 Private Attribute ............................................................ 4.5.3 Elementinitialisierungsliste ............................................. 4.5.4 Explizite Konstruktoren .................................................. 4.5.5 Standardkonstruktor ...................................................... 4.5.6 Kopierkonstruktor .......................................................... Konstanzwahrende Methoden ..................................................... 4.6.1 Veränderliche Attribute .................................................. Überladen von Methoden ............................................................ Statische Klassenelemente ...........................................................
143 144 147 148 149 150 152 153 155 155 156 157 158 159 160 161 161 163 7
Inhalt
4.9 4.10 4.11
4.12 4.13 4.14 4.15 4.16 4.17 4.18 4.19
4.20
5
163 166 167 169 171 172 173 173 176 177 178 180 182 183 185 188 191 192
Fortgeschrittene Sprachelemente ............................................ 193 5.1
5.2
5.3
5.4
8
4.8.1 Statische Methoden ....................................................... 4.8.2 Statische Attribute ......................................................... typedef ........................................................................................ Verschachtelte Klassen ................................................................ Vererbung ................................................................................... 4.11.1 Das Wesen der Vererbung .............................................. 4.11.2 Die Syntax der Vererbung .............................................. Konstruktoren und Vererbung ..................................................... Erweitern durch Vererbung .......................................................... Methoden überschreiben ............................................................. Geschützte Attribute .................................................................... Polymorphie ................................................................................ Virtuelle Methoden ..................................................................... UML ............................................................................................ Schnittstellen ............................................................................... 4.19.1 Rein virtuelle Methoden ................................................ 4.19.2 Rein abstrakte Klassen ................................................... Downcasts ...................................................................................
Namensbereiche .......................................................................... 5.1.1 using namespace ............................................................ 5.1.2 Darstellung in der UML .................................................. 5.1.3 Verschachtelte Namensbereiche ..................................... 5.1.4 Synonyme definieren ...................................................... Dynamische Speicherverwaltung .................................................. 5.2.1 Erzeugen von Objekten .................................................. 5.2.2 Erzeugen von Arrays ....................................................... 5.2.3 Destruktoren .................................................................. 5.2.4 Wenn »new« fehlschlägt ................................................. Ausnahmen ................................................................................. 5.3.1 Ausnahmen werfen ........................................................ 5.3.2 Ausnahmen fangen ........................................................ 5.3.3 Unterschiedliche Ausnahmen auffangen ......................... 5.3.4 Ausnahmen weiterwerfen .............................................. 5.3.5 Eigene Ausnahme-Klassen .............................................. Templates .................................................................................... 5.4.1 Funktionstemplates ........................................................ 5.4.2 Klassentemplates ...........................................................
193 195 196 196 197 197 198 199 199 201 202 202 206 207 208 209 210 211 213
Inhalt
5.5
6
Operatoren überladen ................................................................. 5.5.1 Zuweisungsoperatoren ................................................... 5.5.2 Arithmetische Operatoren .............................................. 5.5.3 Vergleichsoperatoren ..................................................... 5.5.4 Indexoperator ................................................................ 5.5.5 Dereferenzierungsoperator ............................................. 5.5.6 Inkrement- und Dekrementoperator ..............................
214 217 220 223 223 224 225
Die STL ..................................................................................... 227 6.1
6.2
6.3
6.4
6.5
6.6
6.7
Die Philosophie der STL ............................................................... 6.1.1 Container ....................................................................... 6.1.2 Iteratoren ....................................................................... 6.1.3 Algorithmen ................................................................... 6.1.4 Allokatoren .................................................................... Grundlagen .................................................................................. 6.2.1 Zeitkomplexität .............................................................. 6.2.2 Funktionsobjekte ........................................................... 6.2.3 Paare ............................................................................. 6.2.4 Vergleichsoperatoren ..................................................... 6.2.5 Bereichsangaben ............................................................ Vektoren ..................................................................................... 6.3.1 Konstruktoren ................................................................ 6.3.2 Operatoren .................................................................... 6.3.3 Methoden ...................................................................... 6.3.4 Vektoren im Einsatz ....................................................... Deque ......................................................................................... 6.4.1 Aufbau einer Deque ....................................................... 6.4.2 Definition einer Deque ................................................... 6.4.3 Methoden ...................................................................... Listen .......................................................................................... 6.5.1 Datentypen .................................................................... 6.5.2 Konstruktoren ................................................................ 6.5.3 Operatoren .................................................................... 6.5.4 Methoden ...................................................................... Sets ............................................................................................. 6.6.1 Definition ...................................................................... 6.6.2 Konstruktoren ................................................................ 6.6.3 Operatoren .................................................................... 6.6.4 Methoden ...................................................................... Maps ...........................................................................................
227 228 229 233 234 234 234 237 242 243 244 244 246 247 248 255 256 256 259 259 260 262 263 263 264 272 276 277 277 278 283
9
Inhalt
6.8
6.9
6.10
6.11
6.12
10
6.7.1 Konstruktoren ................................................................ 6.7.2 Operatoren .................................................................... 6.7.3 Methoden ...................................................................... Strings ......................................................................................... 6.8.1 char_traits ...................................................................... 6.8.2 basic_string .................................................................... 6.8.3 Konstruktoren ................................................................ 6.8.4 Operatoren .................................................................... 6.8.5 Methoden ...................................................................... Adapter ....................................................................................... 6.9.1 Stacks ............................................................................ 6.9.2 Konstruktoren ................................................................ 6.9.3 Operatoren .................................................................... 6.9.4 Methoden ...................................................................... 6.9.5 Queues .......................................................................... 6.9.6 Konstruktoren ................................................................ 6.9.7 Operatoren .................................................................... 6.9.8 Methoden ...................................................................... 6.9.9 Priority-Queues .............................................................. 6.9.10 Konstruktoren ................................................................ 6.9.11 Methoden ...................................................................... Iteratoren .................................................................................... 6.10.1 Iteratorkategorien .......................................................... 6.10.2 Iterator-Tags .................................................................. 6.10.3 Iterator-Traits ................................................................. Reverse-Iteratoren ....................................................................... 6.11.1 Insert-Iteratoren ............................................................. 6.11.2 Back-Insert-Iterator ........................................................ 6.11.3 Insert-Iterator ................................................................ 6.11.4 Stream-Iteratoren ........................................................... 6.11.5 Methoden für Iteratoren ................................................ Algorithmen ................................................................................ 6.12.1 Sequenzlängen ............................................................... 6.12.2 Iteratorzugriffe ............................................................... 6.12.3 Ein alphabetischer Überblick .......................................... 6.12.4 Nicht-modifizierende Algorithmen ................................. 6.12.5 Elemente suchen ............................................................ 6.12.6 Elemente zählen ............................................................. 6.12.7 Minimum und Maximum ............................................... 6.12.8 Sequenzen suchen ..........................................................
285 285 286 288 289 292 293 294 295 310 310 312 312 313 314 315 316 316 317 319 319 320 321 322 323 326 328 330 330 331 333 334 334 335 336 339 340 342 342 344
Inhalt
6.12.9 6.12.10 6.12.11 6.12.12 6.12.13 6.12.14 6.12.15 6.12.16 6.12.17 6.12.18 6.12.19 6.12.20
7
Sequenzen vergleichen ................................................... for_each ......................................................................... Modifizierende Algorithmen .......................................... Sequenzen kopieren ....................................................... Elemente ersetzen .......................................................... Elemente löschen ........................................................... Elementreihenfolge verändern ........................................ transform – Elemente umwandeln .................................. Sortierende Algorithmen ................................................ Algorithmen für sortierte Sequenzen .............................. Algorithmen für Mengen ................................................ Heap-Algorithmen .........................................................
346 348 348 349 351 353 356 359 359 364 369 372
Praxis – Adressbuch ................................................................. 375 7.1
7.2
7.3
7.4
Die eigene Liste ........................................................................... 7.1.1 Konstruktoren und Destruktoren .................................... 7.1.2 Hilfsmethoden ............................................................... 7.1.3 Öffentliche Methoden .................................................... 7.1.4 Iteratoren ....................................................................... Die Klasse »Kontakt« ................................................................... 7.2.1 Die Klassendefinition ..................................................... 7.2.2 Die Methoden ............................................................... Die Klasse »Kontaktliste« ............................................................. 7.3.1 Die Klassendefinition ..................................................... 7.3.2 Die Methoden ............................................................... Die Hauptfunktion .......................................................................
375 377 379 384 391 394 394 396 398 398 399 404
TEIL II C++/CLI 8
Grundlagen von C++/CLI .......................................................... 409 8.1 8.2
8.3
C++/CLI ....................................................................................... .NET ............................................................................................ 8.2.1 Common Language Runtime (CLR) ................................. 8.2.2 Common Language Specification (CLS) ........................... 8.2.3 Common Type System (CTS) ........................................... 8.2.4 Klassenbibliothek ........................................................... 8.2.5 WPF ............................................................................... CLR-Konsolenanwendung ............................................................ 8.3.1 Die Projekt-Dateien .......................................................
409 410 411 413 414 416 417 418 419
11
Inhalt
8.4
8.5 8.6 8.7 8.8
8.9 8.10 8.11 8.12
9
419 420 420 420 420 421 422 423 424 425 426 426 426 427 427 428 431 431
Klassendefinition unter .NET ................................................... 433 9.1 9.2 9.3
9.4
9.5
9.6 9.7
12
Das Beispielprogramm ................................................................. 8.4.1 stdafx ............................................................................. 8.4.2 Namensbereich »System« ............................................... 8.4.3 main .............................................................................. 8.4.4 WriteLine ....................................................................... Trackinghandle ............................................................................ Trackingreferenz .......................................................................... Ausgabe ...................................................................................... 8.7.1 Formatierte Ausgabe ...................................................... Arrays .......................................................................................... 8.8.1 Arrays initialisieren ......................................................... 8.8.2 Mehrdimensionale Arrays ............................................... 8.8.3 for each ......................................................................... Eingabe ....................................................................................... Typumwandlung .......................................................................... Ausnahmen ................................................................................. 8.11.1 finally ............................................................................. STL/CLR .......................................................................................
Eine verwaltete Klasse erstellen ................................................... 9.1.1 Zugriffsrecht auf die Klasse ............................................. Die Ausgabe ................................................................................ Eigenschaften .............................................................................. 9.3.1 Externe Definition .......................................................... 9.3.2 Unterschiedliche Zugriffsrechte ...................................... 9.3.3 Eigenschaften ohne Attribute ......................................... 9.3.4 Virtuelle und statische Eigenschaften ............................. Indexer ........................................................................................ 9.4.1 Eigenschaften-Indexer .................................................... 9.4.2 Klassen-Indexer .............................................................. 9.4.3 Mehrdimensionale Indexer ............................................. Ressourcenfreigabe ...................................................................... 9.5.1 Deterministische Freigabe verwalteter Ressourcen ......... 9.5.2 Freigabe nicht verwalteter Ressourcen ........................... 9.5.3 Deterministische Freigabe nicht verwalteter Ressourcen .................................................. 9.5.4 Zusammenfassung .......................................................... Wertklassen ................................................................................. Operatoren überladen .................................................................
433 435 436 437 440 441 442 442 442 443 444 445 445 446 448 449 450 450 452
Inhalt
9.8 9.9
9.10 9.11 9.12 9.13 9.14
9.15 9.16
9.7.1 Operatoren für Werttypen ............................................. 9.7.2 Operatoren für Verweistypen ......................................... 9.7.3 Vergleichsoperatoren ..................................................... 9.7.4 Umwandlungsoperatoren ............................................... Literale ........................................................................................ Aufzählungen .............................................................................. 9.9.1 Explizite Typangabe ....................................................... 9.9.2 Flags .............................................................................. Vererbung ................................................................................... 9.10.1 »override« versus »new« ................................................. Abstrakte Methoden und Klassen ................................................ Versiegelte Methoden ................................................................. Versiegelte Klassen ...................................................................... Schnittstellen ............................................................................... 9.14.1 Schnittstellen und Mehrfachvererbung ........................... 9.14.2 Identische Methoden ..................................................... Delegaten .................................................................................... 9.15.1 Multicast-Delegaten ....................................................... Ereignisse .................................................................................... 9.16.1 Die Klasse »Becher« mit Ereignissen ...............................
454 454 455 456 457 458 460 461 463 466 467 469 469 471 473 474 475 478 479 481
10 Nützliche .NET-Klassen ........................................................... 485 10.1
10.2
10.3
10.4
CultureInfo .................................................................................. 10.1.1 DateTimeFormatInfo ...................................................... 10.1.2 NumberFormatInfo ........................................................ String ........................................................................................... 10.2.1 String-Inhalte ansprechen .............................................. 10.2.2 String-Inhalte verändern ................................................ 10.2.3 String-Inhalte hinzufügen ............................................... 10.2.4 String-Inhalte löschen .................................................... 10.2.5 Strings vergleichen ......................................................... 10.2.6 Suchen in Strings ............................................................ 10.2.7 Strings formatieren ......................................................... StringBuilder ................................................................................ 10.3.1 String-Inhalte ansprechen .............................................. 10.3.2 String-Inhalte hinzufügen ............................................... 10.3.3 String-Inhalte verändern ................................................ 10.3.4 String-Inhalte löschen .................................................... 10.3.5 StringBuilder-Objekte vergleichen .................................. Char ............................................................................................
485 486 489 489 490 491 491 492 493 494 495 496 496 496 497 498 498 498
13
Inhalt
10.5 10.6 10.7 10.8 10.9 10.10
10.11 10.12
10.13 10.14
10.15 10.16
10.17
10.18
10.19 10.20
Collections ................................................................................... IComparer ................................................................................... IComparable ................................................................................ Collection-Schnittstellen .............................................................. IEnumerable ................................................................................ ICollection ................................................................................... 10.10.1 Queue ............................................................................ 10.10.2 Stack .............................................................................. IList ............................................................................................. 10.11.1 ArrayList ........................................................................ IDictionary ................................................................................... 10.12.1 Hashtable ....................................................................... 10.12.2 SortedList ....................................................................... Generische Collections ................................................................. 10.13.1 Die generischen Schnittstellen ....................................... Anwendungsbeispiele .................................................................. 10.14.1 Personen verwalten mit List ........................................... 10.14.2 Eine Collection mit int-Werten absteigend sortieren ...... Random – Zufallszahlen ............................................................... Math – mathematische Funktionen .............................................. 10.16.1 Methoden ...................................................................... 10.16.2 Konstanten .................................................................... Console – die Konsole ................................................................. 10.17.1 Eigenschaften ................................................................. 10.17.2 Methoden ...................................................................... Environment – die Umgebung ...................................................... 10.18.1 Eigenschaften ................................................................. 10.18.2 Methoden ...................................................................... GC – der Garbage-Collector ......................................................... Timer – der Taktgeber .................................................................. 10.20.1 Ein Beispiel ....................................................................
499 500 500 501 502 503 503 505 507 508 511 512 513 515 517 518 518 521 522 523 524 528 528 528 530 534 534 535 537 539 540
11 Dateiverwaltung ...................................................................... 541 11.1
11.2 11.3
14
DateTime ..................................................................................... 11.1.1 Öffentliche Eigenschaften ............................................... 11.1.2 Öffentliche Methoden .................................................... Laufwerke .................................................................................... Verzeichnisse ............................................................................... 11.3.1 Directory ........................................................................ 11.3.2 FileSystemInfo ................................................................
541 542 543 545 546 547 550
Inhalt
11.4
11.5 11.6
11.7
11.8 11.9
11.3.3 DirectoryInfo ................................................................. Dateien ....................................................................................... 11.4.1 File ................................................................................ 11.4.2 FileInfo .......................................................................... Dateiströme ................................................................................. 11.5.1 FileStream ...................................................................... Binärströme ................................................................................. 11.6.1 BinaryWriter .................................................................. 11.6.2 BinaryReader .................................................................. Zeichenströme ............................................................................. 11.7.1 StreamWriter ................................................................. 11.7.2 StreamReader ................................................................ Serialisierung ............................................................................... 11.8.1 Das SerializableAttribute ................................................ Praktische Anwendung ................................................................ 11.9.1 Einlesen einer Textdatei ................................................. 11.9.2 Beschreiben einer Log-Datei .......................................... 11.9.3 Datei byteweise kopieren ...............................................
551 551 552 554 554 555 557 557 559 560 560 561 562 563 564 565 566 566
12 Praxis – objektorientiertes Telefonbuch .................................. 567 12.1 12.2
12.3
12.4 12.5
12.6
12.7 12.8
Die Schnittstelle IKontakt ............................................................ Die Klasse »Kontakt« ................................................................... 12.2.1 Klassendefinition ............................................................ 12.2.2 Die externen Definitionen .............................................. Die Klasse »KontaktTxt« ............................................................... 12.3.1 Die Klassendefinition ..................................................... 12.3.2 Die externen Definitionen .............................................. Die Schnittstelle »ITelefonbuch« .................................................. Die Klasse »Telefonbuch« ............................................................. 12.5.1 Die Klassendefinition ..................................................... 12.5.2 Die externen Definitionen .............................................. Die Klasse »TelefonbuchTxt« ........................................................ 12.6.1 Die Klassendefinition ..................................................... 12.6.2 Die externen Definitionen .............................................. Das Hauptprogramm ................................................................... Datei-IO ...................................................................................... 12.8.1 Die angepasste IKontakt-Schnittstelle ............................ 12.8.2 Die angepasste Kontakt-Klasse ....................................... 12.8.3 Die angepasste ITelefonbuch-Schnittstelle ...................... 12.8.4 Die abstrakte Fabrik .......................................................
567 568 569 570 571 571 571 572 573 573 575 577 578 579 580 582 582 582 583 583
15
Inhalt
12.8.5 12.8.6 12.8.7 12.8.8
Die Schnittstelle »IKontaktFabrik« .................................. Die Klasse »KontaktFabrikTxt« ........................................ Die angepasste Klasse »Telefonbuch« ............................. Die angepasste Klasse »TelefonbuchTxt« ........................
584 584 584 586
TEIL III .NET-Klassenbibliothek 13 Einführung in Windows Forms ................................................ 591 13.1 13.2 13.3 13.4 13.5
13.6
13.7
13.8
Das Hauptprogramm ................................................................... Die Form-Datei ............................................................................ Das Eigenschaftenfenster des Designers ....................................... Component ................................................................................. Control – Basis aller Steuerlemente .............................................. 13.5.1 Öffentliche Eigenschaften ............................................... 13.5.2 Öffentliche Methoden .................................................... 13.5.3 Öffentliche Ereignisse ..................................................... ScrollableControl – scrollbare Container ....................................... 13.6.1 Öffentliche Eigenschaften ............................................... 13.6.2 Öffentliche Methoden .................................................... 13.6.3 Öffentliche Ereignisse ..................................................... Form – die Formularklasse ........................................................... 13.7.1 Öffentliche Eigenschaften ............................................... 13.7.2 Öffentliche Methoden .................................................... 13.7.3 Öffentliche Ereignisse ..................................................... Ereignisse im Designer ................................................................. 13.8.1 Handler hinzufügen ........................................................ 13.8.2 Handler entfernen ..........................................................
592 594 596 597 598 599 610 614 622 623 626 626 627 627 634 635 637 637 638
14 Nützliche Windows-Forms-Klassen ........................................ 639 14.1 14.2
14.3
14.4
16
Assembly-Verweise hinzufügen .................................................... Size – die Größenangabe .............................................................. 14.2.1 Eigenschaften ................................................................. 14.2.2 Methoden ...................................................................... Point – die Positionsangabe ......................................................... 14.3.1 Eigenschaften ................................................................. 14.3.2 Methoden ...................................................................... Rectangle – ein rechteckiger Bereich ............................................ 14.4.1 Eigenschaften ................................................................. 14.4.2 Methoden ......................................................................
639 642 642 642 643 643 643 644 644 645
Inhalt
14.5
14.6
14.7 14.8
14.9 14.10
14.11
14.12
14.13
14.14
14.15
Color – Farbangaben .................................................................... 14.5.1 Eigenschaften ................................................................. 14.5.2 Methoden ...................................................................... 14.5.3 Farben im Designer ........................................................ Font – die Schriftart ..................................................................... 14.6.1 Eigenschaften ................................................................. 14.6.2 Fonts im Designer .......................................................... MessageBox – ein Nachrichtenfenster .......................................... Image – die Grundlage der Bilder ................................................. 14.8.1 Eigenschaften ................................................................. 14.8.2 Methoden ...................................................................... Bitmap – die Klasse für konkrete Bilder ........................................ 14.9.1 Methoden ...................................................................... Icon – die kleinen Bilder .............................................................. 14.10.1 Konstruktoren ................................................................ 14.10.2 Eigenschaften ................................................................. 14.10.3 Methoden ...................................................................... 14.10.4 SystemIcons – die Klasse mit den System-Icons .............. ImageList – die Bilderliste ............................................................ 14.11.1 Eigenschaften ................................................................. 14.11.2 Methoden ...................................................................... Cursor – die Mauszeiger ............................................................... 14.12.1 Konstruktoren ................................................................ 14.12.2 Eigenschaften ................................................................. 14.12.3 Methoden ...................................................................... 14.12.4 Cursors – ein Mauszeiger für jede Situation .................... Padding – Abstände und Ränder .................................................. 14.13.1 Konstruktoren ................................................................ 14.13.2 Eigenschaften ................................................................. 14.13.3 Methoden ...................................................................... Standarddialoge ........................................................................... 14.14.1 FileDialog ...................................................................... 14.14.2 OpenFileDialog .............................................................. 14.14.3 SaveFileDialog ............................................................... 14.14.4 FolderBrowserDialog – die Suche nach Verzeichnissen ... 14.14.5 ColorDialog – bringt Farbe ins Leben .............................. 14.14.6 FontDialog – die Auswahl für Schriftarten ...................... Type – Kern der Reflection-API .................................................... 14.15.1 Eigenschaften ................................................................. 14.15.2 Methoden ......................................................................
648 648 650 651 653 653 654 654 657 657 657 658 659 659 660 660 660 661 661 661 662 662 663 663 663 664 664 664 664 665 665 665 669 670 671 672 673 675 675 676
17
Inhalt
15 Steuerelemente I ...................................................................... 677 15.1
15.2 15.3 15.4 15.5
15.6
15.7
15.8
15.9 15.10
15.11 15.12 15.13
15.14
18
Label – Beschriftungen ................................................................. 15.1.1 Eigenschaften ................................................................. 15.1.2 LinkLabel – anklickbare Beschriftungen .......................... GroupBox – Gruppierungen ......................................................... ButtonBase – die Basis der Buttons .............................................. 15.3.1 Eigenschaften ................................................................. Button – Schaltflächen ................................................................. CheckBox – Elemente zum Abhaken ............................................ 15.5.1 Eigenschaften ................................................................. 15.5.2 Ereignisse ....................................................................... RadioButton – Optionen zur Auswahl .......................................... 15.6.1 Eigenschaften ................................................................. 15.6.2 Methoden ...................................................................... 15.6.3 Ereignisse ....................................................................... PictureBox – ein Bilderrahmen ..................................................... 15.7.1 Eigenschaften ................................................................. 15.7.2 Methoden ...................................................................... 15.7.3 Ereignisse ....................................................................... TextBoxBase – die Basis der Texteingabefelder ............................. 15.8.1 Eigenschaften ................................................................. 15.8.2 Methoden ...................................................................... 15.8.3 Ereignisse ....................................................................... TextBox – ein einfaches Texteingabefeld ...................................... 15.9.1 Eigenschaften ................................................................. MaskedTextBox – Eingabe nach Vorschrift ................................... 15.10.1 Eigenschaften ................................................................. 15.10.2 Methoden ...................................................................... 15.10.3 Ereignisse ....................................................................... RichTextBox – die kleine Textverarbeitung ................................... ListControl – die Basis aller Listenelemente .................................. 15.12.1 Eigenschaften ................................................................. ListBox – eine einfache Auflistung ................................................ 15.13.1 Eigenschaften ................................................................. 15.13.2 Methoden ...................................................................... 15.13.3 Ereignisse ....................................................................... 15.13.4 ComboBox ..................................................................... ProgressBar – der Fortschrittsbalken ............................................ 15.14.1 Eigenschaften ................................................................. 15.14.2 Methoden ......................................................................
677 678 680 680 681 681 682 683 684 685 686 686 687 687 687 688 690 690 691 691 693 696 696 697 700 700 705 705 706 707 707 708 708 711 712 712 713 713 714
Inhalt
16 Steuerelemente II ..................................................................... 715 16.1 16.2 16.3 16.4
16.5
16.6
16.7
Panel – die Basis komplexerer Gruppierungen .............................. 16.1.1 Eigenschaften ................................................................. FlowLayoutPanel – Gruppierung wie Fließtext .............................. 16.2.1 Eigenschaften ................................................................. TableLayoutPanel – Gruppierung zu Tabellenform ........................ 16.3.1 Eigenschaften ................................................................. SplitContainer – eine größenveränderbare Aufteilung ................... 16.4.1 Eigenschaften ................................................................. 16.4.2 Ereignisse ....................................................................... TabControl – Gruppierung über Registerkarten ............................ 16.5.1 Eigenschaften ................................................................. 16.5.2 Ereignisse ....................................................................... 16.5.3 TabPage – die Registerkarte ........................................... ListView – zweidimensionale Listen ............................................. 16.6.1 Eigenschaften ................................................................. 16.6.2 Methoden ...................................................................... 16.6.3 Ereignisse ....................................................................... 16.6.4 ColumnHeader – die Überschriften der Liste ................... 16.6.5 ListViewGroup – die Gruppen der Liste .......................... 16.6.6 ListViewItem – die Elemente der Liste ............................ 16.6.7 ListViewSubItem – die Unterelemente der Liste ............. TreeView – die Baumdarstellung .................................................. 16.7.1 Eigenschaften ................................................................. 16.7.2 Methoden ...................................................................... 16.7.3 Ereignisse ....................................................................... 16.7.4 TreeNode – die Knoten des Baums .................................
715 716 716 717 717 718 719 719 721 722 723 724 726 726 728 734 735 737 738 738 740 741 742 744 745 747
17 Menüs & Leisten ...................................................................... 751 17.1 17.2 17.3 17.4 17.5
ToolStrip – die Symbolleiste ......................................................... 17.1.1 Eigenschaften ................................................................. MenuStrip – die Menüleiste ......................................................... StatusStrip – die Statusleiste ........................................................ ContextMenuStrip – das Kontextmenü ......................................... Die ToolStrip-Elemente ................................................................ 17.5.1 ToolStripItem – die Basis der ToolStrip-Elemente ........... 17.5.2 ToolStripButton – ein einfacher Button .......................... 17.5.3 ToolStripComboBox – eine Combobox für ToolStrips ...... 17.5.4 ToolStripDropDownButton – eine aufklappbare Schaltfläche ...............................................
751 752 753 754 755 755 755 757 758 758 19
Inhalt
17.5.5
17.6
ToolStripLabel, ToolStripStatusLabel – eine Leistenbeschriftung ........................................................ 17.5.6 ToolStripMenuItem – ein Menüpunkt ............................ 17.5.7 ToolStripProgressBar – der Fortschrittsbalken in der Leiste ................................................................... 17.5.8 ToolStripSeparator – der Spalter unter den Elementen ... 17.5.9 ToolStripSplitButton – die Kombischaltfläche ................. 17.5.10 ToolStripTextBox – die Textbox in der Leiste .................. ToolStripContainer – die Spielwiese für Leisten ............................
759 760 761 761 762 762 763
18 GDI+ ......................................................................................... 765 18.1
18.2 18.3
18.4
18.5
Brush – die Pinsel ........................................................................ 18.1.1 SolidBrush – eine solide Füllung ..................................... 18.1.2 TextureBrush – der Stempel ........................................... 18.1.3 LinearGradientBrush – der Farbverlauf ............................ 18.1.4 HatchBrush – der Pinsel mit Muster ............................... 18.1.5 Brushes – ein Pinsel für alle Fälle .................................... Pen – der Stift .............................................................................. Graphics – das Zeichenbrett ......................................................... 18.3.1 Eigenschaften ................................................................. 18.3.2 Methoden ...................................................................... StringFormat – das Aussehen der Strings ...................................... 18.4.1 Konstruktoren ................................................................ 18.4.2 Eigenschaften ................................................................. Zeichnen über »Paint« .................................................................. 18.5.1 Partielles Neuzeichnen ................................................... 18.5.2 Double Buffering ............................................................
766 766 767 768 769 770 770 771 771 773 778 778 779 781 781 782
19 Drucken .................................................................................... 785 19.1
19.2
19.3 19.4
20
PrintDocument – die Kernklasse zum Drucken ............................. 19.1.1 Öffentliche Eigenschaften ............................................... 19.1.2 Methoden ...................................................................... 19.1.3 Ereignisse ....................................................................... PrinterSettings – Wer druckt? ...................................................... 19.2.1 Eigenschaften ................................................................. 19.2.2 Methoden ...................................................................... PrintDialog – die Druckerauswahl ................................................ 19.3.1 Eigenschaften ................................................................. PageSettings – die Seiteneigenschaften ........................................
785 785 786 786 788 788 795 795 796 797
Inhalt
19.5 19.6 19.7 19.8
19.4.1 Eigenschaften ................................................................. PageSetupDialog – die Seite einrichten ........................................ 19.5.1 Eigenschaften ................................................................. PrintPreviewDialog – die Druckvorschau ...................................... PrintPreviewControl – das Steuerelement .................................... 19.7.1 Eigenschaften ................................................................. Drucken in der Praxis ................................................................... 19.8.1 Drucken dreier Seiten ....................................................
797 799 800 801 802 802 803 803
20 Datenbankanbindung .............................................................. 809 20.1 20.2
20.3
20.4
20.5
20.6
20.7
Das Zusammenspiel der Klassen ................................................... OleDbConnection – die Datenbankverbindung ............................ 20.2.1 Konstruktoren ................................................................ 20.2.2 Eigenschaften ................................................................. 20.2.3 Methoden ...................................................................... 20.2.4 Die Verbindungszeichenfolge ......................................... 20.2.5 Verbindungspooling ....................................................... 20.2.6 Ein Beispiel .................................................................... OleDbCommand – der SQL-Befehl ............................................... 20.3.1 Konstruktoren ................................................................ 20.3.2 Eigenschaften ................................................................. 20.3.3 Methoden ...................................................................... 20.3.4 Beispiele ........................................................................ OleDbParameter – die Befehlsparameter ...................................... 20.4.1 Konstruktoren ................................................................ 20.4.2 Eigenschaften ................................................................. 20.4.3 Methoden ...................................................................... OleDbDataReader – der Datensatzleser ....................................... 20.5.1 Eigenschaften ................................................................. 20.5.2 Methoden ...................................................................... 20.5.3 Beispiel .......................................................................... OleDbTransaction – die Transaktion ............................................. 20.6.1 Eigenschaften ................................................................. 20.6.2 Methoden ...................................................................... 20.6.3 Beispiel .......................................................................... DataTable – die Tabelle im Speicher ............................................ 20.7.1 Konstruktoren ................................................................ 20.7.2 Eigenschaften ................................................................. 20.7.3 Methoden ...................................................................... 20.7.4 Ereignisse .......................................................................
810 811 811 812 813 814 816 817 819 820 820 822 823 826 827 828 829 830 830 831 832 833 835 836 836 838 839 840 840 842
21
Inhalt
20.7.5 DataColumn – die Tabellenspalte ................................... 20.7.6 DataRow – die Tabellenzeile .......................................... 20.7.7 Beispiel .......................................................................... 20.8 DataSet – die Tabellensammlung ................................................. 20.8.1 Konstruktoren ................................................................ 20.8.2 Eigenschaften ................................................................. 20.8.3 Methoden ...................................................................... 20.9 DataGridView – die sichtbare Tabelle ........................................... 20.9.1 Eigenschaften ................................................................. 20.9.2 Methoden ...................................................................... 20.9.3 DataGridViewColumn – die sichtbare Tabellenspalte ...... 20.9.4 DataGridViewButtonColumn – die Button-Spalte ........... 20.9.5 DataGridViewCheckBoxColumn – die Checkbox-Spalte ...................................................... 20.9.6 DataGridViewComboBoxColumn – die Combobox-Spalte ..................................................... 20.9.7 DataGridViewImageColumn – die Bilder-Spalte .............. 20.9.8 DataGridViewLinkColumn – die Link-Spalte ................... 20.9.9 DataGridViewTextBoxColumn – die Textbox-Spalte ........ 20.9.10 DataGridViewRow – die sichtbare Zeile .......................... 20.9.11 DataGridViewCell – die Tabellenzelle ............................. 20.10 OleDbDataAdapter – automatisierte Kommunikation .................. 20.10.1 Eigenschaften ................................................................. 20.10.2 Methoden ...................................................................... 20.10.3 Beispiel ..........................................................................
844 846 849 851 852 852 853 854 855 859 860 863 863 865 868 869 870 870 872 874 874 875 875
Anhang ........................................................................................... 881 A
Arbeiten mit der Entwicklungsumgebung ............................................... A.1 Der Debugger .............................................................................. A.1.1 Haltepunkte ................................................................... A.1.2 Schrittweise Abarbeitung ............................................... A.1.3 Komplexere Haltepunkte ................................................ A.2 Variablen überwachen ................................................................. A.3 Die Klassenansicht ....................................................................... A.3.1 Der Objektbrowser ........................................................ A.3.2 Die Aufrufhierarchie ....................................................... A.4 Der Klassendesigner .................................................................... A.4.1 Ein Klassendiagramm erstellen .......................................
883 883 885 887 888 890 891 894 894 895 896
Index ............................................................................................................ 899
22
Vorwort
VSchon wieder eine neue Version von Visual C++, aber Entwicklung ist das beste Anzeichen einer lebendigen Sprache. Zugegeben, ein Großteil der Entwicklung fand im Bereich des .NET-Frameworks statt, welches nun in der Version 4 vorliegt. Aber auch C++ hat einen Schritt nach vorn getan, der hauptsächlich in der Behebung von Fehlern der Vorgängerversion besteht. Im Vergleich zur Programmiersprache C#, die bei jeder neuen Version des Visual Studios mit zahlreichen Erweiterungen aufwartet, wird C++ scheinbar stiefmütterlich behandelt. Diese Betrachtung lässt allerdings die Entwicklungsgeschichte dieser beiden Sprachen außer Acht. Während C# speziell für die .NET-Programmierung entworfen wurde und deshalb naturgemäß auch mit dem .NET-Framework wächst und erweitert wird, ist C++ eine Sprache, deren Haupteinsatzgebiet außerhalb von .NET liegt und deren Standard auch nicht von Microsoft vorgeschrieben wird. Es ist daher sinnvoll, die unter C++/CLI notwendigen Ergänzungen für die .NET-Kompatibilität so gering wie möglich zu halten und stattdessen dem C++-Programmierer seine gewohnten Hilfsmittel bereitzustellen, wie z. B. die STL/CLR, das .NET-Pendant der C++-eigenen STL, welche in der nun vorliegenden Version besser denn je einsetzbar ist. Wozu C++?
Sie kennen wahrscheinlich das geflügelte Wort, dass man keiner Statistik trauen sollte, die man nicht selbst gefälscht hat. Trotzdem möchte ich hier einige Zahlen über die momentane Verbreitung (Stand November 2010) der Programmiersprachen nennen. Exemplarisch möchte ich hier den TIOBEIndex (zu finden unter www.tiobe.com) anbringen. Die prozentualen Werte anderer Rankings sind leicht abweichend, das globale Bild bleibt aber dasselbe. Demnach steht Java auf Platz 1 (18,5 %), Platz 2 belegt C (16,7 %), gefolgt von C++ (9,5 %) auf dem dritten Platz. C# findet sich mit 5,7 % auf Platz 5. Visual Basic .NET als dritte Programmiersprache des Visual Studios liegt mit 0,32 % weit abgeschlagen auf Rang 41. C und C++ gemeinsam betrachtet decken
23
Vorwort
mehr als ein Viertel der eingesetzten Programmiersprachen weltweit ab. Ein guter Grund zum Erlernen von C++. Oft entscheidet aber auch der Einsatzbereich. Während sich Java im Internet breitgemacht hat und auch in Handys und Bluray-Playern Verwendung findet, kommt C/C++ überwiegend dort zum Einsatz, wo es schnell gehen muss. Von Gerätetreibern über Signalverarbeitung in Echtzeit bis hin zu High-End 3D-Spielen. Auch sagt man, dass es einem C++-Programmierer leichter fällt, Java zu lernen als umgekehrt. Aber das mag auch nur ein Gerücht sein. Wozu C++/CLI?
Mit Erscheinen von Visual Studio 2010 und der darin enthaltenen Version von C++/CLI ist diese Frage klärungsbedürftiger denn je. Grundsätzlich ist C++/CLI ein C++-Dialekt, der notwendige Ergänzungen für die Kompatibilität mit dem .NET-Framework enthält. Manche behaupten, C++ und C++/CLI seien zwei völlig unterschiedliche Programmiersprachen, die nichts miteinander zu tun hätten. Technisch gesehen ist das korrekt, da das resultierende Kompilat in unterschiedliche Sprachen für unterschiedliche Laufzeitumgebungen übersetzt wird. Syntaktisch und semantisch sind diese Sprachen aber nahezu identisch, so dass es einem C++-Programmierer keine Mühe macht, C++/CLI zu erlernen. Aber die Frage bleibt: Wozu C++/CLI? Microsoft macht ganz klar, dass für die Programmierung von .NET-Applikationen die hauseigene Sprache C# bevorzugt werden sollte, welch’ Wunder. Die Tatsache, dass Intellisense, ein den Programmierer unterstützender Mechanismus, in der Version 2010 nur noch bei nativem C++ und nicht mehr bei C++/CLI vorhanden ist, scheint diese Empfehlung noch zu unterstützen. Hintergrund ist allerdings ein Redesign des Intellisense-Systems. Und weil für diese Version der Entwicklungsschwerpunkt auf anderen Dingen lag, gibt es Intellisense nur für natives C++. Ob es in einem Service Pack oder in einer zukünftigen Version auch wieder für C++/CLI bereitstehen wird, bleibt abzuwarten. Trotzdem kann in C++/CLI jedwede .NET-Applikation programmiert werden, auch wenn der Programmierer dabei nicht so tatkräftig von der Entwicklungsumgebung unterstützt wird, wie bei C# oder Visual Basic .NET. Dass eine .NET-Entwicklung auch für Microsoft nicht völlig abwegig ist, zeigen die Ergänzungen in C++/CLI, die speziell darauf abzielen, dass sich auch C++-Programmierer unter .NET wohlfühlen, wie z. B. die STL/CLR. Unschlagbar ist C++/CLI auf jeden Fall als sogenannte Interop-Sprache, als Mittler zwi-
24
Vorwort
schen nativem Programmcode und dem verwalteten Programmcode von .NET. Ein typisches Anwendungsbeispiel wäre das Kapseln einer in nativem C++ geschriebenen Klasse in eine .NET-Klasse, so dass sie z. B. in C# weiterverwendet werden kann. Um als Programmierer möglichst breit aufgestellt zu sein, bietet es sich daher an, zuerst C/C++ zu lernen, anschließend die .NET-Welt mit C++/CLI zu erkunden, und sich bei exzessiver Entwicklung von .NET-Applikationen noch C# anzueignen, eine C++ sehr ähnliche Sprache. Der Aufbau des Buchs
Das Buch ist im Wesentlichen in drei Teile gegliedert: Der erste Teil erklärt natives C++ ohne .NET-Unterstützung. Er sollte von Programmieranfängern auf jeden Fall durchgearbeitet werden und dient erfahreneren C++-Programmierern als Nachschlagemöglichkeit. Im zweiten Teil werden die Erweiterungen von C++/CLI besprochen. Erfahrende C++-Programmierer können hier bequem in die .NET-Programmierung einsteigen. Der dritte Teil schließlich beschäftigt sich mit der Klassenbibliothek von .NET, allen voran der Oberflächenprogrammierung. Die Klassenbibliothek steht allen .NET-Programmiersprachen zur Verfügung. Die hier vorgestellten Klassen könnten Sie daher auch unter C# oder Visual Basic .NET mit der entsprechenden Syntax verwenden. Die Beispiele in diesem Buch
Das Buch beinhaltet eine Reihe von Beispielen und praktischen Anwendungen, die Sie als Projekte von Visual C++ 2010 Express auf der DVD finden. Für jedes Kapitel, das Beispiele enthält, existiert eine Projektmappe, die wiederum die einzelnen Listings enthält. Oft werden die Beispiele in kleinen Schritten erweitert, so dass es keinen Sinn macht, für jeden Schritt ein eigenes Projekt anzulegen. Wenn also bei den Projekten vermeintliche Lücken vorhanden sind, dann beinhaltet das Folgeprojekt immer alle Ergänzungen und Änderungen, die bis dahin gemacht wurden. Manche Projekte, die in sich geschlossenen sind, wie beispielsweise das Telefonbuch, finden Sie unter ihrem Namen in der Projektmappe.
25
TEIL I ANSI C++
Dieses Kapitel führt Sie in die Grundstruktur eines C++-Programms ein. Es zeigt die Ein- und Ausgabe und stellt die in C++ verfügbaren Datentypen und Operatoren vor.
1
Grundlagen von ANSI C++
1.1
Die Win32-Konsolenanwendung
Die ersten Schritte in C++ werden wir als Win32-Konsolenanwendung vornehmen. Dazu wählen Sie in der Entwicklungsumgebung über das Menü den Punkt Datei 폷 Neu 폷 Projekt. Sie erhalten das in Abbildung 1.1 dargestellte Fenster.
Abbildung 1.1
Neues Projekt anlegen
Je nach Edition des Visual Studios kann der Umfang der angebotenen Projektvorlagen variieren. Die in diesem Buch relevanten Projektgruppen sind CLR für .NET-gestützte Projekte und die nun thematisierte Projektart Win32. In dieser Gruppe finden Sie die Win32-Konsolenanwendung, die Sie jetzt wählen. Unter Name geben Sie den Namen des Projekts an, in unserem Beispiel wurde dort HelloWorld gewählt. Der Punkt Ort bieten Ihnen die Möglichkeit, den Speicherort des Projekts zu bestimmten.
29
1
Grundlagen von ANSI C++
In Visual Studio werden Projekte in einer Projektmappe verwaltet. Soll für diese Projektmappe physikalisch ein eigener Ordner angelegt werden, dann müssen Sie einen Haken vor Verzeichnis für Lösung erstellen setzen und einen Projektmappennamen angegeben. Anschließend öffnen Sie über OK das Einstellungsfenster für die Win32-Konsolenanwendung, zu sehen in Abbildung 1.2.
Abbildung 1.2 Die Anwendungseinstellungen für das Win32-Projekt
Dort setzen Sie einen Haken vor Leeres Projekt. Über die Schaltfläche Fertig stellen wird das Projekt angelegt und in der Entwicklungsumgebung angezeigt.
1.1.1
Eine C++-Datei hinzufügen
Um das erste Programm zu schreiben, benötigen wir noch eine entsprechende Quellcodedatei. Dazu klicken Sie im Projektmappen-Explorer mit rechts auf den Projektnamen und wählen den Punkt Hinzufügen 폷 Neues Element aus. Es erscheint das in Abbildung 1.3 dargestellte Fenster. Zur Einschränkung der Auswahl sollten Sie in der linken Spalte auf Code klicken. Von den verbleibenden Dateitypen wählen Sie C++-Datei, geben dieser unter Name einen Namen (die für diesen Dateityp verwendete Endung .cpp wird automatisch angehängt) und klicken auf Hinzufügen. In C++ gibt es keinerlei syntaktischen Bezug zwischen dem Namen einer Datei und ihrem Inhalt. Zur besseren Übersicht sollten Sie aber möglichst
30
Die Win32-Konsolenanwendung
aussagekräftige Namen vergeben. Die C++-Datei mit der späteren Hauptfunktion können Sie beispielsweise immer main nennen.
Abbildung 1.3 Neues Element hinzufügen
Um an dieser Stelle den vollständigen Entwicklungszyklus eines Programms zu besprechen, schreiben Sie bitte das kleine Programm aus Listing 1.1 in die C++-Datei. Abbildung 1.4 zeigt das Ergebnis. int main() { } Listing 1.1 Das erste Programm
Abbildung 1.4 Das erste Programm in der Entwicklungsumgebung
31
1.1
1
Grundlagen von ANSI C++
Der Stern hinter dem Dateinamen zeigt Änderungen an, die noch nicht gespeichert wurden. Entweder können Sie über die üblichen Punkte Speichern oder Alle speichern die Änderungen manuell sichern, oder Sie starten die Kompilation des Programms, vor der automatisch alle Änderungen gespeichert werden.
1.1.2
Das Projekt kompilieren
C++-Projekte müssen kompiliert, also vom Compiler in Maschinensprache übersetzt werden.Unter dem Menüpunkt Erstellen finden Sie die dafür notwendigen Funkionen. Die erste Gruppe von Menüpunkten betrifft die gesamte Projektmappe, also alle in der Projektmappe enthaltenen Projekte. Die zweite Gruppe bezieht sich nur auf das aktuelle Startprojekt. Das Startprojekt ist im ProjektmappenExplorer daran zu erkennen, dass es fett geschrieben ist (um bei mehreren Projekten das Startprojekt zu wechseln, klicken Sie im Projektmappen-Explorer das gewünschte Projekt mit rechts an und wählen den Punkt Als Startprojekt festlegen). Für beide Gruppen existieren folgende Möglichkeiten: 왘
Erstellen: Alle noch nicht kompilierten Bestandteile werden kompiliert, und ein ausführbares Programm wird erstellt.
왘
Neu erstellen: Alles wird neu kompiliert, egal, ob es bereits kompiliert war oder nicht, und dann wird ein ausführbares Programm daraus erstellt.
왘
Bereinigen: Alle für das Projekt unwesentlichen Dateien werden gelöscht (etwa die kompilierten Dateien des Projekts, die nicht wichtig sind, da sie immer wieder aus den Quellcodedateien erzeugt werden können). Dieser Punkt sollte ausgeführt werden, bevor ein Projekt beispielsweise auf CD gebrannt wird, um unnötigen Speicherverbrauch zu vermeiden.
Für den normalen Kompilationsvorgang reicht der Punkt Projektmappe erstellen, der auch bequem über (F7) aufgerufen werden kann. Der Kompilationsvorgang umfasst je nach gewähltem Punkt die Kompilation aller oder nur der geänderten Dateien, die Erstellung eines Manifests und die abschließende Verknüpfung aller erstellten Dateien des Projekts zu einem ausführbaren Programm. Die letzte Zeile im Ausgabefenster gibt eine kurze Zusammenfassung der Projektzustände:
32
Die Win32-Konsolenanwendung
왘
erfolgreich: Anzahl der erfolgreich kompilierten Projekte
왘
Fehler bei: Anzahl der Projekte mit Fehlern (aus einem fehlerhaften Projekt wird keine ausführbare Datei erzeugt; sollte das Projekt vorher einmal fehlerfrei kompiliert worden sein, dann entspricht die ausführbare Datei diesem Stand)
왘
aktuell: Anzahl der Projekte, an denen nichts geändert wurde und die deswegen auch nicht kompiliert werden mussten
왘
übersprungen: Anzahl der Projekte, die von der Kompilation ausgenom-
men sind.
1.1.3
Das Programm starten
Unter dem Menüpunkt Debuggen finden Sie Möglichkeiten des Programmstarts über die Entwicklungsumgebung. Damit das Ausgabefenster nicht direkt nach Beendigung des Programms wieder geschlossen wird, sollten Sie das Programm über den Punkt Starten ohne Debuggen oder (Strg) + (F5) starten. Bedenken Sie: Nur das als Startprojekt festgelegte Projekt wird ausgeführt. Wie ein Programm im Debug-Modus gestartet wird, erfahren Sie in Abschnitt A.1, »Der Debugger«.
1.1.4
Die Fehlerkorrektur
Nicht selten stellt der Compiler während der Kompilation syntaktische Fehler fest. Zum Beispiel können Sie das Wort int einmal mit zwei n schreiben (innt) und dann das Programm nochmals kompilieren. Das Ausgabefenster (zu sehen in Abbildung 1.5) listet die gefundenen Fehler auf und merkt in der Statuszeile am Ende »Fehler bei 1« an.
Abbildung 1.5 Der Fehler im Ausgabefenster
33
1.1
1
Grundlagen von ANSI C++
Eine strukturiertere Auflistung der gefundenen Fehler bietet die Fehlerliste, die Sie entweder im Menü unter Ansicht 폷 Fehlerliste oder über die Tastenkombination (Strg) + (^) und (Strg) + (E) öffnen können (Abbildung 1.6).
Abbildung 1.6 Die Fehlerliste
In dieser Fehlerliste können Sie sich die aufgetretenen Fehler, Warnungen und Meldungen ansehen. Um die Darstellung einer bestimmten Kategorie zu aktivieren/deaktivieren, klicken Sie auf den Namen der Kategorie. In Abbildung 1.6 wurde nur die Darstellung der Fehler aktiviert. Um einen Fehler schnell im Projekt zu finden, klicken Sie doppelt darauf. Der Editor öffnet automatisch die fehlerhafte Datei und markiert den Fehler mit einem kleinen Pfeil links vor der betreffenden Zeile. Zusätzlich kann der Fehler noch durch eine rote Linie unter der betreffenden Zeile gekennzeichnet sein. Sollte die Fehlerliste mehrere Fehler beinhalten, dann sollten Sie immer zuerst den ersten Fehler beheben, da die weiteren Fehler häufig nur Folgefehler des ersten sind.
1.2
Die Hauptfunktion
So flexibel die Sprache C++ auch ist, etwas haben alle Programme gemeinsam: den durch die Hauptfunktion definierten Startpunkt des Programms. Die Hauptfunktion eines C++-Programms besitzt den Namen main und ist wie folgt aufgebaut: int main() { }
34
Die Hauptfunktion
Jedes C++-Programm benötigt genau eine main-Funktion; sie wird beim Programmstart aufgerufen, und mit ihr wird das Programm beendet. Groß- und Kleinschreibung In C++ muss penibel auf die Groß- und Kleinschreibung geachtet werden, weil diese ein Unterscheidungsmerkmal von Bezeichnern, also der im Programm gewählten Namen für Variablen, Objekte und Klassen, ist. Die Schreibweise von beispielsweise int und Int bezeichnet in C++ zwei unterschiedliche Dinge.
1.2.1
Der Funktionskopf
Die erste Zeile einer Funktion, in der die Parameter und der Rückgabetyp der Funktion definiert werden (int main()), wird als Funktionskopf bezeichnet. Wie eigene Funktionen definiert werden, behandelt Abschnitt 2.3. Hinter dem Funktionskopf steht der Anweisungsblock, gebildet von einem Paar geschweifter Klammern. Die Anweisungen dieses Anweisungsblocks werden beim Aufruf der Funktion ausgeführt, im Falle der main-Funktion also beim Programmstart. C++ ist bei den Möglichkeiten der Quellcodeformatierung sehr flexibel. Das bisherige Beispiel wäre auch wie in Listing 1.2 oder Listing 1.3 formatiert problemlos kompiliert worden: int main(){} Listing 1.2 Alles in einer Zeile
int main( ){ } Listing 1.3 Wilde Formatierung
Allerdings ist eine überschaubare Formatierung ratsam. Üblicherweise schreibt man den Funktionskopf in eine eigene Zeile (mit der öffnenden geschweiften Klammer aus Platzgründen dahinter) und rückt die Anweisungen innerhalb des Anweisungsblocks der Optik wegen etwas ein. Die schließende geschweifte Klammer steht vertikal bündig mit der Zeile der dazugehörenden öffnenden Klammer.
35
1.2
1
Grundlagen von ANSI C++
1.3
Die Ausgabe
Um weitere Grundlagen von C++ vorzustellen, wird das vorige Programm um einige Anweisungen erweitert: #include using namespace std; int main() { cout
