Schweitzer Fachinformationen
Wenn es um professionelles Wissen geht, ist Schweitzer Fachinformationen wegweisend. Kunden aus Recht und Beratung sowie Unternehmen, öffentliche Verwaltungen und Bibliotheken erhalten komplette Lösungen zum Beschaffen, Verwalten und Nutzen von digitalen und gedruckten Medien.
Einleitung 21
Über dieses Buch 21
Konventionen in diesem Buch 21
Törichte Annahmen über den Leser 21
Wie dieses Buch aufgebaut ist 22
Symbole, die in diesem Buch verwendet werden 23
Wie es weitergeht 24
Teil I: Wir programmieren 25
Kapitel 1 Grundgerüst eines Programms 27
Die Funktion main() 27
Kommentare 28
Ausgabe für Anfänger 29
Zahlenspielereien 30
Übungen 31
Kapitel 2 Variablen und Verarbeitung 33
Variablendefinition 33
Namensregeln 35
Ganze Zahlen 36
Wir rechnen 37
Wertveränderungen 38
Ganzzahlige Literale 41
Zeichen 42
Fließkommazahlen 45
Symbolische Konstanten 46
Aufzählungstyp enum 47
Typen umtaufen 49
Fallstricke beim Umgang mit Typen 49
Überlauf 49
Typkonvertierung und Casting 51
Ganzzahlige Division 52
Automatische Typbestimmung 53
Zahlen ein- und ausgeben 53
Ausgabestrom 53
Formatierte Ausgabe 54
Eingabestrom aus cin 54
Übungen 55
Kapitel 3 Abfrage und Wiederholung 57
Verzweigungen 57
Nur unter einer Bedingung: if 58
Andernfalls: else 58
Struktogramm 59
Dangling else 61
Fall für Fall: switch case 62
Bedingter Ausdruck: Fragezeichen 64
Boolesche Ausdrücke 65
Variablen und Konstanten 65
Operatoren 66
Verknüpfung von booleschen Ausdrücken 67
Immer diese Wiederholungen: Schleifen 71
Kopfgesteuert: while 71
Fußgesteuert: do... while 75
Abgezählt: for 76
Der Sprung als Feind der Struktur 79
Der brutale Sprung: goto 80
Schleifenausbruch: break 81
Schleifenrücksprung: continue 82
Beispiel: Größter gemeinsamer Teiler 83
Mitmachbeispiel: Schleifende Hunde und Füchse 85
Übungen 86
Teil II: Datentypen und -strukturen 89
Kapitel 4 Das Array 91
Definition und Zugriff auf ein Array 91
Grenzen und Größen 93
Arrays lieben die for-Schleife 94
Lottozahlen sollten zufällig sein 95
Keine Doppelten beim Lotto 96
Sortierte Lottozahlen 99
Mehrere Dimensionen 102
Beispiel: Bermuda 103
Spielanleitung Bermuda 103
Spielfeld anzeigen 103
Die Schiffskoordinaten 105
Übungen 106
Kapitel 5 Zeiger und dessen Möglichkeiten 109
Der Zeiger und die Adresse 109
Arrays und Zeiger 112
Zeigerarithmetik 113
Wettrennen zwischen Index und Zeiger 114
Klassische Zeichenketten 115
Addition und Subtraktion 116
Konstante Zeiger 116
Der Zeiger auf gar nichts: void* 117
Übungen 117
Kapitel 6 Variablenverbund struct 119
Ein Verbund mehrerer Variablen 119
Arrays von Strukturen 121
Zeiger auf Strukturen 121
Beispiel: Bermuda 123
Objekte dynamisch erzeugen und löschen: new und delete 124
Der Befehl new 124
Zur Laufzeit erzeugte Arrays 125
Verkettete Listen 126
Teil III: Funktionen 131
Kapitel 7 Funktionen im Eigenbau 133
Anweisungen zusammenfassen 133
Funktionsparameter 135
Ein Rückgabewert als Ergebnis 136
Prototypen 137
Noch ein paar Bemerkungen zu Parametern 138
Zeiger als Parameter 138
Arrays als Parameter 140
Die Parameter der Funktion main 144
Referenzparameter 145
Parameter vorbelegen 146
Variable Anzahl von Parametern 147
Überladen von Funktionen 148
Kurz und schnell: Inline-Funktionen 149
Kapitel 8 Hilfreiche Bibliotheksfunktionen 151
Zufall 151
Mathematische Funktionen 153
Zeitfunktionen 155
Kapitel 9 Einsatz von Funktionen 159
Vermeidung doppelten Codes 159
Top-down-Design am Beispiel Bermuda 159
Vom Diagramm zum Listing 160
Die Daten und die Parameter 160
Initialisierung der Datenstrukturen 161
Benutzereingabe 162
Suche die Schiffe 162
Eintrag im Spielfeld 165
Ende des Spiels 165
Globale, lokale und statische Variablen 166
Globale Variablen 166
Lokale Variablen 167
Statische Variablen 167
Rekursion: Selbstaufrufende Funktionen 168
Fibonacci, die Kaninchen und der Goldene Schnitt 168
Einbindungen 170
Türme von Hanoi 171
Rückruf erwünscht: Der Funktionszeiger als Parameter 173
Anonym: Die Lambda-Funktion 175
Übungen 176
Teil IV: Zeichenketten 177
Kapitel 10 Die Standardklasse string 179
Zeichenkettenliterale 179
Definieren und Zuweisen 180
Zugriff auf einzelne Zeichen 181
String-Funktionen 181
Länge des Strings 181
Verändern von String-Inhalten 181
Suche und Informationen 182
Umwandlung von Zahlen und Zeichenketten 183
Vergleiche 185
Ein- und Ausgabe von Strings 186
Umwandlung von string in ein char-Array 187
Kapitel 11 Das char-Array als Erbe von C 189
Speichern im Array 189
Der Zeiger auf char 191
Die String-Bibliothek 192
Strings in Zahlen konvertieren 193
Zahlen in Strings konvertieren 194
Teil V: Klassen 197
Kapitel 12 Am Beispiel zu Bruch gehen 199
Die Klasse Bruch 199
Der Bruch hat eigene Funktionen 202
Initialisierung durch Konstruktoren 205
Konstruktor mit Parameter 207
Destruktor 209
Konstruktor und Destruktor bei Arrays 210
Konvertierungskonstruktor 210
Konvertierungsoperator 211
Private Attribute 212
Operatoren überladen 213
Wir multiplizieren mit dem Stern 213
Alle möglichen Operatoren 214
Besonderheiten bei Inkrement und Dekrement 216
Die Vergleichsoperatoren 217
Ausgabeoperatoren und Freunde 218
Der Indexoperator 220
Der Aufrufoperator () 222
Die Kopie von Zeigern in Klassen 222
Der Zuweisungsoperator 223
Kopierkonstruktor 224
Statische Variablen und Funktionen in Klassen 226
Statische Klassenattribute 226
Statische Methoden 227
Statische lokale Variable 228
Konstante Parameter und Funktionen 229
Übungen 230
Kapitel 13 Vererbung 231
Basisklasse 232
Kompatibilität zur Basisklasse: »Ist ein« 234
Zugriff nur für Erben: protected 234
Zugriffsattribute der Vererbung 235
Konstruktorenvererbung 237
Kopierkonstruktor und Zuweisungsoperator 238
Mehrfachvererbung 238
Objektorientiertes Design für Bermuda 240
Die Koordinate 240
Das Schiff 241
Die Flotte 242
Das Spielfeld 245
Die Spielklasse Bermuda mit Mehrfachvererbung 247
Übungen 247
Kapitel 14 Polymorphie und virtuelle Funktionen 249
Die Mensa der Universität Norgaardholz 249
Ein Objekt weiß, was es tut: Polymorphie 252
Rückgriff auf die Basisklasse 253
Eine abstrakte Suppe 254
Die Mahlzeit als vollkommen abstrakte Klasse 255
Virtueller Destruktor 256
Polymorphie bei grafischen Oberflächen 257
Übungen 258
Teil VI: Fortgeschrittene Programmiertechniken 261
Kapitel 15 Große Programmprojekte 263
Aufteilung der Quelltexte 263
Implementierung und Schnittstelle 263
Doppelter Include 268
Zusammenbinden der Objektdateien 269
Projektsteuerung am Beispiel make 269
Header-Dateien und Schnittstellen 271
Deklaration und Definition 271
Einbinden von Header-Dateien 273
Bibliotheken 274
Eigene Bibliotheken erzeugen 274
Statische Bibliotheken einbinden 275
Dynamische Bibliotheken 276
Namensräume 278
Definition eines Namensraums 278
Zugriff 279
Besondere Namensräume 280
Kapitel 16 Katastrophenschutz: Fehler, Ausnahmen und Vorbedingungen 281
Die klassische Fehlerbehandlung 281
Ausnahmebehandlung 283
try und catch 283
Eigene Ausnahmen werfen 284
Erstellen von Fehlerklassen 287
Die Ausnahmen der Standardbibliotheken 288
Vorbedingungen 290
assert 290
Der Compiler prüft 292
Kapitel 17 Intelligente Sammelbehälter 293
Charakterlose Daten 293
Generische Programmierung 295
Template-Funktionen 296
Template-Klassen 299
Die Container-Klasse vector 302
Dynamik 303
Kapazität und Größe 305
Grenzüberschreitung 306
Iteratoren als Zeigerersatz 307
Methoden des Vektors 309
Die Container-Klasse deque 310
Die Container-Klasse list 312
Sortieren einer Liste: sort 313
Eine Liste in eine andere einsortieren: merge 315
Alles umdrehen: reverse 316
Mengen-Container: set 317
Löschen aus dem Set 317
Suchen und Sortieren 318
Sortierreihenfolge 318
Der assoziative Container map 319
Container-Adapter 321
Der Container-Adapter stack 321
Der Container-Adapter queue 322
Iteratortypen 323
Die Algorithmen der STL 324
Suchen: find 325
Sortieren 326
Binäres Suchen 327
Kopieren: copy 327
Umdrehen: reverse 328
Füllen: fill 329
equal 329
Funktionsobjekt als Parameter: find_if 329
for_each 332
Vereinigung und Durchschnitt 333
Die Template-Klasse bitset 335
Teil VII: Dauerhaftes Ablegen von Daten 337
Kapitel 18 Ein- und Ausgabe in Dateien 339
Formatierte Ausgabe im Datenstrom 339
Ausgabestrom ausrichten 340
Dateioperationen mit fstream 344
Öffnen und Schließen 345
Lesen und Schreiben sequenzieller Daten 346
Binäre Daten blockweise verarbeiten 350
Problembehandlung 353
Exceptions 354
Dateizugriffe nach ANSI-C 355
Kapitel 19 Datenbanken 361
Objektorientierter portabler Zugang: CppDB 363
Installation 363
Einbindung 363
Verbindungsaufname zur Datenbank 364
SQL-Befehle übergeben 365
Auslesen mit SELECT 366
Beispielhafte Person 366
Datenbankbibliothek SQLite 369
Einrichtung 369
Programmieren mit SQLite 370
Tabelle erzeugen und mit Daten füllen 371
Auslesen der Daten 373
Teil VIII: Grafische Fensterprogramme GUI 377
Kapitel 20 Grafische Oberflächen 379
Kapitel 21 C-API am Beispiel Win32 381
Hauptprogramm 382
Die Fensterfunktion WndProc 382
Mausverhalten 384
Kontrollelemente 384
Bermuda in Win32 385
Kapitel 22 Objektorientiert mit wxWidgets 391
Installation von wxWidgets 391
wxWidgets für Linux einrichten 392
wxWidgets für Windows und Mac beschaffen 392
Ein wxWidgets-Programm erstellen 393
Code::Blocks unter Linux und Windows 394
Ein minimales xwWidgets-Programm 395
Grafik 396
Grafische Kontroll- und Eingabeelemente 398
Layout 400
BoxSizer 400
GridSizer 401
FlexGridSizer 402
Die Kombination mehrerer Layouts 402
Bermuda in der wxWidgets-Version 403
Kapitel 23 Qt 409
Geschichte eines portablen Frameworks 409
Installation 410
Linux 410
Windows und Mac 410
Ein Qt-Widgets-Projekt 410
Der Qt-Designer 412
Teil IX: Programmierumgebung 415
Kapitel 24 Compiler beschaffen und einrichten 417
Der GNU-C++-Compiler 417
Der GNU-C++-Compiler unter Linux 417
Der GNU-C++-Compiler unter MS Windows 418
Microsoft Visual Studio 418
Projekt erstellen 419
Windows Desktopassistent 421
Code::Blocks 421
Linux 422
Windows 422
Der Aufbau von Code::Blocks 422
Ein Projekt anlegen 423
Übersetzen und starten 424
Eclipse als C++-Umgebung 424
Anlegen eines Projekts 425
Generieren und ausführen 425
NetBeans 425
Linux 426
Windows 426
Ein C++-Projekt erzeugen 427
Kapitel 25 Programmierwerkzeuge 429
Der Compiler und der Linker 429
Compiler-Aufruf 429
Compiler-Optionen 430
Fehlermeldungen 431
Der Präprozessor 432
Einbinden von Dateien: #include 433
Konstanten und Makros: #define 433
Abfragen: #if 435
Auf Fehlersuche mit dem Debugger 437
Debuggen in der IDE 437
Konsolen-Debug 438
Versionsverwaltungen 439
Arbeitsweise 439
Subversion 441
Git 443
Teil X: Der Top-Ten-Teil 445
Kapitel 26 10 Gründe, warum Sie C++ einsetzen wollen 447
Sie wollen native Programme schreiben 447
Sie wollen sehr schlanke Programme schreiben 447
Das Programm soll schnell starten 447
Das Programm soll schnell laufen 447
Das Programm soll direkt an eine API ankoppeln 448
Sie wollen verhindern, dass jemand Ihren Source Code
aus der ausführbaren Datei rekonstruiert 448
Sie müssen ganz dicht an die Maschine heran 448
Sie mögen keine ideologischen Vorschriften 448
Sie müssen sehr vertrackte Datenstrukturen auslesen 449
Sie lieben das Hashtag-Zeichen 449
Kapitel 27 Die 10 beliebtesten C++-Fehler 451
Sie benutzen beim n-dimensionalen Array n als Index 451
Ihre Schleife läuft ewig, weil Ihre Bedingung falsch formuliert ist 451
Ihre Schleife läuft ewig, weil sich die Variable, die für die Bedingung geprüft wird, im Schleifenkorpus nie ändert 451
Sie haben direkt hinter der Klammer von if/while/for ein Semikolon gesetzt 452
Sie haben vergessen, den #include zu setzen, und wundern sich, warum die Bezeichner unbekannt sind 452
Sie arbeiten mit deutschen Umlauten und verwenden kein unsigned char 452
Sie haben delete aufgerufen, aber den Zeiger anschließend nicht auf nullptr gesetzt 452
Sie verwenden häufiger new als delete 453
Ihre Klasse enthält ein Zeigerattribut, aber es fehlt der Copy-Konstruktor und der Zuweisungsoperator 453
Sie verwechseln es mit Java 453
Stichwortverzeichnis 457
Kapitel 2
IN DIESEM KAPITEL
Sie haben erfahren, dass Sie mit C++ rechnen können wie mit einem Taschenrechner. Ein guter Taschenrechner hat Speicherplätze, in denen Sie Zwischenergebnisse speichern können. C++ kennt so etwas auch, nennt es aber Variablen. Sie können im Gegensatz zum Taschenrechner beliebig viele davon anlegen. Damit Sie sie voneinander unterscheiden können, geben Sie ihnen Namen, die man auch Bezeichner nennt.
C++ unterscheidet Variablen für ganze Zahlen, Fließkommazahlen, Zeichen oder andere Datenarten. Diese Variablenart bezeichnet man als Typ. Variablen könnte man als Dreiklang aus Speicher, Name und Typ bezeichnen. Der Typ bestimmt den Speicherbedarf, aber auch die anwendbaren Operationen auf die Variable.
Typ
Das folgende Beispiel zeigt eine Variablendefinition innerhalb der Hauptfunktion main():
main()
Eine Variablendefinition beginnt immer mit dem Typ der Variablen. Hier heißt der Typ int. Dieser Typ steht für eine ganze Zahl mit Vorzeichen, aber ohne Nachkommastellen (Integer). Durch ein Leerzeichen abgesetzt, beginnt der Name der Variablen. Zu guter Letzt folgt das Semikolon. Damit wird jede Anweisung abgeschlossen, auch eine Variablendefinition.
int
Wir können nun die Berechnung von Listing 1.7 in der Variablen ergebnis speichern. Das Ergebnis der Berechung wird einer Variablen zugewiesen, indem man ein Gleichheitszeichen zwischen der Variablen auf der linken und dem Rechenausdruck auf der rechten Seite stellt.
ergebnis
In einer Zuweisung wird zunächst der Ausdruck auf der rechten Seite des Gleichheitszeichens ausgewertet und dann der Variablen auf der linken Seite zugewiesen.
In der Ausgabezeile darunter wird die Variable ergebnis ausgegeben, da sie nicht durch Anführungszeichen eingeschlossen ist. Es erscheint also die Zahl 2241 auf dem Bildschirm.
Sie können und sollten Variablen gleich bei ihrer Definition mit einem Wert vorbelegen. Dazu setzen Sie hinter den Variablennamen ein Gleichheitszeichen. Das initialisiert die Variable mit dem nachfolgenden Wert.
Im Laufe seiner Geschichte hat C++ für die Initialisierung verschiedene Varianten gelernt.
int ergebnis=0;
int ergebnis(0);
int ergebnis{0};
int ergebnis={0};
Die Form, die einer Zuweisung ähnelt, ist weit verbreitet. Zunächst werden Sie damit gut zurechtkommen. Sie sollten aber darauf vorbereitet sein, dass Ihnen die anderen Formen der Initialisierung auch begegnen werden.
Es können mehrere Variablen gleichen Typs direkt hintereinander definiert werden, indem sie durch Kommata getrennt werden. Alle Variablen haben dann den gleichen Typ.
Hier werden die Variablen i, j und k als int-Variablen definiert. j wird mit 0 initialisiert. Diese Schreibweise ist mit der folgenden gleichwertig:
i
j
k
Sie können in C++ eine Variable erst verwenden, nachdem Sie sie deklariert haben, damit der Compiler prüfen kann, ob die Variable ihrem Typ gemäß verwendet wird.
Die Variable löst sich in Luft auf, wenn der Block verlassen wird, in dem die Variable definiert wurde. Sie erinnern sich, dass ein Block durch geschweifte Klammern definiert wird.
In C++ unterliegen alle Namen, die vom Programmierer gewählt werden können, den gleichen Regeln. Diese Regeln gelten nicht nur für Variablen, sondern auch für Funktionen oder Klassen. In der englischen Literatur werden diese Namen »identifier« genannt. Das wird meist mit »Bezeichner« übersetzt.
Die Buchstaben können klein oder groß sein. In C und C++ wird zwischen Groß- und Kleinschreibung unterschieden. Der Bezeichner Anton unterscheidet sich vom Bezeichner ANTON und dieser ist wiederum ein anderer Bezeichner als anton.
Anton
ANTON
anton
Die Buchstaben umfassen A bis Z und a bis z. Grundsätzlich ist die Verwendung nationaler Sonderzeichen in Namen nicht erlaubt. Umlaute oder ein ß im Variablennamen führen also immer zu einer Fehlermeldung.
Es dürfen keine Schlüsselwörter der Sprache C++ als Bezeichner verwendet werden.
Ganze Zahlen vermitteln ein ungebrochenes Vertrauen, vermutlich, weil wir sie bereits in frühester Kindheit kennengelernt haben. Im Englischen und insbesondere im Computer-Umfeld nennt man sie gern Integer. Der Typ einer Integer-Variablen heißt int. Um eine Variable vom Typ int zu definieren, wird zuerst der Typ int genannt. Es folgt zur Unterscheidbarkeit ein Leerraum und dann der Name der Variablen. Abgeschlossen wird die Definition durch ein Semikolon.
Es gibt verschiedene Geschmacksrichtungen des Integers. Um sie zu spezifizieren, stellen Sie einen Modifizierer vor den Typ int.
unsigned: Eine normale int-Variable kann einen negativen Wert enthalten. Wird davor das Schlüsselwort unsigned gestellt, kann der Wert nur positive Zahlen enthalten.
unsigned
Auf diese Weise wird nicht nur verhindert, dass die Variable zaehler negativ wird. Der Zahlenbereich ins Positive wird verdoppelt.
zaehler
short
long
long long
Wie viele Bytes die verschiedenen Typen annehmen, ist bei C++ nicht festgelegt, sondern liegt im Ermessen des Compiler-Herstellers.
Wenn ein Modifizierer wie short oder unsigned verwendet wird, kann das Schlüsselwort int auch weggelassen werden. Damit sind auch folgende Definitionen zulässig und werden vom Compiler als attributierte Integer-Variablen verstanden:
Wenn Sie genau wissen wollen, wie viel Speicher ein Typ beziehungsweise eine Variablen von Ihrem Compiler bekommt, fragen Sie ihn doch einfach mit dem Ausdruck sizeof.
sizeof
Wenn schon einmal Zahlen da sind, dann sollten wir damit auch rechnen. Für das Rechnen benutzt man Operatoren. So nennen Informatiker gern das Pluszeichen und seine Kollegen. Hier eine Übersicht.
Operator
Bedeutung
a + b
Addition
a - b
Subtraktion
a * b
Multiplikation
a / b
Ganzzahlige Division
a % b
Modulo: Rest einer ganzzahligen Division
Tabelle 2.1: Operatoren
Addition und Subtraktion dürften seit der Grundschule kein Problem darstellen.
Bei der Multiplikation verwenden Sie auch außerhalb der Weihnachtszeit einen Stern.
Dass die Punkt- vor der Strichrechnung geht, gilt auch bei C++. Falls das nicht zu Ihrer Rechnung passt, können Sie wie in der Mathematik ein Rudel Klammern einsetzen.
Die Division zweier ganzen Zahlen ergibt eine ganze Zahl. Also ergibt 1 geteilt durch 2 eben 0. Überrascht? Leider gibt es 0,5 nur bei Fließkommazahlen. Auf diesen miesen Trick fallen allerdings auch Profis noch hin und wieder rein.
Zum Ausgleich gibt es die Modulo-Rechnung. Sie liefert den Rest einer ganzzahligen Division. 1 modulo 2 ergibt nämlich 1. Erinnern Sie sich daran, wie Sie in den ersten Schulklassen dividiert haben! Damals fielen Sätze wie: »25 geteilt durch 7 ist 3, Rest 4«.
Schreiben wir ein Beispielprogramm! Sie wollen...
Dateiformat: ePUBKopierschutz: Adobe-DRM (Digital Rights Management)
Systemvoraussetzungen:
Das Dateiformat ePUB ist sehr gut für Romane und Sachbücher geeignet – also für „fließenden” Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Adobe-DRM wird hier ein „harter” Kopierschutz verwendet. Wenn die notwendigen Voraussetzungen nicht vorliegen, können Sie das E-Book leider nicht öffnen. Daher müssen Sie bereits vor dem Download Ihre Lese-Hardware vorbereiten.Bitte beachten Sie: Wir empfehlen Ihnen unbedingt nach Installation der Lese-Software diese mit Ihrer persönlichen Adobe-ID zu autorisieren!
Weitere Informationen finden Sie in unserer E-Book Hilfe.
