InhaltsverzeichnisFeedback

Stichwortverzeichnis

Symbols
! (NOT-Operator)
!= (Ungleich)
# (Präprozessor)
#define
Konstanten
Makros
Vergleich zu const
#endif
#ifdef
#ifndef
#include
% (Modulo)
%= (Modulo mit Zuweisung)
& (Adreßoperator)
& (bitweises AND)
& (Referenz)
&& (AND-Operator)
* (Indirektion)
* (Multiplikation)
* (Zeiger)
*= (Multiplikation mit Zuweisung)
+ (Addition)
++ (Inkrement)
+= (Addition mit Zuweisung)
- (Subtraktion)
-- (Dekrement)
/ (Division)
/* (Kommentare)
// (Kommentare)
/= (Division mit Zuweisung)
< (Kleiner als)
<< (Ausgabe-Operator)
<< (Umleitung)
<= (Kleiner oder gleich)
-= (Subtraktion mit Zuweisung)
= (Zuweisung)
== (Gleich)
-> (Elementverweis)
> (Größer als)
>= (Größer oder gleich)
>> (Eingabe-Operator)
[] (Index)
^ (bitweises XOR)
| (bitweises OR)
|| (OR-Operator)
~ (Destruktor)
~ (Komplement)
A
Ableitung
ADTs von anderen ADTs
Syntax
Ableitung Siehe Vererbung
Abwärts
Additionsoperator, überladen
Adressen
Variablen
Zeiger
Adreßoperator
ADT (abstrakter Datentyp)
abstrakte Funktionen
als Basisklasse
Deklaration
in Java
sinnvoll einsetzen
Algorithmen
Aliase (Namensbereiche)
Analyse
Analyse Siehe Objektorientierte Software-Entwicklung
AND
AND (bitweises)
Anforderungsanalyse (OOA)
ANSI-Standard
Antworten, zu den Fragen
Anweisungen
#define
#else
#endif
#ifdef
#ifndef
#include
break
case
continue
default
einrücken
else
for
Funktionen
goto
if
Label
Präprozessor
return
switch
while
zusammengesetzte
argc
Argumente
als Referenz übergeben
als Wert übergeben
an Basisklassenkonstruktoren übergeben
Funktionen
Klammern in Makros
Referenzen
Standardparameter
Templates übergeben
Zeiger
Zeiger auf Funktionen
argv
Arrays
Anzahl der Elemente
Array-Klassen
Bereichsüberschreitung
char
deklarieren
Dimensionen
Elemente
Elemente initialisieren
Fehlersuche
Größe
Heap
Index
initialisieren
mehrdimensionale
mehrdimensionale Arrays initialisieren
Name
Objekte
Offset
Speicher
Strings
Zeiger
Zeiger auf Arrays
Zeiger auf Elementfunktionen
Zeiger auf Funktionen
Zeigerarithmetik
Zugriff
ASCII
Assembler (Debugger)
assert
Ebenen der Fehlersuche
Fehlersuche
Nebeneffekte
versus Exceptions
Zwischenwerte ausgeben
Aufrufen
Destruktoren
Konstruktoren
Methoden
Aufruf-Stack
Aufzählungskonstanten
Aufzählungstypen
Ausdrücke
Klammerung
Wahrheitswerte
Ausführung von Programmen
Ausgaben
Bildschirm
Breite der Ausgabe
cout
Füllzeichen
printf()
Puffer leeren
put()
write()
Zwischenwerte
Ausgabe-Operator
cout
flush()
Friend-Deklaration
Manipulatoren
überladen
Ausnahmen
Ausnahmen Siehe Exceptions
Autor, Adressen
B
Bäume
Bag
Basis, Zahlensysteme
Basisklassen
Mehrfachvererbung
private
Virtuelle Vererbung
Bedingungen
testen
unveränderliche
Bedingungsoperator
Befehlszeile, Fehlersuche aktivieren
Befehlszeilenverarbeitung
Begrenzer (für Strings)
Begriffe
abgeleiteter Typ
Ableitung
abstrakter Datentyp
Alias
Anweisungen
Argumente
Array
Ausdrücke
Bindung
Bit
Byte
Cast
Datenelemente
Datenfeld
Definition (Elementfunktion)
Definition (Funktion)
Deklaration
Dekrementieren
Elementfunktionen
Elementvariablen
elementweise Kopie
flache Kopie
Fließkommazahlen
Funktionen
Gigabyte
Gültigkeitsbereich
Implementierung
Inkrementieren
Instanzbildung
Instanzen
Integer
Interface
Interpreter
Iteration
Kapselung
Kilobyte
Klassen
Kommentare
konstante Elementfunktionen
konstante Zeiger
Konstanten
literale Konstanten
L-Wert
Megabyte
Methoden
Nibble
objektorientierte Programmierung
Operatoren
Parameter
Parameter (Templates)
Polymorphie
Postfix
Präfix
private
Prototyp
public
Referenzen
Rückgabewerte
R-Wert
Schnittstellen
Sichtbarkeit
Slicing
Stack
Stub-Routinen
Symbolische Konstanten
Template
Textzeichenfolge
tiefe Kopie
Token
Typendefinition
Typumwandlung
Verbundanweisungen
Vererbung
Vorrang
V-Tabelle
Whitespace
Zeichen
Zeiger
Zeiger auf Konstanten
Zugriffsfunktionen
Zuweisungsoperatoren
Bereichsüberschreitung
Bezeichner
Bibliotheken
Header-Dateien
Mehrfachdeklaration von Header-Dateien
Namensbereiche
Standard Template Library
Standardbibliotheken
Stream-Bibliothek
Strings
Bildschirm
Ausgaben
cout
Binärsystem
Binärzahlen
Binden
dynamisches Binden
zur Kompilierzeit
zur Laufzeit
Bindung
Bitfelder
Bits
Felder
löschen
manipulieren
maskieren
setzen
umschalten
Blöcke
catch
try
Booch, Grady
break
Byte
C
C++
ANSI-Standard
Geschichte
Schlüsselwörter
Standard Template Library
Vergleich mit C
Vergleich mit Java
C, Vergleich mit C++
case
catch-Blöcke
Reihenfolge
C-Dateien
cerr
char
cin
Begrenzer
Eingabe-Operator
get()
getline()
ignore()
peek()
putback()
class
clog
Code
Code Siehe Quellcode
Compiler
Exceptions
Hersteller
Namenskonflikte
Präprozessor
Schalter
Stack
Templates
Vergleich mit Interpreter
Visual C++
vordefinierte Makros
Zwischendateien
const
Elementfunktionen
Stil
this-Zeiger
Variablen
Vergleich zu #define
Zeiger
Container
assoziative
deque
Iteratoren
list
map
queue
sequentielle
stack
vector
Containment Siehe Einbettung
continue
cout
Ausgabe-Operator
endl
fill()
flush
put()
versus print()
width()
write()
CPP-Dateien
CRC-Karten
CRC-Sitzungen
D
Dateien
Binärdateien
C
CPP
Dateistreams
Ein- und Ausgabe
H
Header
HELLO.CPP
HPP
include
Mehrfachdeklaration
OBJ
öffnen
Öffnungsmodi
ofstream
Quelldateien
Streamstatus
temporäre
Textdateien
Daten
mit Zeigern manipulieren
statische Datenelemente
Datenelemente
Einbettung
geschützte
im Heap
initialisieren
Klasseninstanzen als Datenelemente
private
statische
Zugriff auf eingebettete Objekte
Datenfelder
Datentypen
abgeleitete
abstrakte
abstrakte Datentypen sinnvolleinsetzen
ADTs von anderen ADTs ableiten
Aufzählungstypen
elementare
Klassen
Klassen als abstrakte Typen
konvertieren
neue erzeugen
parametrisierte
Strukturen
vordefinierte
Vorzeichen
Datum und Uhrzeit (Makros)
Debugger
Assembler
Haltepunkte
Speicherinhalte
Symbole
überwachte Ausdrücke
default
Definition
Funktionen
Klassen
Konstanten
Makros
Methoden
Objekte
Templates
Variablen
Deklaration
Arrays
Arrays im Heap
Friend-Funktionen
Friend-Klasse
Funktionen
Header-Dateien
Indirektion
Klassen
Klassen als abstrakte Datentypen
Mehrfachvererbung
Namensbereiche
Schutz gegen Mehrfachdeklarationen
statische Elementfunktionen
statische Elementvariablen
Templates
Zeiger
Zeiger auf konstante Objekte
Dekrementieren
Delegierung
delete
Arrays im Heap löschen
aufrufen
deque (Container)
Dereferenzierung
Dereferenzierungsoperator
Design
CRC-Karten
CRC-Sitzungen
dynamische Modelle
statische Modelle
Design Siehe Objektorientierte Software-Entwicklung
Destruktoren
Vererbung
virtuelle
Dimensionen (von Arrays)
do...while-Schleifen
Dokumentation
Dynamisches Binden
E
Editoren
Einzüge
Tabulatoren
Einbettung
Klasseninstanzen als Datenelemente
Kopierkonstruktor
Nachteile
versus Vererbung
Zugriff auf eingebettete Klasseninstanzen
Eingaben
Begrenzer
cin
get()
getline()
ignore()
Mehrfacheingabe
newline
Operationen verketten
peek()
putback()
Strings
Tastatur
Whitespace auslesen
Eingabe-Operator
Probleme mit Strings
Rückgabewert
Verkettung
Einrücken, Code
Einzüge
Elementfunktionen
abstrakte
Arrays mit Zeigern auf
aufrufen
Basisversion aufrufen
geschützte
konstante
Konstruktoren
Namen
rein virtuelle
Signatur
Standardwerte
statische
this-Zeiger
überladen
überschreiben
verbergen
virtuelle
V-Tabelle
Zeiger auf
Zugriffsoperator
Elementvariablen
initialisieren
Namen
statische
else
Endlosschleifen
Entwicklungsumgebungen
Entwicklungszyklus
Entwurf, von Programmen
enum
Escape-Zeichen
Exceptions
abfangen
als Referenz abfangen
Anwendung
auslösen
catch(...)
catch-Blöcke
Datenelemente
Hierarchien von Exception-Klassen
Klassen
Komponenten
Konzept
mehrere catch-Anweisungen
Methoden
Polymorphie
Templates
throw
try-Blöcke
unabhängig von Fehlern verwenden
versus assert
Exklusiv-OR
F
Fehler
Debugger
Kompilierzeit
Laufzeitfehler
logische
syntaktische
Fehlersuche
Arrays
assert
Debugger
default-Zweig in switch
Definition statischer Elementvariablen
delete
Ebenen
Fence Post Error
Klammern in Makros
konstante Funktionen
Leerzeichen in Makro-Definitionen
Makros
Mehrfachdeklaration
Methoden überschreiben
Methoden verbergen
new ohne delete
Quellcode
Schlüsselwort const
Seiteneffekte
Speicher freigeben
vagabundierende Zeiger
vordefinierte Makros
Zeitbomben
Zwischenwerte ausgeben
Fence Post Error
Fibonacci-Reihe
Flags (Bitmanipulation)
Fließkommazahlen
for-Schleifen
Gültigkeitsbereich
leere Anweisungen
leerer Rumpf
Mehrfachinitialisierung
verschachtelte
Freunde
Friends
Ausgabe-Operator
Deklaration
Funktionen
Klassen
Templates
überladene Operatoren
Funktionen
abstrakte
als Argumente
Anweisungen
Arbeitsweise
Argumente
Argumente als Referenz übergeben
Arrays mit Zeigern auf
Arrays mit Zeigern auf Elementfunktionen
assert-Anweisungen
aus Namensbereichen definieren
Ausführung
definieren
deklarieren
Elementfunktionen
Elementfunktionen überladen
Friends
geschützte
Header
inline-Funktionen
Klammern in Makros
konstante Zeiger übergeben
Kopf
Kurzaufruf
lokale Variablen
main()
Makros
mehrere Werte zurückgeben
Methoden
Objekte übergeben
Parameter
Parameterliste
Polymorphie
Prototypen
Referenzen als Parameter
rein virtuelle
Rekursion
Rückgabewerte
Rückkehr
Rumpf
Signatur
Stack
Standardparameter
statische Elementfunktionen
strcpy()
strncpy()
Stub-Routinen
swap()
this-Zeiger
überladen
überschreiben
verbergen
Vergleich zu Makros
verlassen
virtuelle Elementfunktionen
void
Zeiger
Zeiger als Parameter
Zeiger auf andere Funktionen
Zeiger auf Elementfunktionen
Zeiger auf Funktionen
Funktionsobjekte
Funktionszeiger
als Parameter
G
Gbyte (Gigabyte)
Geordnete Kollektion
Geschichte, von C++
Gigabyte (Gbyte)
goto
Größe (Arrays)
Groß-/Kleinschreibung
Gültigkeitsbereichauflösungsoperator
Gültigkeitsbereiche
for-Schleifen
lokale Variablen
statische Datenelemente
statische Elementfunktionen
Variablen
H
Haltepunkte
H-Dateien
Header-Dateien
Mehrfachdeklaration
Heap
Arrays
Arrays löschen
Datenelemente
delete
Objekte erzeugen
Objekte löschen
Speicher freigeben
Speicher mit new zuweisen
Speicherlücken
Zugriff auf Datenelemente
Hexadezimalsystem
HPP-Dateien
I
if
Bedingungen testen
else-Klausel
Implementierung
abstrakte Funktionen
Funktionen
inline
Methoden
Methoden überschreiben
include-Dateien
Index
Dimensionen
Operator
Zahlensysteme
Indirektion
Indirektionsoperator
Initialisieren
Arrays
Datenelemente
Elementvariablen
Konstanten
mehrdimensionale Arrays
Objekte
Variablen
Zeiger
Inkrementieren
inline
Inline-Funktionen
Instanzbildung
Integer
Interpreter
Invarianten
Iteration
Iteratoren
J
Jacobson, Ivar
Java
K
Kapselung
Kbyte (Kilobyte)
Kilobyte (Kbyte)
Klammern
Array-Elemente gruppieren
ausrichten
geschweifte
in verschachtelten if-Anweisungen
Makros
Rangfolge
spitze
verschachtelte
Klassen
Ableitung
als abstrakte Datentypen deklarieren
als Datenelemente
aufbauen
Basisklassen
Datenelemente
deklarieren
Einbettung
Elementfunktionen
Elementvariablen
Exceptions
Friends
Header-Dateien
Implementierung
Inline-Implementierung
Invarianten
Klasseninstanzen als Datenelemente
konstante Methoden
Mehrfachdeklaration
Methoden
Methoden in Basisklasse verbergen
Namen
Polymorphie
private
public
Schnittstellen
statische Elementfunktionen
Stil
Strings
Strukturen
Templates
unveränderliche Bedingungen
Vererbung
Vergleich mit Objekten
virtuelle Vererbung
Zugriff auf eingebettete Klasseninstanzen
Zugriff auf Elemente
Zugriffsfunktionen
Knoten (verkettete Listen)
Ende
interne
Kopf
Kommentare
/*
//
Kompilieren
Kompilierzeit
Komplement
Komponenten (verkettete Listen)
Konstanten
#define
aus Aufzählungen
definieren
initialisieren
literale
symbolische
Konstruktoren
Argumente an Basisklassenkonstruktoren übergeben
Kopierkonstruktor
Standardkonstruktor
überladen
Vererbung
virtuelle Kopierkonstruktoren
Konventionen
für Makronamen
für Variablennamen
Konvertierung
Konzeptionierung (OOA)
Kopf, von Funktionen
Kopieren
elementweise
Strings
Kopierkonstruktor
eingebettete Elemente
virtueller
L
Label
Laufzeit, Binden zur
Laufzeitfehler
Laufzeit-Typidentifizierung (RTTI)
Leeranweisung
Linken
Linker, Namenskonflikte
list (Container)
Listen
Bäume
doppelt verkettete
einfach verkettete
Fallstudie
Templates
verkettete
Listings
1.1 - HELLO.CPP, das Programm Hello World
1.2 - Demonstration eines Compiler-Fehlers
2.1 - Teile eines C++-Programms
2.2 - Die Verwendung von cout
2.3 - Hello.cpp mit eingefügten Kommentaren
2.4 - Aufruf einer Funktion
2.5 - Eine einfache Funktion
3.1 - Die Größe der Variablentypen füreinen Computer bestimmen
3.2 - Einsatz von Variablen
3.3 - Demonstration von typedef
3.4 - Speichern eines zu großen Wertes in einer Variablen vom Typ unsigned integer
3.5 - Addieren einer zu großen Zahl auf eine Zahl vom Typ signed int
3.6 - Ausdrucken von Zeichen auf derBasis von Zahlen
3.7 - Ein Beispiel zur Verwendung von Aufzählungskonstanten
3.8 - Das gleiche Programm mit Integer-Konstanten
4.1 - Auswertung komplexerAusdrücke
4.2 - Subtraktion und Integer-Überlauf
4.3 - Typumwandlung in einen Float
4.4 - Präfix- und Postfix-Operatoren
4.5 - Eine Verzweigung auf der Grundlage von Vergleichsoperatoren
4.6 - Einsatz der else-Klausel
4.7 - Verschachtelte if-Anweisung
4.8 - Klammern in if- und else-Klauseln
4.9 - Richtige Verwendung von geschweiften Klammern bei einer if-Anweisung
4.10 - Der Bedingungsoperator
5.1 - Deklaration, Definition und Verwendung einer Funktion
5.2 - Lokale Variablen und Parameter
5.3 - Globale und lokale Variablen
5.4 - Variablen innerhalb eines Blocks
5.5 - Übergabe als Wert
5.6 - Eine Funktion mit mehreren return-Anweisungen
5.7 - Standardwerte für Parameter
5.8 - Ein Beispiel für Funktionspolymorphie
5.9 - Ein Beispiel für den Einsatz einerInline-Funktion
5.10 - Rekursion anhand der Fibonacci-Reihe
6.1 - Zugriff auf die öffentlichen Elemente einer einfachen Klasse
6.2 - Eine Klasse mit Zugriffsmethoden
6.3 - Methoden einer einfachen Klasseimplementieren
6.4 - Konstruktoren und Destruktoren
6.5 - Fehlerhafte Schnittstelle
6.6 - Die Klassendeklaration von Cat in CAT.HPP
6.7 - Die Implementierung von Cat in CAT.CPP
6.8 - Deklaration einer vollständigenKlasse
6.9 - RECT.CPP
7.1 - Schleifenkonstruktion mit goto
7.2 - while-Schleifen
7.3 - Komplexe while-Schleifen
7.4 - Die Anweisungen break undcontinue
7.5 - while(true)-Schleifen
7.6 - Den Rumpf der while-Schleife überspringen
7.7 - Demonstration einer do..while-Schleife
7.8 - Untersuchung einer while-Schleife
7.9 - Beispiel für eine for-Schleife
7.10 - Mehrere Anweisungen in for-Schleifen
7.11 - Eine for-Schleife mit leeren Anweisungen
7.12 - Eine leere for-Schleifen-anweisung
7.13 - Darstellung einer leeren Anweisung als Rumpf einer for-Schleife
7.14 - Verschachtelte for-Schleifen
7.15 - Den Wert einer Fibonacci-Zahl mittels Iteration ermitteln
7.16 - Einsatz der switch-Anweisung
7.17 - Eine forever-Schleife
8.1 - Adressen von Variablen
8.2 - Daten mit Hilfe von Zeigern manipulieren
8.3 - Untersuchen, was in einem Zeiger gespeichert ist
8.4 - Reservieren und Löschen vonZeigern
8.5 - Objekte auf dem Heap erzeugen und löschen
8.6 - Zugriff auf Datenelemente von Objekten auf dem Heap
8.7 - Zeiger als Datenelemente
8.8 - Der Zeiger this
8.9 - Einen vagabundierenden Zeiger erzeugen
8.10 - Zeiger auf const-Objekt
8.11 - Wörter aus einem Zeichenstring parsen
9.1 - Referenzen erzeugen undverwenden
9.2 - Die Adresse einer Referenzermitteln
9.3 - Zuweisungen an eine Referenz
9.4 - Referenzen auf Objekte
9.5 - Übergabe von Argumenten alsWert
9.6 - Übergabe als Referenz mitZeigern
9.7 - Die Funktion swap mit Referenzen als Parametern
9.8 - Rückgabe von Werten mit Zeigern
9.9 - Neufassung von Listing 9.8 mit Übergabe von Referenzen
9.10 - Objekte als Referenzübergeben
9.11 - Übergabe von konstantenZeigern
9.12 - Referenzen auf Objekteübergeben
9.13 - Rückgabe einer Referenz auf ein nicht existierendes Objekt
9.14 - Speicherlücken
10.1 - Überladen von Elementfunktionen
10.2 - Standardwerte
10.3 - Den Konstruktor überladen
10.4 - Codefragment zur Initialisierung von Elementvariablen
10.5 - Kopierkonstruktoren
10.6 - Die Klasse Counter
10.7 - Einen Inkrement-Operator hinzufügen
10.8 - operator++ überladen
10.9 - Ein temporäres Objekt zurück-geben
10.10 - Ein namenloses temporäres Objekt zurückliefern
10.11 - Rückgabe des this-Zeigers
10.12 - Präfix- und Postfix-Operatoren
10.13 - Die Funktion Add()
10.14 - Der operator+
10.15 - Ein Zuweisungsoperator
10.16 - Versuch, einem Zähler einen int-Wert zuzuweisen
10.17 - Konvertierung eines int in ein Counter-Objekt
10.18 - Konvertieren eines Counter-Objektsin einen unsigned short
11.1 - Einfache Vererbung
11.2 - Ein abgeleitetes Objekt
11.3 - Aufgerufene Konstruktoren undDestruktoren
11.4 - Konstruktoren in abgeleiteten Klassen überladen
11.5 - Eine Methode der Basisklasse in einer abgeleiteten Klasse überschreiben
11.6 - Methoden verbergen
11.7 - Die Basismethode einer überschriebenen Methode aufrufen
11.8 - Virtuelle Methoden
11.9 - Mehrere virtuelle Elementfunktionen der Reihe nach aufrufen
11.10 - Slicing bei Übergabe als Wert
11.11 - Virtueller Kopierkonstruktor
12.1 - Ein Array für Integer-Zahlen
12.2 - Über das Ende eines Array schreiben
12.3 - Konstanten und Aufzählungskonstanten zur Array-Indizierung
12.4 - Ein Array von Objektenerzeugen
12.5 - Ein mehrdimensionales Arrayerzeugen
12.6 - Ein Array im Heap unterbringen
12.7 - Ein Array mit new erzeugen
12.8 - Ein Array füllen
12.9 - Ein Array füllen
12.10 - Die Funktion strcpy()
12.11 - Die Funktion strncpy()
12.12 - Verwendung einer String-Klasse
12.13 - Eine verkettete Liste
13.1 - Wenn Pferde fliegenkönnten ...
13.2 - Abwärts gerichtete Typumwandlung
13.3 - Mehrfachvererbung
13.4 - Mehrere Konstruktoren aufrufen
13.5 - Gemeinsame Basisklassen
13.6 - Einsatz der virtuellen Vererbung
13.7 - Shape-Klassen
13.8 - Abstrakte Datentypen
13.9 - Abstrakte Funktionen implementieren
13.10 - ADTs von anderen ADTs ableiten
14.1 - Statische Datenelemente
14.2 - Zugriff auf statische Elemente über die Klasse
14.3 - Zugriff auf statische Elemente mittels nicht-statischer Elementfunktionen
14.4 - Statische Elementfunktionen
14.5 - Zeiger auf Funktionen
14.6 - Neufassung von Listing 14.5 ohne Funktionszeiger
14.7 - Ein Array von Zeigern auf Funktionen
14.8 - Übergabe von Zeigern auf Funktionen als Funktionsargumente
14.9 - Einsatz von typedef, um einen Code mit Zeiger auf Funktionen lesbarer zu machen
14.10 - Zeiger auf Elementfunktionen
14.11 - Array mit Zeigern auf Elementfunktionen
15.1 - Die Klasse String
15.2 - Die Klasse Employee und das Rahmenprogramm
15.3 - Konstruktoraufrufe für enthaltene Klassen
15.4 - Übergabe als Wert
15.5 - Delegierung an ein eingebettetes PartsList-Objekt
15.6 - Private Vererbung
15.7 - Beispiel für eine Friend-Klasse
15.8 - Der freundliche +-Operator
15.9 - Überladen des Ausgabe-Operators <<
16.1 - cin arbeitet mit unterschiedlichen Datentypen
16.2 - Mehr als ein Wort mit cineinlesen
16.3 - Mehrfacheingabe
16.4 - get() ohne Parameter
16.5 - get() mit Parametern
16.6 - get mit einem Zeichen-Array verwenden
16.7 - getline()
16.8 - ignore()
16.9 - peek() und putback()
16.10 - put()
16.11 - write()
16.12 - Die Breite der Ausgabeanpassen
16.13 - fill()
16.14 - setf()
16.15 - Ausgabe mit printf()
16.16 - Dateien zum Lesen und Schreiben öffnen
16.17 - An das Ende einer Dateianhängen
16.18 - Eine Klasse in eine Dateischreiben
16.19 - Befehlszeilenargumente
16.20 - Befehlszeilenargumente
17.1 - Verwendung eines Namens-bereichs
19.1 - Template für eine Array-Klasse
19.2 - Implementierung des Array-Templates
19.3 - friend-Funktion, die kein Template ist
19.4 - Einsatz des ostream-Operators
19.5 - Template-Objekte an Funktionen übergeben und zurückliefern
19.6 - Template-Implementierungen spezialisieren
19.7 - Statische Datenelemente und Funktionen in Templates
19.8 - Einrichtung eines vector-Containers und Zugriff auf die Elemente
19.9 - Einen list-Container mit Hilfe von Iteratoren durchwandern
19.10 - Ein map-Container
19.11 - Ein Funktionsobjekt
19.12 - Einsatz des for_each()-Algorithmus
19.13 - Ein verändernder, sequentiellerAlgorithmus
20.1 - Eine Exception auslösen
20.2 - Mehrere Exceptions
20.3 - Klassenhierarchien undExceptions
20.4 - Daten aus einem Exception-Objekt holen
20.5 - Übergabe als Referenz und virtuelle Methoden in Exceptions
20.6 - Exceptions und Templates
21.1 - Einsatz von #define
21.2 - Klammern in Makros
21.3 - Inline-Funktion statt Makro
21.4 - Ein einfaches assert-Makro
21.5 - Der Einsatz von Invarianten
21.6 - Ausgabe von Werten im DEBUG-Modus
21.7 - Ebenen für die Fehlersuche
21.8 - Einsatz von Bitfeldern
R1.1 - Rückblick auf die erste Woche
R2.1 - Rückblick auf die zweite Woche
R3.1 - Rückblick auf die dritte Woche
R3.2 - Ein Beispiel für Kontravarianz
Löschen, Objekte
Lösungen, zu den Übungen
long-Integer
L-Wert
M
main()
Makros
__DATE__
__FILE__
__LINE__
__TIME__
assert
Datum und Uhrzeit
Ebenen der Fehlersuche
Fehlersuche
Fehlersuche mit assert
fortsetzen auf neuer Zeile
Klammern
Nachteile
Parameter
Seiteneffekte
Vergleich zu Funktionen
Vergleich zu Templates
vordefinierte
Zwischenwerte ausgeben
Manipulatoren
Manipulieren, Strings
map (Container)
Maskieren
Mbyte (Megabyte)
Mehrdeutigkeiten (Mehrfachvererbung)
Mehrdimensionale Arrays
Mehrfachdeklaration
Mehrfachvererbung
Auflösung von Mehrdeutigkeiten
Deklaration
gemeinsame Basisklasse
Java
Konstruktoren
Probleme
virtuelle Vererbung
Menge
Menüs, mit switch
Methoden
abstrakte
Argumente als Referenz übergeben
Arrays mit Zeigern auf
aufrufen
Basismethoden aufrufen
const
geschützte
konstante
konstante this-Zeiger
konstante Zeiger übergeben
Konstruktoren
mehrere Werte zurückgeben
Namen
Objekte übergeben
Referenzen als Parameter
rein virtuelle
Signatur
Standardwerte
statische
this-Zeiger
überladen
überladen vs. überschreiben
überschreiben
verbergen
virtuelle
V-Tabelle
Zeiger
Zeiger als Parameter
Zeiger auf
Zugriffsoperator
Mixin-Klassen
N
Namen
Arrays
Elementfunktionen
Elementvariablen
Groß-/Kleinschreibung
Klassen
Konventionen
Namensbereiche
Namenskonflikte
Schlüsselwörter
Variablen
Zeiger
Namensbereiche
Aliase
alle Elemente in Gültigkeitsbereich einführen
einrichten
einzelne Elemente in Gültigkeitsbereich einführen
Elemente deklarieren
Elemente hinzufügen
Funktionen definieren
Standardnamensbereich std
unbenannter
using-Deklaration
using-Direktive
verschachteln
versus static
verwenden
namespace
new
aufrufen
Speicher reservieren
newline, Eingaben abschließen
Newsgroups
Nibble
NOT
Null-Referenzen
Null-Zeiger
Nummernzeichen
Nutzungsfälle (OOA)
O
OBJ-Dateien
Objectory-Methode
Objektdateien
Objekte
als Referenz übergeben
Arrays
auf dem Heap erzeugen
cerr
cin
clog
cout
Datenelemente im Heap
definieren
Exceptions
Gleichheit
Größe
initialisieren
konstante this-Zeiger
Kopien auf dem Stack
Kopierkonstruktor
löschen
Referenzen
Referenzen auf nicht existente Objekte
Slicing
temporäre Objekte
this-Zeiger
Vergleich mit Klassen
virtuelle Elementfunktionen
Zeiger auf konstante Objekte
Objektorientierte Analyse
Objektorientierte Programmiersprachen
Objektorientierte Programmierung
Kapselung
Merkmale
Polymorphie
Vererbung
Objektorientierte Software-Entwicklung
Aktoren
Analyse
Anforderungsanalyse
Anwendungsanalyse
Artefakte
Assoziation
CRC-Karten
CRC-Sitzungen
Design
Diskriminatoren
Domänen-Experte
Domänen-Modell
Dynamische Modelle
Einbettung
Generalisierungen
Interaktionsdiagramme
iteratives Design
Klassenbeziehungen
Kollaborationsdiagramm
Konzeptionierung
Modelliersprachen
Nutzungsfälle
Nutzungsfalldiagramme
Objectory-Methode
objektorientierte Modelle
Pakete
Powertypen
Sequenzdiagramme
Spezialisierungen
statische Modelle
Systemanalyse
Szenarien entwerfen
Transformationen
UML
Vorgehensweise
Zustandsdiagramme
Objektorientiertes Design
Offset (Arrays)
ofstream
Online-Dienste
Operanden
L-Wert
R-Wert
Operatoren
-- (Dekrement)
- (Subtraktion)
! (logisches NOT)
!= (Ungleich)
% (Modulo)
%= (Modulo mit Zuweisung)
& (Adressen)
& (bitweises AND)
& (Referenz)
&& (logisches AND)
* (Indirektion)
* (Multiplikation)
*= (Multiplikation mit Zuweisung)
+ (Addition)
++ (Inkrement)
+= (Addition mit Zuweisung)
/ (Division)
/= (Division mit Zuweisung)
< (Kleiner als)
<< (Ausgabe-Operator)
<< (Umleitung)
<= (Kleiner oder Gleich)
-= (Subtraktion mit Zuweisung)
= (Zuweisung)
== (Gleich)
-> (Elementverweis)
> (Größer als)
>= (Größer oder gleich)
>> (Eingabe-Operator)
^ (bitweises XOR)
| (bitweises OR)
|| (logisches OR)
~ (Komplement)
Additionsoperator überladen
Ausgabe-Operator
Bedingungsoperator
bitweise
Dereferenzierung
Einschränkungen beim Überladen
Gültigkeitsbereichauflösungsoperator
Index
Inkrement überladen
Komplement
logische
mathematische
operator+ überladen
operator= überladen
Postfix
Postfix überladen
Präfix
Präfix im Vergleich zu Postfix
Präfix überladen
Rangfolge
relationale
Rückgabetypen
Strings manipulieren
Strings verketten
temporäre Objekte zurückgeben
überladen
Umwandlung
Vergleich
Vorrang
Zeichenkettenbildung
zusammengesetzte
Zuweisung
OR
OR (bitweises)
P
Parameter
als Referenz übergeben
als Wert übergeben
an Basisklassenkonstruktoren übergeben
const
für Templates
Funktionen
Makros
Referenzen
Standardparameter
Templates übergeben
Zeiger
Zeiger auf Funktionen
Parameterliste
Funktionen
überladene Funktionen
Piping
Polymorphie
Exceptions
Typumwandlung
überladene Funktionen
virtuelle Methoden
Wesen
Postfix
überladen
Unterschied zu Präfix
Präfix
überladen
Unterschied zu Postfix
Präprozessor
#define
#else
#ifdef
#ifndef
#include
assert
Klammern in Makros
Leerzeichen in Makro-Definitionen
Makros
Strings manipulieren
Strings verketten
Token
Zeichenkettenbildung
printf()
private
Programme
anhalten
Ausführung
Befehlszeilenverarbeitung
Definition
Erstellung
Funktionen
HELLO.CPP
Kommentare
Komponenten
Linken
Speicher freigeben
Standardbibliotheken
Verzweigungen
Programmiersprachen
C
C++
Interpreter
Java
Programmierung
Anweisungen
assert-Anweisungen
const
Endlosschleifen
Entwicklungszyklus
Entwurf
Fehler
geschweifte Klammern
Groß-/Kleinschreibung
include-Dateien
Klassendefinitionen
Kommentare
lange Zeilen im Quellcode
objektorientierte
prozedurale
Quellcode
Schleifen
Stil
strukturierte
protected
Prototypen (Funktionen)
public
Pufferung
Punktoperator
Q
Quellcode
catch-Blöcke
const
Einzüge
Entwickungszyklus
Exceptions
Fehler
Fehlersuche
Groß-/Kleinschreibung
include-Dateien
Klassendefinitionen
Kommentare
Kompilieren
lange Zeilen
Leerzeichen
Linken
Mehrfachdeklaration
Stil
try-Blöcke
Whitespace
Zeilennummern
Quelldateien
Editoren
Erweiterungen
queue (Container)
R
RAM
Rangfolge
Operatoren
Vergleichsoperatoren
Referenzen
Adreßoperator
auf nicht existente Objekte
auf Objekte
auf Objekte übergeben
erzeugen
konstante Referenzen
mehrere Werte zurückgeben
Null-Referenzen
Speicherlücken
Vergleich mit Zeigern
Ziel
Referenzoperator
Register
Rekursion
Ressourcen
Speicher
return
RTTI
Rückgabewerte
Funktionen
Operatoren
temporäre Objekte
this-Zeiger
Umwandlungsoperatoren
void
Rumbaugh, James
Rumpf, von Funktionen
R-Wert
S
Schalter (Compiler)
Schleifen
break
continue
do...while
Endlosschleifen
for
for ohne Rumpf
goto
Label
Sprungmarken
verlassen
verschachtelte
while
while(true)
Schlüsselwörter
class
const (this-Zeiger)
const (Zeiger)
delete
enum
inline
namespace
new
private
protected
public
return
struct
template
typedef
using
Schnittstellen
Design
Friends
Java
Seiteneffekte
Semikolon
short-Integer
Sichtbarkeit
Signatur
catch-Blöcke
Funktionen
signed-Variablen
sizeof
Slicing
Sparsame Arrays
Speicher
Adressen
Arrays
Arrays im Heap
Arrays im Heap löschen
Daten mit Zeigern manipulieren
Datenelemente im Heap
freigeben
Heap
mit delete freigeben
mit new reservieren
Objekte erzeugen
Objekte im Heap löschen
RAM
Register
Ressourcen
Stack
statische Elementvariablen
vagabundierende Zeiger
Variablen
Zeiger
Zeiger auf Datenelemente
Speicherlücken
Referenzen
Spezialisierungen
Sprungmarken
Stack
auflösen
Aufruf-Stack
Exceptions abfangen
Funktionen
Kopien von Objekten
lokale Variablen
stack (Container)
Standard Template Library
Algorithmen
Container
deque-Container
Funktionsobjekte
Iteratoren
list-Container
map-Container
queue-Container
stack-Container
vector-Container
Standardbibliotheken
Namensbereich std
Stream-Bibliothek
Standard-E/A-Objekte
Standardkonstruktoren
Standardparameter
Standardwerte
Elementfunktionen
Methoden
Vergleich zu überladenen Funktionen
Stapelspeicher
Statische Datenelemente
Statische Elementfunktionen
Stil
assert-Anweisungen
Einzüge
geschweifte Klammern
Groß-/Kleinschreibung
include-Dateien
Klassendefinitionen
Kommentare
lange Zeilen
Leerzeichen
Namen von Bezeichnern
switch-Anweisungen
strcpy()
Streams
Ausgabe
Ausgabepuffer leeren
Breite der Ausgabe
cerr
cin
clog
cout
cout versus printf()
Dateien öffnen
Dateistreams
E/A-Operationen verketten
Eingabe
Flags
Füllzeichen für die Ausgabe
get()
getline()
ignore()
Manipulatoren
Mehrfacheingabe
ofstream
peek()
Pufferung
putback()
Standard-E/A-Objekte
Streamstatus
Strings einlesen
Terminierungszeichen für Strings
Überblick
umleiten
Whitespace auslesen
stringizing operator
Strings
#define
abschließen
Arrays
Begrenzer
Bibliothek
einlesen
Ersetzung
Klassen
kopieren
manipulieren
Null-Zeichen
strcpy()
strncpy()
Token
verketten
strncpy()
struct
Strukturen
swap()
switch-Anweisungen
break
default
im Quellcode einrücken
Symbole (Makros)
Syntax
Ableitung
Vererbung
T
Tabellen, für virtuelle Methoden
Tabulatoren
Tastatur, Eingaben von
Templates
als Parameter
Definition
Exceptions
Friends
implementieren
Instanzbildung
Instanzen
parametrisierte Listen
Spezialisierungen
Standard Template Library
statische Elemente
Templatefunktionen
Vererbung
Vergleich zu Makros
this-Zeiger
konstante
Operatoren
statische Elementfunktionen
throw
Tilde
Token
try-Blöcke
typedef
Typen
abgeleitete
Aufzählungstypen
elementare
Klassen
Konstanten
konvertieren
neue erzeugen
parametrisierte
Rückgabewerte
Strukturen
vordefinierte
Vorzeichen
Typendefinition
Typumwandlung
Umwandlungsoperatoren
Zeiger
U
Übergabe
als Referenz mit Referenzen
als Referenz mit Zeigern
Argumente als Referenz
konstante Zeiger
Objekte als Referenz
Referenzen auf Objekte
Template-Objekte
Zeiger auf Funktionen
Zeiger auf Objekte
Überladen
Additionsoperator
Ausgabe-Operator
binäre Operatoren
Einschränkungen
Elementfunktionen
Funktionen
Gleichheitsoperator
Inkrement-Operator
Konstruktoren
Methoden
Mißbrauch
operator+
operator=
Operatoren
Postfix-Operator
Präfix-Operator
unäre Operatoren
Überschreiben, Methoden
Überwachte Ausdrücke
Überwachungsmuster
Umleitungsoperator
Umwandlungsoperatoren
Ungarische Notation
Unified Modeling Language (UML)
Assoziation
Diskriminatoren
Einbettung
Generalisierungen
Interaktionsdiagramme
Klassenbeziehungen
Kollaborationsdiagramm
Nutzungsfalldiagramme
Pakete
Powertypen
Sequenzdiagramme
Spezialisierungen
Zustandsdiagramme
unsigned-Variablen
using
using-Deklaration
using-Direktive
V
Variablen
Adressen
analysieren
Auswahl eines Typs
Bereichsüberschreitung
Bindung
const
Datenelemente von Klassen
definieren
globale
Größe
Groß-/Kleinschreibung
Gültigkeitsbereich
Indirektion
initialisieren
konstante
konstante Zeiger
lokale
mehrere gleichzeitig definieren
mit new im Heap erzeugen
Namen
neue Typen erzeugen
Platzbedarf
Sichtbarkeit
Speicher
Speicher mit delete freigeben
Speicherlücken
Speicherung
this-Zeiger
Typen
vagabundierende Zeiger
Vorzeichen
Wert
Werte zuweisen
Zeiger
Zeiger auf Datenelemente
Zeiger deklarieren
vector (Container)
Verbergen, Methoden
Vererbung
Ableitung
Argumente an Basisklassenkonstruktoren
Destruktoren
einfache
Elementfunktionen überschreiben
Funktionen in Basisklassen auslagern
Funktionen überschreiben
Konstruktoren
Mehrfachvererbung
Methoden überschreiben
Mixin-Klassen
private
private vs. protected
Probleme bei der einfachen Vererbung
Probleme bei der Mehrfachvererbung
Syntax
Templates
Typumwandlung
versus Einbettung
virtuelle Vererbung
Vergleichsoperatoren
Verketten, Strings
Verkettete Listen
interne Knoten
Knoten
Komponenten
Verschachteln
Klammern
Namensbereiche
Schleifen
Verschiebung (Array-Zugriff)
Verzweigungen
Virtuelle Destruktoren
Virtuelle Kopierkonstruktoren
Virtuelle Methoden
Effektivität
Virtuelle Vererbung
Virtueller
Visual C++
void
Vorrang
Vorzeichen
V-Tabelle
V-Zeiger
W
Werte
Variablen
zuweisen
while(true)-Schleifen
while-Schleifen
Whitespace
in Makro-Definitionen
Stil
Wörterbuch
X
XOR (bitweises)
Z
Zahlensysteme
Basis
Binärsystem
Hexadezimalsystem
Umwandlung
Zeichen
Escape-Zeichen
Whitespace
Zeichenkettenbildung
Zeichensätze
Zeiger
Adressen
Array-Namen
Arrays
auf Arrays
auf Elementfunktionen
auf Funktionen
auf Funktionen als Parameter
auf konstante Objekte deklarieren
auf Objekte übergeben
Daten manipulieren
Datenelemente im Heap
deklarieren
delete
Einsatzfälle
Funktionen aufrufen
Funktionszeiger
Heap
Indirektion
Indirektionsoperator
initialisieren
konstante
konstante this-Zeiger
löschen
mehrere Werte zurückgeben
Namen
neu zuweisen
new
Objekte auf dem Heap erzeugen
Objekte im Heap löschen
Polymorphie
Speicher freigeben
this
Typumwandlung
Übergabe konstanter Zeiger
vagabundierende
Vergleich mit Referenzen
V-Zeiger
Wert
wilde
Zeigerarithmetik
Zeigerarithmetik
Zeilennummern
Zeilenschaltung
Zeitbomben
Zeitschriften
Zirkumflex
Zugriff
Arrays
auf Elemente enthaltener Klassen
Datenelemente im Heap
Klassenelemente
Zugriffsrechte vergeben
Zugriffsfunktionen
konstante
Zugriffsoperator, Zeiger auf Elementfunktionen
Zuweisen
Zuweisungsoperatoren
überladen
Zwischendateien
Zwischenwerte
InhaltsverzeichnisFeedbackKapitelanfang

© Markt&Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH