Vorlesungsskript - Hochschule Emden/Leer

Informatik I/II 

Studiengänge Photonik, IBS – 1./2. Semester 

WS 2010/11, SS 2011 

Inhaltsverzeichnis 

Rumpfskript 

c○ Prof. Dr. B. Bartning 

Hochschule Emden/Leer 

http://www.bartning.org 

Stand: 13. September 2011 

0 Vorbemerkungen 4 

0.1 Legende, Sprachhinweise, Bildsymbole . . . . . . . . . . . . . . . . . . . . . . 4 

0.2 Skripte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 

0.3 Hinweise zum Umgang mit älteren C ++-Compilern . . . . . . . . . . . . . . . 5 

I Informatik I (1. Semester) 6 

1 Rechnersysteme (Kurzüberblick) 6 

1.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

1.1 Grundlegende Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

1.2 Rechneraufbau, Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

1.3 Software, Betriebssysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 

1.4 Zahlen, Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 

2 Algorithmenstrukturen, Operatoren 

(sprachunabhängige Betrachtung) 17 

2.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

2.1 Einführung in Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

2.2 Folge (Sequenz) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 

2.3 Auswahl (Selektion) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 

2.4 Wiederholung (Iteration) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 

2.5 Schachtelung der drei Algorithmenstrukturen . . . . . . . . . . . . . . . . . . 28 

2.6 Operatoren, logische Verknüpfungen . . . . . . . . . . . . . . . . . . . . . . . 30 

3 Erste Schritte mit C ++ 33 

3.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 

3.1 Die ersten Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

c○ Prof. Dr. B. Bartning, HS Emden/Leer Rumpfskript ” Informatik I/II“ (WS/SS 2010/11) 2 

3.2 Einfache Datentypen, Zeichenketten, Operatoren . . . . . . . . . . . . . . . . 34 

3.3 Ausdrücke, Seiteneffekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 

4 Algorithmenstrukturen in C ++ 38 

4.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

4.1 Folge (Sequenz), Gültigkeitsbereich in Blöcken . . . . . . . . . . . . . . . . . 38 

4.2 Boolesche Ausdrücke, Datentyp bool . . . . . . . . . . . . . . . . . . . . . . . 38 

4.3 Auswahl (Selektion) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 

4.4 Wiederholung (Iteration) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 

4.5 Die Bedingung in Kontrollstrukturen, Gültigkeitsbereiche bei neueren Compilern 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 

4.6 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 

4.7 Empfehlungen für Namensgebung und Lay-out, 

symbolische Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 

5 Ein- und Ausgabe, Typ Array und String, Ergänzungen 47 

5.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 

5.1 Übersicht Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 

5.2 Standardstreams, Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . 50 

5.3 Umgang mit Textdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 

5.4 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 

5.5 Strings (C-Strings) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 

5.6 Übersicht Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 

5.7 Präprozessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 

6 Konstruktion von Baueinheiten, 

Problem der Trennung in Verborgenheit und Öffentlichkeit 

(sprachunabhängige Betrachtung) 65 

6.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 

6.1 Entwurf von Systemen: Baueinheiten und Geheimnisprinzip . . . . . . . . . . 65 

6.2 Prozedurale Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 

6.3 Speicherklassen, Modulare Programmierung . . . . . . . . . . . . . . . . . . . 71 

6.4 Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . 73 

7 Prozedurale Programmierung 76 

7.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 

7.1 Funktionsdefinition und Funktionsaufruf, Gültigkeitsbereich in Blöcken . . . . 76 

7.2 Funktionsdeklaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 

7.3 Referenztyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 

7.4 Parameterübergabearten Wert und Referenz, konstante Referenz . . . . . . . 82 

7.5 Globale und lokale Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 

7.6 Überladen von Funktionsnamen, Standardargumente . . . . . . . . . . . . . . 87 

7.7 Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 

7.8 Leitlinien zur Entwicklung von Funktionen . . . . . . . . . . . . . . . . . . . . 90


7.9 Agile Methoden in der Softwareentwicklung . . . . . . . . . . . . . . . . . . . 91 

II Informatik II (2. Semester) 92 

8 Speicherklassen, modulare Programmierung 92 

8.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 

8.1 Statische und automatische Speicherklasse . . . . . . . . . . . . . . . . . . . . 92 

8.2 Modulare Programmierung: Aufteilung in mehrere Übersetzungseinheiten . . 94 

9 Objektorientierte Programmierung: 

Kapselung von Daten und Funktionen mit Zugriffskontrolle 102 

9.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 

9.1 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 

9.2 Konstruktor und Destruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 

9.3 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 

10 Einige C ++-Ergänzungen, Zeigertyp, Freispeicher 109 

10.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 

10.1 Symbolische Konstanten, Makros und inline-Funktionen . . . . . . . . . . . 109 

10.2 Datentyp Zeiger, Typinterpretation, Array und Zeiger . . . . . . . . . . . . . 110 

10.3 Freispeicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 

11 Objektorientierung: 

Ergänzungen, Vererbung, Polymorphie, statische Klassenelemente 116 

11.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 

11.1 Klassen und Objekte: Ergänzungen . . . . . . . . . . . . . . . . . . . . . . . . 116 

11.2 Überladen von Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 

11.3 Einfache Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 

11.4 Polymorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 

11.5 Statische Klassenelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 

12 Operatoren, Typen, Ergänzungen zu Zeiger, Binärdateien 136 

12.0 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 

12.1 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 

12.2 Aufzählungstyp, Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . 139 

12.3 Zeigerarithmetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 

12.4 Zeiger als Funktionsparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 

12.5 Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 

12.6 Umgang mit Binärdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 

12.7 Mehrdimensionale Arrays und zugehörige Zeiger, 

Kommandozeilenparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 

12.8 Typlose Zeiger, C-Bibliotheksfunktionen . . . . . . . . . . . . . . . . . . . . . 159


0 Vorbemerkungen 

0.1 Legende, Sprachhinweise, Bildsymbole 

Erläuterungen 

xyz 

abc 

 

terminales xyz“ (unverändert zeichenweise zu übernehmen) 

” 

metasprachl. Symbol: für abc“ Einsetzen der Definition von abc 

” 

Definitionszeich. (ggf. auch innerh. einer Alternative) – dagegen terminales Gleichheitsz.: = 

| 

| metasprachl. Alternativ-Zeichen – dagegen terminaler senkrechter Strich: | 

[- ]- metasprachl. Klammer – dagegen terminale eckige Klammern: [ ] 

abc0..n null oder mehrere Male abc“, Folge beliebig vieler abc“ 

” ” 

abc1..n ein oder mehrere Male abc“, Folge mit mindestens einem abc“ 

” ” 

abcopt optionales abc“ (gleiche Bedeutung wie: abc0..1) 

 

” 

- abc 

 

def - gleichwertig zu: [- abc | 

| def ]- 

Op2 Op2 [NV] Definition nicht vollständig 

[NErl] nicht erlaubt (in dieser Vorlesung) 

Bezug auf Operator(-Hierarchiestufe) 

〈Text〉 Fachausdruck in englisch 

10 

Bezug auf Syntaxelement 

[. . . ] Erläuterung (nicht zur Syntax gehör.) 

Sprachhinweise: 

(nichts) in C und C ++ 

C++ nur in C ++ 

C nur in C 

C/C++ in C; auch in C ++ möglich und üblich (meist als Gegensatz zu C++ gebraucht) 

C (C++) in C; in C ++ zwar auch möglich, aber nicht empfohlen: dort bessere Konstrukte vorhanden 

C++(neu) C ++, neu, ggf. noch nicht in gängigen Compilern implementiert 

C++(alt) C ++, alt, ggf. gerade noch in gängigen Compilern implementiert 

Bildsymbole: 

△! Warnung: Bemerkungen zu Gefahren; aufpassen, bitte ernst nehmen! 

Empf Empfehlung: meist Vorschlag, aus mehreren Möglichkeiten eine zu bevorzugen, da andere (ggf. inzwischen) 

weniger üblich oder eher zu Fehlern führen können – zumindest beim aktuellen Wissensstand 

Anm Anmerkung: zusätzliche Bemerkung zum laufenden Text 

↑↑ Hinweis: Erläuterung in größerem Zusammenhang oder zusätzliche Bemerkungen, nicht relevant für die 

Klausur zur laufenden Vorlesung 

↗ Vorwärtsverweis: Bezug auf spätere Inhalte der laufenden Vorlesung 

↙ Wiederholung 

NEU Neu – als Gegensatz zur Wiederholung 

Zus Zusammenfassung 

Übb Überblick 

Bsp Beispiel 

Bew Beweis 

0.2 Skripte 

Copyright: Bitte beachten Sie, dass alle Skripte nur für eigene Studien benutzt werden dürfen. 

Weitergehende Verbreitung oder Nutzung ist untersagt. 

Das zu dieser Vorlesung gehörige Skript ” Sprache C ++“ wird hier in der Form (Cpp/Kap. kapitel.punkt) öfter 

zitiert. Es ist in der jeweils neuesten Fassung als PDF-Datei auf dem bekannten Server verfügbar. 

Dieses Skript – ohne eigene Zusätze – ist als Hilfsmittel zur Klausur zugelassen, das vorliegende Skript 

der Vorlesung natürlich nicht. 

Beim Zitieren von Vorlesungspunkten wird die Form (kapitel.punkt) gewählt. 

Die Vorlesungsskripte sind sog. Durchläufen zugeordnet; ein Student bleibt bei planmäßigem Studium 

der Durchlaufkennung treu. Die zum vorliegenden Skript gehörige Durchlaufkennung ist (vgl. 

Kopfzeile).


Beispiele: 

Durchlauf : Beginn WS 2008/09, 2. Semester SS 2009 



Ggf. werden auch Bücher zitiert: 

K&R2/ Kernighan/Ritchie, The C Programming Language, 2. Auflage, Prentice Hall 1988; 

dt.: Programmieren in C, 2. Auflage, Hanser 1990 

Str2/ Stroustrup, The C ++ Programming Language, 2. Auflage, Addison-Wesley 1991; 

dt.: Die C ++ Programmiersprache, 2. Auflage, Addison-Wesley 1992 u. später 

(dt. Auflage: Vorsicht! Viele Fehler!) 

Str3/ Stroustrup, The C ++ Programming Language, 3. Auflage, Addison-Wesley 1997; 

dt.: Die C ++ Programmiersprache, 3. Auflage, Addison-Wesley 1998 

EffCpp/ Meyers, Effective C ++: 50 Specific Ways ..., 2. Auflage, Addison-Wesley 1998; 

dt.: Effektiv C ++ programmieren, 3. Auflage, Addison-Wesley 1998 

MEffCpp/ Meyers, More Effective C ++: 35 Specific Ways ..., Addison-Wesley 1997; 

dt.: Mehr Effektiv C ++ programmieren, Addison-Wesley 1997 

D&E/ Stroustrup, Design and Evolution of C ++, AT&T Bell Lab. 1994; 

dt.: Design und Entwicklung von C ++, Addison-Wesley 1994 

ARM/ Ellis/Stroustrup, The Annotated C ++ Reference, Addison-Wesley 1990 

0.3 Hinweise zum Umgang mit älteren C ++-Compilern 

Diese Vorlesung und auch die Übungen sind für den Umgang mit neuen Compilern gedacht. 

Wenn Ihnen ein älterer C ++-Compiler zur Verfügung steht: 

• Der Compiler kennt vielleicht den Datentyp bool nicht; dann bitte folgende Zeilen einfügen: 

typedef int bool; 

const bool true=1, false=0; 

• Bei Definition von Variablen im Initialisierungsteil einer for-Anweisung: ggf. gesamte for- 

Anweisung in Block einfügen, s. (4.51c). 

• Er kennt ggf. die Include-Zeilen in der angegebenen Form noch nicht. Dann bitte folgende (beispielhaft 

aufgezeigten) Ersetzungen vornehmen: 

// C++-Include-Dateien 

#include 

// Statt: #include (d. h. ".h" hinzufügen) 

// C-Include-Dateien: 

#include 

// Statt: #include (d. h. führendes "c" weglassen 

// und ".h" hinzufügen) 

Zusätzlich muss dann auch die folgende Zeile weggelassen werden: 

using namespace std; 

Näheres dazu ist in (8.23c) kurz angedeutet. 

Sehr wichtig: Sie sollten auf keinen Fall in einem Projekt diese beide Schreibweisen der Include- 

Zeilen mischen!


Teil I 

Informatik I (1. Semester) 

1 Rechnersysteme (Kurzüberblick) 

1.0 Überblick 

Dieses Kapitel befasst sich mit den Hardware- und Software-Komponenten eines Rechners 

und ihrem Zusammenspiel. Es handelt sich um die kurze Aufzählung der wichtigsten Zusammenhänge. 

Der Stoff wird hier kaum erläutert; hier ist nur kurz zusammengestellt, welches 

Wissen für den weiteren Verlauf des Kurses erwartet wird. Für Studierende, die noch nicht 

sehr viel über Rechner wissen, kann dieser Überblick (selbst zusammen mit den Erläuterungen 

in der Vorlesung) zu knapp und daher unverständlich sein; bitte nehmen Sie dann zu 

einzelnen Themen einführende Büchern über Informatik in die Hand (Bibliothek!). 

1.1 Grundlegende Begriffe 

(1.10) Übb Die grundlegenden Begriffe (die immer wieder in der Vorlesung vorkommen werden) 

müssen verstanden werden: Hardware, Software, Programm, analog und digital, Zeichen, 

Bit, Byte und die Vorsatzzeichen K, M, G, T. 

(1.11) Einige Begriffe – teilweise als vorläufige Erklärungen: 

(a) Hardware 〈hardware〉: physikalisch-technisch realisierte Bestandteile eines Rechnersystems. 

(b) Software 〈software〉: Gesamtheit aller Programme. 

Programm 〈program〉: Sammlung von Arbeitsanweisungen zur Lösung einer bestimmten 

Aufgabe in einer Form, die ein Rechner direkt oder indirekt versteht – vgl. auch (2.11). 

(c) Daten 〈data〉: Informationen (Angaben über Sachverhalte oder Vorgänge) aufgrund bekannter 

Abmachungen in maschinell verarbeitbarer Form. 

(1.12) Die Darstellung und Übermittlung von Informationen geschieht meist in Form von physikalische 

Größen. 

Bsp Elektrische Spannung, Weg (räumliche Verschiebung), Helligkeit, Magnetfeld, Temperatur und viel andere. 

Nimmt die physikalische Größe hierbei nur gewisse, eindeutig voneinander unterscheidbare 

Werte an, spricht man von digitaler Information(sdarstellung). Kann sie – innerhalb eines 

bestimmten Bereichs – jeden beliebigen Wert annehmen (kontinuierlich), spricht man von 

analoger Information(sdarstellung). 

Bsp Analog: Zeigeruhr (ohne Schrittwerk), physikalische Schwingung, kontinuierliche Bewegung. 

Digital: Digitaluhr, Schalten ein/aus, Bewegung durch Schrittmotor. 

Digitalrechner/Analogrechner: Rechner, der die Daten intern digital/analog verknüpft. 

(1.13) Zeichen 〈character〉: Element aus einer endlichen Menge zur Darstellung von Informationen 

(für digitale Informationsdarstellung). Zur Codierung siehe (1.45). 

In der Datenverarbeitung sind üblich: 

• Ziffern (0..9), 

• Buchstaben (A..Z, a..z, dazu auch nationale Sonderbuchstaben, dt. z. B. ÄÖÜäöüß), 

• Sonderzeichen (z. B. + - . , ; * / @ $ u. a.). 

(1.14) Bit (aus ” binary digit“), Binärziffer: kleinste Informationeinheit, kann nur zwei Zustände 

annehmen (Interpretation z. B. 0/1, Ja/Nein, Wahr/Falsch, Strom/kein Strom, hell/dunkel). 

Byte = 8 Bit (heutzutage). Pro Byte gibt es 2 8 = 256 verschiedene Bitmuster. Heute wird 

ein Zeichen (1.13) meist in einem Byte dargestellt, neuere Codes (z. B. Unicode) nehmen 2 

Byte.


1 k = 10 3 (z. B. 1 km, 1 kg) – jedoch: 

1 K = 2 10 = 1024 1000 

Bsp 1 KByte = 1024 Byte 

1 KBit = 1024 Bit 

Größenordnung: eine Schreibmaschinenseite hat etwa 2000–3000 Zeichen, d. h. 2–3 KByte 

1 MByte (Mega) = 2 20 Byte = (1024) 2 Byte = 1 048 576 Byte 1 Million Byte 

1 GByte (Giga) = 2 30 Byte = (1024) 3 Byte = 1 073 741 824 Byte 1 Milliarde Byte 

1 TByte (Tera) = 2 40 Byte = (1024) 4 Byte = 1 099 511 627 776 Byte 1 Billion Byte 

△! In der Physik sind jedoch exakte Zehnerpotenzen gemeint (so wie oben bei 1 k angegeben), 

z. B. 1 MHz = 1 000 000 Hz, 1 GHz = 1 Mrd. Hz. 

1.2 Rechneraufbau, Hardware 

(1.20) Übb Der grundsätzliche Aufbau eines heutigen Rechners (mit sog. von-Neumannscher 

Architektur) wird zunächst kurz vorgestellt, und zwar i. w. die Hardware-Seite (1.21). Punkt 

(1.22) zählt die wichtigsten Peripheriegeräte auf, (1.23) stellt Begriffe zu Charakterisierung 

verschieder Aspekte von Speicher vor. 

(1.21) 

(a) Prinzipieller Rechneraufbau: 

Prozessor: 

Rechenwerk, 

Steuerwerk, 

Register 

Zentraleinheit 

Hauptspeicher 

Peripherie 

Rechenwerk 〈ALU ” arithmetic logical unit“〉: arithmetische Operationen, Vergleiche, Adressenberechnungen. 

Leitwerk, Steuerwerk 〈CU ” control unit“〉: Steuerung und Überwachung der Befehlsverarbeitung, 

Entschlüsselung der gespeicherten Befehle. 

Register: wenige, sehr schnelle Zwischenspeicher, Anzahl z. B. 16. 

Prozessor: Zusammenfassung von Rechnerwerk, Leitwerk, Register. 

Hauptspeicher, Zentralspeicher, Arbeitsspeicher 〈main memory〉, RAM (s. u.): ” Schubladenschrank“ 

mit nummerierten Fächern ( ” Adressen“). Fassungsvermögen je Adresse heute 

meist 1 Byte. 

Zentraleinheit 〈CPU ” central processing unit“〉: Zusammenfassung von Prozessor und 

Hauptspeicher. 

△! Bei Mikroprozessoren andere Begriffsbildung: CPU = Prozessor ohne Hauptspeicher 

Peripherie, periphere Geräte, Ein-/Ausgabewerke 〈input/output devices〉: alles außerhalb 

der Zentraleinheit. 

(b) Größenordnung für Übertragungszeiten: 

• Rechenwerk–Register: 1–2 ns, 

• Rechenwerk–Hauptspeicher: etwa 10 ns, 

• Rechenwerk–Festplatte: etwa 10 ms, 

• Rechenwerk–Magnetband: bis sec. 

Achtung: Faktor 10 6 zwischen 10 ns und 10 ms! Bei der Festplatte ist jedoch die Übertragung 

von Folgebytes wesentlich schneller – im Gegensatz zum Hauptspeicher. 

Zur Überbrückung großer Geschwindigkeitsunterschiede werden meist Zwischenspeicher, sog. 

” Cachespeicher“, eingesetzt, z. B. Platten-Cache (meist innerhalb des Festplattengeräts), 

externer und interner Cache (zwischen Hauptspeicher und Rechenwerk). 

(c) Die originale Bedeutung von RAM und ROM ist missverständlich:


(1.22) Peripherie 

• RAM (aus ” random access memory“, dt. Speicher mit wahlfreiem Zugriff) hat heute 

die Bedeutung Schreib-Lese-Speicher in Form des Hauptspeichers, er hat die Zugriffsart 

direkt (synonym: wahlfrei), 

• ROM (aus ” read only memory“, dt. Nur-Lese-Speicher) hat die ursprüngliche Bedeutung 

Nur-Lese-Speicher behalten (ROM als Gegensatz zum Schreib-Lese-Speicher RAM), 

Zugriffsart auch hier normalerweise direkt (wahlfrei). 

(a) Externe Speicher, Massenspeicher: alle Speicher außerhalb der Zentraleinheit: 

• Magnetbandspeicher, Streamer (Zugriffsart: sequentiell) 

• Magnetplattenspeicher, Festplatte; 

Organisation: mehrere Plattenoberflächen, Sektor 〈sector〉, Spur 〈track〉, Zylinder 

〈cylinder〉 (letzteres: Zusammenfassung aller Spuren derselben Nummer); 

Zugriffsart: halbdirekt (Spur/Zylinder direkt, Sektor indirekt) 

• Diskette 〈floppy disk〉 

• CD ( ” compact disk“) 

△! SEHR WICHTIG: Sicherung aller wichtigen Daten i. a. täglich; eine Sicherung, wenn 

sie benötigt wird, ist im nachhinein nicht mehr möglich!! 

(b) Eingabegeräte: Tastatur, Maus, Klarschriftleser, Balkencodeleser, Prozessfühler (Prozessrechner), 

Mikrofon, Tablett, Lichtgriffel, Scanner, CD-Lesegerät; 

früher: Lochstreifenleser, Lochkartenleser. 

〈Keyboard, mouse, optical character reader, bar code reader, sensor, microphone, (graphics) 

tablet, electronic pen, scanner, CD read device; paper tape reader, punched card reader.〉 

(c) Ausgabegeräte: Bildschirm, Drucker, Plotter, Lautsprecher, CD-Gerät ( ” Brenner“); 

früher: Lochstreifenstanzer, Lochkartenstanzer. 

〈Screen, printer, plotter, loud speaker, CD device (burner); paper tape punch, card punch.〉 

(1.23) Speicherkategorien 

bezogen auf . . . Kategorien z. B. 

Zugriff (auf eine spezielle Stelle) wahlfreier Zugriff, 

direkter Zugriff 

〈random/direct access〉 

(Zugriffszeit unabhängig vom 

Ort des letzten Zugriffs) 

sequentieller Zugriff, 

indirekter Zugriff 

〈sequential/indirect access〉 

(Zugriff nacheinander) 

Hauptspeicher 

Mischung Festplatte, 

(halbdirekter Zugriff) Diskette, 

auch CD 

Richtung des Informationsflusses nur lesen ROM-chip 

CD-ROM 

1.3 Software, Betriebssysteme 

Streamer (Magnetband) 

lesen und schreiben Hauptspeicher, 

Festplatte, 

Streamer 

Mischung WORM, EPROM 

(1.30) Übb Dieses Unterkapitel befasst sich überblickartig mit der Software eines Rechnersystems. 

Es werden die verschiedenen Sprachgenerationen vorgestellt, danach der Weg vom


Quelltext zu einem ausführbaren Programm. Dann werden die verschiedenen Arten von 

Software eingeordnet, dabei wird auch der Begriff ” Betriebssystem“ definiert wird. In (1.34) 

wird ein hierarchisches Dateisystem erläutert (DOS/Windows und andere, i. w. auch Unix); 

das Navigieren in einer solchen Hierarchie, das Benennen von Pfaden (absolut und relativ) 

gehört zum wichtigen Grundverständnis. Durch Umleitung, Datenübergabe, Filter können 

man mit Hilfe des Betriebssystems recht interessante Wirkungen erzielen, häufig einfacher 

als über direkte Programmierung. 

(1.31) Verschiedene Sprachgenerationen 

Anm Die Zählung in Generationen ist heute kaum noch üblich mit Ausnahme der ” 4GL“. 

(a) Maschinensprache (Sprache der ersten Generation), kann Prozessor direkt verstehen. 

Bsp Ausführbare Programme. 

(b) Assembler, maschinenorientierte Sprache (Sprache der zweiten Generation): je Maschinenbefehl 

ein Assemblerbefehl, sehr prozessorabhängig, für Menschen besser lesbar als 

Maschinensprache. 

Übersetzungsprogramm für in dieser Sprache geschriebenen Quellcode: Assembler (doppeldeutiger 

Name!), Assemblierer. 

(c) Höhere Programmiersprache, Hochsprache, problemorientierte Sprache (Sprache 

der dritten Generation): orientiert sich am zu lösenden Problem und weniger an dem ausführenden 

Prozessor. 

Bsp Fortran, Cobol, Algol, Basic, Pascal, C, C ++. 

Übersetzungsprogramm für in dieser Sprache geschriebenen Quellcode: Compiler, Kompilierer, 

Übersetzer. 

(d) Sprache der vierten Generation ( ” 4GL“): Sprache, bei der der ausführenden Einheit mitgeteilt 

wird, was für ein Ergebnis der Benutzer haben möchte, aber nicht, auf welchem Weg 

dieses erhalten werden soll. 

Bsp Manche Datenbankabfragesprachen. 

(1.32) Übergang vom Quelltext zur Programmausführung: 

(1.33) 

• Schreiben des Quelltextes in einer Quellsprache (Assembler, Hochsprache, 4GL) mit 

einem Editorprogramm: Klartext ohne Textformatierungen – außer einem guten Layout 

durch Zeilenumbrüche und Einrückungen. 

• Übersetzen dieses Quellprogramms mit einem Compiler oder Assembler, Ergebnis: 

Objektprogramm (teils in Maschinensprache, dazu Tabellen mit unaufgelösten [d. h. 

benötigten] und angeboteten Referenzen). 

• Binden des/der Objektprogramms/e mit dem Binder, Linker 〈linker〉 unter Zuhilfenahme 

von Bibliotheken, Erfüllen der objektprogramm-übergreifenden Referenzwünsche, 

Erstellen eines ausführbaren Programms auf der Platte. 

• Laden des ausführbaren Programms in den Hauptpeicher durch den Lader und Anstoß 

zur Ausführung. 

In einer integrierten Entwicklungsumgebung ( ” IDE“, integrated development environment) 

bemerkt man diese einzelnen Schritte kaum. 

Ein anderer Ablauf ist möglich in manchen Programmiersprachen durch einen Interpreter: 

der Quelltext (Hochsprache) wird durch den Interpreter sofort in Maschinencode übertragen 

und zur Ausführung gegeben, dann wird der erzeugte Maschinencode wieder verworfen. 

Vorteil: sofortiges Testen aus dem Quellcode heraus. Nachteil: ungünstige Performanz. Entscheidender 

Nachteil: verleitet zum Programmieren ohne Nachdenken (Basic!). 

(a) Je nach Verwendungszweck kann man Software unterteilen in verschiedene Arten: 

• Verarbeitungsprogramme: 

◦ Anwendungsprogramme (Gehaltsabrechnung, NC-Programm, Textverarbeitung, 

Datenbankprogramm), 

◦ Übersetzer,


◦ Dienstprogramme 〈utilities〉 (Sortierpgramm, Testprogramm, Datenübertragungsprogramm); 

• Systemprogramme (= Betriebssystem). 

(b) Betriebssystem 〈operating system〉: Gesamtheit aller Systemprogramme; diese Programme 

steuern die Abwicklung der Verarbeitungsprogramme, bilden zusammen mit der Hardware 

die funktionelle Struktur und Betriebsart des Systems. 

(1.34) Hierarchisches Dateisystem (DOS, Windows, i. w. auch Unix) 

(a) Datei 〈file〉: Sammlung von zusammengehörigen Informationen. 

Verzeichnis 〈directory〉, dt. manchmal auch Ordner 〈folder〉: Behälter für Dateien und 

Verzeichnisse. 

Ein Verzeichnis kann Dateie(en) und/oder Verzeichnis(se) enthalten, eine Datei enthält weder 

eine andere Datei noch ein Verzeichnis. 

Grafische Darstellung (UML, s. (2.14b ↑↑)): 

Erläuterung: 

AbstrakteDatei 

❅ ❅ 

NormaleDatei Verzeichnis 

NormaleDatei und Verzeichnis haben viele Gemeinsamkeiten; das Gemeinsame kann man sich in 

AbstrakteDatei zusammengefasst denken. Die Art der Beziehung (Pfeil mit hohlem Dreieck) ist eine 

Spezialisierung: NormaleDatei und Verzeichnis sind jeweils eine spezielle Art von AbstrakteDatei. 

Die Bezeichnung ” abstrakt“ entspricht der Terminologie in der Objektorientierung; dieses bedeutet, 

dass AbstrakteDatei selbst real nicht existieren kann, sondern immer nur in der spezialisierten Form 

NormaleDatei oder Verzeichnis. 

Zusätzlich gibt es eine Ganzes-Teile- oder Enthält-Beziehung (Linie mit Raute) zwischen Verzeichnis 

und AbstrakteDatei (diese wiederum als NormaleDatei oder als Verzeichnis); der Stern deutet an, 

dass diese Beziehung zu beliebig vielen (0..n) Elementen AbstrakteDatei bestehen kann. 

↑↑ Die Art der Darstellung (UML) und die darauf fußende Erläuterung sind für diesen Kurs nicht 

relevant, deren Bedeutung (normale Dateien, Verzeichnisse, rekursive Schachtelungsmöglichkeit) 

ist jedoch wichtig. In Unix gibt es noch weitere Dateiarten als Spezialisierung, z. B. 

die ” spezielle Datei“ (Gerätedatei). Korrekt ist das obige Bild für Unix nur, wenn keine 

zusätzlichen Links existieren. Näheres zur Spezialisierungsbeziehung (Objektorientierung: 

Vererbung) s. auch (11.31). 

(b) Aufbau einer Verzeichnishierarchie ( ” Baum“) 

Stammverzeichnis, Wurzelverzeichnis 〈root directory〉: Verzeichnis, welches in keinem anderen 

enthalten ist. 

* 

✁❆ 

❆✁


Bsp (Stammverzeichnis) 

✘✘✘ 

❳❳ 

✘✘ 

❳❳❳ 

✘✘✘ 

❳❳❳ 

✘✘✘ 

❳❳❳ 

✘ 

✘ 

❳❳❳ 

Math 

Phys 

Inf 

 

 

Sem1 Sem2 

Vorl Uebg ZuTun 

❅ ❅ 

✟ 

✟❳ 

✟✟ 

❅ 

❳❳ ❳❳❳❳ 

❅ 

 

 

Vorl Uebg 

Alt Neu Plan 

❅ ❅ 

✟ 

✟❳ 

✟✟ 

❅ 

❳❳ ❳❳❳❳ 

❅ 

 

 

VorJahr LfdJahr 

Sommer Winter Uebg 

❅ ❅ 

✟ 

✟❳ 

✟✟ 

❅ 

❳❳ ❳❳❳❳ 

❅ 

Pfad 〈path〉: Weg von einem Verzeichnis(punkt) zu einem anderen Verzeichnis(punkt) innerhalb 

eines Verzeichnisbaumes. 

Ein Betriebssystem erlaubt es i. a., ein Verzeichis als Standardverzeichnis (aktuelles Verzeichnis) 

〈default directory〉 festzulegen (und auch zu ändern). Daher gibt es zwei Arten von 

Pfaden: 

• relativer Pfad: Pfad mit dem Standardverzeichnis als Quellpunkt, 

• absoluter Pfad: Pfad mit dem Stammverzeichnis als Quellpunkt – unabhängig vom 

Standardverzeichnis. 

(c) DOS/Windows und Unix 

Trennzeichen zwischen Pfadbestandteilen: DOS/Windows ” \“, Unix ” /“. 

Unterscheidung der beiden verschiedenen Pfadarten: 

• vorangestelltes Trennzeichen bedeutet absoluter Pfad, 

• kein Trennzeichen am Anfang bedeutet relativer Pfad. 

Angabe des Weges: 

• abwärts: Angabe des Verzeichnisnamens, 

• aufwärts: ” ..“ (DOS/Windows und Unix). 

Zusätzlich gibt es noch die Angabe des Standardverzeichnisses als Punkt ” .“ in DOS/Windows 

und Unix. 

Bsp Pfadangaben zur Abbildung in (b): 

Quellpunkt Zielpunkt Betriebssystem Relativpfad Absolutpfad 

Vorl VorJahr Dos/Windows ..\..\..\Inf\VorJahr \Inf\VorJahr 

(links unten) Unix ../../../Inf/VorJahr /Inf/VorJahr 

Neu Phys Dos/Windows ..\.. \Phys 

(Mitte unten) Unix ../.. /Phys 

Stammverzeichnis Sem2 Dos/Windows Math\Sem2 \Math\Sem2 

Unix Math/Sem2 /Math/Sem2 

Inf Stammverzeichnis Dos/Windows .. \ 

Unix .. / 

Angabe einer Datei (in [ ] wahlfreie Angabe): 

• Unix: [pfad]dateiname 

• DOS/Windows: [laufwerk:][pfad]dateiname 

Falls bei nichtleerer Pfadangabe der Pfad nicht mit einem Trennzeichen endet (d. h. wenn er nicht 

das Stammverzeichnis als Absolutpfad ist), muss zwischen Pfad und Dateiname ein zusätzliches 

Trennzeichen gesetzt werden. 

Dateinamenbildung: 

• DOS/Windows: Buchstaben unabhängig von Groß-/Kleinschreibung, 

• Unix: Groß- und Kleinbuchstaben gelten als unterschiedliche Zeichen. 

Eine Dateinamenangabe oder ein Dateiname (i. w. S.) ist i. a. zusammengesetzt aus Dateiname 

(i. e. S.) und wahlfreier Erweiterung, getrennt durch einen Punkt. Die Dateinamenerweiterung 

sollte die Art der Datei angeben.


Bsp1 .EXE ausführbare Datei, .CPP C ++-Quelltextprogramm, .BAT Stapelverarbeitungsdatei, .OBJ Objektdatei, 

.SYS Systemdatei, .INI Initialisierungsdatei, .DOC Dokumentendatei, .TXT Textdatei. 

Anm1 In Unix gilt der Punkt als normales Zeichen innerhalb eines Dateinamens, er darf also mehrfach 

vorkommen. 

Bei manchen Betriebssystembefehlen ist es erlaubt, Globalzeichen 〈wild card characters〉 

als Platzhalter zu benutzen (gültig für DOS/Windows und für Unix): 

? für genau ein Zeichen, 

* für beliebig viele Zeichen (auch null). 

In Unix (nicht in DOS/Windows) werden auch Zeichen nach einem * verglichen. In DOS/ 

Windows gelten Globalzeichen für jeden der beiden Bestandteile Dateinamen und Erweiterung 

getrennt, in Unix gilt auch der Punkt als durch Globalzeichen ersetzbares Zeichen. 

Anm2 Neuere Windowsversionen können bezüglich Globalzeichen schon das Unix-Verhalten zeigen. 

Bsp2 ?t4* 

DOS/Windows, möglich: at4 zt489 zt4wert (alle OHNE Dateinamenerweiterung) 

DOS/Windows, nicht: at4.txt zt489.exe t4 

Unix, möglich: wie DOS/Windows, dazu auch: at4.txt zt489.exe 

r*.t* 

DOS/Windows (auch Unix), möglich: alle Dateien mit Dateinamenbeginn r und Erweiterungsbeginn t 

Alle Dateien des aktuellen Verzeichnisses in DOS/Windows: *.* 

Das gleiche in Unix: * (Bedeutung in DOS: nur alle Dateien ohne Dateinamenerweiterung) 

(1.35) Umleitung, Datenübergabe, Filter 〈indirection, piping, filter〉 

(a) In Betriebssystemen ist i. a. eine Standardeingabe (ein Standardeingabegerät) und eine 

Standardausgabe (ein Standardausgabegerät) definiert. Meist gilt als Standardeingabe die 

Tastatur, als Standardausgabe der Bildschirm. 

Programme kommunizieren häufig mit dem Betriebssystem, indem sie Zeichen aus der Standardeingabe 

von ihm anfordern oder ihm Zeichen für die Standardausgabe übergeben. Was 

nun die Standardeingabe oder -ausgabe tatsächlich ist, legt nicht das Verarbeitungsprogramm 

fest, sondern das Betriebssystem. 

(b) In DOS/Windows und in Unix kann die Zuordnung auf der Befehlszeilenebene geändert 

werden (Umleitung 〈redirection〉): 

befehl >datausopt >“, es 

bedeutet bei Dateien, dass der bisherige Inhalt nicht gelöscht wird, sondern Neues angehängt 

wird. 

(c) Datenübergabe 〈piping〉: 

Eine Verkettung von Befehlen auf der Befehlszeilenebene ist möglich (DOS/Windows und 

Unix), wobei die Standardausgabe des ersten Befehls die Standardeingabe des nächsten 

Befehls wird. Das Verkettungssysmbol ist ” |“, z. B.: 

befehl1 | befehl2 

In DOS/Windows ist eine solche Verkettung selten, in Unix wird sie sehr häufig angewendet. 

(d) Ein Filter 〈filter〉 ist ein Programm, das aus der Standarddateneingabe eine (veränderte) 

Standarddatenausgabe erzeugt. Es wird viel in Verkettungen eingesetzt. 

Bsp Sortierprogramm sort, seitenweise Ausgabe auf dem Bildschirm more. 

(1.36) Stapelverarbeitungdatei 〈batch file〉, Unix: Skriptdatei 〈script file〉: eine Textdatei, deren 

einzelne Zeilen aus Betriebssystembefehlen bestehen. Diese Datei kann zur Ausführung 

gelangen; die zugehörigen Befehle werden so abgearbeitet, als wenn sie direkt auf der Befehlszeilenebene 

eingegeben würden. 

1.4 Zahlen, Zeichen 

(1.40) Übb Um manche Wirkungen von Programmen richtig zu verstehen und ggf. auch zu 

steuern, ist es nötig, die Darstellung von Zahlen und Zeichen zu kennen. Das polyadische 

Zahlensystem ist Ihnen in Form des Zehnersystems bekannt:


(1.41) 

Bsp 7305 = 7 · 10 3 + 3 · 10 2 + 0 · 10 1 + 5 · 10 0 

Hier wird dieses System auf andere Basen ausgedehnt; insbesondere die Basis 2 werden Sie 

immer wieder antreffen, aber auch die Basis 16, seltener die Basis 8. 

Um die überdeckbaren Zahlenbereiche bei vorzeichenbehafteten Typen verstehen zu können, 

wird in (1.42) die Darstellung negativer Ganzzahlen erläutert. Hierbei ist die Zweierkomplementdarstellung 

sehr wichtig, zumal sehr viele Prozessoren und C ++-Compiler diese Darstellung 

benutzen. 

Bei der Darstellung der sog. ” reellen Zahlen“ (1.43) muss die Festkomma- und die Gleitkommadarstellung 

unterschieden werden, und zwar einmal als rechnerinterne Darstellung, 

zum andern aber auch – unabhängig von dieser internen Repräsentation – als externe Darstellung 

für Eingabe und Ausgabe. 

Problematisch kann eine Fehlersuche in einem Programm werden, wenn zur Laufzeit Überläufe 

oder Unterläufe (beide: Überschreiten des darstellbaren Zahlenbereichs) geschehen, 

weil dadurch meist unentdeckt völlig falsche Zahlen entstehen (1.44). 

Ein sehr kurzer Überblick über verschiedene Zeichencodes (1.45) schließt das Unterkapitel 

ab. Hierbei sollten Sie den ASCII-Aufbau im Prinzip verstehen; zum andern sollten Sie sich 

merken, an dieser Stelle verschiedene Codierungen für die deutschen Sonderzeichen finden 

zu können. 

(a) Polyadisches Zahlensystem zur Basis B (B ∈ N {1}): 

Zahlensystem mit den insgesamt B Symbolen ( ” Ziffern“) der Wertigkeiten 0, 1, . . . , B − 1 

zur Darstellung nichtnegativer Ganzzahlen in der Form: 

bnB n + bn−1B n−1 + · · · + b1B 1 + b0B 0 

mit bi ∈ {0, 1, · · · B − 1} Ziffern. 

Dieser Ausdruck in der Stellenschreibweise (bei bekannter Basis B): 

b bn−1 · · · b1 b0 

Auch gebrochene Zahlen lassen sich so formulieren: 

· · · + b0B 0 + b−1B −1 + b−2B −2 + · · · 

· · · b0 , b−1 b−2 · · · (mit dem Komma als Dezimalkennzeichen) 

Gebräuchlich: B = 10 Dezimalsystem 

B = 2 Dualsystem; Ziffern: 0 und 1 (sehr häufig bei Rechnern) 

B = 16 Hexadezimalsystem; Ziffern: 0. . . 9, dazu A. . . F bzw. a. . . f 

B = 8 Oktalsystem; Ziffern: 0. . . 7 

Wichtig für diese Vorlesung: neben Dezimalsystem das Dual- und das Hexadezimalsystem. 

Mit n Stellen sind insgesamt B n verschiedene Zahlen darstellbar. 

Bsp B = 2, n = 8: 256 verschiedene Bitmuster je Byte. 

(b) Ein immer anwendbarer Algorithmus zur Umrechnung von einem beliebigen polyadischen 

Zahlensystem in ein anderes: fortwährende ganzzahlige Division der Zahl durch die neue 

Basis (diese Division kann in einem beliebigen polyadischen Zahlensystem geschehen); die 

zugehörigen Teilerreste ergeben – in umgekehrter Reihenfolge – die umgerechnete Zahl in 

Stellenschreibweise. 

Bsp 14010 = 120123 (die tiefgestellte Zahl gebe die zugehörige Basis an); hier die zugehörige Berechnung: 

140:3 = 46 + 2:3 

46:3 = 15 + 1:3 

15:3 = 5 + 0:3 

5:3 = 1 + 2:3 

1:3 = 0 + 1:3 (Aufhören bei Divisionsergebnis 0) 

Die Umrechnung in unser Zehnersystem kann auch so vorgenommen werden: Multiplikation 

jeder Ziffer mit der zugehörigen Wertigkeit und Summation. (Dieses kann sinngemäß auch 

in einem anderen als dem Zehnersystem geschehen.) 

Bsp 120123 = 1 · 3 4 + 2 · 3 3 + 0 · 3 2 + 1 · 3 1 + 2 · 3 0 = 140 

Umwandlung von Zahlen zur Basis 2 in Zahlen zur Basis 8 bzw. 16 (entspr. auch umgekehrt): 

Zusammenfassung – von hinten her – von jeweils 3 bzw. 4 Bit zu einer Ziffer.


Bsp 14010 = 100011002 = 8C16 (aus 1000 1100) = 2148 (aus 10 001 100) 

(c) Für Spezialfälle gibt es andere Codes: 

• ” BCD“ 〈binary coded decimal〉: jede Dezimalziffer wird binär kodiert. Man benötigt 

je Ziffer 4 Bits (eine Tetrade). Es gibt sechs unerlaubte Bitmuster (Pseudotetraden): 

schwieriges Rechnen, manchmal aber nötig, da hierbei Rundungen wie im Zehnersystem. 

Anwendung: kaufmännisches Rechnen. 

• Beim Abtasten von Weg- oder Winkelunterschieden ist das Dualsystem unbrauchbar: 

bei etwas schiefliegendem Abtaster oder unscharfen Bitübergängen gibt es zwischen 

den Zahlen sehr stark abweichende Fehlerwerte. Abhilfe: Codes, bei denen sich beim 

Übergang zwischen aufeinanderfolgenden Zahlen nur ein Bit ändert. Beispiel: Gray- 

Code. 

(1.42) Negative Ganzzahlen 

(a) Negative Ganzzahlen lassen sich auf sehr unterschiedliche Weise darstellen: 

• Zusätzliches Vorzeichenbit: 

unsere gewohnte Schreibweise im Zehnersystem; für Rechner allgemein ungünstig, jedoch 

bei Gleitkommazahlen für die Mantisse benutzt (1.43b). 

• (B − 1)-Komplement, bei B = 2: Einerkomplement 〈one’s complement〉 

Die betragsgleiche Zahl mit umgekehrten Vorzeichen erhält man durch Ergänzen jeder 

Ziffer auf B − 1, d. h. auf die höchste mögliche Ziffer – oder durch Subtraktion der Zahl 

von B s − 1 bei s Anzahl der mitgeführten Ziffern. 

Bei B = 2: Invertieren jeder Ziffer (jedes Bits); oberstes Bit ( ” MSB“, most significant 

bit) 0 bedeutet positive Zahl (oder Null), oberstes Bit 1 bedeutet negative Zahl (oder 

Null). 

Ungünstiges Rechnen (früher manche Rechner); Kuriosität: es gibt zwei Nullen ( ” positive 

Null“ und ” negative Null“). 

• B-Komplement, bei B = 2: Zweierkomplement 〈two’s complement〉 

Die betragsgleiche Zahl mit umgekehrten Vorzeichen erhält man durch durch Subtraktion 

der Zahl von B s bei s Anzahl der mitgeführten Ziffern – oder durch Bildung des 

(B − 1)-Komplements und anschließende Addition von 1. 

Bei B = 2: Invertieren jeder Ziffer (jedes Bits), dann Addition 1; oberstes Bit 0 bedeutet 

positive Zahl (oder Null), oberstes Bit 1 bedeutet negative Zahl. Weitere Eigenschaften 

und Beispiele s. (b) 

Heute sehr häufig anzutreffen bei Rechnern. 

(b) Zweierkomplement (zu Zahlensystem der Basis 2): 

Häufig benutzte Akronyme: 

• MSB 〈most significant bit〉: werthöchstes Bit, 

• umgekehrt: LSB 〈least significant bit〉 wertniedrigstes Bit. 

Umrechnungsschema, vgl. (a): 

Nichtnegative Zahl 

(betragsgleich) 

– MSB 0 – 

✛ 

✲ 

Einerkomplement 

(Inversion jedes Bits), 

danach Addition +1 

✛ 

✲ 

Negative Zahl 

(betragsgleich) 

im Zweierkomplement 

– MSB 1 – 

Der Zahlenbereich bei s Ziffern: −2 s−1 . . . 0 . . . (2 s−1 − 1). Es gibt gleich viele nichtnegative 

Zahlen (positive und Null) wie negative Zahlen. 

Beispiele für positive und negative Zahlen im Zweierkomplement, mit größter positiver und 

kleinster negativer Zahl (s sei Anzahl der Ziffern):


Zifferndarstellung Wert Bsp s = 8 (1 Byte) Wert 

01. . . 11 2 s−1 − 1 01111111 127 

01111110 126 

00000100 4 

00000010 2 

00. . . 01 1 00000001 1 

00. . . 00 0 00000000 0 

11. . . 11 -1 11111111 -1 

11. . . 10 -2 11111110 -2 

10000001 -127 

10. . . 00 −2 s−1 10000000 -128 

(1.43) 

” Reelle“ Zahlen 

(a) Festkommadarstellung 〈fixed point notation〉: eine Zahlendarstellung, bei der jede Ziffer 

allein aufgrund ihrer Stellung eine fest vorgegebener Wertigkeit besitzt, d. h. das Dezimalkomma 

steht fest an vorgegebener bzw. vereinbarter Stelle. 

Bsp Technisch-wissenschaftliche Rechnungen: Darstellung von Ganzzahlen; das (gedachte) Dezimalkomma 

liegt hinter der letzten (wertniedrigsten) Stelle. 

Kommerzielle Rechnungen, z. B. Rechnen mit Geldbeträgen (meist zwei Dezimale). 

Nachteil: sehr betragskleine und sehr betragsgroße Zahlen nicht nebeneinander darstellbar. 

(b) Gleitkommadarstellung, auch Fließkommadarstellung oder halb-logarithmische Darstellung 

〈floating point notation〉: Darstellung als Produkt aus Mantisse m und Potenz zur Basis 

B mit Exponent n; der Zahlenwert beträgt m · B n . Der Name der Darstellung rührt daher, 

dass das wertrichtige Dezimalkomma in der Mantisse nicht an vorgegebener Stelle stehen 

kann, sondern vom Exponenten abhängt. 

Bei bekannter Basis werden nur Mantisse und Exponent abgespeichert. Bei Digitalrechnern 

werden beide binär gespeichert (Mantisse mit Extra-Vorzeichenbit, Exponent meist als 

Charakteristik, entstanden aus Exponent mit additivem Korrekturterm, der Vorgabe, damit 

nicht negativ). 

Für möglichst hohe relative Genauigkeit muss eine Gleitkommazahl normalisiert werden; 

dabei ist in der Mantisse die werthöchste Ziffer ungleich Null (es sei denn, die Mantisse ist 

hat Wert Null). 

(c) △! Das Rechnen mit Fließkommazahlen kann infolge von impliziten Rundungsfehlern 

zu völlig falschen Ergebnissen führen, wenn man einen ungünstigen Algorithmus benutzt: 

Unterschied zwischen ” reiner“ und numerischer Mathematik. Dazu können auch Fehler durch 

Bereichsüberschreitungen erfolgen, s. (1.44). 

(1.44) Bereichsüberschreitungen beim Rechnen mit Zahlen 

(a) Überlauf 〈overflow〉: der Betrag des Rechenergebnisses ist zu groß ist für die gewählte 

Darstellung; kann auftreten bei Festkommadarstellung und bei Gleitkommadarstellung. 

Praxis: je nach Art der Rechenoperation Weiterrechnen mit falschem Bitmuster oder Laufzeitfehler; 

siehe auch (c). 

(b) Unterlauf 〈underflow〉: der Betrag des Rechenergebnisses ist zu klein für die gewählte Darstellung; 

kann auftreten bei der Gleitkommadarstellung und bei der Festkommadarstellung 

(dort aber nur, wenn Dezimalkomma vor der wertniedrigsten Ziffer steht, also nicht bei 

Ganzzahlen). 

Praxis: je nach Art der Rechenoperation stillschweigendes Setzen auf Null, nur sehr selten 

mit Laufzeitfehler versehen. 

(c) △! Bei C ++/C im vorzeichenlosen Ganzzahlbereich gilt der Überlauf – in beide Richtungen 

– nicht als Fehler! Bei Überlauf nach oben geschieht ein Überschlag zur Null und 

aufwärts, bei Überlauf nach unten ein Überschlag zur werthöchstem Zahl und abwärts. 

(1.45) Codes zur Zeichendarstellung 

(a) Der ASCII 〈American standard code for information interchange〉 ist ein weitverbreiterter 

7-Bit-Code zur Zeichendarstellung.


Aufbau des Codes: 

Code (hex) Code (dez) Bedeutung 

00. . . 1F 00. . . 31 Steuerzeichen 

Beispiele: 

0A 10 LF 〈line feed〉 – Zeilenvorschub 

0C 12 FF 〈form feed〉 – Seitenvorschub 

0D 13 CR 〈carriage return〉 – ” Wagenrücklauf“ 

30. . . 39 48. . . 57 Dezimalziffern 0. . . 9 

41. . . 5A 65. . . 90 Großbuchstaben A. . . Z 

61. . . 7A 97. . . 122 Kleinbuchstaben a. . . z 

Rest Rest Sonderzeichen 

Beispiel: 

20 32 SP 〈space〉 – Leerzeichen 

Die deutschen Sonderlaute sind nicht enthalten; in der sog. deutschen Referenzversion des 

ASCII verdrängen diese einige Sonderzeichen, s. Tabelle (c). 

(b) Günstiger – und heute praktisch überall angewendet – ist die Erweiterung dieses Codes auf 8 

Bit: zusätzliche 128 Zeichen, Wert (dez.) 128. . . 255. Leider gibt es sehr viele unterschiedliche 

Erweiterungen; die wichtigsten: 

• ANSI-Zeichensatz (auch von Windows benutzt), 

• IBM-Erweiterung des ASCII (von DOS benutzt), z. B. die sog. Codetabelle 437 

(älteste IBM-Erweiterung) oder Codetabelle 850 (inzwischen für Deutschland als Standard 

vorgeschlagen). 

(c) Die deutschen Sonderlaute einschließlich des Paragraph-Zeichens in den wichtigsten Codierungen 

(Code jeweils hexadezimal, in [ ] dezimal): 

Zeichen ANSI IBM-erweiterter ASCII Dt. Referenzversion 

(Windows) (DOS) des ASCII *) 

Ä C4 [196] 8E [142] 5B [91] [ 

Ö D6 [214] 99 [153] 5C [92] \ 

Ü DC [220] 9A [154] 5D [93] ] 

ä E4 [228] 84 [132] 7B [123] { 

ö F6 [246] 94 [148] 7C [124] | 

ü FC [252] 81 [129] 7D [125] } 

ß DF [223] E1 [225] 7E [126] ∼ 

§ A7 [167] F5 [245] 1 ) bzw. 15 [21] 2 ) 40 [64] @ 

Anmerkungen: *) hinter den [ ]: verdrängtes Originalzeichen des ASCII 

1 ) nur Codetabelle 850, 

2 ) beide Codetabellen 437 und 850 – Codewert jedoch im Bereich 

der ASCII-Steuerzeichen(!!), vgl. (a)


2 Algorithmenstrukturen, Operatoren 

(sprachunabhängige Betrachtung) 


Dieses Kapitel befasst sich mit den grundlegenden Möglichkeiten, wie Rechnerprogramme 

formuliert werden können. Diese Erläuterungen werden unabhängig von einer bestimmten 

Programmiersprache geboten; in späteren Kapiteln werden diese Grundgedanken auf die 

spezielle Sprache C ++ angewandt. 

Der zentrale Begriff ” Algorithmus“ und dessen Bestandteile, nämlich die ” Anweisungen“ 

in ihren verschiedenen Arten, bilden das Thema bis zum Unterkapitel 5. Es ist wichtig 

für die Studierenden, diese Grundstrukturen kennenzulernen und sie – sprachunabhängig – 

benutzen zu können. Dabei werden eine Text- und zwei Grafikformen zu ihrer Darstellung 

eingeführt. 

Die zu diesem Kapitel angebotenen Übungsaufgaben (s. Internet) sollen sorgfältig wahrgenommen 

werden. Das Ziel ist es, Verständnis für vorformulierte Algorithmen und Kreativität 

zum ” Erfinden“ von Algorithmus zu fördern. Diese Kreativität ist sicher nicht ohne weiteres 

erlernbar; ein Üben und Probieren, ferner das Nach-Denken von Beispielalgorithmen sollte 

sie jedoch hervorlocken können. 

Das letzte Unterkapitel führt den Begriff des Operators ein, dazu die wichtigsten Operatoren, 

die auf logische Ausdrücke ( ” Aussagen“) angewandt werden. 

2.1 Einführung in Algorithmen 

(2.10) Übb Zunächst wird der für die Informatik sehr zentrale Begriff Algorithmus eingeführt 

(2.11, 2.12). In diesem Kurs spielt er bis einschließlich Kap. 7 eine wesentliche Rolle. Ein 

Algorithmus besteht aus Anweisungen; die drei wichtigen Arten von Anweisungen werden 

kurz vorgestellt (2.13). Zur Darstellung von Algorithmen werden hier eine Textform und zwei 

grafische Formen eingeführt (2.14). In den kommenden Unterkapiteln werden die Begriffe noch 

ausführlicher beschrieben. 

(2.11) 

(a) Algorithmus (hier): vollständige, eindeutige, nicht widerspüchliche, durchführbare, (statisch) 

endliche Verfahrensvorschrift zur Lösung einer bestimmten Klasse gleichartiger Probleme 

in endlich vielen Schritten. 

Anm In Spezialfällen, z. B. bei einer Prozesssteuerung, ist eine dynamische Endlichkeit ( ” in endlich 

vielen Schritten“) unerwünscht. 

(b) Programm (hier): Algorithmus, formuliert in einer für einen Rechner direkt oder indirekt 

verständlichen Sprache. 

(2.12) Die Abarbeitung eines Algorithmus wird auch Prozess genannt. Die Einheit, die einen 

Algorithmus abarbeitet, heißt Prozessor. 

(2.13) 

Anm Der genannte Prozess ist nicht zu verwechseln mit dem (natürlichen oder technischen) Prozess 

für eine Prozesssteuerung (z. B. für einen Prozessrechner). 

(a) Bei der Formulierung von Algorithmen unterscheidet man zwei verschiedene Arten von Anweisungen: 

• Anweisungen, die direkt durchgeführt werden sollen, 

• Steueranweisungen oder Kontrollstrukturen: diese geben an, ob, unter welcher Bedingung, 

wie oft o. ä. eine oder mehrere Anweisungen ausgeführt werden sollen. 

Hierbei gibt es zwei (Unter-)Arten: 

◦ Auswahl: die Abarbeitung unterliegt einer Bedingung, 

◦ Wiederholung: die Abarbeitung wird – abhängig von einer Bedingung – ggf. mehrfach 

durchgeführt.


Anm Der Ausdruck Kontroll. . . (-Struktur) ist eine etwas unglückliche Übersetzung des englischen 

Wortes 〈control . . . 〉, der Ausdruck hat sich jedoch leider durchgesetzt. Besser wäre: Steuer(ung). 

. . 

(b) Entsprechend dieser insgesamt drei Arten von Anweisungen gibt es drei wichtige Grundstrukturen 

zur Formulierung von Algorithmen: 

• Folge (Sequenz), 

• Auswahl (Selektion), 

• Wiederholung (Iteration). 

Man kann beweisen, dass jede Problemlösung, die überhaupt als Algorithmus formulierbar 

ist, immer so gestaltet werden kann, dass nur diese drei Algorithmenstrukturen benutzt werden. 

Insbesondere kann immer auf direkte Sprunganweisungen ( ” goto“) verzichtet werden. 

(2.14) Beschreibungsarten für Algorithmen 

(a) Beschreibung mit formalisiertem deutschen Text ( ” textuell Form“, ” Pseudocode“). Diese 

Beschreibungsform ist nicht genormt. In dieser Vorlesung wird sie benutzt, um Zusammenhänge 

sprachnah, aber unabhängig von einer speziellen Programmiersprache zu formulieren. 

(b) Grafische Darstellungen: 

• Programmablaufplan (PAP), 

• Struktogramm oder Nassi-Shneiderman-Diagramm. 

Anm Beide grafische Beschreibungsarten sind genormt (DIN). Der Programmablaufplan ist leichter 

herzustellen und abzuändern, führt aber meist zu schwer verständlichen und kaum wartbaren 

Programmen. Das Struktogramm hat diesen Nachteil nicht, ist aber schwieriger bei der 

Darstellung und Änderung. Für den Übergang zum Programmieren ist das Struktogramm 

auf jeden Fall vorzuziehen. 

↑↑ Zur Entwicklung und Darstellung sehr komplexer Systeme gibt es andere grafische Formen. 

Entwickelt man objektorientiert, so bieten sich u. a. Anwendungsfalldiagramme, Objektdiagramme 

und Klassendiagramme an. Eine weltweitweit verbreitete grafische Beschreibungssprache 

hierfür ist genormt (ANSI), sie wird UML 〈unified modeling language〉 genannt. 

2.2 Folge (Sequenz) 

(2.20) Übb Bei einer Folge (Sequenz) werden die einzelnen Bestandteile (Anweisungen) hintereinander 

ohne Änderung der Reihenfolge und ohne eine Auslassung abgearbeitet. Diese sehr 

einfache Algorithmen-Grundstruktur wird im folgenden mit den drei Darstellungsformen 

(Text und Grafik) erläutert. Ein ausführliches Beispiel (2.25) – bitte dort den Entwicklungsweg 

mitdenken! – rundet dieses Unterkapitel ab. 

(2.21) Die Folge in den drei Darstellungsarten: 

(a) Pseudocode, Beschreibung s. (2.22), 

(b) Programmablaufplan, Beschreibung s. (2.23), 

(c) Struktogramm, Beschreibung s. (2.24). 

Anweisung 1 

Anweisung 2 

Anweisung 3 

(a) (b) (c) 

❄ 

Anweisung 1 

❄ 

Anweisung 2 

❄ 

Anweisung 3 

❄ 

Anweisung 1 

Anweisung 2 

Anweisung 3


(2.22) Pseudocode 

(a) Die Anweisungen werden – laut Vereinbarung, für diese Vorlesung geltend – in einen Kasten 

geschrieben. Die für die Abarbeitung benötigten Datenspeicherplätze ( ” Kästchen“, ” Variable“ 

mit ” Typ“) werden ebenfalls angegeben, vgl (2.25a). 

Der Name für den Algorithmus wird, wenn vorhanden, in einem darübergestellten Kasten 

festgelegt, s. (2.25a). 

(b) Empf Wichtige Lay-out-Empfehlung (für Studierende derzeit ein Muss), vgl. (2.51): 

Jede Anweisung sollte jeweils (i. a.) in eine Zeile geschrieben werden. Ist eine Anweisung zu 

lang, wird sie – eingerückt – in der Folgezeile fortgesetzt. 

(2.23) 

(a) Beim Programmablaufplan unterscheidet man (zunächst) die folgenden Arten von Symbolen 

(siehe (2.21b) und (b)): 

• (normale) Anweisungen: jeweils im rechteckigen Kasten, meist in konstanter Größe, 

• Programm-Ablauflinien: Pfeile für die Ablaufreihenfolge (für den Kontrollfluss oder 

Steuerfluss), 

• Anfangs- und Endesymbole: abgerundete Kästen, 

• spezielle Anweisungen für Ein- und Ausgabe 〈input, output〉: Parallelogramme. 

(b) Symbole für Anfang/Ende und für Ein-/Ausgabe, jeweils mit Ablauflinien gezeichnet: 

✛ 

Anfang 

✚ 

❄ 

✘ 

✙ 

✛ ❄ 

Ende 

✚ 

✘ 

✙ 

✄ ✄ 

✄ 

✄✄ 

✄ 

❄ 

Lies . . . 

❄ 

Schreibe . . . 

(2.24) Ein Struktogramm besteht immer aus einem (großen) Rechteck mit interner feinerer Unterteilung. 

Jede Anweisung darin steht jeweils wiederum innerhalb eines Rechtecks. 

Ein Struktogramm-Rechteck(-Teil) wird immer von der oberen Begrenzungslinie her betreten 

und durch die untere Linie wieder verlassen. 

Im Struktogramm dieser Vorlesung werden ab und zu zusätzlich – außerhalb der Norm – 

zwei Kästen darübergestellt: Name des Algorithmus und Aufzählung der benötigten Speicherplätze 

( ” Variable“), siehe (2.25c). 

(2.25) Bsp Berechnung des Volumens eines Kreiskegels 

(a) Pseudocode: 

In dem in dieser Vorlesung vorgestellten Pseudocode sollen die sog. ” Schlüsselwörter“ (Wörter, 

die in der jeweils verwendeteten Sprache in dem vorhandenen Kontext eine fest vorgegebene 

Bedeutung haben) in Großbuchstaben erscheinen, damit sie mehr auffallen: hier 

zunächst die Wörter 

(a1) ALGORITHMUS, ANFANG, ENDE; 

(a2) VARIABLE, TYP; 

(a3) KONSTANTE, WERT. 

Später werden weitere Schlüsselwörter hinzukommen. 

(1) Vorläufige Formulierung: 

❄ 

✄ ✄ 

✄ 

✄✄ 

✄


ALGORITHMUS VolKreisKegel 

ANFANG 

Verwende die Kästchen Radius, Höhe, Pi, Volumen 

Lies die erste Zahl, speichere sie in Radius ab 

Lies die nächste Zahl, speichere sie in Höhe ab 

Speichere 3,14159 in Pi ab 

Berechne 1 

3 ·Radius·Radius·Pi·Höhe, 

speichere Ergebnis in Volumen ab 

Schreibe Volumen 

ENDE 

(2) Endgültiger Pseudocode – so in dieser Vorlesung häufig für die textuelle Darstellung von 

Algorithmen benutzt: 


ANFANG 

VARIABLE radius, höhe, pi, volumen TYP Fließkommazahl 

Lies radius, höhe 

pi ← 3,14159 

volumen ← radius∗radius∗pi∗höhe/3 

Schreibe volumen 

ENDE 

Für ” VARIABLE“ wird hier zusätzlich der ” TYP“ angegeben. Damit wird dem Prozessor 

mitgeteilt, welcher Art die Speicherung und Codierung der angegebenen Variablen sein soll 

– und damit verbunden die Speicherplatzgröße und die erlaubten Rechenoperationen. Als 

Zuweisungszeichen wird hier bewusst das Zeichen ” ←“ genommen, um sprachenunabhängig 

zu sein. Die Variablennamen beginnen mit einem Kleinbuchstaben; die genauere Regel als 

Empfehlung s. (4.71b). 

(3) Eine Variation der Algorithmusbeschreibung (a2): Da die Zahl π bei jedem Algorithmusdurchlauf 

denselben Wert hat (Konstante), kann auf eine Zuweisung verzichtet werden; statt 

dessen werde zu Beginn ein Speicherplatz mit richtiger Belegung ( ” Initialisierung“) bereitgestellt: 


(4) 

ANFANG 

VARIABLE radius, höhe, volumen TYP Fließkommazahl 

// Die Zahl pi wird hier als Konstante eingeführt: 

KONSTANTE pi TYP Fließkommazahl WERT 3,14159 


volumen ← radius∗radius∗pi∗höhe/3 


ENDE 

Es wird vereinbart, wie schon im obigen Kasten zu sehen, dass hinter dem Doppel-Schrägstrich 

” //“ beliebiger Text als Kommentar stehen kann; der Prozessor soll alle Zeichen ab 

einschließlich ” //“ bis zum Zeilenende ignorieren. 

Zur Umgang mit den Variablen (bzw. Kästchen) – WICHTIG zum Erfassen des Sinns 

eines unbekannten Algorithmus: 

Zum Durchspielen eines Algorithmus unbedingt die Variablen-Werte notieren, und 

zwar am besten in Form einer Tabelle (je Variable eine Zeile); bei Wertänderung alten 

Wert jeweils leserlich durchstreichen, neuen Wert daneben schreiben. 

(bc) Die zu (a2) gehörigen Darstellungen Programmablaufplan (b) und Struktogramm (c):


✄✄ 

✄ 

✄✄ 

✄ 

(b) (c) 

✛ ✘ 

Anfang 

✚ 

❄ 


❄ 

pi ← 3,14159 

❄ 

volumen ← 

radius∗radius∗pi 

∗höhe/3 

❄ 


✛ ❄ 

Ende 

✚ 

✙ 

✄✄ 

✄ 

✄✄ 

✄ 

✘ 

✙ 

ALGORITHMUS 

VolKreisKegel 

Verwende radius, höhe, 

pi, volumen 


pi ← 3,14159 

volumen ← 

radius∗radius∗pi∗höhe/3 


(d) Ohne weitere Kommentierung hier der Algorithmus (a3) als C ++-Programm: 

// Berechnung des Volumens eines Kreiskegels 

#include 


int main() 

{ 

double radius, hoehe, volumen; 

const double pi=3.14159; 

} 

cin >> radius >> hoehe; 

volumen=radius*radius*pi*hoehe/3; 

cout


◦ Mehrfachauswahl als WENN-SONSTWENN-Kette, 

◦ Mehrfachauswahl mit Selektorwert (FALLUNTERSCHEIDUNG ANHAND ...). 

Anm Die Mehrfachauswahl mit Selektorwert wird nicht durch alle Programmiersprachen unterstützt. 

(2.31) Die Bedingung bei der Auswahl und bei der Wiederholung (Kap. 2.4) entspricht einer Aussage, 

wie sie in der formalen Logik bzw. Logistik definiert wird: 

Eine Aussage (im Sinne der Logik) ist ein sprachliches Gebilde, dem man (im Prinzip) 

eindeutig die Qualität WAHR oder FALSCH zuordnen kann. Die Qualität WAHR bzw. 

FALSCH heißt Wahrheitswert der Aussage. 

Näheres zu Aussagen, insbesondere zu Verknüpfungen durch Operatoren, siehe (Kap. 2.6). 

(2.32) Bei der zweiseitigen Auswahl wird zunächst die Bedingung geprüft; hat sie den Wert 

WAHR, wird die Dann-Anweisung ausgeführt, beim Wert FALSCH wird die Sonst-Anweisung 

abgearbeitet. 

Die zweiseitige Auswahl in den drei verschiedenen Darstellungsarten: 

(a) Pseudocode, (b) Programmablaufplan, (c) Struktogramm: 

(a) 

❄ 

✟ 

✟❍ 

W ❍ 

✟ ❍ F 

❍Bedingung✟ 

❍ 

❍✟ 

✟ 

❄ ❄ 

Dann-Anweisung 

(ggf. Folge) 

✲✛ 

❄ 

WENN Bedingung DANN 

Dann-Anweisung(s-Folge) 

SONST 

Sonst-Anweisung(s-Folge) 

(b) (c) 

Sonst-Anweisung 

(ggf. Folge) 

✏✏✏✏✏✏✏✏✏✏ 

 

Bedingung 

W 

F 

 

Dann-Anweisung Sonst-Anweisung 

(ggf. Folge) (ggf. Folge) 

Zu (a): Die Wörter WENN, DANN, SONST sind weitere Schlüsselwörter (2.25a). 

Zum Lay-out (Studierende: als Muss): Obwohl SONST die Anweisung fortsetzt, sollte es – 

entgegen (2.22b) – nicht eingerückt werden, sondern direkt unter dem korrespondierendem 

WENN stehen, vgl. Regeln in (2.51). Begründung dafür s. (2.34 ↑↑) 

Zu (b): Im PAP wird eine Bedingung in Form einer Raute gezeichnet, die je nach Beantwortung 

zwei (oder auch mehr (2.37b)) Ausgänge hat – hier W (wahr) und F (falsch). 

Zu (c): Im Struktogramm tritt man von oben zunächst in die Bedingung ein und verlässt 

das Dreieck entweder in den Ja-Zweig oder in den Nein-Zweig. 

(2.33) Bsp für die zweiseitige Auswahl in den drei Darstellungsarten: 

(a) 

WENN es schneit DANN 

Zieh Schneeschuhe an 

SONST 

Zieh Turnschuhe an


✟ 

❄ 

❍ 

W ✟ ❍ 

✟ ❍ F 

❍ es schneit ✟ 

❍ 

❍✟ 

✟ 

❄ ❄ 

Zieh Schneeschuhe an Zieh Turnschuhe an 

✲✛ 

❄ 

(b) (c) 

✏✏✏✏✏✏✏✏✏✏ 

 

es schneit 

W 

F 

 

Zieh Schneeschuhe an Zieh Turnschuhe an 

(2.34) Die einseitige Auswahl ist eine Verkürzung der zweiseitigen Auswahl durch Weglassen des 

Sonst-Zweiges. 

Die einseitige Auswahl in den drei verschiedenen Darstellungsarten: 


(a) 

WENN Bedingung DANN 

Dann-Anweisung(s-Folge) 

(b) (c) 

✟❄❍ 

W ✟ ❍ 

✟ ❍ 


❍ 

❍✟ 

✟ 

F 

❄ 


(ggf. Folge) 

✲❄ 

❄ 

✟ ✟✟✟✟✟✟ 

 

 

Bedingung 

 

W 

F 

 


(ggf. Folge) 

↑↑ Die grammatische Zweideutigkeit des Konstruktes ” WENN Bedingung DANN Anweisung“ 

– nämlich einmal als vollständige einseitige Auswahl, zum andern als erster Teil der zweiseitigen 

Auswahl – wird hier im Pseudocode bewusst zugelassen, da sie (leider!) auch in 

vielen Programmiersprachen besteht – auch in C ++/C. Um für den Menschen die Übersichtlichkeit 

zu erhöhen, wurde auch in (2.32) die Empfehlung (Stud.: die Regel) gegeben, das 

unterscheidende SONST nicht einzurücken, damit es auffällt. 

(2.35) Bsp für die einseitige Auswahl: 

(a) 

WENN es regnet DANN 

Zieh Regenmantel über


❄ 

Zieh Regenmantel über 

(b) (c) 

✟❄ 

✟ 

❍ 

W ❍ 

✟ ❍ 

❍ es regnet ✟ 

❍ 

❍✟ 

✟ 

F 

✲❄ 

❄ 

✟ ✟✟✟✟✟✟ 

 

 

es regnet 

 

W 

F 

 

Zieh Regenmantel über 

(2.36) Die Mehrfachauswahl als WENN-SONSTWENN-Kette wird durch eine mehrstufige 

Schachtelung einer zweiseitigen Auswahl (2.32) gebildet, und zwar jede jeweils im SONST- 

Zweig der übergeordneten zweiseitigen Auswahl (Näheres zur Schachtelung s. Kapitel 2.5). 

Empf Zum Lay-out (für Stud. ein Muss): Da die Schachtelung bei mehreren Stufen zu 

unübersichtlich wird und da mit SONST WENN nie eine Anweisung beginnen kann, wird 

empfohlen, jedes SONST WENN und das letzte SONST direkt unter das erste (führende) 

WENN zu schreiben, vgl. (2.51), entgegen (2.22b) 

Pseudocode (links mit exakter Schachtelungs-Einrückung, rechts mit empfohlenem übersichtlicherem 

Lay-out): 

WENN y < 0 DANN 

Schreibe ” y negativ“ 

SONST 


Schreibe ” 0 y < 5“ 

SONST 



SONST 



SONST 

Schreibe ” 20 y“ 


Schreibe ” y negativ“ 

SONST WENN y < 5 DANN 






SONST 

Schreibe ” 20 y“ 

Man achte darauf, dass hier die einzelnen Bedingungen nacheinander geprüft werden, die 

Lösungsmengen brauchen daher nicht disjunkt zu sein, d. h. sie dürfen sich teilweise überlappen. 

(2.37) Bei der Mehrfachauswahl mit Selektorwert wird anhand des Wertes eines Ausdrucks, 

des sog. Selektorwertes, entschieden, zu welchem Verzweigungspunkt gegangen wird. Allen 

Verzweigungen enden jeweils beim folgenden Verzweigungspunkt. 

Anm Die Mehrfachauswahl wird durch die Sprache Pascal (und Visual Basic) unterstützt, nicht 

jedoch durch C ++ oder C; dort gibt es jedoch ein Konstrukt, das zur Nachahmung einer 

Mehrfachauswahl genutzt werden kann. 


(b) Programmablaufplan: 

FALLUNTERSCHEIDUNG ANHAND Jahreszeit: 

Frühling: Freu dich auf Blumen 

Sommer: Geh baden 

Herbst: Ernte Äpfel 

Winter: Zieh dich warm an


❄ 

Frühling 

Freu dich 

auf Blumen 

❄ 

Geh baden 

❄ 

✟ 

✟❍ 

❍ 

✟ ❍ 

❍Jahreszeit= 

✟ 

❍ 

❍✟ 

✟ 

Sommer 

❄ 

❄ 

Herbst 

Ernte Äpfel 

(c) Struktogramm: 

❳ ❳❳❳ 

❳❳❳ 

❳❳❳ 

❳❳❳ Jahreszeit = 

❳❳❳ 

❳❳❳ 

❳❳❳ 

❳❳❳ 

Frühling Sommer Herbst Winter ❳ ❳ 

Freu dich 

auf Blumen 

Geh baden Ernte Äpfel Zieh dich 

warm an 

(2.38) Manchmal ist es sinnvoll, einen SONST-Zweig zu formulieren. 

❄ 

Zieh dich 

warm an 

Anm Nicht alle Programmiersprachen. die eine Mehrfachauswahl unterstützen, kennen den 

SONST-Zweig. 

Beispiel für Mehrfachauswahl mit SONST-Zweig: 


FALLUNTERSCHEIDUNG ANHAND Wetter: 

Sonne: Bleib im T-Shirt 

Trübtrocken: Zieh Pullover über 

Regen: Zieh Regenmantel an 

SONST: Verkriech dich zu Hause 

(b) Struktogramm: 

❳ ❳❳❳ 

❳❳❳ 

✚ 

❳❳❳ 

✚ 

❳❳❳ Wetter = ✚ 

❳❳❳ 

✚ 

❳❳❳ 

✚ 

Sonne Trübtrocken Regen 

❳❳ 

✚ 

✚ SONST 

Bleib 

im T-Shirt 

Zieh 

Pullover 

über 

Zieh 

Regenmantel 

an 

Verkriech dich 

zu Hause 

(2.39) Wie aus dem Pseudocode ersichtlich, muss ein Prozessor zur Verwirklichung der Auswahlstruktur 

fähig sein, Vorwärtssprünge im Befehlstext durchzuführen, d. h. Anweisungen in 

Vorwärtsrichtung zu überspringen, vgl. (2.26). 

2.4 Wiederholung (Iteration) 

(2.40) Übb Bei der Wiederholung (Iteration), der zweiten der beiden Kontrollstrukturen 

(2.13a), wird eine Anweisung, die sog. Schleifenanweisung, mehrfach ausgeführt. 

Man unterscheidet zunächst zwei Arten von Schleifen: 

Winter


• Prüfen der Eintrittsbedingung vor Schleifeneintritt: 

kopfgesteuerte Schleife oder abweisende Schleife; hierbei kann es vorkommen, 

dass die Schleifenanweisung gar nicht durchlaufen wird. 

• Prüfen der Bedingung nach dem Schleifendurchlauf: 

fußgesteuerte Schleife oder nicht-abweisende Schleife; hierbei wird die Schleife 

mindestens einmal durchlaufen. 

Je nach Sprache unterscheidet man bei der fußgesteuerten Schleife zwei Formulierungen: 

◦ Formulierung der Bedingung als Wiedereintrittsbedingung, 

◦ Formulierung der Bedingung als Austrittsbedingung. 

Die Bedingung bei der ersten Art ist logisch invers zur zweiten Art (vgl. Nicht-Operator 

(2.63)). 

Anm In dieser Vorlesung wird die fußgesteuerte Schleife immer in der Form mit Wiedereintrittsbedingung 

benutzt, da diese Art durch C ++ und C unterstützt wird; die Formulierung 

als Austrittsbedingung entspricht der Sprache Pascal. 

Gemeinsam ist bei der kopf- und bei der fußgesteuerten Schleife, dass die Anzahl der Wiederholungen 

(Schleifendurchläufe) nicht unbedingt beim ersten Schleifeneintritt feststeht. 

Bei einer weiteren Schleifenart steht die Anzahl der Wiederholungen bei Schleifeneintritt 

fest: Zählschleife (2.44). 

(2.41) Die kopfgesteuerten Schleife (abweisende Schleife) wird folgendermaßen gedeutet: 

Zunächst die Bedingung geprüft: ist sie FALSCH, wird die Schleife gar nicht betreten, ist 

sie WAHR, wird die Schleife einmal durchlaufen. Danach wird die Bedingung wieder geprüft; 

falls die Bedingung den Wert WAHR ergibt, wird die Schleife nochmals durchlaufen - 

usw. Sehr ” beliebt“ – nicht nur bei Programmieranfängern – sind Endlosschleifen bei falsch 

formulierter Bedingung: wird sie nie FALSCH, wird die Schleife endlos oft durchlaufen. 

Daher wichtig: die Schleifenbedingung muss (i. a.) in irgendeiner Weise durch die Schleifendurchläufe 

verändert werden. (Andere Möglichkeit, nicht in dieser Vorlesung genutzt: die 

Bedingung hängt von äußeren Ereigissen ab, z. B. Tastendruck.) 

Die kopfgesteuerte Schleife in den drei verschiedenen Darstellungsarten: 


Schleifen-Anweisung 

(ggf. Folge) 

✛ 

(a) 

SOLANGE Bedingung TUE 

Schleifen-Anweisung(s-Folge) 

(b) (c) 

✲❄ 

✟❄ 

✟ 

❍ 

W ❍ 

✟ ❍ 


❍ ✟ 

❍✟ 

F 

❄ 

SOLANGE Bedingung 


(ggf. Folge) 

(2.42) Die fußgesteuerte Schleife (nicht-abweisende Schleife) – formuliert in der C ++/Cüblichen 

Art als Wiedereintrittsbedingung – wird folgendermaßen interpretiert: Zunächst 

wird die Schleife einmal durchlaufen. Danach wird geprüft, ob sie nochmals durchlaufen 

wird, nämlich dann, wenn die Wiedereintrittsbedingung den Wert WAHR ergibt. Nach dem 

nächsten Schleifendurchlauf wird die Bedingung wieder geprüft – usw. Auch hierbei besteht 

wie in (2.41) die Gefahr einer Endlosschleife. 

Die fußgesteuerte Schleife (in der C ++/C-üblichen Art) in den drei verschiedenen Darstellungsarten: 


(a) 

TUE 


SOLANGE Bedingung


❄ ✛ 

❄ 


(ggf. Folge) 

(b) (c) 

W 

✟ 

✟❍ 

❍ 

✲✟ 

❍ 


❍ ✟ 

❍✟ 

F 

❄ 


(ggf. Folge) 

SOLANGE Bedingung 

Anm Im Pseudocode ist das Schlüsselwort SOLANGE gewählt, wie es auch bei der kopfgesteuerten 

Schleife vorkommt. Hier handelt es sich jedoch nicht um einen grammatischen Konflikt 

wie bei der Auswahlstruktur (2.34 ↑↑), die Grammatik ist hier eindeutig. Man wird jedoch 

bei nur flüchtigem Anschauen des Algorithmus zu Fehlinterpretationen verleitet: nämlich 

Verwechselung von kopf- und fußgesteuerter Schleife. Diese Verwechselungsgefahr wird hier 

bewusst in Kauf genommen, da sie (leider!) in gleicher Weise auch in den Sprachen C ++/C 

besteht. Die empfohlene Nicht-Einrückung von SOLANGE – entgegen (2.22b) – ist daher 

etwas problemtisch; zur Problemlösung in C ++/C s. (4.73). 

(2.43) Die fußgesteuerte Schleife in der Pascal-Art (Bedingung als Austrittsbedingung formuliert) 

in den drei verschiedenen Darstellungsarten: 

❄ ✛ 

❄ 


(ggf. Folge) 

(a) 

TUE 


BIS Bedingung 

(b) (c) 

F 

✟ 

✟❍ 

❍ 

✲✟ 

❍ 


❍ 

❍✟ 

✟ 

W 

❄ 

BIS Bedingung 


(ggf. Folge) 

(2.44) Die Zählschleife wird meist mit einer Zählvariablen, in der die Schleifendurchläufe mitgezählt 

werden, verwirklicht. In (a) ist die Zählschleife ohne eine solche Variable, in (bc) mit 

einer Zählvariablen formuliert. 

(a) 

Lies zahl 

WIEDERHOLE 5-mal 

Multipliziere zahl mit sich selbst, 

speichere Ergebnis in zahl ab 

(b) (c) 

Lies zahl 

WIEDERHOLE FÜR i VON 1 BIS 5 

zahl ← zahl∗zahl 

Lies zahl 

WIEDERHOLE FÜR i VON 1 BIS 5 

zahl ← zahl∗zahl 

(2.45) Aus dem Pseudocode ist ersichtlich, dass ein Prozessor zur Verwirklichung der Wiederholungsstruktur 

fähig sein muss, neben Vorwärtssprüngen auch zusätzlich Rückwärtssprünge 

im Befehlstext durchzuführen, d. h. Anweisungen in Rückwärtsrichtung zu überspringen, 

vgl. (2.26).


2.5 Schachtelung der drei Algorithmenstrukturen 

(2.50) Übb Diese drei Algorithmenstrukturen Folge, Auswahl, Wiederholung können beliebig 

ineinander geschachtelt werden. (Die Schachtelung einer Folge innerhalb einer Auswahl oder 

Wiederholung ist bereits in früheren Diagrammen angedeutet worden.) 

Nur durch Benutzung dieser drei Strukturen mit der Möglichkeit, sie ineinander zu schachteln, 

können beliebig komplizierte Algorithmen gebaut werden. Wie bereits in (2.13b) erwähnt, 

reichen diese Grundstrukturen aus; insbesondere ist es nicht nötig, direkte Sprunganweisungen 

( ” goto“) zu benutzen. Solche Sprunganweisungen sind im Rahmen dieses Kurses für die 

Studierenden verboten; daher werden sie in C ++ auch nicht eingeführt. 

Theoretisch kann die Schachtelung in beliebige Tiefe gehen. Eine für die Praxis äußerst 

wichtige Grenze liegt in der Forderung, dass die Algorithmenstruktur für den menschlichen 

Leser noch überschaubar bleiben muss. Daher wird in diesem Kurs auf das Lay-out von 

Programmtext (als Pseudocode oder in einer Programmiersprache) sehr großer Wert gelegt. 

Im folgenden Punkt (2.51) werden die Grundregeln erläutert; dieselben Regeln, dort noch 

etwas ausführlicher, werden in (4.73) auf C ++ angewendet. 

Die Punkte (2.52) und (2.53) bringen Beispiele für Schachtelungen. Das zweite Beispiel, der 

Algorithmus ” Bubble-Sort“, kann ggf. auch für spätere Anwendungen benötigt werden; ein 

Auswendiglernen ist nicht erforderlich, Erinnern und Wiederauffinden reichen aus. 

(2.51) Empf – für Studierende nicht nur eine Empfehlung, sondern ein Muss – 

Anfang und Ende der verschiedenen Schachtelungsebenen müssen streng beachtet werden. 

Im Pseudocode geschieht dieses durch Einrückungen, vgl. (2.52a). 

Wichtig wird es beim Programmieren sein, selbst so viel Disziplin beim Lay-out des 

Programmtextes zu zeigen, dass die Einrückungen für die einzelnen Schachtelungsebenen 

genau vorgenommen werden (je Schachtelungsstufe mit einem bestimmten 

Einrückabstand) – und zwar nur wegen der Übersichtlichkeit für den betrachtenden 

Menschen. Ein C ++-Compiler überliest die Einrückungen. da die Sprache ein beliebiges 

Lay-out gestattet. 

Auch hierbei gilt weiterhin (2.22b): Jede Anweisung sollte jeweils (i. a.) in eine Zeile 

geschrieben werden. Ist eine Anweisung zu lang: Fortsetzung eingerückt in der 

Folgezeile. 

Ausnahmen, und zwar keine Einrückung, obwohl Fortsetzung einer Anweisung (einer 

Kontrollstruktur): 

• Zweiseitige Auswahl: SONST direkt unter WENN, nicht eingerückt (2.32, 2.34 ↑↑), 

• WENN-SONSTWENN-Kette (2.36), 

• Fußgesteuerte Wiederholung: SOLANGE direkt unter TUE, nicht eingerückt – 

obwohl problematisch (2.42 Anm); zu C ++/C s. (4.73). 

Im Struktogramm werden die Schachtelungsebenen durch ein echtes Ineinander-Schachteln 

der Rechtecke deutlich, vgl. (2.52c). 

(2.52) Bsp Zu den Schachtelungsebenen des folgenden Beispiels: In der obersten (ersten) Schachtelungsebene 

gibt es – neben der Angabe der benötigten Speicherplätze – insgesamt drei Anweisungen. 

Die zweite unter ihnen hat eine Unterstruktur, sie ist eine zweiseitige Auswahl; 

in der nächsten Schachtelungsebene sieht man, dass sowohl der DANN-Zweig als auch der 

SONST-Zweig wieder aus je einer zweiseitigen Auswahl (jeweils zweite Schachtelungsebene) 

bestehen. Die einzelnen Zuweisungen stehen in der dritten Schachtelungsebene. 

(a) Pseudocode – einmal normal mit Einrückungen, einmal mit Extrakennzeichnung der Schachtelungsebenen:


ALGORITHMUS WasMachtEr 

ANFANG 

VARIABLE x, y, z, w TYP Ganzzahl 

Lies x, y, z 

WENN x > y DANN 

WENN x > z DANN 

w ← x 

SONST 

w ← z 

SONST 

WENN y > z DANN 

w ← y 

SONST 

w ← z 

Schreibe w 

ENDE 

(b) Programmablaufplan: Übung selbst, Bespr. in Vorlesung 

(c) Struktogramm: 


VARIABLE x, y, z, w TYP Ganzzahl 

Lies x, y, z 

❳ 

❳ ❳ ❳ 

✘✘✘ 

❳ ❳ ❳ ❳ x > y 

✘✘✘ 

❳ ❳ 

✘✘✘ 

W ❳ ❳ ❳ ✘✘✘✘✘ F 

✏✏✏✏✏✏✏ 

x > z 

W 

F 

 

✏✏✏✏✏✏✏ 

y > z 

W 

F 

 

w ← x w ← z w ← y w ← z 

Schreibe w 


ANFANG 

| VARIABLE x, y, z, w TYP Ganzzahl 

| Lies x, y, z 

| WENN x > y DANN 

| | WENN x > z DANN 

| | | w ← x 

| | SONST 

| | | w ← z 

| SONST 

| | WENN y > z DANN 

| | | w ← y 

| | SONST 

| | | w ← z 

| Schreibe w 

ENDE 

Die einzelnen Schachtelungsebenen: 

[n] bedeute: Anweisung in der Schachtelungsebene n; diese so gekennzeichneten Anweisungen sind 

jeweils in der Folgeabbildung in ihrer inneren Struktur dargestellt. 

Lies x, y, z 

[1] 

Schreibe w 

W F 

❳ 

❳ ❳ ❳ 

✘✘✘ 

❳ x > y 

❳ ❳ ❳ ✘✘✘ ✘✘✘ 

W F 

[2] [2] 

x > z ✏ 

✏✏✏ 

y > z ✏ 

W ✏✏✏F 

[3] [3] [3] [3] w ← x w ← z w ← y w ← z


(2.53) Algorithmus zum Sortieren: 

Bubble-Sort, deutsch sinngemäß: 

Sortieren durch Nachbarvertauschungen. 

Der Typ 

Ganzzahl-FELD[anzahl] 

bedeute ein Feld oder Array 

von anzahl Ganzzahl-Elementen; 

die Nummerierung laufe 

von 0 bis (anzahl-1). 

Entwicklung dieses Algorithmus 

und nähere Besprechung s. Vorlesung. 

Aufgabe: 

Zeichnen Sie ein Struktogramm 

zum nebenstehenden Algorithmus. 

ALGORITHMUS BubbleSort 

ANFANG 

VARIABLE nr TYP Ganzzahl 

VARIABLE vertauschung TYP Boolesch 

KONSTANTE anzahl TYP Ganzzahl WERT . . . 

VARIABLE zahlFeld TYP Ganzzahl-FELD[anzahl] 

Lies anzahl Zahlen, besetze damit zahlFeld 

TUE 

vertauschung ← falsch 

nr ← 0 

SOLANGE nr < anzahl−1 TUE 

nr ← nr + 1 

WENN zahlFeld[nr-1] < zahlFeld[nr] DANN 

Vertausche beide Zahlen 

vertauschung ← wahr 

SOLANGE vertauschung 

Schreibe zahlFeld 

ENDE 

(2.54) Prinzip der schrittweisen Verfeinerung 〈top-down-design〉: eine Zerlegungsform, die 

sich am Ablauf zur Problemlösung orientiert. Je Verfeinerungsstufe wird der Ablauf in kleinere 

Handlungseinheiten zerlegt, bis er nur noch aus Elementaralgorithmen besteht (d. h. 

Algorithmen, die der Prozessor direkt ausführen kann). In jedem Verfeinerungsschritt können 

die drei Algorithmenstrukturen Folge, Auswahl und Wiederholung eingesetzt werden. 

↑↑ Für manche Autoren sind ” schrittweise Verfeinerung“ 〈wörtlich: stepwise refinement〉 und 

” top-down-design“ nicht synonym. 

2.6 Operatoren, logische Verknüpfungen 

(2.60) Übb Dieses Unterkapitel befasst sich zunächst mit der Erläuterung von Operatoren (d. h. 

Symbole für Funktionen) und ihren Anwendungen (2.61). Danach werden spezielle Ausdrücke 

näher betrachtet, und zwar die logischen Ausdrücke oder Aussagen (sie können nur ” Wahr“ 

oder ” Falsch“ sein). Hierbei werden insbesondere die zugehörigen Operatoren vorgestellt 

(2.62ff.). Diese Begriffe werden in den Folgekapiteln auf die Sprache C ++ angewandt, sie werden 

dort für das Verständnis unbedingt benötigt. 

(2.61) 

(a) Ein Operator 〈operator〉 ist ein Symbol für eine Funktion, nämlich für eine eindeutige 

Zuordnungsvorschrift, und zwar zwischen einem oder mehreren Elementen, den sog. Operanden, 

und dem Ergebniswert. 

(b) Ein Ausdruck 〈expression〉 kann bestehen aus: 

• einer Konstanten (ohne Operator oder als Operand) oder 

• einer Variablen (ohne Operator oder als Operand) oder 

• einem Operator einschließlich der zugehörigen Operanden, 

dieses rekursiv beliebig tief geschachtelt. 

(c) Man unterscheidet die Operatoren z. B. anhand der Anzahl ihrer Operanden: 

(1) Ein Operator mit genau einem Operand heißt unär oder monadisch 〈unary〉. 

Unterschiedliche Schreibweise in Bezug auf Reihenfolge Operator und Operand (Operatorsymbol 

sei ⊛, Operand a): 

⊛a präfix 〈prefix〉 Bsp f(a), −a (Vorzeichen als Operator), 

a⊛ postfix 〈postfix〉 Bsp 

¬p (log. Negation, s. (2.63)) 

4! (Fakultät) 

(2) Ein Operator mit genau zwei Operanden binär oder dyadisch 〈binary〉. 

Schreibweise (Operatorsymbol sei ⊛, Operanden a, b): 

⊛ab präfix Bsp f(a, b), +(3, 4) 

a ⊛ b infix 〈infix〉 Bsp 5 + 6, 4 · 3 

ab⊛ postfix Bsp 5 6 +, vgl. manche HP-Taschenrechner ( ” umgekehrte polnische Notation“)


Manchmal wird ein binärer Operator gar nicht geschrieben, z. B. ab für a · b, oder nur 

durch unterschiedliche Schriftart der Operanden dargestellt, z. B. a b für den Operator 

Potenziation. 

(3) Ein Operator mit genau drei Operanden heißt ternär 〈ternary〉. 

(d) Treten mehrere unterschiedliche Operatoren in einem Ausdruck auf, so müssen Prioritäten 

oder Hierarchiestufen definiert sein; Operatoren höherer Priorität binden ihre Operanden 

stärker als die geringerer Priorität; diese Bindungen können allerdings durch explizite Klammerung 

() durchbrochen werden. 

Bsp Operatoren verschiedener Hierarchie: 7 + 5 · 3 ( ” Punktrechnung geht vor Strichrechnung“) – dagegen mit 

Klammerung anders: (7 + 5) · 3 

(e) Beim Auftreten von mehreren Operatoren gleicher Hierarchiestufe (oder der gleichen Operatoren) 

nebeneinander muss die Assoziativität (Bindungsrichtung) vereinbart sein, 

nämlich die Richtung, in der zusammengefasst werden soll: linksassoziativ (linksbindend), 

d. h. von links nach rechts zusammenzufassen (meist), oder auch rechtsassoziativ (rechtsbindend), 

d. h. von rechts nach links (seltener, in C ++/C jedoch bei einigen Operator-Hierarchiestufen). 

(2.62) 

(a) Definition der Begriffe Aussage und Wahrheitswert siehe unter (2.31). 

Die Wahrheitswerte WAHR und FALSCH sollen mit W und F abgekürzt werden. 

Bsp Aussage? Wahrheitswert, wenn Aussage? 

Die Sonne scheint jetzt in Emden. 

Kein Studierender lernt Informatik. 

1 = 2 

16 + 3 · 7 

Komm bitte her! 

Regnet es jetzt? 

(a + b) 2 = a 2 + 2ab + b 2 

16 > 17 

Am 1. 1. 2010 um 12 Uhr scheint in Emden die Sonne. 

Abkürzung für Aussagen (häufig): lat. Buchstaben (p, q, r, . . .). 

(b) Der TYP von Variablen, die einen Wahrheitswert annehmen können, soll logisch“ oder 

” 

” Boolesch“ genannt werden (nach Boole, brit. Mathematiker, vgl. Begriff Boolesche Alge- 

” 

bra“, d. h. Algebra mit Booleschen Werten). 

(2.63) Angewendet auf Aussagen, gibt es insgesamt vier verschiedene unäre Operatoren. 

↑↑ Es gibt zwei verschiedene Ausgangswerte W und F, jeder Wert kann auf zwei verschiedene 

Ergebnisse abgebildet werden: 2 2 verschiedene Operatoren. 

Interessant – neben der Identität – ist hier nur der Operator Nicht bzw. Verneinung, (logische) 

Inversion: er invertiert den Wahrheitswert seines Operanden. 

Zeichen: ¬p oder p. 

Wahrheitswerttabelle: 

p ¬p 

W F 

F W 

(2.64) Angewendet auf Aussagen, gibt es insgesamt 16 verschiedene binäre Operatoren. 

↑↑ Es gibt vier verschiedene Ausgangswert-Paare (W,W), (W,F), (F,W), (F,F); jedes Paar kann 

auf zwei verschiedene Ergebnisse abgebildet werden: 2 4 verschiedene Operatoren. 

(a) Vier dieser Operatoren sind hier wichtig: 

• Konjunktion, Und, Zeichen: ∧ 

• Disjunktion, (inklusives) Oder, Zeichen: ∨ 

• Antivalenz, exklusives Oder, Zeichen: ≻−≺ oder XOR oder ⊕ 

• Äquivalenz, Zeichen: ←→


(b) 

Zugehörige Wahrheitswerttabellen: 

p q p ∧ q p ∨ q p XOR q p ←→ q 

W W W W F W 

W F F W W F 

F W F W W F 

F F F F F W 

Die Und-Beziehung ist genau dann WAHR, wenn beide Operanden WAHR sind. 

Die (Inklusiv-)Oder-Beziehung ist genau dann FALSCH, wenn beide Operanden FALSCH 

sind. 

Die Antivalenz- oder Exklusiv-Oder-Beziehung ist genau dann WAHR, wenn beide Operanden 

verschiedene Wahrheitswerte haben. In deutsch genauer: entweder . . . oder . . . 

Die Äquivalenz-Beziehung ist genau dann WAHR, wenn beide Operanden die gleichen 

Wahrheitswerte haben. 

(1) Alle vier Operatoren aus (a) sind – soweit ohne Kurzschlussverfahren (b2) – kommutativ 

und, wenn ungemischt, assoziativ. 

(2) Bei den Operatoren Und und (Inlusiv-)Oder wird in manchen Programmiersprachen das 

Kurzschlussverfahren angewendet: in einem Und-Ausdruck bzw. einem Oder-Ausdruck 

wird der rechte Operand nur dann ausgewertet, wenn der Ergebniswert nicht schon bereits 

durch den Wert des linken Operanden feststeht: 

• Bei dem Operator Inklusiv-Oder steht der Ergebniswert fest (W), wenn der erste Operand 

W ist; der Wert des zweiten Operanden spielt keine Rolle mehr. 

• Bei dem Operator Und steht der Ergebniswert fest (F), wenn der erste Operand F ist; 

auch hier spielt der Wert des zweiten Operanden keine Rolle mehr. 

In Falle der Ausnutzung des Kurzschlussverfahrens sind daher die beiden Operatoren Und 

und Oder nicht kommutativ △! – im Gegensatz zu (b1). 

Bsp Die Hierarchiestufen der in diesem Beispiel benutzten Operatoren seien folgendermaßen festgelegt (fallende 

Hierarchie, je Zeile mit gleicher Priorität): 

/ (Division) 

> = = (= sei der Operator für den Test auf Gleichheit) 

∧ ∨ 

Der Ausdruck a = 0 ∧ b/a > 3 ist nur dann immer auswertbar, wenn das Kurzschlussverfahren 

garantiert ist, da sonst ggf. eine Division durch Null versucht wird, nämlich bei a = 0 FALSCH. 

Der Ausdruck a = 0 ∨ b/a > 3 ist ebenfalls nur bei garantiertem Kurzschlussverfahren immer 

auswertbar, da sonst eine Division durch Null (bei a = 0 WAHR) vorkommen würde. 

△! 

Schwierig wird die Übersicht bei garantiertem Kurzschlussverfahren, wenn der rechte Operand 

zusätzliche Wirkungen hat ( Seiteneffekte“, (Kap. 3.3)), z. B. bei folgendem Ausdruck: 

” 

b > 0 ∧ (liesZahl()< 10) 

(liesZahl() lese eine Zahl ein und gebe deren Wert zurück), 

da im Falle b > 0 WAHR die Zahl gelesen würde, im Falle FALSCH nicht. 

Anm Die Sprachen C ++/C garantieren bei den Operatoren Und und (Inklusiv-)Oder das Kurzschlussverfahren; 

bei Pascal darf der Compiler so verfahren, muss es aber nicht. 

(c) De-Morgansche Gesetze: 

p ∧ q ←→ p ∨ q p ∨ q ←→ p ∧ q 

Die Verneinung einer Und-Beziehung wird zur Oder-Beziehung der verneinten Operanden 

und umgekehrt. 

(d) Vereinfachung von komplexeren Booleschen Ausdrücken: Anwenden von Logik-Regeln (s. 

Lehrbücher Formale Logik) oder Karnaugh-Veit-(KV-)Diagramme (s. Digitale Elektronik).


3 Erste Schritte mit C ++ 


Dieses Kapitel soll einen ersten Einstieg in sehr einfache C ++-Programm bieten. Hier wird begonnen, 

die C ++-Syntax zu erläutern, ferner die grundlegenden Datentypen. Das Unterkapitel 

3 erläutert mögliche Wirkungen von Ausdrücken zur Laufzeit (Haupteffekt, Seiteneffekt); 

die häufige Benutzung dieser Begriffe ist sicher eine Eigenart dieses Kurses (im Gegensatz 

zu fast allen Lehrbüchern). 

3.1 Die ersten Programme 

(3.10) Übb Nach der Vorstellung von zwei sehr einfachen, aber vollständigen C ++-Programmen 

wird die formale Seite dieser Programme, nämlich die Syntax, näher beschrieben. Es ist für 

Sie später sehr viel einfacher, wenn Sie sich gleich mit dieser Art der Syntax-Beschreibung 

(einer modifizierten BNF-Notation, s. (Kap. 0.1)) vertraut machen und anhand der Syntaxbeschreibung 

die formale Seite der Beispielprogramme nachvollziehen können. In der Vorlesung 

wird dieses noch ausführlicher erläutert als hier angegeben. 

(3.11) // Mein erstes Programm in C++ (Beispieldatei D03-11.CPP) 

#include 


int main() 

{ 

cout radius >> hoehe; 

volumen=radius*radius*pi*hoehe/3; 

cout


(b) 54 ZusammengesetzteAnweisung { Anweisung0..n } 

50T eil Anweisung 

ZusammengesetzteAnweisung 

51 AusdrucksAnweisung [NV] 

Variable = Ausdruck ; | 

| 

C++ cout [- > Variable ]- 1..n ; 

| 

| AusdrucksAnweisung 

| 

| DeklarationsAnweisung 

Anm1 Semantik des Zuweisungsausdrucks (oben erste Alternative): Der Ausdruck rechts des Zuweisungsoperators 

= wird im Wert berechnet und der Variablen links des Operators zugewiesen. 

Die Denkrichtung ist demnach hier von rechts nach links – ähnlich wie bei aufgelösten Formeln 

in der Mathematik oder den Naturwissenschaften. 

Anm2 Die Ausgabe auf Bildschirm geschieht mit einer cout-Anweisung (oben zweite Alternative). 

Zur Erzeugung eines Zeilenvorschubs kann als spezieller Ausdruck endl gegeben werden. 

↗ Genaueres s. (5.22). 

Anm3 Die Eingabe von der Tastatur wird mit einer cin-Anweisung durchgeführt (oben dritte Alternative). 

↗ Genaueres s. (5.21). 

Beispiele für 57/11usf . DeklarationsAnweisung: 

int VarName ; 

double NochEinVarName ; 

double VarName1, VarName2 ; 

Anm4 Durch die obigen DeklarationsAnweisungen wird zur Laufzeit Speicherplatz für eine int- 

Variable und für drei double-Variablen unter den angegebenen Namen bereitgestellt. Genaueres 

zu den Typen int und double s. (Kap. 3.2). 

(c) Name, Bezeichner 〈name, identifier〉 Buchstabe [- Buchstabe | 

| 

Anm C/C++ unterscheidet Klein- und Großbuchstaben; aufpassen! 

| 

| Dezimalziffer ]- 0..n 

Empf Auch zu Anfang eines Namens zwar Unterstrich erlaubt; besser jedoch nicht, da sonst Kollision 

mit compiler-internen Namen möglich. 

Buchstabe A 

| 

| B 

| 

| C 

| 

| ... | 

| Z 

Dezimalziffer 0 | 

| 1 | 

| 2 | 

| ... | 

| 9 

| 

| a 

| 

| b 

| 

| ... | 

| z 

(3.14) Kommentare, werden vom Compiler ignoriert, dienen aber der Übersichtlichkeit für den 

menschlichen Leser: 

C++ // . . . Zeilenende-Kommentar 

C/C++ /* . . . */ allg. Kommentar, auch über mehrere Zeilen oder Zeilenteil 

(3.15) Zur Anweisung return 0; am Ende des Programms: 

Rücksprung mit Wert 0 (meist die Bedeutung: ” ohne Fehler“) zum programmaufrufenden Prozess, 

i. a. zum Betriebssystem. Ein Fehlen wird bei älteren Compilern (fälschlicherweise) ignoriert, bei 

[NErl] C++(neu) wird die Anweisung automatisch hinzugefügt, wenn nötig. 

3.2 Einfache Datentypen, Zeichenketten, Operatoren 

(3.20) Übb (Daten-)Typ: ein Name oder eine Beschreibung für Wertemenge mit zugehörigen 

erlaubten Operationen, vgl. Bemerkungen zu TYP in (2.25a2). 

In diesem Unterkapitel werden einfache (d. h. nicht zusammengesetzte) Datentypen beschrieben; 

wichtig ist es, dass Sie bei den vielen möglichen Typen das Grundprinzip der 

Namensbildung und die Bedeutung verstehen, ferner eine Vorstellung erhalten (und sie 

behalten) über die zugehörigen Wertebereiche. In diesem Zusammmenhang lohnt es sich, 

einen Wiederholungs-Blick auf (Kap. 1.4) zu werfen. Ferner werden hier die wichtigsten Operatoren, 

die auf diese Grundtypen angewandt werden können, kurz erläutert. Ohne nähere 

Typ-Erläuterung (die erst viel später kommen wird) wird auch die Zeichenketten-Konstante 

vorgestellt.


(3.21) 

(a) Beipiele für einfache Datentypen: 

• Ganzzahlen: 

◦ ” Zeichen“, meist als sehr kleine Ganzzahlen: 

char 

signed char 

unsigned char 

◦ kleine Ganzzahlen (selten benutzt): 

Synonyme: short int, short, signed short, signed short int 

Synonyme: unsigned short int, unsigned short 

◦ ” normale“ Ganzzahlen: 

Synonyme: int, signed int, signed 

Synonyme: unsigned int, unsigned 

◦ große Ganzzahlen: 

Synonyme: long int, long, signed long int, signed long 

Synonyme: unsigned long int, unsigned long 

◦ △! Achtung bei vorzeichenlosen Typen: große Gefahr (Typumwandlungen, Bereichsüberschreitungen), 

vgl. (1.44c)!! ↑↑ Näheres s. (Cpp/Kap. 7). 

• Gleitkommazahlen (in aufsteigender Genauigkeit): 

◦ float 

◦ double (als ” normaler“ Gleitkommatyp) 

◦ long double 

(b) Speicherbreite, Zahlenbereich 

Typ Speicherbreite vorzeichenbehaftet vorzeichenlos 

(i. a.) (Annahme Zweierkomplement) 

char 1 Byte −128 . . . 127 0 . . . 255 

short int, 2 Byte −2 15 . . . 2 15 − 1 0 . . . 2 16 − 1 

int (Anm1) (−32 768 . . . 32 767) (0 . . . 65 535) 

long int, 4 Byte −2 31 . . . 2 31 − 1 0 . . . 2 32 − 1 

int (Anm1) (−2 147 483 648 . . . 2 147 483 647) (0 . . . 4 294 967 295) 

Anm1 Der Typ int – als Standard-Ganzzahltyp – ist (i. a.) je nach Implementierung eine 2-Byte- 

Zahl (wie oben short int) oder eine 4-Byte-Zahl (wie oben long int). 

Anm2 Die oben angegebenen Speicherbreiten sind jeweils die geforderten Mindestbreiten; die Implementierung 

darf genauere Darstellungen wählen. 

Anm3 signed char ist vorzeichenbehaftet, unsigned char ist vorzeichenlos; char jedoch je nach 

Implementation bzw. Prozessor vorzeichenbehaftet (meist) oder vorzeichenlos (seltener). Alle 

drei Typen gelten als verschieden. 

Bei Compilern für Intelprozessoren ist der Typ char i. a. vorzeichenbehaftet. 

Anm4 Die drei char-Typen haben eine gewisse Zwitterstellung: arithmetisch sind sie schmale Ganzzahltypen, 

bei Ein-/Ausgabe (mit cin/cout) sind sie Zeichen. 

(3.22) GanzzahlKonstante - + 

- - opt ZiffF Suffixopt 

ZiffF Dezimalziffernfolge 

Suffix: u oder U: unsigned, l oder L: long, beides: unsigned long, 

fehlend: int, wenn vom Zahlenbereich her passend 

↑↑ Genaueres s. (Cpp/7.5) 

Interpretation (NUR bei Ganzzahl, nicht bei Gleitkommazahl): 

• dezimal, wenn ohne führende Null, 

• △! oktal, wenn mit führender Null, 

• hexadezimal, wenn mit führendem 0x oder 0X. 

(3.23) GleitkommaKonstante 

+ 

- - - opt - ZiffF.ZiffFopt 

 

- ExpTeilopt Suffixopt 

 

.ZiffF 

+ 

- - - opt ZiffF ExpTeil Suffixopt 

| 

|


ExpTeil - e E 

 

- - 

+ 

- 

 

- opt ZiffF 

Suffix: fehlend: double, f oder F: float, l oder L: long double 

(3.24) Operatoren – Begriffe s. (2.61c): 

• unär präfix für Ganz- und Gleitkommazahlen: 

+ - (Op3ef: Vorzeichenoperatoren) 

• binär infix für Ganzzahlen: 

* / % (Op5abc: Multiplikation, Division, Divisionsrest) 

+ - (Op6ab: Addition, Subtraktion) 

• binär infix für Gleitkommazahlen: 

* / (Op5ab: Multiplikation, Division) 

+ - (Op6ab: Addition, Subtraktion) 

Hierarchie: eine kleinere Op-Nummer (z. B. Op5) soll hier stärker als eine größere Nummer 

(z. B. Op6) binden; diese Nummern beziehen sich auf die Hierarchiestufen, allg. Übersicht s. 

(Cpp/Kap. 2) und (5.11). 

Zum Durchbrechen von Zusammenfassungsregeln werden runde Klammern benutzt. 

Bsp 5 + 7 ∗ 3 bedeutet: zu 5 wird das Produkt aus 7 und 3 addiert. 

(5 + 7) ∗ 3 bedeutet: die Summe 5+7 wird mit 3 multipliziert. 

Implizite Typanpassung bei binären Operatoren: 

Wenn nicht beide Operanden vom gleichen Typ, so wird einer der Typen in den Typ des 

anderen umgewandelt, das Ergebnis ist vom umgewandelten Typ; Umwandlungsrichtung: 

Ganzzahl zu Gleitkommazahl, schmalerer Typ zu breiterem Typ. 

↑↑ Genauere Regeln s. (Cpp/Kap. 7) – △! bei unsigned-Typen!! 

(3.25) ZeichenKonstante ’ Zeichen ’ 

ZeichenkettenKonstante " Zeichen0..n " 

Zeichen: (fast) jedes darstellbare Zeichen (auch Leerzeichen), dazu: 

\" statt " (insbesondere bei ZeichenkettenKonstante) 

\’ statt ’ (insbesondere bei ZeichenKonstante) 

\\ statt \ 

\n als ” NeueZeile-Zeichen“ – unabhängig von betriebssysteminterner Darstellung 

dazu einige andere ” Zeichen“ 

(3.26) Spezialfall der DeklarationsAnweisung: 

KonstantenDefinition [NV] const Typ KonstantenName = KonstAusdruck ; 

Anm Initialisierung MUSS erfolgen! Spätere Zuweisung nicht möglich – würde der Konstantheit 

widersprechen! 

(3.27) Zusammengesetzte Zuweisungsoperatoren, s. Op16b-k: 

Es gilt: a op= b 

ist äquivalent zu: a = a op ( b ) mit op einer der angegebenen binären Operatoren. 

3.3 Ausdrücke, Seiteneffekte 

(3.30) Übb Dieses Unterkapitel wird Ihnen vermutlich auch nach der (ersten) Erläuterung in der 

Vorlesung immer noch schwierig erscheinen. Den Begriff Seiteneffekt finden Sie in fast allen 

C ++/C-Lehrbüchern, den Begriff Haupteffekt (als den dazugehörigen anderen Effekt) 

jedoch vermutlich nicht. Wenn Sie jedoch begriffen haben, dass ” Haupteffekt“ nur ein anderer 

Name für ” Wert (eines Ausdrucks)“ ist und dass ” Seiteneffekt“ jede ggf. vorhandene 

zusätzliche Wirkung zur Laufzeit ist, dann werden Sie erkennen, dass viele Besonderheiten 

der Sprachen C ++/C sehr einfach beschreibbar sind, die sonst – ohne diese Begriffe – 

wesentlich umständlicher zu erläutern sind. 

↗ Einfachere Beschreibung (wenn ” Haupteffekt“ und ” Seiteneffekt“ verstanden sind) z. B. an 

folgenden Stellen (bitte noch nicht beim ersten Lesen nachverfolgen, jedoch beim späteren 

Wiederholen sicher lohnend!): (2.64b2 Bsp, 3.32b,d,e, 4.31c, 4.43, 5.12, 5.13, 5.21 Anm3, 5.22 Anm3, 5.24d, 

5.25c) und weitere Stellen.


(3.31) In C ++/C ist ein Ausdruck definiert durch (Definition nicht vollständig, vgl. (2.61b)): 

(3.32) Bsp 

Ausdruck 

Konstante 

| 

| Variable 

( Ausdruck ) | 

| 

| 

FunktionsAufruf (7.12) | 

UnärPräfixOperator Ausdruck 

Ausdruck BinärOperator Ausdruck 

| 

| 

| 

| Ausdruck UnärPostfixOperator 

Bei Ausdrücken sind (häufig) zwei verschiedene Wirkungen zu unterscheiden: 

• Haupteffekt – als anderes Wort für Wert des Ausdrucks (fast immer vorhanden). 

Bsp Ausdrücke mit Haupteffekt (Wert), aber ohne Seiteneffekt (i sei eine initialisierte Variable): 

34 

i 

(i-17)/5 

• Seiteneffekt, Nebeneffekt – sonstige Wirkung(en) des Ausdrucks (nicht immer vorh.), 

z. B. Wertänderung Variable, Ausgabe Bildschirm, Einlesen, Aufruf Funktion. 

Der Begriff ” Seiten. . .“ bedeutet nicht, dass es sich hierbei um unwichtige, nicht gewollte 

Wirkungen handelt; nein, wenn Ausdrücke Seiteneffekte haben, sind diese gewollt! 

Bsp Ausdrücke mit Seiteneffekt (die durch ein nachgestelltes Semikolon zu einer Ausdrucksanweisung 

(3.32a) gemacht werden können): 

cout > i (Eingabe) 

(a) 51 AusdrucksAnweisung Ausdruckopt ; 

• Haupteffekt unwichtig (wird verworfen), 

daher Ausdrucksanweisung i. a. nur sinnvoll, wenn Seiteneffekt vorhanden (häufig: Zuweisungsausdruck, 

Funktionsaufruf), 

andere Benutzung: als Leeranweisung (Ausdruck fehlend), wenn Anweisung syntaktisch gefordert, 

aber nichts zu tun ist. 

(b) ZuweisungsAusdruck Variable = Ausdruck ( = Op16a ) 

• Haupteffekt: Wert (und Typ) der Variablen nach der Zuweisung, 

• Seiteneffekt: Variable erhält Wert des Ausdrucks. 

(c) ZuweisungsAnweisung Variable = Ausdruck ; 

(Spezialfall der 51 AusdrucksAnweisung) 

• Haupteffekt (der gesamten Zuweisung) unwichtig, 

• Seiteneffekt wichtig: Wertzuweisung. 

(d) Zuweisungskette: Var1 = Var2 = Var3 = 25 ; 

Assoziativität von rechts nach links (Op16), daher Interpretation: 

Var1 = (Var2 = (Var3 = 25)) ; 

Beim inneren Zuweisungsausdruck Var3 = 25 ist auch der Haupteffekt wichtig, da er den Ausdruck- 

Wert für die Zuweisung an Var2 darstellt; der Haupteffekt des Zuweisungsausdrucks Var2 = (. . . ) 

ist der Ausdruck-Wert für die Zuweisung an Var1. Nur der Haupteffekt des Zuweisungsausdrucks 

Var1 = (. . . ) ist unwichtig, er wird verworfen. 

(e) Inkrement-, Dekrementoperator (unär präfix Op3ab und postfix Op2fg): ++ -- 

• Seiteneffekt: Wertänderung des Operanden um +1 bzw. -1 – unabhängig, ob präfix oder 

postfix!! 

• Haupteffekt (hierbei streng Präfix- und Postfixstellung zu unterscheiden!!): 

◦ postfix: alter Wert des Operanden, 

◦ präfix: neuer Wert des Operanden. 

(3.33) △! Der Zeitpunkt der Ausführung von Seiteneffekten ist nicht festgelegt (implementationsabhängig)!! 

Sicher sind alle Seiteneffekte abgearbeitet, wenn Anweisung beendet 

ist. 

△! Keine Ausdrücke formulieren, deren Wert vom Zeitpunkt bzw. der Reihenfolge der 

Ausführung von Seiteneffekten abhängt! 

| 

|


4 Algorithmenstrukturen in C ++ 


Die in (Kap. 2) sprachunabhängig eingeführten drei wichtigen Algorithmus-Grundstrukturen 

werden hier auf die Sprache C ++ übertragen. Sie lernen hier alle durch C ++ unterstützten 

Formen von Folge, Auswahl und Wiederholung kennen. Ohne dieses Rüstzeug ist es 

kaum möglich, ein C ++-Programm zu schreiben. 

Nach einem Beipielprogramm werden dann in Unterkapitel 7 äußerst wichtige Grundregeln 

für das Schreiben von Programmen erläutert, die das Lesen beträchtlich erleichtern, nämlich 

Regeln für das Erzeugen von Namen und das Lay-out. Diese Regeln werden den ganzen 

Kurs über und auch für mögliche Folgekurse Gültigkeit haben. 

4.1 Folge (Sequenz), Gültigkeitsbereich in Blöcken 

(4.10) Übb Es wird der Begriff Block im Sinne einer zusammengesetzten Anweisung eingeführt. 

Das zugehörige geschweifte Klammernpaar ist in C ++/C sehr häufig anzutreffen. In diesem 

Zusammenhang werden weitere Begriffe (Gültigkeitsbereich, Verdeckung und lokale Namen) 

erläutert; ausführlicher wird dieses später in (7.15) geschehen. 

(4.11) Die (schachtelungsfähige) Folge (Kap. 2.2) wird in C ++ durch den Block verwirklicht: 

54 ZusammengesetzteAnweisung (oder Verbundanweisung, Block) C++ 

{Anweisung0..n} 

(4.12) Innerhalb eines Blocks deklarierte Namen werden lokale Namen genannt. Ihr Gültigkeitsbereich 

〈scope〉 (Bereich, in dem dieser Name existiert), erstreckt sich vom Deklarationspunkt 

bis zum Ende dieses Blocks. 

Ein Name kann in untergeordneten Blöcken verdeckt werden, indem er dort neu deklarariert 

wird; nach Austritt aus einem solchen untergeordneten Block ist der Name in der alten 

Bedeutung (bei Variablen: auch mit altem Wert) wieder verfügbar. 

↗ Einzelheiten s. (7.15). 

(4.13) Lokale Variable (Variable, die innerhalb eines Blocks definiert werden z. B. innerhalb von 

main()) haben meist keinen bestimmten Anfangswert, sondern ein ” zufälliges“ Bitmuster. 

Daher müssen solche Variable vor einem lesenden Zugtiff einen definierten Wert erhalten. 

↗ Genauer: eigentlich sind oben automatische Variable (8.13) gemeint. Ausnahmen sind Objekte 

mit sinnvoll gebauten Konstruktoren (9.21), ferner statische Variable (8.12). 

4.2 Boolesche Ausdrücke, Datentyp bool 

(4.20) Übb Im Gegensatz zu C und C++(alt) gibt es in C++(neu) den Booleschen Datentyp; er 

hat nur zwei möglich Werte, nämlich WAHR und FALSCH. Sie sollten diesen Typ viel 

benutzen, wenn nur zwei verschiedene Werte möglich sind, und nicht den Ersatztyp int für 

C-Programmierer. 

Die Boolschen Ausdrücke und ihre Verknüpfungen treten häufig auf; sie sind zur Formulierung 

von Auswahl- und Wiederholungsanweisungen nötig. 

(4.21) Datentypen für Bedingung bzw. Aussage, vgl. (2.31, 2.62). 

(a) C++(neu) Datentyp bool; der Wertevorrat besteht nur aus den beiden Konstanten true und 

false. 

Wenn nötig, geschieht eine implizite Umwandlung eines arithmetischen Ausdrucks in bool, 

und zwar ein Wert ungleich 0 in true und ein Wert gleich 0 in false, vgl. (4.23).


Umgekehrt wird ein Ausdruck des Typs bool, wenn nötig, in eine Ganzzahl des Typs int 

umgewandelt, und zwar true in 1 und false in 0. 

(b) Dagegen C C++(alt) : Ein Boolescher Ausdruck hat den Typ int, und zwar bei WAHR den 

Wert 1, bei FALSCH den Wert 0. 

(4.22) C/C++ : Verknüpfung von numerischen Ausdrücken zu Booleschen Ausdrücken: 

Op8: NumAusdruck < NumAusdruck NumAusdruck NumAusdruck NumAusdruck >= NumAusdruck 

Op9: NumAusdruck == NumAusdruck NumAusdruck != NumAusdruck 

(== Test auf Gleichheit) (!= Test auf Ungleichheit) 

△! Ein ” beliebter“ Fehler ist die Verwechselung der beiden Operatoren = und ==: 

Op16a: = Operator für Zuweisung (und auch häufig für Initialisierung) 

Op9a: == Operator für Test auf Gleichheit 

(4.23) C/C++ : Jeder numerische Ausdruck kann logisch (Boolesch), d. h. als Bedingung interpretiert 

werden; ein Wert ungleich 0 gilt als WAHR, ein Wert gleich 0 als FALSCH. 

(4.24) C/C++ : Boolesche Werte (und logisch zu bewertende numerische Ausdrücke) können weiter 

zu Booleschen Ausdrücken kombiniert werden (2.63, 2.64): 

Op13: BoolAusdruck1 && BoolAusdruck2 logisches Und 

Op14: BoolAusdruck1 || BoolAusdruck2 logisches Inklusiv-Oder 

Op3d: ! BoolAusdruck logische Negation 

Zu den beiden binären Operatoren && und || (Op13/14): 

Anm1 Hierbei ist die Berechnung nach dem Kurzschlussverfahren garantiert, d. h. der rechte Ausdruck 

BoolAusdruck2 wird nur dann bewertet, wenn der Wert des Gesamtausdrucks nicht 

schon durch die Bewertung des linken Ausdrucks BoolAusdruck1 feststeht. Wegen des Kurzschlussverfahrens 

sind diese beiden Operatoren nicht kommutativ; ohne Kurzschlussverfahren 

wären sie dagegen kommutativ. Vgl. auch die allgemeine Erörterung in (2.64b2). 

Anm2 Ausnahme zu (3.33): Es ist garantiert, dass auch sämtliche Seiteneffekte von BoolAusdruck1 

abgearbeitet sind, bevor – gegebenenfalls – BoolAusdruck2 bewertet wird. 

(4.25) Ein Ausdruck beispielsweise der Form 

12 < x


Anm1 Eine 99 Bedingung kann jeder Boolesche (logische) Ausdruck sein; zusätzliche Möglichkeit s. 

(4.51). 

Anm2 Als 50 Anweisung kann wiederum jede Anweisung genommen werden: beliebige Schachtelung 

– vgl. Kapitel 2.5! Zur Auflösung von Mehrdeutigkeiten s. a. (b). 

Anm3 Bitte beachten: Anweisung steht im Singular, d. h. es muss (jeweils) genau ein Anweisung 

stehen. 

• Falls mehrere Anweisungen benötigt werden, werden sie zu einem Block (4.11) umschlossen; 

dieser Block wirkt syntaktisch als eine Anweisung. 

• Falls keine Anweisung benötigt wird, ist eine Leeranweisung zu nehmen, z. B.: 

; // Ausdrucksanweisung ohne Ausdruck (3.32a) 

{ } // Block mit null Anweisungen (4.11) 

(b) Schachtelt man ein- und zweiseitige Auswahl, so wird in der textuellen Form die Zugehörigkeit 

des SONST-Zweiges durch Einrückung unterschieden: bei Version A gehört der SONST- 

Zweig zum äußeren WENN, bei Version B zum inneren WENN: 

// Version A 

WENN Bedingung-Außen DANN 

WENN Bedingung-Innen DANN 

Dann-Anweisung-Innen 

SONST 

Sonst-Anweisung-Außen 

// Version B 




SONST 

Sonst-Anweisung-Innen 

Da der C ++-Compiler jedoch unabhängig vom Lay-out arbeitet, wird die Mehrdeutigkeit 

durch folgende Regel aufgelöst: 

Ein else gehört immer zum letzten if, welches selbst noch kein else hatte. 

△! Daher wird – durch den C ++-Compiler – Version A genauso interpretiert wie Version 

B: der SONST-Zweig gehört zum inneren WENN. Um dem C ++-Compiler die Interpretation 

entsprechend dem Lay-out von Version A aufzuzwingen, muss die innere einseitige Auswahl 

maskiert werden, so dass sie formal nach außen nicht wie eine Auswahl wirkt: 

// Version C – nötig für C ++-Compiler 


ANWEISUNGSKLAMMER 



ENDE ANWEISUNGSKLAMMER 

SONST 

Sonst-Anweisung-Außen 

Diese Klammerung von Anweisungen geschieht in C ++ durch die ZusammengesetzteAnweisung 

(4.11), d. h. durch Einschließen in ein Paar geschweifter Klammern { }. 

(c) △! Als Bedingung ist hier wegen seines Haupteffektes (3.32b) auch ein Zuweisungsausdruck 

erlaubt; davon wird für Anfänger dringend abgeraten. Meist wird unabsichtlich eine 

Zuweisung statt eines Vergleichs ( ” =“ statt ” ==“) geschrieben. 

Bsp int i; cin >> i; 

if (i = -1) cout


- default : Anweisung1..n 

 

- opt 

} 

Semantik: 

• Zuerst Bewertung Ausdruck, 

• dann Sprung zur case-Marke mit gleichem Wert, wenn vorhanden, 

• sonst Sprung zur Marke default, wenn vorhanden, 

• sonst sofort Fortsetzung hinter switch-Anweisung. 

△! Die switch-Anweisung ist in C ++ und in C NUR ein Sprungschalter zum Hineinspringen, 

nicht zum Hinausspringen. Zur Nachbildung einer Mehrfachauswahl darf die 

Heraussprung-Anweisung 53 break; nicht vergessen werden!! Näheres zu dieser Anweisung 

s. (4.44a). 

Bsp Herausfiltern der Zahlen 0 bis 3 und sonstiger Eingaben: 

int zahl; 

cin >> zahl; 

switch (zahl) { 

case 1: cout


◦ Haupteffekt unwichtig, 

◦ sinnvoll daher nur, wenn Seiteneffekt vorhanden, z. B. Zuweisung, 

◦ wird genau einmal zu Beginn durchgeführt, 

◦ darf fehlen. 

• Danach Test von Bedingung2 (Einsprungbedingung) 

◦ Haupteffekt wichtig: 

bei Wert true Einsprung in Schleifenanweisung Anweisung (kopfgesteuerte Schleife!), 

sonst Verlassen der for-Anweisung, 

◦ fehlend: Bedeutung true (Endlosschleife). 

• Nach jedem Schleifendurchlauf Bewertung von Ausdruck3 (Reinitialisierung) 

◦ Haupteffekt unwichtig, 

◦ sinnvoll daher nur bei Seiteneffekt, 

◦ wird immer nach jedem Schleifendurchlauf bewertet, ehe (erneut) Bedingung2 geprüft 

wird, 

◦ darf fehlen. 

Anm1 Eine for-Anweisung ist daher äquivalent zu folgendem Konstrukt (Ausnahme nur bei Benutzung 

der Anweisung continue;, s. (4.44b)): 

Ausdruck1 ; 

while ( Bedingung2 ) { 

Anweisung 

Ausdruck3 ; 

} 

Anm2 Erweiterung für Ausdruck1 s. (4.51c): EinfacheDeklaration. 

Bsp Programmfragment für die zweimalige Ausgabe der Zahlen 0 bis 99: 

int i; 

for (i=0; i


(4.51) 

(a) C/C++ Bei der 60 if-Anweisung und bei allen drei 56 Wiederholungsanweisungen ist für Bedingung 

bzw. Ausdruck als Einstiegsbedingung ein BoolescherAusdruck oder ein logisch zu 

bewertender NumerischerAusdruck (4.23) einsetzbar. 

(b) C++(neu) Bei den Anweisungen 

• 60 if-Anweisung, 

• 61 switch-Anweisung, 

• 70 while-Anweisung, 

• 72 for-Anweisung, 

d. h. bei allen Kontrollstrukuren außer bei der 71 do-while-Anweisung gibt es eine weitere 

Möglichkeit, die 99 Bedingung: 

TypSpezifizierer1..n Deklarator = Ausdruck 

– mit anderen Worten eine Definition einer Variablen mit Initialisierung. 

Der Gültigkeitsbereich dieser Variable ist der Bereich nur innerhalb der Kontrollstruktur. 

Diese Variablendefinition ist bei der 71 do-while-Anweisung nicht erlaubt; eine solche Möglichkeit 

wäre auch sinnlos, da die Definition nach der Benutzung erfolgen müsste. 

(c) C++ Zusätzlich ist als Initialisierungsteil einer for-Anweisung eine 11 EinfacheDeklaration 

erlaubt. 

4.6 Beispiel 

△! Der Gültigkeitsbereich dieser Variablen ist je nach C++(alt) oder C++(neu) verschieden: 

• C++(alt) normale Einführung einer Variablen, Gültigkeitsbereich auch hinter der Kontrollstruktur, 

• C++(neu) Gültigkeitsbereich nur innerhalb der Kontrollstruktur, vgl. (Str3/Kap. 6.3.3.1). 

△! Der Compiler Microsoft Visual C ++ 6.0 gilt in diesem Fall – wohl ausnahmsweise – als 

C++(alt) . 

Bei C++(alt) ist eine Nachahmung des neuen Verhaltens einfach möglich durch Eingrenzen 

der gesamten Kontrollstruktur in einen Block. 

(4.60) Übb Es lohnt sich, das Beispielprogramm genauer anzusehen und den Algorithmus Zeile 

für Zeile mit dem Pseudocode zu vergleichen (s. Aufg. 1 in den Übungen zu Kap. 2, 

auch im Internet verfügbar). Wenn Sie das Programm ausprobieren wollen: wie alle Skript- 

Beispielprogramme ist auch dieses im Internet verfügbar. 

(4.61) // Gregorianischer Kalender (Beispieldatei D04-61.CPP) 

// s. Übungen zu Kap. 2 (Algorithmen), Aufg. 1 

// Eingabe als Ganz-Zahlen: Tag Monat Jahr 

#include 


int main() 

{ 

int tag, monat, jahr, 

jahrH, jahrR, hilf, woTagZahl; 

cin >> tag >> monat >> jahr; 

if (monat < 3) { 

monat += 10; 

--jahr; 

} 

else monat -= 2; 

jahrH = jahr/100; 

jahrR = jahr%100;


} 

hilf = tag + jahrR - 2*jahrH; 

hilf += (13*monat-1)/5; 

hilf += jahrR/4 + jahrH/4; 

while (hilf < 0) hilf += 7; 

woTagZahl = hilf%7; 

switch (woTagZahl) { 

case 0: cout


(4.72) Symbolische Konstanten sind für eine gute Programmierung sehr wichtig, da sie ” magische 

Zahlen“ vermeiden. Magische Zahlen verschleiern ihre eigene Bedeutung, selbstdokumentierende 

Namen dagegen betonen sie. 

Bsp Nicht jeder ahnt bei einem Auftreten der Konstanten 6.28, dass vielleicht 2π gemeint sein könnte; bei 

zweiPi ist dieses jedoch klar. Ein späteres Einsetzen eines genaueren Zahlenwertes für 6.28 ist fast 

unmöglich, bei der symbolischen Konstante jedoch ganz einfach. 

Symbolische Konstanten werden am besten mit einer Konstantendefinition (const . . . (3.26)) 

eingeführt. Makros (5.72a) sollten vermieden werden; Aufzählungskonstanten (12.21) dagegen 

können manchmal gut eingesetzt werden, s. a. Zusammenstellung in (10.11). 

Zu symbolischen Konstanten als Arraygrenzen s. (5.44). 

(4.73) Empf Lay-out, Textgestaltung, vgl. (2.51) – für Sie ein Muss! – 

(a) Allgemeine Regeln für das Lay-out: 

• Ein gutes Lay-out ist für den Compiler unwichtig, es ist jedoch überlebenswichtig für 

den Programmierer! Sinn: Übersichtlichkeit! 

• Jede Anweisung in einer eigenen Zeile mit passender Einrückung. 

• Wenn die Anweisung zu lang für eine Zeile ist: Fortsetzung einrücken; 

Ausnahme: else nicht einrücken, sondern unter zugehöriges if positionieren, auch sogar 

mehrfach bei if-else-if-Kette. 

• Sehr problematisch ist die do-while-Schleife; das while sollte nicht am Zeilenanfang 

stehen, da sonst sehr leicht Verwechselung mit while-Anweisung, vgl. (4.42Anm2). 

• Einrückungen: je Stufe 3 bis 4 Spalten (Zeichenpositionen), später mit größerer Erfahrung 

nur 2 Spalten. 

• Block (ZusammengesetzteAnweisung): 

ÜbergeordneterText { 

//...... 

//...... 

} 

Öffnende Klammer: am Zeilen-Ende von ÜbergeordneterText, 

schließende Klammer: am Zeilen-Anfang in gleicher Position wie Anfang von ÜbergeordneterText. 

Ausnahme: Funktionsblöcke, z. B. main(): öffnende Klammer am Zeilenanfang der Folgezeile. 

(b) Bsp 

Legende: (...) Bedingung (bei for ausführlicherer Inhalt), 

Anweisung beliebige Anweisung, z. B. Ausdrucksanweisung (3.32a) oder 

auch ein (geschachtelter) Block (4.11) 

Einrückung je Schachtelungsebene hier jeweils 3 Spalten (3 Zeichenpositionen). 

int main() 

{ 

int a, b, c; 

double d; 

// einseitige Auswahl 

if (...) Anweisung 

if (...) 

Anweisung 

if (...) { 

Anweisung 

Anweisung 

} 

// zweiseitige Auswahl 

if (...) Anweisung 

else Anweisung 

if (...) {


} 

Anweisung 

Anweisung 

} 

else { 

Anweisung 

Anweisung 

} 

// if-else-if-Kette 

// (log. Struktur eigentl. anders, s. (2.36)) 

if (...) 

Anweisung 

else if (...) 

Anweisung 

else if (...) 

Anweisung 

else 

Anweisung 

// switch-Anweisung 

switch (...) { 

case ...: Anweisung break; 

case ...: // no break 

case ...: Anweisung 

Anweisung 

break; 

default: Anweisung 

} 

// while-Schleife 

while (...) Anweisung 

while (...) 

Anweisung 

while (...) { 

Anweisung 

Anweisung 

} 

// for-Schleife 

for (....) Anweisung 

for (....) 

Anweisung 

for (....) { 

Anweisung 

Anweisung 

} 

// do-while-Schleife (kann problematisch sein) 

// wichtig: "while" nicht am Zeilenanfang! 

do Anweisung while (...); 

do { 

Anweisung // sollte ein Block sein ... 

Anweisung // ... selbst wenn nur eine Anweisung 

} while (...); 

return 0;


5 Ein- und Ausgabe, Typ Array und String, Ergänzungen 


Dieses Kapitel stellt eine Sammlung sehr unterschiedlicher Themen dar, die besprochen werden 

müssen, bevor in den Folgekapiteln (ab Kap. 6) verschiedene Programmierstile erläutert 

werden. 

Zunächst werden die Operatoren als Gesamtheit vorgestellt (Unterkap. 1); die zugehörige 

Tabelle sollte häufig – auch später noch – zu Rate gezogen werden! 

Unterkap. 2 erläutert die äußerst wichtigen Eigenschaften der sog. Streams ( ” Ströme“). Mit 

Hilfe dieser Ströme geschieht in C ++ die Eingabe und Ausgabe. Da wohl kaum ein Programm 

ohne Ein- oder Ausgabe auskommt, ist die Beschäftigung hiermit notwendig. 

Anm Eine Anwendung der Ein- oder Ausgabefunktionen aus C (5.21Anm4, 5.22Anm4) wird in diesem 

Kurs nicht geduldet, da sie sehr fehleranfällig ist, da zum anderen die C ++-Streams sehr 

einfach zu benutzen sind, sobald man das Verhalten verstanden hat. 

Das Verallgemeinern des Strom-Konzepts auf den Umgang mit Textdateien wird in Unterkap. 

3 vorgestellt. 

Der in naturwissenschaftlich-technischen Anwendungen häufig anzutreffende Arraytyp wird 

in Unterkap. 4 eingeführt und im Folge-Unterkapitel auf Strings (Zeichenfolgen) angewendet. 

Eine Kurzeinführung in Typen und insbesondere ihren Umwandlungen ineinander stellt 

Unterkap. 6 dar; eine Nichtbeachtung solcher Regeln kann manchmal überraschende und 

schwierig eingrenzbare Fehler bewirken. 

In Unterkap. 7 wird das Präprozessor-Konzept erläutert, das in C sehr viel, in C ++ weniger 

benutzt wird. Jedoch gibt es einige auch in C ++ sehr wichtige Anwendungsfälle. 

5.1 Übersicht Operatoren 

(5.10) Übb Hier werden sämtliche Operatoren von C ++/C zusammengefasst. Sie werden diese Tabelle 

sicher auch später noch öfters nachschlagen. Für Klausuren gibt es im Skript ” Sprache 

C ++“ (Kap. 0.2) eine Kurzfassung dieser Tabelle. Wichtig ist es, dass Sie anhand der Tabelle 

die grundlegende Operatoren-Struktur (die in einer solchen Reichhaltigkeit kaum in anderen 

Sprachen verfügbar ist) erlernen und behalten. 

Danach werden zwei bisher noch nicht beprochene Operatoren vorgestellt: Bedingungsoperator 

und Kommaoperator. Diese beiden Operatoren werden je nach eigenem Programmierstil 

sehr selten oder auch häufiger benutzt. Man kann sehr häufig auf sie verzichten, sie können 

jedoch ein Programm übersichtlicher machen. Die Kenntnis, wie der Kommaoperators in 

einem for-Schleifenkopf (5.13 Bsp) benutzt werden kann, ist obligatorisch. 

(5.11) Auflistung aller C ++-Operatoren mit Verweisen, falls sie in dieser Vorlesung besprochen 

werden (nicht hier besprochen: ↑↑) 

Operatorstufen 1 bis 17: fallende Hierarchie (2.61d) 

– ein Durchbrechen der Hierarchie ist durch runde Klammern ( ) möglich – 

Assoziativität (2.61e): linksassoziativ −→; 

Ausnahmen ( ” @“, Stufen 3, 15, 16): rechtsassoziativ ←−


Stufe Operator Bedeutung Verweis 

1 a :: C++ unär präfix: global (7.52) 

b :: C++ binär: Bereichsauflösung (9.12a) 

2 a [ ] Index (5.41) 

b ( ) Funktionsaufruf (7.12) 

c ( ) C++ Umw. EinfTypName (5.64b) 

d . Elementzugriff (5.23a, 9.13) 

e -> Elementzugriff über Zeiger (10.29) 

fg ++ -- Postfix-Inkrement/Dekrem. (3.32e) 

h static cast() C++(neu) Typumwandlung (5.64a) 

i dynamic cast() C++(neu) Typumwandlung ↑↑ 

j const cast() C++(neu) Typumwandlung ↑↑ 

k reinterpret cast() C++(neu) Typumwandlung (10.24 Anm4), 

(12.63, 5.64) 

l typeid C++(neu) Typidentifizierung ↑↑ 

3@ ab ++ -- Präfix-Inkrement/Dekrem. (3.32e) 

unär c ∼ Bitinversion (12.11) 

präfix d ! logische Negation (4.24) 

ef + - Vorzeichen (3.24) 

g & Adresse (10.21b) 

h * Dereferenzierung (10.21b) 

i ( ) Typumwandlung (5.64c) 

j sizeof Speichergröße (5.14, 12.11) 

kl new delete C++ Freispeicher (10.31ff.) 

4 ab ->* .* C++ Elementzugriff ↑↑ 

5 a * Multiplikation (3.24) 

b / Division (3.24) 

c % Teilerrest (3.24) 

6 ab + - Addition, Subtraktion (3.24) 

7 ab > Bitverschiebung (12.11) 

Streams: Ausgabe, Eingabe (5.22, 5.21) 

8 abcd < >= Vergleich (4.22) 

9 ab == != (Un-)Gleichheit (4.22) 

10 & bitw. Und (12.11) 

11 ∧ bitw. Exklusiv-Oder (12.11) 

12 | bitw. Inklusiv-Oder (12.11, 5.33b) 

13 && logisches Und (4.24) 

14 || logisches Inklusiv-Oder (4.24) 

15@ ? : Bedingungsoperator (5.12) 

ternär 

16@ a = (einfache) Zuweisung (3.13b) 

bcde *= /= %= += zusammenges. Zuweisung (3.27) 

fgh -= >>=


↑↑2 Manchmal wird auch throw als Operator aufgeführt (für die sog. Ausnahmebehandlung), 

vgl. (Str3/Kap. 6.2). 

(5.12) Der Bedingungsoperator (Op15) ist die Übertragung einer zweiseitigen Auswahl (2.32), 

(4.31) auf Ausdrücke: 

Ausdruck1 ? Ausdruck2 : Ausdruck3 

(entspricht:) WENN Ausdruck1 DANN Ausdruck2 SONST Ausdruck3 

Semantik: 

• Zunächst wird Ausdruck1 im Booleschen Sinn bewertet (Kap. 4.2), dazu werden auch 

sämtliche ggf. vorhandene Seiteneffekte (3.31) von Ausdruck1 ausgeführt, 

• dann: 

◦ entweder Bewertung von Ausdruck2 (wenn Ausdruck1 WAHR) 

◦ oder Bewertung von Ausdruck3 (wenn Ausdruck1 FALSCH), 

• Haupteffekt des Gesamtausdrucks ist entweder Ausdruck2 oder Ausdruck3 – je nachdem, 

welcher Ausdruck bewertet wurde. 

Empf Da Ausdruck1 Boolesch bewertet wird, kann man ihn zur Erinnerung daran in Klammern 

( ) schreiben. 

Bsp Zuweisung des Betrags von i an k: k = (i>=0) ? i : -i; 

(5.13) Kommaoperator (Op17): Ausdruck1 , Ausdruck2 

Semantik: 

• Zunächst Bewertung von Ausdruck1 einschließlich Durchführung sämtlicher zugehöriger 

Seiteneffekte, 

• dann Bewertung Ausdruck2, 

• Haupteffekt des Gesamtausdrucks: Ausdruck2. 

Anwendung: Wenn mehrere Ausdrücke (mit Seiteneffekten) benötigt werden, wo syntaktisch 

nur einer erlaubt ist. 

Bsp Häufig wird dieser Operator in der for-Anweisung (4.43) benutzt, z. B. wenn mehrere Schleifenvariable 

benötigt werden: 

int i,j; 

for (i=0,j=10; j>0; ++i,--j) ... 

Andere Anwendung: (5.26d Abwandlung). 

(5.14) Operator sizeof (Op3j) 

Dieser Operator gibt die Speichergröße (in Bytes) seines Operanden zurück. Er kann auf 

zwei Arten benutzt werden: 

sizeof(Typ) 

sizeof(Ausdruck) 

Es wird berechnet: die Speichergröße, die ein Element des Typs Typ benötigt, bzw. die 

Speichergröße, die Ausdruck beim Abspeichern hätte – nicht der Wert von Ausdruck. 

Bsp – siehe auch (5.55b) und (12.63a) 

cout


5.2 Standardstreams, Fehlerbehandlung 

– siehe auch (Cpp/Kap. 3) – 

(5.20) Übb Dieses Unterkapitel führt genauer in die Welt der Streams ( ” Ströme“) ein. Daher 

wird es in der Vorlesung ausführlich erläutert. Eine genaue Kenntnis der hier abgehandelten 

Punkte ist für die Programmierung unerlässlich. Sie lernen die genaueren Eigenschaften 

der Ausgabe- und Eingabestromobjekte kennen (5.21, 5.22), danach den Zugriff über Elementfunktionen 

und Manipulatoren (5.23), wobei dadurch auch eine bequeme Formatierung der 

Ausgabe erfolgen kann. 

Es ist sehr wichtig, die zwei verschiedenen Arten des Einlesens zu unterscheiden: das Einlesen 

mit Hilfe des Eingabeoperators (>>), wo zunächst führende Zwischenraumzeichen überlesen 

werden (5.21 Kasten), und das Einlesen jedes einzelnen Zeichens mit der get-Funktion und 

verwandten Funktionen (5.24). 

Der Punkt (5.25) bietet eine Einführung in die Fehlerbehandlung durch Stromobjekte; ohne 

diese Kenntnisse ist es Sie kaum möglich, gut laufende Programme zu schreiben; denn 

fehlerhafte Eingaben durch Benutzer sind immer möglich. Da ein Stromobjekt im Fehlerfall 

(fast) nichts mehr tut, muss man wissen, dass (und wie) dieser Zustand behandelt werden 

muss. 

In (5.26) sehen Sie Beispielprogramme (im Internet jeweils als vollständige Programm erhältlich); 

es ist sehr wichtig, die Wirkung dieser Programm zu verstehen. 

(5.21) Variablenname für die Standardeingabeeinheit: cin (character in) 

Standardeingabe: meist Tastatur, kann auf der Betriebssystemebene umgeleitet werden, s. 

(1.35). 

” Dateiende-Zeichen“ bei Eingabe von Tastatur unter DOS/Windows: Strg-Z (Ctrl-Z, ASCII dez. 

26), unter Unix je nach Systemeinstellung ebenfalls Strg-Z oder anders, unter Linux standardmäßig 

Strg-D. 

Anweisung zum Einlesen: cin [- >> Variable ]- 1..n ; 

Anm1 Genauer eigentlich [- . . . ]- 0..n, jedoch nullmal wenig sinnvoll. 

Anm2 Haupteffekt des obigen Ausdrucks: s. (5.25c) (Streamobjekt als Referenz). 

Anm3 Die Eingabe über cin wird i. a. durch das BS (Betriebssystem) gepuffert: 

Anforderung C ++ an BS bzw. dessen Tastaturpuffer: zeichenweise, 

Einlesen vom Benutzer durch BS in BS-Tastaturpuffer: zeilenweise. 

Bei dieser gepufferten Eingabe über cin gibt der Ausdruck 

cin.rdbuf()->in avail() 

die Anzahl der im Augenblick im Puffer befindlichen Zeichen an (einschließlich ggf. Zeilenendezeichen). 

Bsp s. (5.26e). 

Anm4 Zum Einlesen bei C (C++) s. folgende Bibliotheksfunktionsfamilien aus : 

scanf, gets, getchar. 

Grundsätzlich sind zwei verschiedene Arten des Einlesens über cin zu unterscheiden: 

• Lesen mithilfe des Eingabeoperators ” >>“ – so wie oben angegeben: 

◦ Zunächst Überlesen aller möglicherweise vorhandenen Zwischenraumzeichen; 

als Zwischenraumzeichen (oder Trennungszeichen) 〈white spaces〉 gelten hier 

Leerzeichen, horizontTab, CR ( ” Wagenrücklauf“), LF (NeueZeile), NeueSeite, 

vertikTab. 

◦ Beginn des eigentlichen Lesens, d. h. der Übernahme/Umwandlung von Zeichen 

in die zugehörige Variable: mit dem ersten Nicht-Zwischenraumzeichen. 

◦ Ende des Einlesens: beim ersten zum Variablentyp nicht passenden Zeichen 

(beim Typ String ist es ein Zwischenraumzeichen); 

wichtig: dieses unpassende Zeichen bleibt im Lesepuffer, ist also beim nächsten 

Lesevorgang das als erstes zu lesende Zeichen. 

• Benutzung von Elementfunktionen, s. (5.24), (5.23b): keine Sonderbehandlung 

von Zwischenraumzeichen, jedes Zeichen gilt als ein zu lesendes Zeichen.


(5.22) Variablenname für die Standardausgabeeinheit: cout (character out) 

Variablenname für die Standardfehlerausgabeeinheit: 

cerr und C++(neu) clog (character error, character log) 

Standardausgabe: meist Bildschirm, kann auf der Betriebssystemebene umgeleitet werden. 

Standardfehlerausgabe: meist Bildschirm, kann unter DOS nicht umgeleitet werden, unter 

Unix ist eine Umleitung möglich; cerr Ausgabe ungepuffert, C++(neu) clog gepuffert. 

(5.23) 

Anweisung zum Ausgeben: [- cout 

| 

| cerr 

| 

| clog ]- [- verfügbar (5.22, 5.21). 

Bei dieser Ausgabeart sind weitere Formen für Ausdruck (rechter Operand in (5.22)) möglich, 

nämlich die sog. Manipulatoren: diese manipulieren den Datenstrom, geben aber (meist) 

selbst nichts aus. Sie werden meist benutzt zum Formatieren der Ausgabe. Für die meisten 

Manipulatoren gibt es äquivalente Elementfunktionen. Alle Setzungen gelten bis zur nächsten 

Änderung; Ausnahme: ein Setzen der Mindestausgabebreite wird nach der nächsten 

Ausgabe sofort wieder zurückgesetzt. 

Anm Auch für die Eingabe gibt es Manipulatoren; sie werden jedoch seltener eingesetzt. 

Die wichtigsten Manipulatoren und gleichwertige Elementfunktionen: 

Manipulator Element-Fkt. Std.-Wert Bedeutung 

endl — Ausgabe Zeilenvorschub und 

Leeren des Ausgabepuffers 

flush flush() Leeren des Ausgabepuffers 

dec, oct, hex — dec Basis für Ganzzahlausgabe setzen 

setw(Breite) ⊛ width(Breite) 0 Mindestausgabebreite setzen ▽ 

setfill(Zeichen) ⊛ fill(Zeichen) ’ ’ Füllzeichen setzen 

▽ nach nächster Ausgabe automatisch wieder auf Standardwert 0 

– alle anderen Setzungen bleiben erhalten, bis sie geändert werden – 

⊛ Einfügen von notwendig (immer bei Manipulatoren mit Parameter(n))


(d) Bsp 

Für das Formatieren der Ausgabe von Fließkommazahlen gibt es u. a. folgende Möglichkeiten: 

Manipulator bzw. Bedeutung 

E Elementfunktion 

Setzen Ausgabeformat für Gleitkommazahlen 

(Standard: wechselnd je nach Wert): 

ios::scientific wissenschaftlich 

(Gleitkommadarstellung mit Exponent), 

ios::fixed Festkommadarstellung 

E setf(0,ios::floatfield) Rücksetzen Ausgabeformat wieder auf Standard 

setprecision(GanzWert) ⊛ (bei sci./fixed:) Anzahl Nachkommastellen 

(sonst:) Anzahl der führenden Ziffern insgesamt 

⊛ Einfügen von notwendig (immer bei Manipulatoren mit Parameter(n)) 

↑↑ Weitere Übersicht siehe (Cpp/Kap. 3,4) 

#include // Beispiel D05-23.CPP 

#include 


int main() 

{ 

// Nur zum Abzählen der Schreibpositionen bei der Ausgabe: 

cout


• Seiteneffekt: Zeichen/Zeichenkette wird eingelesen, Parameter wird damit belegt. 

• Haupteffekt: Streamobjekt (als Referenz) im Zustand nach dem Einlesen, vgl. (5.25c). 

↑↑ Genaueres siehe auch (Cpp/Kap. 4). 

△! Auch cin.get() (ohne Parameter) ist möglich, es wird der Wert des Zeichens 

zurückgegeben, dieser sollte an Zeichen-Variable zugewiesen werden. Aufpassen bei 

Nicht-Standardzeichen, z. B. bei Umlauten oder ” ß“: überraschende Effekte! (Mögliche 

Lösung: nach (nicht vor) dem Test auf Dateiende eine Typumwandlung auf 

char durchführen!) Besser: nicht benutzen. Die oben erwähnte Benutzung von 

get(ZeichenVariable) nach (a) ist auch bei Umlauten oder ” ß“ unproblematisch. 

(5.25) Fehlerbehandlung bei Streams 

(a) Den internen Stream-Fehlerzustand charakterisieren drei Bits, genannt 

eofbit, failbit, badbit, 

dazu noch das Pseudobit goodbit als Abwesenheit der Fehlerbits: 

• eofbit wird gesetzt beim Leseversuch hinter Dateiende (EOF 〈end of file〉) 

– zusätzlich wird dabei failbit gesetzt –, 

• failbit wird gesetzt bei Fehler, der vermutlich reparabel ist 

(z. B. Leseversuch hinter EOF, Einleseversuch Buchstabe auf int), 

• badbit wird gesetzt bei Fehler, der den Strom nicht mehr reparabel erscheinen lässt 

(z. B. Versuch, eine nicht existierende Datei zu öffnen). 

(b) Die Abfrage auf den Fehlerzustand erfolgt beispielsweise mit der Elementfunktion fail(); 

sie ergibt true, wenn failbit oder badbit gesetzt ist, sonst false. 

Einfacher ist die Boolesche Abfrage des Streamobjekts selbst; sie ergibt den invertierten 

fail()-Wert: 

• if (StreamobjektName) ... entspricht if (!StreamobjektName.fail()) ... 

• if (!StreamobjektName) ... entspricht if (StreamobjektName.fail()) ... 

(c) Viele Ausdrücke mit einem Streamobjekt als Operand ergeben als Haupteffekt das Streamobjekt 

selbst (genauer: Referenz darauf (7.31)), und zwar im Zustand nach der Operation. 

Also sind auch diese Ausdrücke Boolesch abfragbar, um den Fehlerzustand des Streamobjekts 

zu erfahren. Dadurch ergibt sich die elegante Möglichkeit, Lesen und Abfragen des 

Fehlerzustandes danach in einem Ausdruck zu formulieren. 

Bsp1 Links: drei Ausdrucksanweisungen; der Haupteffekt des Gesamtausdrucks vor dem Semikolon (wird hier 

verworfen (3.32a)) ist jeweils das Streamobjekt selbst im Zustand nach der Operation – zu get() s. (5.24a); 

Mitte: Fehlerabfrage mit fail (WAHR bei Fehler); 

Rechts: Kombination beider Teile mit negierter Boolescher Abfrage (ebenfalls WAHR bei Fehler): 

cin >> Variable; if (cin.fail()) ... if (!(cin >> Variable)) ... 

cout zahl; 

while (cin.fail()) { 

// Fehlerbehandlung nach (d) 

cin >> zahl; 

} 

/* 2 */ cin >> zahl; 

while (!cin) { 


cin >> zahl;


} 

/* 3 */ while (cin >> zahl, cin.fail()) { 


} 

/* 4 */ while (!(cin >> zahl)) { 


} 

(d) △! Im Fehlerfall (eines der drei Fehlerbits gesetzt) tut der Strom nichts mehr, was man 

auch immer ihm befiehlt; daher unbedingt (im Falle eines reparablen Zustands) das Löschen 

des/der Fehlerbit(s) nicht vergessen! Dies geschieht durch Aufruf der Elementfunktion 

clear(), vgl. (5.26d). 

△! Zusätzlich muss i. a. die Fehlerursache beseitigt werden, da sonst bei Wiederholung 

der Operation wieder der gleiche Fehler erzeugt wird. Beim Einlesen z. B. bleibt das fehlerverursachende 

Zeichen im Strom! Es muss demnach mindestens ein Zeichen verworfen 

werden, beispielsweise durch ignore (5.23b). Meist ist es sinnvoll, die ganze Eingabezeile zu 

verwerfen, vgl. (5.26d). 

↑↑ Weitere Informationen zur Fehlerfindung und -behandlung bei Streams s. (Cpp/Kap. 4). 

(e) Die Elementfunktion zum Testen auf Dateiende-Bedingung (d. h. ob eofbit gesetzt ist) ist 

die eof-Funktion: 

StreamobjektName.eof() 

Sie gibt true zurück, wenn eofbit gesetzt ist (d. h. nach einem Leseversuch hinter das 

Dateiende), sonst false. Diese Funktion ist wichtig, wenn man mit Dateien umgeht (s. 

nächstes Unterkapitel), insbesondere wenn man einen allgemeinen Fehler von dem speziellen 

Dateieende-Fehler unterscheiden möchte. 

(f) Wenn das Einlesen auf eine Variable fehlschlägt, sollte ihr bisheriger Wert unverändert 

bleiben. Dies ist nach (Str3/Kap. 21.3.3) auch bei den vordefinierten Stromobjekten der Fall. 

Leider hält sich der Compiler Microsoft Visual C ++ 6.0 nicht an diese Regel, er setzt im 

Fehlerfall die Variable auf den Wert Null. 

(5.26) Bsp 

Bsp Bei folgendem Programmfragment sollte im Fehlerfalle die Zahl 35 ausgegeben werden; bei Kompilation 

mit MS VC++ 6.0 wird jedoch der Wert 0 ausgegeben. 

int zahl=35; 

cout zahl)) { 

// Bei Einlesefehler: 

cout c) cout


} 

(c) Filterprogramm: 

while (cin.get(c)) cout zahl)) { 

cin.clear(); // unbedingt nötig!! 

cin.ignore(1000,’\n’); // Zeile im BS-Puffer leerlesen; 

// andere Möglichkeit: s. (e) 

cerr zahl, !cin) ... 

(e) Programmfragment: Leeren des Eingabepuffers C++(neu) , vgl. (5.21 Anm3); zur Variablendefinition 

siehe (4.51b) 



// ... 

if (int anz=cin.rdbuf()->in_avail()) 

cin.ignore(anz); 

// ... 

Änderung für C++(alt) s. Vorlesung. 

5.3 Umgang mit Textdateien 

(5.30) Übb Wenn Sie den Umgang mit den Standardstrom-Objekten (s. voriges Unterkapitel) 

verstanden haben, werden Sie bemerken, dass der Umgang mit Textdateien in C ++ sehr 

einfach ist. Die Benutzung von Dateien mit Hilfe von Stromobjekten ist genauso wie Sie es 

schon von cout und cin her kennen; neu ist hier nur, dass Sie sich für die Kommunikation mit 

einer Datei zuerst ein Stromobjekt erzeugen und es mit einer Datei verknüpfen müssen (5.33); 

am Ende sollten Sie diese Verknüpfung wieder lösen (5.34). Das Dateikopier-Beispielprogramm 

(5.35) zeigt alle diese Schritte. 

Der Umgang mit Binärdateien wird später besprochen (Kap. 12.6). 

(5.31) Zwei Arten von Dateien (bzw. zwei Arten, Dateien zu bearbeiten) sind zu unterscheiden:


• Textdateien: sie geben normalen Text wieder, sie sind in Zeilen gegliedert, besondere 

Formatierungen sind nicht erlaubt – außer den Zwischenraumzeichen (5.21 Kasten) und 

(ggf.) einem Dateiendezeichen (ASCII dez. 26, vgl. (5.21)). 

Hierbei übernimmt das C ++-Laufzeitsystem beispielsweise die ggf. notwendige Transformation 

zwischen der Betriebssystemdarstellung eines Zeilenendes und der C ++-Darstellung 

’\n’. 

Bsp In Unix wäre dafür i. a. keine Transformation nötig; unter DOS/Windows wird ein Zeilenende durch 

das Doppelzeichen CR/LF (ASCII dez. 13/10, s. (1.45a)) dargestellt, unter C ++ durch ’\n’ (meist 

als Zeichen LF, ASCII dez. 10). 

• Binärdateien: Dateien mit beliebigen Bytes; diese Bytes werde beim Bearbeiten nicht 

speziell interpretiert, sondern unverfälscht zwischen Betriebssystem und C ++-Programm 

übertragen. 

Hier wird nur der Umgang mit Textdateien besprochen; zu Binärdateien s. (Kap. 12.6). 

(5.32) Umgang mit Textdateien 

In C ++ ist der Umgang mit (Text-)Dateien sehr einfach, nämlich ähnlich wie die Benutzung 

der Standardeingabe cin und der Standardausgabe cout. 

(a) Gar keine Änderung zum Bisherigen ist nötig, wenn eine Umleitung der Standardeingabe 

oder der Standardausgabe auf der Betriebssystemebene erfolgt: normale Benutzung von cin 

und cout. 

(b) Anders beim direkten Umgang mit Dateien; hierbei sind folgende Schritte nötig: 

• Vorbereitungen, s. (5.33): 

◦ Erzeugen eines Streamobjekts passender Bauart durch Variablendefinition, 

◦ Verknüpfen dieser Variablen mit der gewünschten Datei: Öffnen der Datei. 

Diese beiden Schritte können meist auch mit einem einzigen Befehl durchgeführt werden. 

• Arbeiten mit dieser Datei wie mit der Standardeingabe bzw. -ausgabe: Lesen bzw. 

Schreiben (s. voriges Unterkapitel); statt der Namen cin, cout ist jeweils der Streamobjektname 

(Variablenname) anzugeben. 

• Nachbereitung, s. (5.34): Schließen der Datei und Zerstören des Streamobjekts. 

(5.33) Vorbereitung von Streamobjekten 

(a) Typ des benötigten Streamobjekts (Klassenname): 

ifstream bei beabsichtigtem Lesen, 

ofstream bei beabsichtigten Schreiben, 

fstream bei Lesen und Schreiben. 

Damit die Namen verfügbar sind, ist die passende Headerdatei einzuschließen: 

#include 

Das passende Streamobjekt wird beispielsweise durch folgende Variablendefinition erzeugt: 

StreamobjektTyp StreamobjektName ; 

(b) Das Verknüpfen dieses Streamobjekts mit der gewünschten Datei geschieht durch Aufruf 

der open()-Elementfunktion: 

StreamobjektName.open(DateiName); 

StreamobjektName.open(DateiName,Modus); 

Der DateiName ist in betriebssystemspezifischer Weise anzugeben, ggf. einschließlich Pfad. 

△! Bei Pfadangaben in DOS/Windows, wenn Angabe als Stringkonstante, ist das Doppelzeichen 

” \\“ statt des Einzelzeichens ” \“ zu nehmen, vgl. (3.25) – dagegen (5.74)! 

Als Modus sind angebbar: 

ios::in Lesemodus (Standard bei ifstream) 

ios::out Schreibmodus (Standard bei ofstream) 

ios::app beim Schreiben anhängen 

ios::ate ans Dateiende positionieren 〈at end〉 

ios::trunc bisherigen Inhalt löschen 

ios::binary Binärzugriff, s. (5.31, 5.36), ohne Angabe: Textmodus 

Diese Einzelangaben sind verknüpfbar mit Hilfe des Operators ” |“ Op12 (5.11), z. B. 

ios::in | ios::out.


Bei bisherigen Compilern – nicht unbedingt mehr bei sehr neuen – sind zusätzlich auch die 

Flags ios::nocreate und ios::noreplace verfügbar. 

Öffnen zum Lesen ohne Modusangabe, wenn Datei nicht vorhanden: 

C++(neu) Fehlermeldung, Datei wird nicht (leer) erzeugt. 

C++(alt) Datei wird leer erzeugt; eine Modusangabe ios::nocreate verhindert dieses. 

Empf Der Erfolg oder Misserfolg des Öffnens sollte vor weiteren Operationen als Streamzustand 

(5.25b) abgefragt werden. 

(c) Beide Schritte (a) und (b) sind auch in einer einzigen Anweisung möglich (ggf. jedoch nicht 

bei fstream): 

StreamobjektTyp StreamobjektName(DateiName); 

StreamobjektTyp StreamobjektName(DateiName,Modus); 

(5.34) Das Schließen des Streams erfolgt durch den Aufruf 

StreamobjektName.close(); 

Das Zerstören des Objekts geschieht wie das Zerstören anderer Variablen, z. B. durch Verlassen 

des zugehörigen Blocks. 

Falls der Stream zuvor noch nicht geschlossen wurde, geschieht dieses implizit durch das 

Zerstören des Streamobjekts (Destruktoraufruf (9.23a)). Jedoch: 

Empf Gewöhnen Sie sich das explizite Schließen durch die Elementfunktion close() an. 

(5.35) Bsp Kopieren einer Textdatei – nicht für binäre Dateien geeignet! 


#include 


int main() 

{ 

ifstream ein; 

ein.open("DATEI.TXT"); 

// Angabe ios::in nicht nötig, da Typ ifstream 

// Oder mit nur einer Anweisung: 

// ifstream ein("DATEI.TXT"); 

} 

if (!ein) { 

cerr


(5.36) Die obigen Erläuterungen sind nur teilweise auf den Umgang mit Binärdateien übertragbar. 

5.4 Arrays 

↗ Bei Binärdateien ist unbedingt der Modus ios::binary (5.33b) zu setzen; das Lesen bzw. 

Schreiben erfolgt am besten mit den Elementfunktionen read und write, siehe (Kap. 12.6) und 

(Cpp/Kap. 4). 

(5.40) Übb Array: Zusammenfassung mehrerer Komponenten des gleichen Typs unter einem 

einzigen Typ. 

Mathematik: 

• eindimensional: Vektor, n-Tupel (bei letzterem: Komp. jeweils gleichen Typ), 

• zweidimensional: Matrix. 

Um Verwirrungen zu vermeiden, wird dieses Konstrukt hier bewusst nicht Vektor genannt 

(so dagegen in den meisten C ++- und C-Büchern), da Vektor als mathematischer Begriff 

anders gefasst ist. 

In Programmen für naturwissenschaftliche und technische Anwendungen wird das Array 

sehr häufig benutzt. Da manche Autoren vermutlich mehr von anderen Anwendungsgebieten 

kommen, wird das Gebiet manchmal in Lehrbüchern zu kurz gehalten. Den Problemen, die 

sich durch den äußerst schwerwiegenden Fehler eines Indexüberlaufs ergeben (5.41△! ), kann 

man entgehen, indem man auf Typen der neuen C ++-Laufzeitbibliothek übergeht (nicht in 

diesem Kurs besprochen). Das ist jedoch in wissenschaftlich-technischen Anwendungen nicht 

immer sinnvoll und bei genauer (nachdenkender) Programmierung auch nicht nötig. 

(5.41) Deklaration 10/11 eines Array-Typs (eindimensional) 

Typ ArrayName [ KonstanterAusdruck ] ; 

ArrayKomponente (als Variable) ArrayName [ Ausdruck ] 

• Der angegebene Typ ist der Typ der einzelnen Komponente des Arrays. 

• KonstanterAusdruck gibt die Anzahl der Komponenten des Arrays an (Ausdruck muss 

zur Kompilationszeit berechenbar sein). 

• Die Nummerierung der einzelnen Komponenten läuft von 0 bis KonstanterAusdruck-1. 

• △! Eine Index-Bereichsüberschreitung wird bei ArrayKomponente nicht geprüft! 

Bsp int vektor[20]; // Definition: Array mit 20 int-Komponenten 

vektor[0]=-12; // Zuweisung an das erste Element 

vektor[19]=23; // Zuweisung an das letzte(!) Element 

// Jetzt seien alle Elemente des Arrays belegt; Ausgabe aller Elemente der Reihenfolge nach: 

int lauf; 

for (lauf=0; lauf


Werden zuwenige Elemente angegeben, werden die restlichen automatisch mit Null oder 

zugehörigen Nullwerten aufgefüllt; zu viele Elemente erzeugen einen Kompilierfehler. 

Bsp int arr[20] = { 2, 5, 7, -23 }; Anm.: die restlichen 16 Werte werden mit 0 gefüllt. 

double matrix[3][2] = { { 1.0, 7.3 }, { -0.7, 6. }, { 3.7, 5.3 } }; 

Im Falle der Initialisierung ist es erlaubt, die (innerste) Dimension wegzulassen, da dann der 

Compiler die Anzahl Elemente selbst zählt, s. (5.51, 12.71c). 

(5.44) Gerade auch bei Arraygrenzen sollten i. a. symbolische Konstanten (4.72) genommen werden, 

da dadurch ein Programm besser wartbar wird; denn die Grenzen können später viel leichter 

geändert werden. 

Bsp Bei einer Arraygrenze von 50 müsste bei einer späteren Änderung jedes Auftreten von 50 und auch von 

49 (als letzter erlaubter Index) geprüft werden; eine automatische Ersetzung ist nicht möglich, da diese 

beiden Zahlen auch in anderer Bedeutung auftreten können. Eine Änderung des Wertes einer Konstanten 

maxAnz (und dadurch implizit des Wertes maxAnz-1) ist jedoch in seiner Definition einfach möglich. 

5.5 Strings (C-Strings) 

(5.50) Übb Strings (Zeichenketten) sind in der Programmierpraxis sehr häufig anzutreffen. In 

diesem Kurs sollen die Strings nur in der (älteren) Art der sog. C-Strings besprochen werden. 

Diese Strings sind zwar schwieriger zu handhaben, da sie Arrays aus Zeichen sind und daher 

die große Gefahr des Speicherüberlaufs bieten. Wenn man jedoch gewohnt ist, allgemein mit 

Arrays umzugehen (s. voriges Unterkapitel), werden die C-Strings wenig Schwierigkeiten 

bereiten. 

Diese speziellen Zeichen-Arrays haben eine zusätzliche Eigenschaft, die über die allgemeinen 

Array-Eigenschaften hinausgeht: den Nullbyte-Abschluss (5.51). Wie allgemein bei Arrays 

kann nicht durch Zuweisung kopiert werden (5.52). Die wichtigsten Stringfunktionen stellt 

Punkt (5.53) vor. Die Besonderheiten beim Einlesen und Ausgeben werden in (5.55) erläutert. 

Anm In C++(neu) gibt es eine Bibliotheks-Klasse string; Objekte dieses Typs sind einfacher zu 

handhaben als C-Strings, insbesondere sind Speicherplatzüberläufe kaum möglich. Wie oben 

erwähnt, wird dieser Typ jedoch in dieser Vorlesung nicht besprochen. 

(5.51) String (genauer: C-String), Zeichenkette: 

spezielles Array aus char mit Kennzeichnung der aktuellen Länge: hinter letztem Nutzzeichen 

steht das Zeichen ’\0’ (Nullbyte, d. h. alle Bits 0 – nicht die Ziffer ’0’, diese im ASCII 

Wert dez. 48 (1.45a)). 

Daher ist der Mindest-Speicherbedarf eines Strings um 1 höher als die Anzahl der Nutzzeichen. 

Beispiele: 

char zeile[81]; 

char meldung[20]="Hallo!"; 

Das char-Array zeile wird nicht initialisiert, es muss später sinnvoll belegt werden. Das 

Array meldung wird initialisiert (keine Zuweisung, sondern Angabe der Erstbelegung, vgl. 

(5.52)), abschließendes Nullbyte wird automatisch hinzugefügt. 

△! Dimensionierung muss mindestens AnzahlZeichen+1 sein!! 

↑↑ Bei der Initialisierung in C ist auch AnzahlZeichen als Dimensionierung erlaubt, jedoch sehr 

gefährlich △! , da Nullbyte fehlt. In C++ ist diese Fehlerquelle nicht mehr erlaubt. 

Das Zählen der benötigten Anzahl kann man auch dem Compiler überlassen, jedoch nur bei 

der Inititalisierung; es wird automatisch die richtige Länge einschließlich Nullbyte eingesetzt: 

char neuMeldung[ ]="Hallo!"; 

(5.52) Kopieren eines Strings auf einen anderen ist nicht durch Zuweisung möglich, sondern nur 

durch Kopieren aller Zeichen einschließlich des Nullbytes, s. auch (5.53a). Dies gilt allgemein 

für Arrays, vgl. (5.65b). Ein Initialisieren dagegen (mit konstanten Werten, nicht mit Variablen) 

ist möglich (5.51). 

(5.53) Vier wichtige Stringfunktionen (für alle jeweils nötig: #include ): 

(a) strcpy(Zielarray, Quellarray);


Funktion kopiert auf Zielarray, und zwar alle Nutzzeichen von Quellarray bis einschließlich 

des (ersten) Nullbytes, d. h. es wird der aktuelle Quellstring kopiert. 

△! Ein Prüfen, ob Zielarray genügend Speicherplatz hat, kann nicht stattfinden! Verantwortung 

des Programmierers! Wichtige Fehlerquelle! 

(b) strcat(Zielarray, Quellarray); 

Anhängen (Konkatenieren 〈concatenate〉) des Quellarrays an das Zielarray, d. h. das bisherige 

Nullbyte des Zielarrays wird durch das erste Zeichen des Quellarrays überschrieben usf. 

Auch hier keine Prüfung des benötigten Speicherplatzes! 

(c) strlen(ZeichenArray) 

gibt die aktuelle Stringlänge zurück, d. h. die Anzahl der Nutzzeichen ohne das Nullbyte; 

die Funktion muss die Länge jeweils berechnen. 

△! Wert ist ein unsigned-Typ, daher aufpassen bei Mischung mit (normalen) signed- 

Typen, vgl. (12.23△! )! Falls der Wert in einem Ausdruck gebraucht wird: besser vorher 

diesen Wert einer int-Variablen zuweisen und dann diese Variable benutzen! 

(d) strcmp(Array1, Array2); 

vergleicht 〈compare〉 beide Strings, gibt die alphabetische Sortierung der beiden Strings an 

(entsprechend der internen Zeichendarstellung): 

• Rückgabewert < 0, wenn Array1 0, wenn Array1>Array2, d. h. Array1 im Alphabet hinter Array2 steht. 

(5.54) Leerstring, Nullstring: String der (Nutz-)Länge Null, d. h. mit Nullbyte als erstem Zeichen; 

Leerstring als Konstante: "" (zwei Zeichen Doppelanführungsstriche ohne Zwischenraum). 

(5.55) Ergänzungen zu (Kap. 5.2): 

arr sei eine gültige Stringvariable. 

(a) cin >> arr liest genau ein ” Wort“: zunächst Überlesen aller Zwischenraumzeichen, danach 

Lesen der Zeichenfolge, Ende bei nächstem unpassenden Zeichen, d. h. hier bei Zwischenraumzeichen; 

dieses Zwischenraumzeichen bleibt im Lesepuffer. 

Es findet keine Überprüfung auf Speicherüberschreitung statt. 

↑↑ Ein Begrenzen der Anzahl der mit dem Operator >> zu übernehmenden Zeichen ist z. B. 

möglich durch cin.width(AnzahlZeichen). Dadurch werden – jedoch nur bei dem nächsten 

Einlesen – maximal AnzahlZeichen-1 übernommen. Empf besser (b,c). 

(b) cin.getline(arr,AnzahlZeichen) liest genau eine Zeile, jedoch maximal AnzahlZeichen-1 

Zeichen, dazu Erzeugung Nullbyteabschluss. Bei richtiger Größenangabe geschieht daher 

keine Speicherüberschreitung. Empfehlung: Als AnzahlZeichen am besten die richtige Speichergröße 

durch sizeof(arr) nehmen (Op3j, s. (5.14)). 

Das Zeilenendezeichen ’\n’ wird zwar gelesen (wenn nicht vorher Lesen zu Ende), aber 

nicht in den String kopiert. 

(c) Nur für spezielle Anwendungen, s. △! ! 

cin.get(arr,AnzahlZeichen) arbeitet wie getline; jedoch wird das Zeilenendezeichen im 

Lesepuffer gelassen. Dadurch kann anschließend geprüft werden, ob eine ganze Zeile gelesen 

wurde. 

△! Bei mehrfacher Benutzung dieser Funktion hintereinander ohne andere Lesebefehle 

dazwischen: das Lesen tritt auf der Stelle! Gefahr einer Endlosschleife! 

(d) Arrayname arr als formaler Funktionsparameter: 

△! Innerhalb der Funktion wird der Ausdruck sizeof(arr) nämlich anders interpretiert; 

statt dessen sollte sizeof(ArrayTyp) genommen werden, s. a. (7.46 ↑↑). 

(e) cout


5.6 Übersicht Typen 

(5.60) Übb Ein Typ ist ein Name oder eine Beschreibung für eine Wertemenge mit zugehörigen 

erlaubten Operatoren, vgl. (2.25a2), (3.20). 

Es wird nun gezeigt, wie ein Benutzer (ein Programmierer) eigene neue Typ(namen) erzeugen 

und benutzen kann (5.61, 5.62). 

Häufig muss ein Ausdruck eines Typs in einen anderen Typ umgewandelt werden. Dieses 

kann implizit geschehen (5.63), d. h. ohne ausdrückliche Angabe durch den Programmierer. 

Aber auch eine explizite Typumwandlung ist möglich. Typumwandlungen ( ” Typ-Casts“ 

〈type casts〉) sind in der Sprache C eine häufige Fehlerquelle, wenn der Programmierer nicht 

genügend Kenntnisse hat (oder, falls er sie hat, sie beim Programmieren nicht anwendet). 

Daher hat C++(neu) weniger fehleranfällige Typumwandlungs-Operatoren eingeführt (insbesondere 

static cast, s. (5.64a) und Hinweis (5.64 ↑↑2)). Diesen neuen Operatoren ist der 

Vorrang gegenüber den älteren C-Umwandlungen (5.64c) und der auch fehleranfälligen alten 

C ++-Umwandlung (5.64b) zu geben, obwohl diese neuen Operatoren in der Schreibweise an 

Schwerfälligkeit kaum zu überbieten sind (äußerst lange Namen!). 

Mit (5.65) wird der Zeigertyp kurz angesprochen. Zunächst ist nur wichtig, seine prinzipielle 

Bedeutung zu kennen, da der Begriff des Zeigers für manche Erläuterungen benötigt wird. 

Die wichtigste Erläuterung wird schon in (5.65b) angedeutet (automatische Umwandlung Arrayname 

in Zeiger), die Konsequenzen werden bald genannt (7.46). Direkt angewendet wird 

der Zeigertyp erst viel später, und zwar ab (Kap. 10.2). 

(5.61) In vielen Programmiersprachen – so auch in C ++ – gibt es Typen, die dem Compiler von 

vornherein bekannt sind, sog. eingebaute Typen. 

Bsp int, float, unsigned char. 

Zusätzlich hat der Benutzer (Programmierer) die Möglichkeit, eigene Typen zu konstruieren: 

benutzerdefinierte Typen. Diese Typen müssen dem Compiler in ihrem inneren Aufbau 

bekanntgegeben werden, bevor sie benutzt werden können. Bei einfach gebauten benutzerdefinierten 

Typen geschieht die Typdefinition meist zusammen mit einer Variablendefinition. 

Bsp int arr[34]; 

Eine Variable mit Namen arr wird erzeugt, ihr Typ ist ” Array mit 34 int-Komponenten“. 

Bei komplizierteren Typen ist es sinnvoll, teilweise auch notwendig, die Typen dem Compiler 

vor der Benutzung explizit bekanntzugeben (Typdefinition). Dieses kann mit einem 

typedef (5.62) geschehen, bei Klassen (o. a.) auch ohne typedef (9.11). 

(5.62) Definition eines Typs mit typedef in C ++/C: 

Einführung eines neuen Namens, der synonym zum angegebenen Typ ist; keine Einführung 

eines neuen (einzigartigen) Typs. 

TypDefinition typedef DefinitionEinerVariablen 

Der neu eingeführte Name – ohne typedef wäre er ein Variablenname – wird durch das 

typedef zu einem Typnamen für diesen Typ. 

Bsp Synonyme: int und Ganz, ferner Zeil und ” char-Array mit max(=81) Elementen“ 

// ... 

typedef int Ganz; 

Ganz neuZahl; neuZahl=32; cout


Gefährlicher sind implizite Umwandlungen, wenn dadurch Informationen verlorengehen, 

z. B. durch Zuweisung eines double-Wertes an ein int (gebrochener Anteil wird abgeschnitten, 

ggf. Bereichsüberschreitung) oder eines int-Wertes an ein char (Gefahr der Bereichsüberschreitung). 

Meist warnt der Compiler dabei; dann sollte eine explizite Typumwandlung 

durchgeführt werden (5.64), um diese Warnungen zu vermeiden. 

(5.64) Explizite Typumwandlungen 〈type cast〉 

(a) C++(neu) Neuer Operator (Op2h): 

static cast(Ausdruck) 

Hierdurch wird die Umwandlung von Ausdruck in Typ durchgeführt, und zwar mit Prüfung 

schon zur Kompilationszeit, ob eine solche Umwandlung überhaupt sinnvoll ist. 

Bsp int i; double d=34.9; i=static cast(d); 

(b) C++ △! Op2c; hierdurch können auch ” unsinnige“ Umwandlungen durchgeführt werden, 

daher gefährlicher! Schreibweise des neuen Typs wie ein Funktionsname; nur möglich, wenn 

der neue Typ ein Name ist. 

Bsp int i; double d=34.9; i=int(d); 

(c) C/C++ △! Op3i, Wirkung wie Op2c, jedoch nicht so übersichtlich; hier kein TypName wie bei 

Op2c erforderlich. 

Bsp int i; double d=34.9; i=(int)d; 

△! Wegen der Gefährlichkeit und Unübersichtlichkeit gelten die beiden letzten Umwandlungen 

(b,c) inzwischen als ” missbilligt“ (Str3/Kap. B.2.3). 

Es gibt viele Umwandlungen, die zumindest für den Anfänger sehr gefährlich sind, da 

er die Folgen nicht übersehen kann. Daher unbedingt die Empfehlung im folgenden 

Kasten beherzigen! 

Bei Compilerwarnungen in Hinsicht auf Typumwandlungen sollen Sie zunächst überlegen, 

ob der Compiler das meint, was Sie meinen. Falls ja, benutzen Sie static cast 

(a); dann sollte die Warnung nicht mehr erscheinen. 

↑↑1 Genaueres über Typumwandlungen, insbesondere implizite, siehe (Cpp/Kap. 7). 

↑↑2 Andere Typumwandlungsoperatoren Op2i-k siehe C ++-Bücher, zu reinterpret cast s. a. 

(10.24 Anm4) und (12.63a, 12.64a). 

(5.65) Datentyp Zeiger 〈pointer〉 

(a) Der Datentyp Zeiger ist dadurch charakterisiert, dass sein Wert als Adresse einer anderen 

Variablen interpretiert wird, der Zeiger ” zeigt“ auf einen anderen Speicherplatz. 

↑↑ Näheres hierzu, insbesondere die Definiton, Benutzung mit zugehörigen Operatoren s. (Kap. 

10.2) 

(b) WICHTIG jedoch in diesem Zusammenhang: 

Ein Arrayname durch den Compiler automatisch umgewandelt in einen Zeiger auf das erste 

Array-Element (Element mit Index 0). Überraschende Folgerungen bei Funktionen mit 

Array-Parametern siehe (7.46); dieses ist auch der Grund, warum Arrays nicht durch Zuweisung 

kopiert werden können (5.52). 

5.7 Präprozessor 

(5.70) Übb Der Präprozessor ist ein Textprozessor, der den Quelltext bearbeitet, bevor der Compiler 

den Text sieht. Er arbeitet zeilenorientiert – unabhängig von der C ++/C-Syntax. In 

älteren Programmen, insbesondere in C, werden Präprozessoreigenschaften sehr intensiv benutzt. 

In C++(neu) ist das meist nicht mehr nötig, da bessere Konstrukte zur Verfügung 

stehen. 

Geblieben jedoch ist die Benutzung des #include (5.74), ferner die bedingte Kompilierung 

(5.75): jede später durch Sie erstellte Headerdatei (8.24) muss einen Include-Wächter haben


(5.75c). Warum das Vermeiden eines Mehrfacheinschlusses nötig ist, wird später erläutert 

werden, insbesondere ab (Kap. 9). 

Syntax für Zeile mit einer Präprozessordirektive: 

Zeilenbeginn mit # (nach ggf. Zwischenraumzeichen). 

(5.71) Zeilenfortsetzungszeichen (für Präprozessorzeile; für Compilerzeile unnötig): \ mit sofort 

anschließendem ” Zeilenendezeichen“ (kein Leerzeichen); Präprozessor entfernt \ und Zeilenendezeichen, 

bevor er die Gesamtzeile untersucht. 

(5.72) Makro ohne Parameter 

C (C++) sehr viel benutzt für symbolische Konstanten; C++ besser: const ... 

C/C++ benutzt bei Definitionen für bedingte Übersetzung, s. (5.75) . 

(a) #define Name Textersatz 

Semantik: Ab dieser Zeile wird Name (als lex. Bestandteil, nicht innerhalb eines Strings) 

ersetzt durch Textersatz ( ” dummer“ Ersatz, unabhängig von Syntax); Textersatz darf auch 

Leerzeichen enthalten. Wenn Textersatz fehlt, wird Name gelöscht, d. h. durch nichts ersetzt. 

Bsp 

// Ersatz für Empfehlung in Kap. 0.3 

#define bool int 

#define true 1 

#define false 0 

(b) Beenden des Ersetzens: Quelltextende oder Auftreten von: 

#undef Name 

Danach ist Name nicht mehr als zu ersetzender Bestandteil bekannt. 

Ein #undef bei unbekanntem Name ist unschädlich, ein #define bei bekanntem Namen 

bewirkt (i. a.) einen Fehler. 

(5.73) Makro mit Parameter ↗ (10.12b) 

C++ besser: inline ... (10.12a) – wird hier noch nicht besprochen. 

(5.74) Einfügungen 

// Form 1: 

#include 

// Form 2: 

#include "DateiName" 

Einfügen von der Datei DateiName (i. a. eine sog. Header-Datei) an dieser Stelle. Befehl ist 

schachtelungsfähig. 

• Form 1: Suchen an den dem Präprozessor bekannten Stellen (i. a. Verzeichnis/se für 

allg. Headerdateien) 

• Form 2: Zunächst Suche im aktuellen Verzeichnis, dann wie Form 1; diese Form ist 

geeignet für eigene Headerdateien. Falls DateiName eine Pfadangabe einschließt (DOS/ 

Windows: Zeichen ” \“ nicht doppelt im Gegensatz zu (3.25) und (5.33b)), dann Suche nur 

im angegebenen Pfad. 

△! Leider sind Leerzeichen innerhalb von < > und " " signifikant, daher Vorsicht! 

(5.75) Bedingte Übersetzung 

(a) #if KonstanterAusdruck1 

Textzeilen1 

#elif KonstanterAusdruck2 

Textzeilen2 

#else 

Textzeilen3 

#endif


Semantik: 

• Wenn KonstanterAusdruck1 WAHR (ungleich 0), werden nur Textzeilen1 genommen, 

Textzeilen2 und Textzeilen3 werden ignoriert. 

• Sonst: wenn #elif-Zeile vorhanden und KonstanterAusdruck2 WAHR (ungleich 0), 

werden nur Textzeilen2 genommen, Textzeilen3 (und natürlich auch Textzeilen1) werden 

ignoriert. 

• Sonst: wenn #else-Zeile vorhanden, werden nur Textzeilen3 genommen. 

• Sonst: keine Textzeile zwischen #if und #endif wird genommen. 

(b) Statt der #if-Zeile in (a) kann auch eine der folgenden Zeilen genommen werden: 

#ifdef Name 

#ifndef Name 

Semantik: WAHR, wenn Name (durch ein #define) definiert bzw. nicht definiert (auch 

Leerdefinition ohne Textersatz gilt als Definition); weitere Präprozessorzeilen (#endif, ggf. 

auch #else) wie bei (a). 

(c) Anwendung als Beispiel: Ausschluss von Mehrfacheinschluss einer Header-Datei ( ” Include- 

Wächter“). Hierbei kann der benutzte Name (im Beispiel BEISPIEL_H_) beliebig gewählt 

werden, er muss nur eindeutig über alle Programmdateien sein und nicht mit irgendwelchen 

C ++-Namen kollidieren. Sinnvoll ist daher ein Name, der aus dem Dateinamen zusammengesetzt 

ist. 

// Beispiel-Headerdatei BEISPIEL.H 

#ifndef BEISPIEL_H_ 

#define BEISPIEL_H_ 

// Definitionen dieser Headerdatei 

// ... 

#endif 

Ein doppeltes #include schließt die Definitionen der Datei nur einmal ein: 

#include "BEISPIEL.H" 

#include "BEISPIEL.H" // unschädlich, selbst wenn dopp. Def. unerlaubt 

Weitere Anwendung: schachtelungsfähiges Auskommentieren größerer Textteile (auch bei 

enthaltenen Kommentaren), vgl. Übungen: 

#if 0 

Textzeilen – werden ignoriert 

#endif 

(5.76) Weitere Tätigkeiten des Präprozessors (z. B.) 

• Durch Zwischenraumzeichen (auch Zeilenende) getrennte Stringkonstanten werden verkettet; 

auf diese Weise sind auch lange Stringkonstanten über mehrere Zeilen möglich. 

Bsp cout


6 Konstruktion von Baueinheiten, 

Problem der Trennung in Verborgenheit und Öffentlichkeit 

(sprachunabhängige Betrachtung) 


Dieses Kapitel – ebenso wie Kap. 2 unabhängig von einer speziellen Programmiersprache – 

stellt die Grundprinzipien dar, wie man bei größeren Programmen verfahren muss, um sie 

übersichtlich zu erhalten. 

In Unterkap. 1 wird erläutert, dass diese Übersichtlichkeit für den Menschen grundsätzlich 

nur möglich ist, indem er das zu bearbeitende Problemfeld in Teile unterteilt. Diese Zerlegungsteile 

– unabhängig davon, in welcher Art sie tatsächlich konstruiert werden – werden 

hier Baueinheiten genannt. Dieser Begriff ist kein feststehender Begriff in der Informatik; 

er wurde hier bewusst gewählt, um die grundlegenden Eigenschaften der Zerlegungsteile unabhängig 

von der Realisierung entsprechend eines gewählten Programmierstils zu beschreiben. 

Keine Softwareentwicklung ist möglich ohne ein Verständnis für das Prinzip, Baueinheiten 

zu konstruieren und sie zu benutzen. Eine sinnvoller Entwurf solcher Baueinheiten 

nutzt dabei die Chance aus, dass die Außensicht und die Innensicht dieser Baueinheiten 

durch Kapselung weitgehend entkoppelt werden kann. Die Sicht von außen beantwortet die 

Frage nach dem ” Was?“, die Sicht von innen die Frage nach dem ” Wie?“: Was leistet die 

Baueinheit? Wie verwirklicht sie es? 

Anschließend wird gezeigt, wie in drei unterschiedlichen Programmierstilen solche Baueinheiten 

gebaut und benutzt werden. 

• In der Prozeduralen Programmierung (Unterkap. 2) baut man sog. Funktionen 

oder Prozeduren, die jeweils einen kleinen oder auch größeren Teil des Lösungsweges 

beinhalten, nämlich die Kapselung einer Reihe von Aktionen. 

• Die Modulare Programmierung (Unterkap. 3) kapselt mehrere zusammengehörige 

Funktionen mit den zugehörigen Daten. Diese Daten sind je Modul genau einmal 

vorhanden. 

• Die Objektorientierte Programmierung (Unterkap. 4) generiert ebenso Kapseln 

aus Funktionen und Daten, deren Bauplan hier in Form sog. Klassen festgelegt wird. 

Zur Laufzeit können aus diesen Klassen (Bauplänen) beliebig viele Objekte erzeugt 

werden (mit jeweils einem eigenen Datensatz), die unabhängig voneinander benutzt 

und zerstört werden können. 

Außerdem wird in Unterkap. 3 der Begriff der Speicherklasse zur Charakterisierung der 

Art und Dauer der Speicherplatzreservierung für Daten zur Laufzeit eingeführt. Es werden 

dabei zwei verschiedene Speicherklassen vorgestellt: “automatisch“ (begrenzte Lebensdauer 

zur Laufzeit mit automatischer Verwaltung durch das Laufzeitsystem) und ” statisch“ 

(Speicherplätze während der gesamten Programmlaufzeit vorhanden). 

6.1 Entwurf von Systemen: Baueinheiten und Geheimnisprinzip 

(6.10) Übb Größere Programme sind für den Menschen nur dann beherrschbar, wenn das Problemfeld 

in Teile aufgeteilt wurde; die Art dieser Zerlegung hängt stark vom Programmierstil 

ab ((6.11). Diese Zerlegungsteile werden hier Baueinheiten genannt. 

Völlig unabhängig vom Programmierstil ist es sinnvoll (eigentlich sogar zwingend), diese 

Baueinheiten gekapselt zu konstruieren; dadurch wird es möglich, dass die zwei Sichten auf 

sie (nämlich die von außen und die von innen) weitgehend entkoppelt sind. Die erste Sicht 

beantwortet die Frage nach dem ” Was?“ (d. h. Was tut die Baueinheit?), die zweite nach 

dem ” Wie?“ (d. h. Wie verwirklicht sie es?), s. (6.12). Durch die weitgehende Entkopplung 

der Außen- von der Innensicht (6.13) ist die Benutzung der Baueinheit und ihre Konstruktion 

unabhängig voneinander; sie kann z. B. auch durch verschiedene Personen(gruppen) 

geschehen. Für die Benutzung (Anwendung) ist nur die Kenntnis des Was nötig, für die 

Konstruktion benötigt man die Beantwortung des Wie.


(6.11) Entwurf von Systemen 

Entsprechend der Eigenart des Menschen, nur einen begrenzten Bereich gleichzeitig erfassen 

und beschreiben zu können, gibt es für ihn nur eine einzige Möglichkeit, komplexe Systeme 

zu beherrschen, nämlich diese logisch (und auch physikalisch) zu unterteilen, um sie 

anschließend wieder zusammenzusetzen. 

Anhand des Kriteriums, wie man unterteilt, unterscheiden sich die verschiedenen Programmierstile; 

dieses Kriterium kann sogar einer ” Weltanschauung“ unterliegen, nämlich einer 

Art, wie man die Welt sieht und begreift. Zwei Arten seien herausgegriffen, da sie für diese 

Vorlesung wichtig sind: 

• Ablauforientierte Zerlegung, ” strukturierte Programmierung“ 

(auch algorithmische oder prozedurale Zerlegung): 

Die Zerlegung geschieht anhand des Handlungsablaufs, des Tuns. 

• Objektorientierte Zerlegung, ” objektorientierte Programmierung“: 

Die Zerlegung geschieht anhand der in der nachzubildenden Welt anzutreffenden, mit 

gewisser Eigenständigkeit versehenen Einheiten ( ” Objekte“ wie Dinge, Menschen, Ereignisse, 

gedachte Einheiten, z. B. Organisationseinheiten). Diesen Objekten übergibt man 

weitgehende Eigenverantwortung für ihr Handeln; sie kommunizieren miteinander, indem 

sie Nachrichten austauschen und so andere Objekte bitten, gewisse (Teil-)Aufgaben 

zu übernehmen, die diese ggf. weiter delegieren dürfen. 

Ferner gibt es die datenorientierte Zerlegung, dazu auch unterschiedliche Mischformen. 

(6.12) Bei jeder Zerlegungart – unabhängig vom Zerlegungskriterium (6.11) – ist es zweckmäßig, in 

sich abgeschlossene Baueinheiten zu erstellen. Diese Baueinheiten enthalten häufig auch 

wieder Baueinheiten feinerer Granularität oder sind in solchen größerer Granularität enthalten. 

(6.13) 

Die Baueinheiten (Steckerkomponenten, Prozeduren/Funktionen, Module, Objekte) kann 

man, wenn sie sinnvoll entworfen sind, in zwei weitgehend voneinander entkoppelten Aspekten 

betrachten: 

• Von außen: ” Was?“ 

der Benutzer oder Anwender der Baueinheit muss wissen, was die Baueinheit leistet, 

nicht wie sie es verwirklicht ( ” black box“). Ferner kann er diese Baueinheit beliebig 

oft einsetzen, ohne sie jeweils neu konstruieren zu müssen. Notwendig für den richtigen 

Einsatz: genaue Kenntnis der Übergabestelle (Schnittstelle). 

• Von innen: ” Wie?“ 

der Erbauer oder Konstrukteur der Baueinheit muss wissen, wie er die Anforderungen 

verwirklicht, die der Benutzer erwartet, z. B. welchen Algorithmus er einsetzt, welche 

Daten er verwendet. Er muss nicht die Anwendungsfälle kennen, solange er die Schnittstellenvereinbarung 

beachtet. 

Anm Entsprechend dieser beiden Betrachtungsweisen soll jetzt der Erbauer einer Baueinheit von 

dem Benutzer dieser Baueinheit (ein Programmierer mit nicht unbedingt minder guten Programmierkenntnissen) 

unterschieden werden. 

Bsp In vielen Programmiersprachen ist die Sinusfunktion implementiert: 

• Von außen: der Benutzer von sin(x) muss nur wissen, dass x im Bogenmaß anzugeben ist. 

• Von innen: der Erbauer muss ein geeignetes Näherungspolynom für die Sinus-Berechnung implementieren. 

Damit dieses Zusammenspiel zwischen Außen- und Innenbetrachtungsweise (zwischen Benutzer 

und Erbauer) richtig läuft, muss die Schnittstelle genau festgelegt sein, nämlich die 

Übergabestelle der Informationen zwischen außen und innen, zwischen der Benutzer- und 

der Erbauer-Sicht. 

(a) Es hat große Vorteile, wenn das Innere einer Baueinheit dem Benutzer gegenüber weitgehend 

verborgen ist (Geheimnisprinzip), wenn ihm nur ein kleiner Teil direkt zugänglich ist 

(Öffentlichkeit):


• Hierdurch können Benutzer und Erbauer verschiedene Personen oder gar verschiedene 

Programmierergruppen sein, die mehr oder weniger unabhängig voneinander arbeiten 

können. 

• Das Innere kann später geändert werden, ohne dass die vielen Stellen der Benutzung 

der Baueinheit geändert werden müssen. Es kann sich zudem beispielsweise später herausstellen, 

dass das Innere – inzwischen – nicht gut genug ist oder bestimmte, zunächst 

unwichtige Spezialfälle nicht berücksichtigt. 

Anm Das Jahr-2000-Problem ist ein gutes Beispiel hierfür. Allerdings konnten Programmierer 

der sechziger und siebziger Jahre kaum ahnen, dass ihre Programme bis zum Jahr 2000 

immer noch genutzt werden; ferner gab es damals kaum das Problembewusstsein Verborgenheit/Öffentlichkeit 

und auch kaum Unterstützung von Lösungsmöglichkeiten durch Programmiersprachen, 

dazu war Speicherplatz zum temporären und zum dauerhaften Abspeichern 

sehr teuer. 

(b) Dieser Schutz des Inneren vor dem Benutzer wird – je nach Möglichkeiten der Programmiersprache 

und je nach (Er-)Kenntnis des Erbauers – mehr oder weniger gut sein: 

(1) Gut ist ein Schutz, den der Benutzer nicht aus Gedankenlosigkeit oder Unachtsamkeit umgeht. 

Anm Auch Benutzer-Programmierer sind Menschen, die nicht immer an alles denken! 

(2) Gegebenenfalls wäre ein Schutz noch besser, der dem Benutzer auch ein gewolltes Eindringen 

in das Innere verwehrt – und sei der Zweck des Eindringens auch noch so hehr: z. B. 

” Tricks“ beim Programmieren, damit die Ausführung (in diesem gerade betrachteten Anwendungsfall) 

schneller läuft. 

Anm 

” Tricks“ ehren zwar zunächst den Programmierer, danach stellen sich aber meist große Nachteile 

ein, wenn nämlich ein anderer Programmierer (oder nach einiger Zeit er selbst) Fehler 

suchen oder auch nur die Funktionalität erweitern soll. 

Heutzutage ist die Hardware meist so schnell, dass häufig eine noch schnellere Ausführung 

weniger wichtig ist als die gute Wartbarkeit. 

(c) In Bezug auf spätere Wartbarkeit der Software (Änderbarkeit, Fehlersuche), dazu Erweiterungsfähigkeit, 

Wiederverwendbarkeit in anderen Projekten kann man folgende Regel 

aufstellen: 

• Verborgenheit: so viele Einzelheiten wie irgend möglich sollten dem Benutzer gegenüber 

versteckt sein. Hierfür wurde der Begriff ” information hiding“ geprägt. 

• Öffentlichkeit: nur so wenig wie gerade noch nötig sollte dem Benutzer zugänglich 

sein, und zwar (i. a.) nur über die vereinbarte Schnittstelle. 

(6.14) Die Konsequenzen aus (6.12, 6.13) sind sehr verschieden. Sie hängen ab 

• vom Anwendungsfall, 

• von der ” Weltanschauung“ (6.11) des Entwicklers, 

• von der Weitsichtigkeit des Programmierers, 

• von der eingesetzten Programmiersprache, 

• von den Kenntnissen innerhalb der benutzten Programmiersprache. 

Drei wichtige Programmierstile und ihre zugehörigen Baueinheiten sollen näher betrachtet 

werden: 

• die Prozedurale Programmierung (Kap. 6.2), 

• die Modulare Programmierung (Kap. 6.3), 

• die Objektorientierte Programmierung (Kap. 6.4). 

6.2 Prozedurale Programmierung 

(6.20) Übb In der Prozeduralen Prgrammierung bestehen die Baueinheiten jeweils aus einem 

Satz von Aktionen. Sie beschreiben daher das Tun, um einen kleinen oder größeren Teil der 

Problemlösung auszuführen. 

Je nachdem, ob der Satz der Aktionen an den Benutzer einen Wert zurückgibt oder nicht, 

unterscheidet man zwei verschiedene Arten dieser Baueinheiten: Funktionen und Prozeduren


(6.21) 

(6.21). Der Punkt (6.22) beschreibt, wie die Konstruktion von Funktionen oder Prozeduren 

( ” Definition“ genannt) und deren Benutzung ( ” Aufruf“ genannt) als Pseudocode dargestellt 

werden soll. 

Die Schnittstelle zwischen der Außen- und Innenansicht wird in Form von Parametern (6.23) 

verwirklicht (zusätzlich zur Möglichkeit der Wertrückgabe). Die Parameter beim Aufruf 

(d. h. bei der Benutzung der Funktion) heißen aktuelle Parameter, die bei der Definition 

formale Parameter. Sehr wichtig ist es hierbei, die beiden hier vorgestellten Arten der Parameterübergabe 

zu verstehen und anwenden zu können: Wertübergabe (Kopieren des Wertes 

des aktuellen Parameters auf den formalen) und Referenzübergabe (der formale Parameter 

wird zu einem Synonym für den aktuellen). 

Ein Beispiel für die (geschachtelte) Zerlegung einer Problems in Prozeduren und Funktionen 

zeigt (6.24). 

(a) Wendet man die ablauforientierte Zerlegung (6.11) an – das kann bei kleineren Problemkreisen 

vernünftig sein –, so ist es häufig sinnvoll, Teile des Handlungsablaufs zu kapseln und mit 

einem Namen zu belegen, um diese mehrfach benutzen zu können. Solche Baueinheiten nennt 

man hierbei – je nach Sprache – Funktionen, Prozeduren, Unterprogramme. 

(b) Wie in den meisten Programmiersprachen wollen wir zwei verschiedene Arten dieser 

Baueinheiten unterscheiden: 

• Funktion: Die Baueinheit liefert – nach Durchführung ihrer Aufgabe – einen Wert 

zurück, der dem Benutzer zur Verfügung steht, wie z. B. in der Mathematik bei Funktionen 

üblich (Funktionswert). Dieser Wert wird üblicherweise ” Rückgabewert“ genannt. 

• Prozedur: Die Baueinheiten liefert – nach Durchführung ihrer Aufgabe – keinen Wert 

an der Benutzungsstelle zurück, beispielsweise ein Druckauftrag. Hierbei gibt es daher 

keinen Rückgabwert. 

Die Namen für diese zwei Arten sind in den Programmiersprachen unterschiedlich, z. B.: 

• Pascal (Namen wie schon oben benutzt): Funktion, Prozedur 〈function, procedure〉, 

• Fortran: Funktion, Unterprogramm 〈function, subroutine〉, 

• C ++ und C: Funktion 〈function〉 für beide Arten. 

Bei den sprachunabhängigen Betrachtungen übernehmen wir die Bezeichnungen Funktion 

und Prozedur. Als gemeinsamer Oberbegriff soll ” Funktion“ dienen. 

(c) Das Geheimnisprinzip soll dadurch gewahrt sein, dass als Schnittstelle, d. h. für die Kommunikation 

zwischen außen und innen (6.12), nur die sog. Parameterliste dienen soll, dazu 

(wenn vorhanden) der Rückgabewert der Funktion; Näheres s. (6.22, 6.23). 

(d) Einen Programmierstil, der im wesentlichen nur solche Baueinheiten einsetzt, nennt man 

Prozedurale Programmierung. 

Gute Beispiele für die Anwendung dieses Programmierstils sind Berechnungen aus Eingabewerten, 

z. B. sin(x). Der Berechnungsalgorithmus ist völlig von der Benutzung entkoppelt. 

(6.22) Vereinbarung über die Formulierung von Prozeduren und Funktionen in der textuellen Darstellung: 

(a) Bau(-plan) der Baueinheit, meist Definition 〈definition〉 genannt: 

PROZEDUR neuProz(formalPar1 TYP typ1, formalPar2 TYP typ2) 

// . . . 

// optional: 

WENN . . . DANN 

RÜCKSPRUNG 

// . . . 

// optional: 

RÜCKSPRUNG 

ENDE PROZEDUR


FUNKTION sonderFkt(formalPar1 TYP typ1, formalPar2 TYP typ2) TYP typFkt 

// . . . 

// optional: 

WENN . . . DANN 

RÜCKSPRUNG WERT . . . 

// . . . 

RÜCKSPRUNG WERT . . . 

ENDE FUNKTION 

Beide Baueinheitarten können sog. formale Parameter haben, durch die mit ihnen kommuniziert 

werden kann; oben sind jeweils zwei Parameter angegeben. Näheres dazu s. (6.23). 

Bei beiden Baueinheiten gibt es das neue Schlüsselwort RÜCKSPRUNG; es soll bedeuten, 

dass der Steuerfluss an dieser Stelle die Baueinheit verlässt. 

Bei der Prozedur kann am Ende (direkt vor ENDE PROZEDUR) auf RÜCKSPRUNG 

verzichtet werden, da dort sowieso die Prozedur verlassen wird. 

Bei der Funktion muss mit RÜCKSPRUNG auch der Wert angegeben werden, der zurückgegeben 

werden soll; daher kann am Ende (direkt vor ENDE FUNKTION) nicht auf RÜCK- 

SPRUNG verzichtet werden, das sonst kein Rückgabewert vorhanden wäre. Außerdem hat 

der Funktionsname – nicht der Prozedurename – einen TYP, nämlich den Typ des Rückgabewertes, 

im Beispiel ” typFkt“. 

(b) Die Benutzung oder Anwendung der Baueinheit wird Aufruf 〈call〉 genannt; sie geschieht 

durch Nennung des Namens, dazu, wenn nötig, mit Angabe der zugehörigen sog. aktuellen 

Parameter: 

(6.23) Parameter 

neuProz(aktPar1, aktPar2) 

sonderFkt(aktPar1,aktPar2) 

ANFANG 

VARIABLE x, y TYP Ganzzahl 

x ← 23 

neuProz(16, 2∗x) 

y ← sonderFkt(x, 34) + 3 

Schreibe x, y 

ENDE 

(a) Es muss streng zwischen den beiden Parameterarten unterschieden werden: 

• formale Parameter – sie werden bei der Definition eingeführt, sie sind Formen, Hüllen, 

noch ohne Inhalt, 

• aktuelle Parameter – sie werden beim Aufruf angegeben, sie sind die Inhalte zu den 

Hüllen der formalen Parameter. 

Jedem aktuellen Parameter (beim Aufruf) entspricht genau ein formaler Parameter (in der 

Definition); Anzahl und Reihenfolge, ferner (nach ggf. erlaubter Anpassung) jeweils auch 

der Typ müssen übereinstimmen. 

(b) Denkbar sind viele verschiedene Arten der Verknüpfung oder der Kopplung zwischen einem 

aktuellen Parameter und seinem zugehörigen formalen Parameter. Daher unterschiedet 

man in der Informatik verschiedene Parameterübergabearten. In dieser Vorlesung sollen 

zwei von ihnen besprochen werden, nämlich die durch die Sprache C ++ unterstützten 

Parameterübergabearten: 

• Übergabe per Wert ( ” CALL BY VALUE“): der Wert des aktuellen Parameters 

wird kopiert auf den eigenen Speicherplatz des formalen Parameters, danach gibt es 

keine Verbindung mehr zwischen aktuellem und formalem Parameter. 

• Übergabe per Referenz ( ” CALL BY REFERENCE“): der formale Parameter 

wird zu einem Synonym des aktuellen Parameter, zu einer sog. Referenz; alles, was 

mit dem formalen Parameter geschieht, geschieht in Wirklichkeit mit dem aktuellen 

Parameter. 

Die Auswirkungen dieser beiden Parameterübergabearten sind je nach Zugriff innerhalb der 

Prozedur/Funktion unterschiedlich:


• Greift die Funktion nur lesend auf den formalen Parameter zu, so gibt es im Ergebnis 

keinen Unterschied zwischen den beiden Übergabarten. Es gibt lediglich Unterschiede 

im Speicher- und Zeitverhalten. 

• Wird jedoch der formale Parameter innerhalb der Baueinheit verändert (Zugriff schreibend), 

z. B. durch Zuweisung, so bemerkt im Falle der Wertübergabe der aktuelle 

Parameter nichts davon, anders jedoch im Falle der Referenzübergabe: geändert wird 

nämlich in Wirklichkeit der aktuelle Parameter, da der formale Parameter ein Synonym 

für ihn ist. 

(6.24) Bsp Ein Roboter soll folgende Aufgabe erfüllen: 

Zeichnen der untenstehenden Figur 

(zwei geschachtelte Quadrate): 

20 cm 

(Ruhestellung) 

Das gleiche 

mit Bemaßung: 

4 cm 

20 cm 

15 cm 

Der Roboter soll folgende elementare Algorithmen (2.54) kennen: 

neu fährt zum definierten Anfangspunkt 

senken senkt Schreibstift 

heben hebt Schreibstift 

längs Bewegung um eine Position des Längsschrittmotors in aktueller Richtung 

dreh Bewegung um eine Position des Drehschrittmotors in Linksrichtung 

Der Algorithmus: 

ALGORITHMUS ZweiQuadrate 

PROZEDUR bewegung (länge TYP Ganzzahl) 

// Bewegt Schreibstift um länge cm in aktueller Richtung 

VARIABLE n TYP Ganzzahl 

n ← länge/(ein Schritt des Längsschrittmotors in cm) 

WIEDERHOLE n-mal 

längs 

ENDE PROZEDUR 

PROZEDUR drehung (winkel TYP Ganzzahl) 

// Bewegt Bewegungsrichtung um winkel Grad (in math. pos. Richtung) 

VARIABLE n TYP Ganzzahl 

n ← winkel/(ein Schritt des Drehschrittmotors in Grad) 

WIEDERHOLE n-mal 

dreh 

ENDE PROZEDUR 

PROZEDUR zeichneQuadrat (kante TYP Ganzzahl) 

// Zeichnet Quadrat der Kantenlänge kante cm 

senken 

WIEDERHOLE 4-mal 

bewegung(kante) 

drehung(90) 

heben 

ENDE PROZEDUR


PROZEDUR schrägBewegung (deltaX TYP Ganzzahl, deltaY TYP Ganzzahl) 

// Bewegt Schreibstift um deltaX cm in x-Richtung, 

// um deltaY cm in y-Richtung 

bewegung(deltaX) 

drehung(90) 

bewegung(deltaY) 

drehung(270) 

ENDE PROZEDUR 

ANFANG 

neu 

schrägBewegung(20,15) 

zeichneQuadrat(20) 

schrägBewegung(8,8) 

zeichneQuadrat(4) 

neu 

ENDE 

Da bei den formalen Prozedurparametern nur lesender Zugriff geschieht, ist die Parameterübergabeart 

(Wert oder Referenz) unerheblich. 

Die beiden ersten Prozeduren sind am wenigsten komplex, die beiden anderen benutzen 

diese einfacheren Baueinheiten. Das (Haupt-)Programm (zwischen ANFANG und ENDE) 

benutzt fast nur noch die komplexeren Prozeduren. Eine solche Schachtelung von Baueinheiten 

geschieht in der Praxis sehr häufig. 

(6.25) Zur Verwirklichung von Funktions-Baueinheiten in C ++ siehe (Kap. 7). 

6.3 Speicherklassen, Modulare Programmierung 

(6.30) Übb Es ist zur Lösung mancher Aufgaben sinnvoll, mindestestens zwei verschiedene Speicherklassen 

zu unterscheiden (6.31), d. h. verschiedene Arten der Lebensdauer und Verwaltung 

von Datenspeicherplätzen. Speicherplätze, die während der gesamten Programmlaufzeit bestehen 

bleiben, gehören zur statischen Speicherklasse. Daten der automatischen Speicherklasse 

benutzen Speicherplatz nur während eines Teils der Programmlaufzeit; die Verwaltung 

(Reservierung und Freigabe) des Speichers erfolgt hierbei automatisch durch das Laufzeitsystem. 

In (6.32) wird beispielhaft gezeigt, wie statischer und automatischer Speicherplatz 

sinnvoll benutzt werden kann. 

(6.31) 

Danach wird die Modulare Programmierung (6.33) kurz vorgestellt. Hierbei fasst man mehrere 

Funktionen mit den Daten zusammen, die durch sie bearbeitet werden sollen. In C ++/C werden 

solche Module durch einzelne Programmdateien (Übersetzungseinheiten) verwirklicht. 

Ein Beispiel (6.34) in Pseudocode verdeutlicht diese Modulbildung. 

(a) Mit der Prozeduralen Programmierung ist jedoch beispielsweise der Aufbau eines Kellerspeichers 

oder (synonym) Stapelspeichers 〈stack〉 schwierig. Will man die Daten dem äußeren 

(ungewollten oder auch gewollten) Zugriff entziehen, so ist das nur möglich, wenn man eine 

” Funktion mit Gedächtnis“ bauen kann. Man muss daher statischen Speicherplatz zulassen, 

der unabhängig von der Möglichkeit des aktuellen Zugriffs über die gesamte Programmlaufzeit 

erhalten bleibt: statische Speicherklasse. 

△! Dadurch wird allerdings das Funktionskonzept aus dem vorigen Unterkapitel abgeändert 

bzw. erweitert: ein Funktionsaufruf hängt nicht mehr nur von den Parameterwerten, 

sondern nunmehr ggf. auch von früheren Funktionsaufrufen ab. Das 

kann bei unübersichtlicher Programmierung gefährlich sein. 

(b) Speicherplätze, die nur während des Durchlaufs einer Funktion reserviert bleiben, unterliegen 

der sog. automatischen Speicherverwaltung: automatische Speicherklasse; dies ist


eine Form der dynamischen Speicherverwaltung. Der Programmierer braucht sich um Reservierung 

und Freigabe dieser Speicherplätze nicht zu kümmern, das geschieht automatisch 

durch das (Laufzeit-)System. Die Variablen aller bisherigen Programme gehören zu dieser 

Speicherklasse. 

(6.32) In der textuellen Form der Programmbeschreibung soll das Wort STATISCH die Reservierung 

des zugehörigen Speicherplatzes während der ganzen Programmlaufzeit bewirken 

(statische Speicherklasse). Die Beschränkung des Zugriffs auf Anweisungen nur innerhalb 

der Funktion – völlig unabhängig vom Statisch-Sein – soll durch Ansiedlung des Speicherplatzes 

innerhalb der Funktion erfolgen. 

Bsp Kellerspeicher, gebaut mit statischen Variablen (zum Schlüsselwort FELD s. (2.53)): 

// Definition der Funktion kellerSpeicher 

FUNKTION kellerSpeicher(schiebenJaNein TYP Boolesch, 

wert TYP Ganzzahl) TYP Ganzzahl 

STATISCH VARIABLE speich TYP Ganzzahl-FELD[100] 

STATISCH VARIABLE zähler TYP Ganzzahl (Erstbelegung 0) 

WENN schiebenJaNein DANN 

// Schieben hier ohne Fehlerbehandlung (Ueberlauf) 

speich[zähler] ← wert 

zähler ← zähler+1 

SONST 

// Holen hier ohne Fehlerbehandlung 

zähler ← zähler-1 

wert ← speich[zähler] 

RÜCKSPRUNG WERT wert 

ENDE FUNKTION 

// Benutzung der Funktion kellerSpeicher 

ANFANG 

VARIABLE zahl TYP Ganzzahl 

Lies zahl 

kellerSpeicher(wahr,zahl) 

kellerSpeicher(wahr,199) 

Schreibe kellerSpeicher(falsch,0) // 199 

Schreibe kellerSpeicher(falsch,0) // eingeles. Zahl 

ENDE 

(6.33) Ein Nachteil der Funktion kellerSpeicher aus (6.32) ist es, dass das statische Array nicht zwei 

getrennten Funktionen zur Verfügung steht, z. B. schiebe(wert) und hole() 〈push, pop〉, wobei 

die erste dem Aufbau, die zweite dem Abbau des Speichers dienen soll. Eine Auslagerung 

des Speichers (hier als Array speich) aus der Funktion würde dieses Problem zwar lösen; 

dann wäre es jedoch möglich, auf den Speicher ungewollt oder gewollt zuzugreifen, ohne 

diese Zugriffsfunktionen (die auch die zugehörige Fehlerbehandlung einschließen sollten) zu 

benutzen. 

Das Problem kann man dadurch beheben, dass man eine Möglichkeit bereitstellt, mehrere 

Funktionen und zugehörige Daten zu kapseln in der Art, dass nur Teile daraus öffentlich, 

andere Teile verborgen sind. Dieses wird durch die Modulare Programmierung erreicht, 

nämlich die Aufteilung von Funktionen und der Daten auf mehrere Module mit zusätzlicher 

Angabe der Zugriffserlaubnis auf jeden der Bestandteile. Diese veränderte Programmiersichtweise 

ergibt sich demnach durch Verlagern des Schwerpunkts der Aufmerksamkeit vom 

Entwurf von Funktionen auf die Organisation von Daten, die zugehörige Zerlegung ist mehr 

datenorientiert (6.11). 

Ein solches Modul besteht aus einem Satz von verwandten Funktionen und den von ihnen 

zu manipulierenden Daten. Nun sind die Funktionen meist nicht mehr allein zu gebrauchen, 

nicht mehr ohne weiteres aus dem Modul herauslösbar (z. B. für andere Programme), sondern 

nur im Rahmen des gesamten Moduls. 

In der Praxis werden solche Module meist in Form von Übersetzungseinheiten 〈translation 

units〉 verwirklicht.


(6.34) In der textuellen Form der Programmbeschreibung soll ein Modul durch einen eigenen Kasten 

dargestellt werden. Zusätzlich werden die Zugriffsspezifizierungen VERBORGEN und 

ÖFFENTLICH eingeführt. Innerhalb des Kastens kann auf jedes Element unabhängig von 

der Zugriffsspezifizierung zugegriffen werden. Von außen sind nur die öffentlichen Bestandteile 

(direkt) zugänglich. Die Gesamtheit der öffentlichen Bestandteile heißt Schnittstelle 

des Moduls. 

Bsp Kellerspeicher aus (6.32), als Modul formuliert: 

VERBORGEN STATISCH VARIABLE speich TYP Ganzzahl-FELD[100] 

VERBORGEN STATISCH VARIABLE zähler TYP Ganzzahl (Erstbelegung 0) 

ÖFFENTLICH PROZEDUR schiebe(wert TYP Ganzzahl) 

// hier ohne Fehlerbehandlung (Überlauf) 



RÜCKSPRUNG 

ENDE PROZEDUR 

ÖFFENTLICH FUNKTION hole() TYP Ganzzahl 

// hier ohne Fehlerbehandlung 


RÜCKSPRUNG WERT speich[zähler] 

ENDE FUNKTION 

// Benutzung des Kellerspeichers 

ANFANG 


Lies zahl 

schiebe(zahl) 

schiebe(199) 

Schreibe hole() // 199 

Schreibe hole() // eingeles. Zahl 

ENDE 

(6.35) Zur Verwendung verschiedener Speicherklassen und zur Verwirklichung von Modulen (Übersetzungseinheiten) 

in C ++ siehe (Kap. 8). 

6.4 Objektorientierte Programmierung 

(6.40) Übb Die Objektorientierte Programmierung erlaubt es wie die Modulare Programmierung, 

Funktionen und Daten zu kapseln. Im Gegensatz zur Modularen Programmierung, 

wo jedes Modul genau einen Satz von Daten enthält, wird hier zwischen der Beschreibung 

der Struktur von Daten und Funktionen, der sog. Klassendefinition, und der tatsächlichen 

Erzeugung des zugehörigen Speicherplatzes zur Laufzeit, der Erzeugung der sog. Objekte, 

unterschieden. Hier können beliebig viele Objekte der gleichen Bauart (derselben Klasse) 

unabhängig voneinander erzeugt, benutzt und wieder vernichtet werden. 

Eine gute Kapselung liegt vor, wenn Daten ( ” Attribute“) von außen niemals direkt zugänglich 

sind, sondern immer nur über zugehörige Funktionen ( ” Methoden“), die dann auch die 

Kontrolle über den Zugriff ausüben, z. B. zur Wahrung der Konsistenz der internen Daten. 

Zusätzlich wird die Objektorientierung anhand eines Beispiels (6.43) näher erläutert. 

(6.41) Die Modulare Programmierung (voriges Unterkapitel) ermöglicht es zwar, eine Zugriffskontrolle 

von außen zu definieren. Ein wichtiger Nachteil ist dadurch jedoch immer noch nicht 

behoben: es können nicht mehrere Kellerspeicher nebeneinander existieren. Ein Notbehelf 

wäre zwar die Einführung mehrerer verborgener Arrays; jedoch müsste dann die Maximalzahl 

der jemals gleichzeitig benötigten Kellerspeicher von vornherein feststehen. 

(6.42) 

(a) Die Objektorientierte Programmierung gibt eine Lösung hierfür: es wird ein neuer Typ 

Klasse eingeführt, der sowohl Daten als auch zugehörige Zugriffsfunktionen beinhaltet, und


zwar mit der Möglichkeit der expliziten Zugriffskontrolle VERBORGEN oder ÖFFENT- 

LICH für jedes seiner Daten- und Funktions-Elemente. Innerhalb der Klasse kann auf jedes 

Element, auch auf ein verborgenes, zugegriffen werden, von außen direkt nur auf öffentliche 

Elemente. Eine Variable dieses Typs nennt man Objekt. Jedes Objekt hat seinen eigenen 

Satz an Daten. Die Zugriffsfunktionen sind dagegen i. a. nur einmal je Klasse zentral 

vorhanden. 

Sprachenunabhängig werden die Daten einer Klasse meist Attribute, die Funktionen meist 

Methoden genannt. In C ++ nennt man sie auch (Daten-)Elemente bzw. Elementfunktionen. 

(b) Sinnvoll im Sinne einer guten Trennung zwischen Verborgenheit und Öffentlichkeit (6.13) ist 

es hierbei, alle Attribute als VERBORGEN zu kennzeichnen und den Zugriff darauf nur 

über öffentliche Zugriffsfunktionen zu erlauben. 

(c) Die oben beschriebenen Abstraktionen reichen eigentlich noch nicht aus, um den Namen Objektorientierung 

zu vergeben. Sehr wesentlich ist noch die in (6.45a) angedeutete Erweiterung 

durch Vererbung. 

↑↑1 Seit den Anfängen geistert bei den Progammierern die Idee der Trennung der Daten von 

den zugehörigen Funktionen durch die Köpfe. Ein nicht durch Programmiertechnik Infizierter 

käme nie auf die Idee, dieses zu tun. In der realen Welt bilden (fast) immer Daten und 

zugehörige Funktionen (d. h. die Beschreibung des Zustands und die Funktionalität) eine 

Einheit, z. B. hat ein Auto eine Höchstgeschwindigkeit, ein maximales Tankvolumen, einen 

Durchschnittsverbauch (Daten); zusätzlich fährt es, hält es, verbraucht Treibstoff (Funktionen). 

Zu einem realen Auto gehören sowohl die Daten als auch die Funktionen. 

↑↑2 Der Übergang zur Objektorientierung (oder Objekttechologie) sollte sich nicht nur auf die 

Objektorientierte Programmierung (OOP) beschränken. Eine sinnvolle Ausnutzung der 

zugehörigen Ideen ist nur möglich, wenn schon weit vor der Programmierung (Implementation) 

der Ausschnitt der realen Welt, der mit der zu erstellenden Software beeinflusst werden 

soll, im Sinne der neuen Sichtweise beschrieben wird (OOA, Objektorientierte Analyse) 

und das daraus erhaltene Modell auf Software-Erfordernisse verändert bzw. erweitert wird 

(OOD, Objektorientierter Entwurf 〈design〉). Manche Autoren sprechen berechtigterweise 

von einer Änderung der Sichtweise der Welt, der Weltanschauung (wörtlich gemeint), von 

einem Wechsel des ” Weltbildes“ beim Entwickler: ” Paradigmenwechsel“, vgl (6.11). 

↑↑3 In der Modellierung der Objekttechologie geht es hauptsächlich darum, die reale Welt als ein 

Netz von interagierenden Objekten zu beschreiben. Jedes Objekt (als ein Exemplar, gebaut 

nach dem Baumuster einer Klasse) hat eine gewisse Eigenständigkeit und Eigenverantwortung. 

Eine an ihn gerichtete Nachricht oder Botschaft 〈message〉 versteht das Objekt als 

eine (höfliche) Aufforderung, entsprechend seiner Funktionalität zu reagieren. Dazu führt es 

eine seiner Methoden aus; die Art der Reaktion ist seiner Eigenverantwortung unterstellt, da 

die Methode zu ihm gehört, vgl. (6.11). 

↑↑4 Die Sichtweise der Welt in der Objekttechologie ist ganzheitlich; sie lässt Objekte als Einheiten 

miteinander kommunizieren. Viele Programmierer, die der herkömmlichen Programmiersichtweise 

unterliegen, haben große Schwierigkeiten, den Paradigmenwechsel zu vollziehen. 

↑↑5 Leider kann in der aktuellen Vorlesung nur wenig auf dieses ” Weltbild“ (Paradigma) eingegangen 

werden; intensiver kann dieses in entsprechenden Kursen des Hauptstudiums geschehen. 

(6.43) Bsp Kellerspeicher aus (6.34), objektorientiert entworfen:


KLASSE Keller 

VERBORGEN VARIABLE speich TYP Ganzzahl-FELD[100] 

VERBORGEN VARIABLE zähler TYP Ganzzahl (Erstbelegung 0) 

ÖFFENTLICH PROZEDUR schiebe(wert TYP Ganzzahl) 

// hier ohne Fehlerbehandlung (Überlauf) 



RÜCKSPRUNG 

ENDE PROZEDUR 

ÖFFENTLICH FUNKTION hole() TYP Ganzzahl 

// hier ohne Fehlerbehandlung 


RÜCKSPRUNG WERT speich[zähler] 

ENDE FUNKTION 

ENDE KLASSE 

// Benutzung des Kellerspeichers: 

ANFANG 

VARIABLE keller1, keller2 TYP Keller 


Lies zahl 

keller1.schiebe(zahl) 

keller2.schiebe(199) 

Schreibe keller1.hole() // eingeles. Zahl 

Lies zahl 

keller2.schiebe(zahl) 

Schreibe keller2.hole() // eingeles. Zahl 

Schreibe keller2.hole() // 199 

ENDE 

Neu ist das Schlüsselwort KLASSE (und ENDE KLASSE); hierdurch werde eine Klasse 

definiert. Der Zugriff auf eine Methode eines Objekts geschehe durch die Aufrufsyntax 

ObjektName.MethodenName ( ... ) . 

(6.44) Zur Verwirklichung von Klassen-Baueinheiten in C ++ siehe (Kap. 9). 

(6.45) ↑↑ 

(a) Die Einführung des Klassentyps, d. h. die Kapselung von Daten und Funktionen, reicht noch 

nicht aus, um die reale Welt genügend einfach und übersichtlich beschreiben zu können. 

Manche Autoren sprechen daher bei den bisher geschilderten Gedanken von objektbasierter 

Programmierung, die zugehörigen Datentypen werden auch manchmal abstrakte Datentypen 

genannt. Die Objektorientierung erhält ihre Mächtigkeit erst durch die Einführung von 

Beschreibungsmöglichkeiten für Ähnlichkeiten von Klassen: die Vererbung 〈inheritance〉. 

Eine Oberklasse (〈super class〉, in C ++ Basisklasse genannt 〈base class〉) vererbt ihre Merkmale 

(Daten und Funktionen) an eine Unterklasse (〈subclass〉, in C ++ abgeleitete Klasse 

genannt 〈derived class〉). Diese erhält die Möglichkeit, diese Merkmale zu erweitern oder zu 

überschreiben (ersetzen). 

(b) Auch zeigt es sich, dass es manchmal hilfreich ist, Klassen zu formulieren, deren Elemente 

vom Typ her noch nicht festgelegt sind; eine Festlegung erfolgt erst, wenn die Klasse eingesetzt 

wird: Schablone 〈template〉. Schablonen werden insbesondere bei Containerklassen 

(oder kurz Containern) wichtig, bei Klassen, die eine Ansammlung von Elementen eines 

Typs verwalten. 

Die Vererbung wird in (Kap. 11.3) eingeführt, Schablonen können leider nicht besprochen werden.


7 Prozedurale Programmierung 


Die prozedurale Programmierung ist – sprachunabhängig – in (Kap. 6.2) näher beschrieben. 

Sie setzt im wesentlichen nur Prozeduren oder Funktionen als Baueinheiten ein. 

Eine Funktion oder Prozedur – beides in C ++ Funktion genannt – ist eine Zusammenfassung 

von Programmcode unter einem Namen, so dass man diesen Code öfters nur unter Nennung 

des Namens ausführen kann; hierzu gehören meist auch aktuell immer neu besetzbare 

Parameter. Unterkap. 1 beschreibt, wie eine solche Funktion definiert (gebaut) und wie sie 

aufgerufen (benutzt) werden kann. 

Da in C ++ der Grundsatz gilt, dass dem Compiler vor der Benutzung eines Namens dieser ihm 

erst einmal vorgestellt werden muss, kann die richtige Reihenfolge (Definition einer Funktion 

vor ihrem ersten Aufruf) manchmal recht schwierig sein. Daher wendet man sehr häufig die 

Möglichkeit an, Funktionen anzukündigen, ohne sofort den Funktionscode zu zeigen. Dieses 

wird Funktionsdeklaration genannt (Unterkap. 2). 

Die Referenz erlaubt es, für bereits vorhandene Variable synonyme Namen zu vergeben 

(Unterkap. 3). Dieses wird allgemein nicht sehr häufig angewendet, jedoch im speziellen Fall 

der Funktionsparameter häufiger (Unterkap. 4). Hier wird ausführlich beschreiben, dass es 

in C ++ zwei streng zu unterscheidende Übergabearten für Funktionsparameter gibt (Wert 

und Referenz) und wie diese beiden Arten sinnvoll angewendet werden. 

Der Gültigkeitsbereich von Namen kann lokal (blockbezogen) oder global (dateibezogen) 

sein. Unterkap. 5 beschreibt diesen Sachverhalt und gibt sehr wichtige Programmierhinweise, 

welche Namen global und welche lokal sein sollen. 

Nach einigen Ergänzungen zu Funktionen in Unterkap. 6 führt Unterkap. 7 in das Gebiet der 

Rekursion bei Funktionen ein. Eine solche Rekursion kann in manchen Fällen die Programmierung 

sehr erleichtern. Es kann sein, dass es hier zunächst Probleme beim Verständnis 

gibt, daher sollten Sie den Erläuterungen in der Vorlesung genau folgen. 

Das Kapitel wird abgeschlossen mit einigen Hinweisen, wie man Funktionen erstellen sollte, 

damit sie gut sind. 

7.1 Funktionsdefinition und Funktionsaufruf, Gültigkeitsbereich in Blöcken 

(7.10) Übb Zunächst lernen Sie zu unterscheiden: 

(7.11) 

• Funktionsaufruf: Benutzung einer Funktion, hierzu benötigt man nur die Antwort auf 

die Frage ” Was?“ (Was leistet die Funktion?), s. (7.12), vgl. (6.12). 

• Funktionsdefinition: Konstruktion/Bau einer Funktion, hierbei geschieht die Beantwortung 

der Frage nach dem ” Wie?“ (Wie verwirklicht die Funktion das, was von ihr 

verlangt wird?), s. (7.11). 

In Punkt (7.13) wird ein Beispielprogramm vorgestellt mit Funktionsdefinitionen und Funktionsaufrufen. 

Eine Funktion aufzurufen bedeutet für den Prozessor zur Laufzeit eine große Verwaltungsarbeit. 

Die einzelnen Schritte, wie dieses geschieht, sind in (7.14) beschrieben. Es ist nützlich, 

dieses zu wissen; für das Programmieren selbst ist es meist weniger wichtig. 

Die Aktionen bei der Ausführung einer Funktion stehen in einer ZusammengesetztenAnweisung, 

dem Funktionsblock. (7.15) beschreibt daher Regeln für den Gültigkeitsbereich von 

Namen in Blöcken, auch z. B. in geschachtelten Blöcken. 

(a) 10/33 FunktionsDefinition (spezielle Deklaration, vereinfacht) 

12,14 RückgabeTyp 30,32(Alt.4) FunktionsBezeichner ( Parameterdeklarations-LISTEopt ) 

54 ZusammengesetzteAnweisung


Parameterdeklarations-LISTE (vereinfacht) 

Typ FormalerParameter [- , Typ FormalerParameter ]- 0..n 

FormalerParameter Bezeichner 

Der RückgabeTyp gibt den Typ des Rückgabewertes der Funktion an; entsprechend (6.21b) 

unterscheidet man zwei Arten von Funktionen: 

• Funktion mit Rückgabewert: ” normaler“ Rückgabetyp, der Funktionsname hat am Aufrufort 

den Typ und den zugehörigen Wert (letzteres: Haupteffekt des Funktionsausdrucks). 

• Funktion ohne Rückgabewert: Typ void. 

Bsp s. (7.13) 

Anm Die ZusammengesetzteAnweisung ist der Funktionsblock. 

↑↑ C △! In der Sprache C sollte eine Funktion ohne Parameter statt mit einer leeren Parameterliste 

mit dem Schlüsselwort void definiert werden, Näheres s. (7.23 Anm4). 

(b) Der Rücksprung aus der Funktion wird durch eine zusätzliche Anweisung bewirkt, durch 

eine 53 SprungAnweisung; sie kann an mehreren Stellen der Funktion auftreten: 

return Ausdruckopt ; 

Führt der Programmfluss auf eine return-Anweisung, wird die Funktion direkt verlassen: 

• Bei einer Funktion mit Rückgabewert darf der Ausdruck nicht fehlen. Er gibt nämlich 

den aktuellen Rückgabewert an. 

Anm Der Ausdruck wird aus Übersichtlichkeitsgründen häufig in ( ) gesetzt; dieses ist 

syntaktisch erlaubt, aber nicht notwendig. 

• Bei einer void-Funktion muss Ausdruck fehlen. In diesem Fall darf eine return- 

Anweisung am Ende der Funktion fehlen, da sie dann implizit durch den Compiler 

eingefügt wird. 

(7.12) Der Aufruf (d. h. die Benutzung) der Funktion geschieht durch einen Ausdruck: 

FunktionsaufrufAusdruck FunktionsBezeichner ( Parameter-LISTEopt ) 

Parameter-LISTE AktuellerParameter [- , AktuellerParameter ]- 0..n 

AktuellerParameter Ausdruck 

Beim Aufruf einer Funktion springt der Kontrollfluss in die Funktion (und zwar zum Anfang 

des Funktionsblocks); er kehrt zum Aufrufort zurück, sobald er auf ein return oder auf das 

Ende des Funktionsblocks trifft. 

Der FunktionsaufrufAusdruck kann zwei Effekte haben, vgl. (3.31): 

• Seiteneffekt (immer vorhanden): Sprung in die Funktion, Ausführung des Codes, 

• Haupteffekt (Wert des Ausdrucks): 

◦ Haupteffekt ist vorhanden bei Funktion mit Rückgabewert, nämlich der Wert des 

Ausdrucks der return-Anweisung, mit der die Funktion verlassen wurde. 

◦ Haupteffekt ist nicht vorhanden bei Funktion ohne Rückgabewert, d. h. bei einer 

void-Funktion. Daher ist ein Funktionsaufruf ohne Rückgabewert nur dort erlaubt, 

wo der Ausdruckswert ignoriert wird, z. B. bei der Ausdrucksanweisung (3.32a). 

Korrespondenzprinzip bezüglich der Parameter-LISTE: Anzahl, Typ, Reihenfolge der aktuellen 

Parameter müssen zu den formalen Parametern passen – wenn nötig, nach impliziter 

Typanpassung. 

Bsp s. (7.13) 

(7.13) Der Kontrollfluss eines C ++/C-Programms beginnt immer am Anfang der main-Funktion. 

Bsp Beispielprogramm für Funktionsdefinition und Funktionsaufruf 

#include // Beispielprogramm D07-13.CPP 


int wertPlus1(int wert) // -- kürzer, aber gleichwertig: -- 

{ 

int ergebnis; // int wertPlus1(int wert)


ergebnis=wert+1; // { 

return ergebnis; // return wert+1; 

} // } 

int summe(int par1, int par2) // int summe(int par1, int par2) 

{ // { return par1+par2; } 

int ergebnis; 

ergebnis=par1+par2; 

return ergebnis; 

} 

int zahlFest() // int zahlFest() 

{ // { return 4711; } 

int wert; 

wert=4711; 

return wert; 

} 

void intDruck(int wert) // Aufruf ist Ausdruck ohne Haupteffekt 

{ cout


(f) Wenn return-Ausdruck vorhanden: Auswerten des Ausdrucks, typmäßige Anpassung 

an den Rückgabetyp der Funktion (wenn nötig), temporäres Abspeichern dieses Wertes; 

vorher Ausführen aller Seiteneffekte des Ausdrucks (wenn vorhanden). 

(g) Wenn lokale (automatische) Variablen vorhanden waren: Freigabe des zugehörigen Speicherplatzes, 

vgl. (d). 

(h) Rücksprung zur gemerkten Aufrufstelle, vgl. (b). 

(i) Wenn Parameter vorhanden waren: Freigabe des Speicherplatzes der formalen Parameter, 

vgl. (a2). 

(j) Bei Funktion mit Rückgabewert (f): der Wert des Funktionsnamens an der Aufrufstelle 

ist der gemerkte return-Wert. 

(7.15) Regeln für Gültigkeitsbereich in Blöcken, Auflösung von Namenskonflikten 

(Ergänzung zu (4.12), Zusammenfassung s. (Kap. 7.5); Ausnahmen zu mancher dieser Regeln s. in den 

Anmerkungen) 

(a) Namen, die in einem Block ( 54 ZusammengesetzteAnweisung, z. B. Funktionsblock, aber auch 

in einem untergeordneten Block) deklariert werden, heißen lokale Namen. 

Der Gültigkeitsbereich 〈scope〉 eines lokalen Namens erstreckt sich vom Deklarationspunkt 

(siehe [Dekl.-Punkt] in 11 ) bis zum Ende dieses Blocks. 

Innerhalb der Blockebene, in dem der Name deklariert ist, muss er eindeutig sein, er darf 

nicht mehrfach unterschiedlich deklariert sein (genauer: s. (Anm1)). 

(b) Ein Name wird in untergeordneten Blöcken verdeckt, indem er dort neu deklariert wird; 

nach Austritt aus diesem Block ist der Name in der alten Bedeutung (bei Variablen: auch 

mit altem Wert) wieder verfügbar. 

(c) △! Variablen, die innerhalb eines Blocks definiert sind, haben beim Einsprung in diesen 

Block keinen definierten Wert! Daher ist eine Wertbelegung – sie kann durch eine Initialisierung 

oder z. B. auch durch eine Wertzuweisung erfolgen – vor erstem Lesegebrauch 

unbedingt nötig!! 

↗ Ausnahmen hiervon sind Objekte, wenn sie gut gebaute Konstruktoren haben (9.21), 

ferner auch statische Variablen (8.12). 

Bsp Unsinnige Funktion, da gefahr einen zufälligen Wert erhält: 

int unsinn(int wert) 

{ int gefahr; 

return wert+gefahr; // Unsinn! Gefährlich!! Nein!! 

} 

(d) Die Speicherplatzreservierung für lokale Variable der hier besprochenen Art erfolgt automatisch 

beim Einsprung in den zugehörigen Block, der Platz wird bei Verlassen des Blocks 

automatisch wieder freigegeben – daher der Name ” automatische“ Variable (vgl. (7.14 d,g) bei 

Funktionsblöcken) bzw. automatische Speicherklasse (6.31b). Die Reservierung bleibt auch in 

untergeordneten Blöcken erhalten – auch bei Überdeckung des Namens. 

↗ Zur Speicherplatzreservierung für lokale statische Variable siehe (8.11, 8.12), dazu auch 

(6.31a). 

(e) Die formalen Parameter gelten bzgl. dieser Regeln (Gültigkeitsbereich, Eindeutigkeit, 

Überdeckungsmöglichkeit) als im äußeren Funktionsblock definiert. 

Wichiger Unterschied zu den automatischen Variablen: die formalen Parameter werden durch 

die aktuellen Parameter initialisiert, sie haben demnach beim Einsprung in die Funktion 

Anfangswerte. 

Anm1 Mehrfache, nicht widersprüchliche Deklarationen sind erlaubt – wie bei Funktionen, s. 

(7.23 Anm3). 

Anm2 Eine Definition darf in derselben Blockebene nur einmal erfolgen. 

↑↑ Bei Aufzählungen und Klassen/Strukturen sind Ausnahmen hiervon möglich, s. (Cpp/ 

5.1). 

Anm3 Es gibt keinen Namenskonflikt mit ggf. gleichlautenden Namen innerhalb anderer Funktionen. 

(f) Bsp Das folgende Beispielprogramm ist kein gutes Programmierbeispiel, da es sehr un-


übersichtlich ist: unnötige Blockschachtelung und Mehrfachdefinition desselben Namens. 

Trotzdem ist es wichtig, es zu verstehen; es dient daher nur zum Lernen, zur Übung. Die 

Kennzeichnungen *xxx* in den Kommentaren deuten die verschiedenen Speicherplätze mit 

demselben Namen an. 



void druck(int wert) 

{ cout


muss jedoch wissen, was der Name bedeuten soll – spätestens beim ersten Funktionsaufruf. 

Dazu dient eine Funktionsdeklaration; sie führt den Namen ein, teilt dem Compiler mit, 

welche Parameter und welchen Rückgabetyp die Funktion hat. 

Funktionsdeklarationen werden in C ++/C sehr häufig benutzt, selbst dann wenn sie vermeidbar 

wären, weil die Definition vor dem ersten Gebrauch geschehen könnte. 

(7.23) 10/11 FunktionsDeklaration 

12/14 RückgabeTyp 30/32,Alt.4 FunktionsBezeichner ( ParameterDekl.-LISTEopt ) ; 

Eine Funktionsdeklaration ist syntaktisch einer Funktionsdefinition sehr ähnlich, s. (7.11a), 

nur statt des Funktionsblockes (ZusammengesetzteAnweisung) steht ein Semikolon. 

Mit der Funktionsdeklaration erhält der Compiler die Information über: 

• Funktionsname, 

• Signatur der Funktion (Anzahl, Typ, Reihenfolge der Parameter), 

• Rückgabetyp. 

Es fehlt ihm hier nur noch die Information über die Einsprungadresse in die Funktion, s. 

(7.14c). Diese Einsprungadresse muss später eingesetzt werden, und zwar 

• durch den Compiler, wenn die Definition später in der gleichen Programmdatei erfolgt, 

• durch den Linker, wenn die Funktion woanders definiert wird. 

Bsp Deklaration aller Funktionen aus Beispielprogramm (7.13): 

int wertPlus1(int wert); 

int summe(int par1, int par2); 

int zahlFest(); 

void intDruck(int wert); 

Anm1 In den Headerdateien sind viele Funktionsdeklarationen vorhanden, z. B. 

: get, getline; 

: strcpy, strcat, strlen. 

Anm2 In einer Deklaration (i. a. nicht in einer Definition) ist es erlaubt, den Namen – nicht den 

Typ – der formalen Parameter wegzulassen. 

Empfehlung: Namen nicht weglassen, da (hoffentlich!) die Bedeutung der Parameter beschreibend 

( ” selbstdokumentierender Name“). 

Beispiel: 

double potenz(double basis, double exp); // empfohlen 

double potenz(double, double); // erlaubt - aber Bedeutung der Par.? 

Anm3 Eine Funktionsdeklaration darf mehrfach vorhanden sein, solange sich die Deklarationen 

nicht widersprechen (Übereinstimmung Name, Signatur, Rückgabetyp – Parameternamen 

dürfen unterschiedlich sein; eine unterschiedliche Signatur führt zu unterschiedlichen Funktionen, 

vgl. (7.61)). Eine Deklaration ist auch erlaubt, wenn die Funktion nicht aufgerufen 

wird. Eine Funktionsdefinition dagegen darf nur genau einmal auftreten; wenn die Funktion 

nicht benutzt wird, darf sie auch fehlen. 

↑↑ Bei virtuellen Elementfunktionen (einer Klasse) muss auch dann eine Definition vorhanden 

sein, wenn die Elementfunktion nicht benutzt wird, siehe (11.42 ↑↑1). 

Anm4 C △! Wenn kein Parameter vorhanden ist, dann sollte in der Definition und in der Deklaration 

auf jeden Fall statt 

RückgabeTyp FunktionsName() // leere Parameterliste 

besser folgendes geschrieben werden: 

RückgabeTyp FunktionsName(void) 

7.3 Referenztyp 

Die Schreibweise mit void ist auch in C++ erlaubt, aber nicht nötig; in C ist sie sehr 

wichtig, da die Schreibweise mit leerem Klammernpaar aus historischen Gründen eine andere 

Bedeutung hat (Funktion mit einer nicht näher spezifizierten Anzahl von Parametern). 

(7.30) Übb Durch eine Referenz wird zu einer bereits existierenden Variablen ein Synonym erzeugt, 

d. h. ein zusätzlicher Name, der auf denselben Speicherplatz wie der Originalname 

verweist. In diesem Unterkapitel wird allgemein gezeigt, wie in C ++ eine Referenz erzeugt


und benutzt wird. In der Praxis geschieht dieses fast nur in Verbindung mit Funktionen, 

nämlich als Funktionsparameter; dieses beschreibt das darauf folgende Unterkapitel. 

(7.31) C++ Neuer Typ: Referenztyp. 

(a) Mit einer Referenz wird ein Synonym (Zweitname, Aliasname) für eine bereits vorhandene 

Variable erzeugt. Daher sind unbedingt die beiden Schritte zu unterscheiden: 

• Initialisierung der Referenz, d. h. Setzen der Referenz; hierdurch wird der neue Name 

mit einer bereits existierenden Variablen verknüpft. 

• Benutzen der Referenz, und zwar als Synomym für diese andere Variable. 

DefinitionReferenzMitInitialisierung [NV] Typ &Bezeichner = OriginalVariable ; 

Typ der Referenz: wie Typ ohne das Zeichen &. 

Bsp Programmfragment mit Definition und Benutzung Referenz: 

int i; 

int &j=i; // Setzen der Referenz, ab jetzt i und j synonym 

// Beide Definitionen kürzer: int i, &j=i; 

i=5; 

cout


wird, braucht der aktuelle Parameter keine Datenspeicher-Adresse zu haben, er kann daher 

auch ein beliebiger (Rechen-)Ausdruck sein. Nach dem Kopieren existiert keine Verknüpfung 

mehr zwischen formalem und aktuellem Parameter. Eine Änderung des Wertes des formalen 

Parameters (eigener Speicherplatz!) ändert nicht den aktuellen Parameter. 

Bsp s. (7.45). 

(7.43) Übergabeart Referenz ( ” CALL BY REFERENCE“) C++ 

(7.44) 

Der formale Parameter wird innerhalb der Funktion zu einem Synonym des aktuellen Parameters 

(das ist in diesem Fall die Bedeutung von Initialisierung). Jede Änderung des Wertes 

des formalen Parameter wirkt implizit auf den aktuellen Parameter. Wie allgemein zum 

Referenztyp in (7.31) beschrieben, sind auch hier die beiden Schritte Initialisierung und Benutzung 

zu unterscheiden: 

• Initialisierung (Setzen) der Referenz: der formale Parameter wird bei jedem Funktionsaufruf 

mit dem (jeweils) aktuellen Parameter initialisiert. 

Bei dieser Übergabeart muss der aktuelle Parameter eine Variable sein, d. h. er muss eine 

Datenspeicher-Adresse haben; der aktuelle Parameter darf kein (allgemeiner) Ausdruck 

sein. Ausnahme: konstante Referenz (7.44b). 

• Benutzung der Referenz: Benutzen des formalen Parameters innerhalb des Funktionsblockes. 

DefinitionFormalerParameterReferenztyp [NV] Typ &Bezeichner 

Die Initialisierung geschieht durch den Funktionsaufruf, vgl. dagegen (7.31). 

Bsp s. (7.45). 

Anm Mit dieser Übergabeart ist es möglich, mehr als einen Wert aus einer Funktion zurückzuerhalten. 

↑↑ C/C++ Eine andere Möglichkeit, veränderte Werte aus der Funktion zurückzuerhalten, ist die 

(explizite) Benutzung von Zeigern – trotz CALL BY VALUE, vgl. (5.65a). 

Bei der Benutzung von Arrays als Funktionsparameter sind einige wichtige Besonderheiten 

zu beachten, s. (7.46). 

(a) Die Syntax eines Funktionsaufrufs lässt leider nicht erkennen, ob eine Wert- oder Referenzübergabe 

geschieht; das ist nur bei der Funktionsdeklaration oder -definition ersichtlich. 

Daher ist die Übersichtlichkeit und Nachvollziehbarkeit am Ort des Funktionsaufrufs nicht 

gegeben, wenn man nicht weiß, ob die aktuellen Parameter durch den Funktionsaufruf 

geändert werden können – es sei denn, der aktuelle Parameter ist nicht oder nicht nur 

eine Variable (dann keine änderbare Referenz möglich). Es gibt daher Autoren, die empfehlen, 

eine änderbare Referenz zu vermeiden. Dies ist jedoch für Personen, die C ++ gelernt 

haben, ohne vorher tiefe C-Kenntnisse zu haben, nicht problemvoll, da sie gewohnt sind, mit 

Referenzen zu rechnen. 

(b) Welche Übergabeart gewählt werden soll, hängt zunächst davon ab, ob der Parameter durch 

den Funktionausfurf nicht verändert wird bzw. werden soll (1) oder ob man einen geänderten 

Wert zurückerhalten will (2). 

(1) Wenn ein Parameter durch die Funktion nicht geändert werden soll (auch nicht durch 

einen versehentlichen Programmierfehler), ist folgendes zu beachten: 

• Die normale Übergabeart, insbesondere bei eingebauten Typen, sollte CALL BY 

VALUE sein.


• C++ Jedoch manchmal, insbesondere wenn die Variable großen Speicherbedarf beinhaltet, 

möchte man zur Laufzeit den Extraspeicher und die Kopierzeit eines CALL BY 

VALUE sparen, trotzdem aber sicher sein, dass der aktuelle Parameter nicht geändert 

werden kann, auch nicht bei einem ungewollten Programmierfehler in der Funktion. 

Dazu bietet sich die konstante Referenz an (7.31b). Dieses wird sehr oft bei Objekten 

getan (Kap. 9). 

Syntax: 

DeklarationKonstanteReferenz [NV] 14/20 const Typ &Variable 

Bei konstanter Referenz ist als aktueller Parameter ein Ausdruck, ggf. sogar anderen 

Typs, erlaubt (Zwischenspeicherung in temporärer Variable). 

(2) Wenn ein Parameter durch die Funktion geändert werden soll, ist folgendes zu tun: 

• Anwenden der (nichtkonstanten) Referenzübergabe 

• oder einer anderen Möglichkeit (Zeiger), weitere Diskussion siehe (12.42, 12.43). 

Bsp s. (7.45). 

(7.45) Bsp Beispielprogramm zu Parameterübergabe Wert und Referenz (nichtkonstant und konstant); 

in der Vorlesung wird die Speicherbelegung besprochen. 



// Funktionsdeklarationen; Definitionen s. unten 

void tauschDenkste(int par1, int par2); 

void tausch(int &par1, int &par2); 

int neuWert(int par1, const int &par2, int &par3); 

int main() 

{ 

int i, j, k; 

} 

// Vertauschen nein und ja: 

i=5; j=7; 

tauschDenkste(i,j); 

cout


} 

int merk; 

merk=par1; 

par1=par2; 

par2=merk; 

int neuWert(int par1, const int &par2, int &par3) 

{ 

par1+=5; // erlaubt, aktueller Parameter jedoch unverändert 

} 

//par2+=8; // wäre NICHT erlaubt, da konstant; 

// aktueller Parameter würde nämlich verändert 

par3+=2; // erlaubt, da nichtkonstante Referenz 

return par1+par2+par3; 

(7.46) Besonderheiten zu Arrays als Funktionsparameter C/C++ 

Bei Benutzung eines Arraynamens als Parameter liegt scheinbar eine Referenzübergabe 

vor (Genaueres s. ↑↑), d. h. die Wirkung ist wie eine Referenzübergabe. Aus diesem Grund 

ist es möglich, Arrays als Funktionsparameter zu verändern, vgl. strcpy, strcat (VP5.53ab). 

Ein echtes CALL BY VALUE eines Arrays (im Sinne einer lokalen Kopie innerhalb der 

Funktion) ist in C ++/C nicht möglich. Daher sollte, wenn die Funktion das Array nicht 

verändern soll, unbedingt ein const benutzt werden. 

Als Typ des formalen Paramters beim Array kann der tatsächliche Arraytyp angegeben 

werden (ohne das Zeichen &), die Anzahl Elemente (nicht aber das Paar eckiger Klammern) 

kann dabei ausgelassen werden. Im einzelnen wird dieses in (12.44a) diskutiert, dort wird auch 

die üblichere Art der Typangabe beschrieben. 

Bsp Funktionsdeklaration, der Parameter ist ein int-Array mit 20 Elementen (bei der Funktionsdefinition 

müsste statt des Semikolons der Funktionsblock stehen): 

void tuWas(int arr[20]); // Funktionsdeklaration 

Gleichbedeutend wäre folgende Deklaration (die Zahl 20 ist weggelassen): 

void tuWas(int arr[]); 

Ein Aufruf der Funktion (z. B. innerhalb von main()) mit vorheriger Definition eines passenden Arrays 

könnte so aussehen: 

int vieleGanzzahl[20]; 

tuWas(vieleGanzzahl); 

Wesentlich besser als obiger Programmtext wäre allerdings die Benutzung einer symbolischen Konstante 

(5.44): 

const int anzIntArr=20; 

void tuWas(int arr[anzIntArr]); 

oder Anzahl innerhalb des eckigen Klammerpaares weggelassen wie oben: 

void tuWas(int arr[]); 

Aufruf, z. B. innerhalb main(): 

int vieleGanzzahl[anzIntArr]; 

tuWas(vieleGanzzahl); 

Soll das Array in der Funktion nicht verändert werden, so ist ein const dem Arraytyp voranzustellen: 

void tuWasOhneAend(const int arr[20]); // Funktionsdeklaration 

oder (die Zahl 20 ist weggelassen): 

void tuWasOhneAend(const int arr[]); 

Beim Funktionsaufruf ändert sich nichts: 

int vieleGanzzahl[20]; 

tuWasOhneAend(vieleGanzzahl);


↑↑ Nähere Begründung, vgl. (10.26) und (12.44): 

Da Arraynamen nach ihrer Deklaration automatisch (fast) immer in Zeiger auf ihr Element 

Nummer 0 umgewandelt werden, sieht ein Arrayname-Gebrauch wie ein CALL BY REFE- 

RENCE aus, ist aber tatsächlich ein CALL BY VALUE eines Zeigers, vgl. (5.65b). 

In Wirklichkeit wird demnach ein Zeiger übergeben. Dieses ist auch der Grund dafür, dass 

innerhalb einer Funktion der Ausdruck 

sizeof(ParameterArrayName) 

anders interpretiert wird als vielleicht zunächst gedacht: es ist nämlich der Speicherplatzbedarf 

des Zeigers (z. B. 4 Byte) – und nicht der Speicherplatzbedarf für das Original-Array, 

s. (12.44d). 

7.5 Globale und lokale Namen 

(7.50) Übb Zunächst werden die Begriffe lokaler Name (nur innerhalb eines Blocks gültig) 

und globaler Name (gültig praktisch in der ganzen Programmdatei) vorgestellt (7.51). Eine 

einfache Schachtelung von Blöcken wird durch die Verdeckung (7.52) ermöglicht, da durch sie 

Namenskonflikte weitgehend vermieden werden können. Für einen guten Programmierstil 

ist es unerlässlich zu wissen, dass Variable (fast) nie global sein sollen; globale Konstante 

und Typen sind dagegen meist sehr sinnvoll (7.53). 

(7.51) Globale und lokale Namen 

(a) Namen (z. B. von Variablen oder Typen) heißen lokal (früher auch: intern), wenn sie innerhalb 

eines Blocks deklariert werden, vgl. (4.12) und (7.15a). Ihr Gültigkeitsbereich 〈scope〉 

reicht von ihrem Deklarationspunkt (direkt hinter den Namen, genauer: hinter 11 dem Deklarator) 

bis zum Ende des Blocks, in dem sie deklariert sind. Die formalen Parameter 

einer Funktion gelten hierbei als im äußersten Funktionsblock deklariert, d. h. es sind lokale 

Namen (7.15e). 

△! Aufpassen – bereits in (4.13) erwähnt: im allgemeinen werden lokale Variablen (wenn 

sie automatisch sind, s. (8.13)) nicht automatisch initialisiert. Daher sollten Sie sie 

explizit initialisieren oder ihnen kurz nach der Definition einen Wert zuweisen. 

(b) Namen (z. B. von Variablen oder Typen) heißen global (früher auch: extern), wenn sie 

außerhalb von Blöcken deklariert werden. Ihr Gültigkeitsbereich reicht von ihrem Deklarationspunkt 

bis zum Ende der Übersetzungseinheit. 

(c) Klassenelemente unterliegen dem Gültigkeitsbereich Klasse, s. (9.12a). 

(7.52) Namen müssen – in der Ebene ihrer Deklaration – eindeutig sein. Dagegen wird ein (lokaler 

oder globaler) Name durch die Deklaration des gleichen Namens in einem untergeordneten 

Block verdeckt; bei Verlassen dieses Blocks ist der Name in der alten Bedeutung wieder 

verfügbar, vgl. (7.15b). 

C++ Auf globale Namen kann – unabhängig von einer Verdeckung – immer zugegriffen 

werden mit Hilfe des Bereichsauflösungsoperators :: (Op1a); die Verdeckung von lokalen 

Namen kann nicht durchbrochen werden. 

Anm Zusammenfassung s. a. (Cpp/5.1); ↑↑ in dortiger Anmerkung sind auch Ausnahmen von obiger 

Eindeutigkeitsregel vermerkt. 

(7.53) Allgemeine Richtlinien für die Definition und Benutzung globaler Namen: 

• Globale Variablen sind in einem Programm kaum durchschaubar, da sie überall 

geändert werden können. Daher sind sie (für diesen Kurs) nicht erlaubt. Allgemein 

sollten sie vermieden werden wann immer möglich. 

• Dagegen machen globale Konstanten häufig Sinn; ihr Wert kann ja nirgendwo 

geändert werden. 

Übrigens, zur Wiederholung: benutzen Sie symbolische Konstanten anstatt konstanter Zahlen 

wo immer möglich, s. (4.72) und (5.44). 

• Typnamen sind oft global, so dass sie in der ganzen Programmdatei benutzt werden 

können. Die Bedeutung kann nach der Definition nicht geändert werden, daher sind 

globale Typen problemlos.


• Funktionsnamen sind immer global, da C ++/C keine lokalen Funktionen erlaubt (im 

Gegensatz z. B. zu Pascal). 

↗ Wenn mehrere Textdateien benutzt werden (Kap. 8.2), sollten Funktionsnamen soweit 

möglich verborgen werden. Genauere allgemeine Betrachtungen s. (8.21), dazu Anwendung 

für Headerdateien in Hinsicht auf Konstanten, Typen, Funktionen usw. s. (8.24). 

7.6 Überladen von Funktionsnamen, Standardargumente 

(7.60) Übb In diesem Unterkapitel werden zwei weitere C ++-Besonderheiten vorgestellt: Man 

kann mehrere Funktionen mit demselben Namen deklarieren, die Unterscheidung für den 

Compiler geschieht anhand der Signatur. Ferner ist es möglich, formalen Parametern Standardwerte 

zu geben, die automatisch eingesetzt werden, wenn man die aktuellen Parameter 

auslässt. 

(7.61) Identifizieren einer bestimmten Funktion: 

C Der Funktionsname muss (innerhalb seines Gültigkeitsbereichs) eindeutig sein. 

C++ Der Funktionsname einschließlich der Signatur (d. h. Anzahl, Typ, Reihenfolge der Parameter) 

dient der Unterscheidung; hier also Funktionen gleichen Namens erlaubt, wenn sie 

unterschiedliche Signatur haben (Überladen von Funktionsnamen). Von dieser Eigenschaft 

wird häufig Gebrauch gemacht, z. B. auch bei Konstruktoren (9.21) – aber nicht nur dort. 

Bsp 



void ausgabe(int wert); 

void ausgabe(double wert); 

void ausgabe(int wert1, double wert2); 

int main() 

{ 

ausgabe(3); 

ausgabe(3.); 

ausgabe(9,5.3); 

// 2x implizite Typanpassung, ggf. erste mit Compilerwarnung: 

ausgabe(5.6,2); // wie: ausgabe(5,2.0); 

return 0; 

} 

void ausgabe(int wert) 

{ cout


Falls ein solcher Wert beim Aufruf fehlt (immer nur Parameter von hinten her fehlend), wird 

Standardwert eingesetzt. Dieses bedeutet demnach kein Überladen von Funktionsnamen 

(7.61), da der Compiler beim Aufruf automatisch fehlende Werte einsetzt. 

Bsp1 Funktionsdefinition mit Standardparameter: 

void druck(int wert=4711) 

{ cout


muss sie irgendwann aufhören; das bedeutet, dass der Selbst-Aufruf innerhalb der Funktion 

normalerweise unter einer Bedingung steht, so dass nach einer endlichen Zahl geschachtelter 

Aufrufe kein Selbst-Aufruf mehr geschieht. 

↗ Automatische Variable sind lokale Variable, deren Speicherplatz beim Einsprung in einen 

(Funktions-)Block automatisch erzeugt und beim Verlassen automatisch wieder freigegeben 

wird (6.31b, 8.11b, 8.13). (Andere Arten von Variablen sind bisher noch nicht eingeführt.) Die 

formalen Parameter einer Funktion haben in dieser Beziehung dasselbe Verhalten. 

Bei genügend Zeit in der Vorlesung wird anhand des einfachen Beispiels (7.71) die aufwendige 

Speicher-Verwaltungsarbeit für den Prozessor bei der Rekursion erläutert (Verwaltung eines 

Stacks oder Kellerspeichers (7.72a)). 

(7.71) Was bewirkt der folgende Programm? 



const char ende=’$’; 

void merkwuerdig() 

{ 

char c; 

cin.get(c); 

if (c!=ende) merkwuerdig(); 

cout


Aufgabe: Man verlege den Scheibenturm von ort1 nach ort2, und zwar unter folgenden 

Nebenbedingungen: 

• es darf immer nur eine Scheibe bewegt werden, 

• eine Scheibe darf nur auf einen der drei Orte abgelegt werden, 

• sie darf immer nur auf einer größeren oder direkt unten liegen, 

• ort3 und die anderen Orte dürfen beliebig als Zwischenablage benutzt werden, solange 

die obigen Bedingungen nicht verletzt werden. 

(b) Lösungsansatz: 

const int maxHoehe=64; // Wert 64: dauert ggf. zu lange?? 

typedef int Ort; // Ort als Typ 

const Ort ort1=1, ort2=2, ort3=3; // zur besseren Lesbarkeit 3 Orte 

void bewegeScheibe(Ort vonOrt, Ort nachOrt) 

// Oberste Scheibe soll vom Ort vonOrt zum Ort nachOrt bewegt werden 

{ 

// muss implementiert werden (Roboter, Bildschirmanzeige o. a.) 

} 

void transpTurm(int aktHoehe, Ort vonOrt, Ort nachOrt, Ort hilfOrt) 

// Turm der Höhe aktHoehe (von oben aus gesehen: Turm der Tiefe 

// aktHoehe) soll vom Ort vonOrt zum Ort nachOrt transportiert 

// werden; Ort hilfOrt darf als Ablage benutzt werden 

{ 

if (aktHoehe==1) 

bewegeScheibe(vonOrt,nachOrt); 

else { 

transpTurm(aktHoehe-1,vonOrt,hilfOrt,nachOrt); 

bewegeScheibe(vonOrt,nachOrt); 

transpTurm(aktHoehe-1,hilfOrt,nachOrt,vonOrt); 

} 

} 

int main() 

{ 

transpTurm(maxHoehe,ort1,ort2,ort3); 

return 0; 

} 

(c) Berechnung der Anzahl Scheibenbewegungen: 

– s. Vorlesung – 

7.8 Leitlinien zur Entwicklung von Funktionen 

(7.80) Übb Um gute Funktionen zu entwerfen, sollte man gewisse Regeln beachten, von denen 

hier einige vorgestellt werden. Gut ist eine Funktion, wenn sie unter anderem effektiv, übersichtlich 

(schnell einsichtiger Algorithmus) und leicht wartbar (korrigierbar und änderbar) 

ist. 

(7.81) Es gibt einige allgemeine Leitlinien, wie man Funktionen schreiben sollte. Die Anwendung 

dieser Leitlinien führt zu einem verbesserten Programmierstil, vgl. auch die kurzen 

allgemeinen Bemerkungen, wie Baueinheiten gebildet werden sollten (6.12). 

• Funktionen sollten nicht groß sein, z. B. nicht mehr als etwa 100 Zeilen. Es ist besser, 

kleinere Funktionen zu erstellen, die sich gegenseitig aufrufen.


• Oft ist ein geschachtelter (kaskadierter) Entwurf nützlich: 

◦ Funktionen für die grundlegenden Arbeiten, 

◦ Funktionen für komplexere Tätigkeiten, die die grundlegenden Funktionen aufrufen, 

◦ Funktionen, die die komplexeren und vielleicht auch die grundlegenden Funktionen 

aufrufen. 

Vorteil: wenn Sie eine Funktion erstellen (den Funktionsprogrammtext schreiben), 

müssen Sie nur über einen kleinen Problembereich nachdenken. 

• Es sollten verschiedene Arten von Funktionen unterschieden werden: 

◦ Funktionen mit Benutzerinteraktion oder Ein-/Ausgabe; dabei wenn möglich Lesen 

und Schreiben in getrennten Funktionen (z. B. Lesefunktionen, Schreibfunktionen), 

◦ Funktionen zur Durchführung von Berechnungen – diese Funktionen sollten keine 

Benutzerinteraktion/Eingabe/Ausgabe haben! Sonst sind diese Funktionen nicht 

allgemein nutzbar, z. B. bei Berechnungen mit einem woanders berechneten Wert 

anstatt mit einem eingegebenen. 

◦ manchmal (selten!) ist eine Mischung nötig. 

Allgemeine Regel: entweder Benutzerinteraktion oder Berechnungen! 

• Eine Funktion sollte mit dem Rest des Programms nur über die Parameterliste und den 

Rückgabewert der Funktion kommunizieren – sehr wichtig: nicht über globale Variablen. 

Dagegen sind globale Konstanten (und globale Typen) sinnvoll, vgl. auch (7.53). 

• Keine Benutzung der exit-Funktion ( (12.82c), beendet das Programm sofort), 

insbesondere nicht in Berechnungsfunktionen. Grund: manchmal läuft eine Funktion in 

einen Fehler hinein, es kann jedoch nicht hier entschieden werden, wie zu reagieren 

ist. Anstatt das ganze Programm (z. B. eine CAD-Programm) zu beenden, sollte ein 

Fehlerindikator gesetzt werden, so dass die aufrufende Stelle entscheiden kann, was zu 

tun ist. 

7.9 Agile Methoden in der Softwareentwicklung 

(7.90) Übb Moderne Softwareentwicklungsmethoden, die unter dem Oberbegriff ” Agile Methoden“ 

zusammengefasst werden, versuchen, Software größerer Qualität schneller dem Kunden 

liefern zu können. In diesem Kurs werden zwei Aspekte näher erläutert und teilweise auch 

in der Praxis gezeigt. 

(7.91) Teilweise im Gegensatz zu den Ausführungen in (Kap. 6.4) wird seit mehreren Jahren in der 

Softwareindustrie versucht, Programme für Kunden schneller, genauer, kundenorientierter 

zu entwickeln ohne großen Dokumenationsüberbau. Diese Methoden fasst man unter Agile 

Methoden zusammen. Im sog. ” Extreme Programming“ (Kent Beck) gibt es u. a. zwei 

Praktiken, die in diesem Kurs näher erläutert werden: 

• Pair Programming, das Programmieren zu zweit vor einem Rechner; dieses wird auch 

in den Übungen zu diesem Kurs als Option angeboten. 

• Test Driven Development (TDD), das Schreiben von Test-Programmcode vor dem 

Schreiben des zugehörigen produktiven Programmcodes. In der Praxis wird dieses durch 

Werkzeugunterstützung erleichtert. 

Im Kurs wird auf die beiden genannten Aspekte näher eingegangen; hier sollen sie nur kurz 

als Erinnerung erwähnt werden.


Teil II 

Informatik II (2. Semester) 

8 Speicherklassen, modulare Programmierung 


Dieses Kapitel befasst sich mit der Verwirklichung der Grundgedanken, die in (Kap. 6.3) sprachunabhängig 

vorgestellt wurden: Speicherklassen und der Programmierstil der modularen 

Programmierung. 

Unterkapitel 1 beschreibt die von C ++ unterstützten Speicherklassen (d. h. der verschiedenen 

Arten von Lebensdauer und Verwaltung von Datenspeicherplätzen): statisch, automatisch 

und dynamisch-kontrolliert. Die beiden ersten werden hier auch genauer vorgestellt, die 

dritte wird später behandelt (Kap. 10.3). 

Das Unterkapitel 2 zeigt, wie die modulare Programmierung in C ++ verwirklicht wird, 

nämlich mit Hilfe von Programmdateien. Hierbei kennzeichnet es einen guten Programmierer, 

möglichst viele der Namen aus einer Programmdatei zu verbergen, nämlich alle, die 

von außen nicht direkt benötigt werden. Da dieses in C ++/C leider nur durch einen Extra- 

Zusatz möglich ist, unterlassen viele Programmierer meist aus Gedankenlosigkeit das sehr 

wichtige Verbergen, was dazu führen kann, dass solche Programme sehr schlecht zu warten 

sind. Weiterhin wird das Konzept der Headerdateien beschrieben, das zur Wahrung der 

Konsistenz von ” öffentlichen“ Namen eingeführt wurde. 

In manchen Fällen muss man sowohl C- als auch C ++-Programmdateien innerhalb eines 

Programms zusammenbinden. Die dabei zu beachtenden Besonderheiten sind in (8.27) zusammengestellt. 

8.1 Statische und automatische Speicherklasse 

(8.10) Übb In diesem Kapitel werden – als Erweiterung zur sprachunabhängigen Einführung (6.31) 

– die drei Speicherklassen erläutert, die durch C ++ unterstützt werden (8.11): die statische, 

die automatische und die dynamisch-kontrollierte Speicherklasse. In den beiden folgenden 

Punkten wird genauer gezeigt, wie die statische und die automatische Speicherklasse in C ++ 

verwirklicht werden. (8.14) zeigt ein vollständiges Programmbeispiel. Für einen Programmierer 

ist es unerlässlich, die Eigenschaften und die Anwendungen dieser Speicherklassen zu 

kennen. 

(8.11) Eine Speicherklasse definiert die Lebensdauer eines Datenspeicherplatzes, die Art der Reservierung 

und der Freigabe. Die Sprache C ++ unterstützt direkt drei Speicherklassen, die 

Sprache C direkt nur zwei. Allg. Beschreibung der ersten beiden Speicherklassen s. a. (6.31). 

(a) Variable der statischen Speicherklasse 〈static storage class〉 ” leben“ die gesamte Programmlaufzeit, 

ihr Speicherplatz wird einmal zu Beginn des Programmslaufs reserviert und 

am Ende des Programmlaufs wieder freigegeben. Sie können eine Erstbelegung ( ” Initialisierung“) 

erhalten, jedoch i. a. nur mit einem konstanten Ausdruck (d. h. zur Kompilationszeit 

auswertbar); falls nicht explizit initialisiert, werden sie implizit mit einem zugehörigen Nullwert 

initialisiert. 

(b) Variable der automatischen Speicherklasse 〈automatic storage class〉 ” leben“ nur während 

der Durchlaufzeit durch einen Block; ihr Speicherplatz wird bei Eintritt in den Block 

automatisch angelegt und bei Verlassen automatisch wieder freigegeben. Sie können mit 

beliebigem Ausdruck initialisiert werden; eine implizite Initialisierung findet i. a. nicht statt. 

(c) C++ Der dritten Speicherklasse dynamisch-kontrolliert gehören Speicherplätze an, die 

durch den Programmierer mit dem Operator new Op3k explizit angefordert werden und mit 

dem Operator delete Op3l explizit freigegeben werden – und zwar völlig unabhängig von 

der Blockstruktur des Programms. Der Bereich für diese Speicherplätze heißt Freispeicher


(dynamischer Speicher, gelegentlich auch Name Heap, Näheres s. (Kap. 10.3)). Eine implizite 

Initialisierung beim Anlegen des Speicherplatzes findet i. a. nicht statt. 

↑↑ In C dienen Bibliotheksfunktionen – meist malloc(size t) und free() – dem gleichen Zweck 

(10.34). 

Anm Zu dem i. a.“ bei der Beschreibung der Initialisierungen in den drei Speicherklassen: Das 

” 

” i. a.“ kann durch Konstruktoren (Elementfunktionen zum Erzeugen und Initialisieren von 

Objekten) durchbrochen werden. Näheres dazu s. (9.21). 

(8.12) Statische Speicherklasse 

Eigenschaften (s. a. (Cpp/5.2)): 

Lebensdauer während ganzer Programmlaufzeit 

Initialisierung 

- explizit nur durch konstanten Ausdruck ⋆△ 

- implizit mit zugehörigem Nullwert ⋆ 

- wie oft nur einmal, meist zu Beginn des Programmlaufs △ 

⋆ Besonderheiten bei Objekten s. (8.11Anm) und (9.21). 

△ ↑↑ Globale Variablen werden einmal zu Beginn des Programmlaufs initialisiert, statische lokale 

Variable ebenfalls einmal, jedoch C++ erst dann, wenn der Programm-Kontrollfluss die zugehörige 

Definition erstmals erreicht. Der Initialisierungsausdruck braucht in C++ nicht konstant zu sein, er 

muss nur zur Laufzeit bei der Initialisierung auswertbar sein. 

Syntax für Definition einer Variable mit statischer Speicherklasse: 

globale Variable DeklarationNormaleForm ▽ 

lokale Variable 

13 static DeklarationNormaleForm 

▽ Globale Variablen sind immer statisch. 

(8.13) Automatische Speicherklasse 

Eigenschaften (s. a. (Cpp/5.2)): 

Lebensdauer nur während Block durchlaufen wird 

Initialisierung 

- explizit durch einen beliebigen Ausdruck 

- implizit KEINE! ⋆ 

- wie oft jedesmal bei Eintritt in den Block 

⋆ Besonderheiten bei Objekten s. (8.11 Anm) und (9.21). 

Spezialfall formaler Funktionsparameter: 

Lebensdauer nur während Funktionsblock durchlaufen wird 

Initialisierung immer, und zwar durch aktuellen Parameter 

- wie oft jedesmal beim Funktionsaufruf 

Syntax für Variable mit automatischer Speicherklasse: 

globale Variable – nicht möglich – 

lokale Variable DeklarationNormaleForm △⊙ 

Spezialfall 

formaler Funktionsparameter 14 TypSpezifizierer1..n 30 Deklarator ⊙ 

↑↑ 

△ 13 

Vorsetzen des Speicherklassen-Spezifizierers auto erlaubt, wird aber ohne Bedeutungsänderung 

üblicherweise weggelassen. 

⊙ 13 

Ein Vorsetzen des Speicherklassen-Spezifizierers register veranlasst den Compiler, die 

Variable oder den formalen Parameter soweit möglich im Register abzulegen; diese Variable 

hat keine Datenspeicheradresse, d. h. die Anwendung des Adressoperators & (Op3g (10.21b)) 

ist nicht erlaubt. 

(8.14) Bsp Kellerspeicher, ähnlich (6.32): 


using namespace std;


void fehlerSchieben(); // Fehlermeldung Schieben 

void fehlerHolen(); // Fehlermeldung Holen 

int kellerSpeicher(bool schiebenJaNein,int wert) 

{ 

static const int maxanz=100; // "static": statische SpKl 

static int speich[maxanz], // "static": statische SpKl 

zaehler=0; 

} 

if (schiebenJaNein) { 

if (zaehler==maxanz) fehlerSchieben(); // Fehler 

else speich[zaehler++]=wert; 

} 

else { 

if (zaehler) 

wert=speich[--zaehler]; 

else { 

fehlerHolen(); // Fehler 

wert=0; // damit definierter Wert 

} 

} 

return wert; 

void fehlerSchieben() 

{ cout


(8.21) 

es eigentlich sein sollte; das Verbergen wird durch zusätzliche Kennzeichung erreicht. Ohne 

diese zusätzliche Kennzeichnung hat ein Name externe Bindung und ist daher öffentlich. 

In C++(neu) gilt es jedoch als missbilligt, Namen durch interne Bindung zu verbergen. Die 

neue und zu bevorzugende Vorgehensweise geschieht mit unbenannten Namensbereichen 

(8.23a). Das allgemeine Konzept der Namensbereiche wird in (8.23c) kurz erläutert. 

Um bei den Namen, die öffentlich sein sollen, nicht in sehr schwer handhabbare Konsistenzprobleme 

zu geraten, hat sich schon in C ein recht interessantes Konzept entwickelt, 

das auch in C ++ ausgiebig angewandt wird: die Abspaltung der Deklarationen von Namen 

mit externer Bindung in sog. Headerdateien. Diese Headerdateien werden dann mit Hilfe 

einer Include-Direktive in jede Programmdatei eingefügt, in der die dort erwähnten Namen 

in irgendeiner Weise auftreten, d. h. benutzt oder auch definiert werden. Eine genaue Auflistung, 

welche Bestandteile zu einer Header- und welche zu einer Programmdatei gehören, 

ist in (8.24) ausführlich beschrieben. 

Anm Eine Ausnahme bilden die Typdefinitionen, meist in Form von Klassendefinitionen (Kap. 9); 

hier erscheinen i. a. sogar die Definitionen in Headerdateien. 

Zwei ausführliche C ++-Beispielprogramme (8.25, 8.26) erläutern den Umgang mit mehreren 

Programmdateien. 

Die Besonderheiten beim Zusammenbinden von C- und C ++-Programmdateien sind in (8.27) 

zusammengestellt. 

(a) Um ein Zusammenspiel zwischen verschiedenen Übersetzungseinheiten zu erlauben, müssen 

dem Linker in den Objektdateien (d. h. kompilierten Dateien) zu verknüpfende Namen angegeben 

werden. Die Stellen, an denen Referenzen benötigt werden (z. B. ein Funktionsaufruf), 

werden durch den Linker verknüpft ( ” aufgelöst“) mit Referenzangeboten (z. B. eine Funktionsdefinition). 

Diese Namen, die der Linker in den Objektdateien erhält, unterliegen der 

sog. externen Bindung 〈external linkage〉. Zu den Begriffen Objektdatei oder Objektprogramm, 

Linker oder Binder s. (1.32). 

Dagegen haben Namen einer Übersetzungseinheit, die für den Linker versteckt sind, die sog. 

interne Bindung 〈internal linkage〉. Daher können Namen mit interner Bindung nie mit 

gleichlautenden Namen anderer Übersetzungseinheit kollidieren. 

Eine bessere Möglichkeit, Namen zu verbergen, wird in C++(neu) durch einen unbenannten 

Namensbereich 〈unnamed namespace〉 angeboten. Dieses wird im Folgenden normalerweise 

eingesetzt. 

(b) Beim Zusammenspiel mehrerer Übersetzungseinheiten sollte daher folgende Regel beachtet 

werden: 

• Namen sollten normalerweise verborgen sein (durch interne Bindung oder besser durch 

Einschluss in einen unbenannten Namensbereich), und zwar wegen der Übersichtlichkeit; 

dann gibt auch keine Namenskonflikte mit anderen Übersetzungseinheiten. 

• Nur wenn eine Kommunikation mit anderen Übersetzungseinheiten nötig ist, sollte die 

externe Bindung vergeben werden. 

Dieses sollte bei jedem Namen geprüft werden! Diese Regel unterstützt auch das Geheimnisprinzip 

(6.13c). 

(c) Beispiele: Namen von Funktionen, die in anderen Übersetzungseinheiten aufgerufen werden 

sollen, müssen externe Bindung erhalten. Dagegen sollten Funktionen, die für andere 

Funktionen der gleichen Übersetzungseinheit Serviceberechnungen durchführen, verborgen 

werden. Variable sollten (fast) immer verborgen sein! 

(d) In diesem Zusammenhang ist die Regel genau einer Definition 〈one definition rule 

(ODR)〉 wichtig: Zu externen Namen darf und muss genau eine Definition (Referenzangebot) 

gehören, alle anderen Übersetzungseinheiten dürfen nur Deklarationen dieses Namens 

haben. Die ODR gilt natürlich auch für interne Namen. 

↑↑ Erlaubt nach den Regeln von C ++/C ist es, dass ein Linker ggf. keine Groß-/Kleinschreibung 

unterscheidet oder auch nur eine gewisse Anzahl von Zeichen für einen Namen als 

unterscheidend erkennt. Diese Beschränkung trifft heutzutage selten zu. 

Bei deklarierten Funktionen kann auf eine Definition verzichtet werden, wenn sie nirgendwo 

aufgerufen werden (7.23 Anm3).


(8.22) Externe Bindung 

Ein globaler Name erhält externe Bindung: 

Funktionsname Definition NormaleFunktionsDefinition 

Deklaration externopt NormaleFunktionsDeklaration 

Variablenname Definition DefinitionGlobaleVariableOhneSpklassenSpez ⋆ 

Deklaration extern VariablenDeklaration 

Klassenname ⊙ Def./Dekl. – immer externe Bindung – 

Konstantenname Def./Dekl. – s. ↑↑2 – 

⋆ i. a. mit Initialisierung 

↑↑1 Genauere Regeln s. (Cpp/5.3). 

⊙ s. (9.12b) 

↑↑2 Auch Konstantennamen können externe Bindung haben ( ” extern const ...“, und zwar als 

Def., wenn initialisiert, sonst als Dekl.), dieses ist aber unüblich. Statt dessen definiert man 

häufig z. B. den Konstantennamen mit interner Bindung (8.23) in jeder Übersetzungseinheit, 

in der er benötigt wird, d. h. in der zugehörigen Headerdatei (8.24c1). 

(8.23) Um Namen innerhalb einer Programmdatei verborgen zu halten, kann man sie in einen 

unbenannten Namensbereich stellen (C++(neu), s. (a)) oder ihnen interne Bindung geben 

(ältere Methode in C/C ++, s. (b)). 

(a) C++(neu) 

Die in C++(neu) geschaffene und jetzt zu bevorzugende Möglichkeit des Verbergens von Namens 

auf den Bereich innerhalb einer Programmdatei (d. h. eines Moduls) ist der unbenannte 

Namensbereich. 

Das allgemeine Konzept der Namensbereiche wird in (c) kurz erläutert. Daher wird der 

unbenannte Namensbereich hier nur formal ohne nähere Erläuterung der Wirkungsweise 

eingeführt: jede Deklaration und jede Definition, auf die außerhalb einer Programmdatei 

nicht zugegriffen werden soll, erscheint in einer solchen Namensbereich-Definition: 

40T eil DefinitionUnbenannterNamensbereich 

namespace { DeklarationenUndOderDefinitionen } 

Wieviele solcher unbenannten Namensbereiche innerhalb einer Programmdatei gebildet werden, 

ist gleichgültig; der Compiler betrachtet alle unbenannten Namensbereich-Definitionen 

einer Datei als eine einzige. Bei zu verbergenden Funktionen ist es wichtig, dass sowohl die 

Deklaration als auch die Definition in einem solchen unbenannten Namensbereich liegen. 

Die Wirkung ist genau, was gewünscht wird: wenn ein Name in einer solchen unbenannten 

Namensbereich-Definition erscheint, kann auf diesen Namen von einer anderen Datei aus 

nicht mehr zugegriffen werden. Er ist demnach verborgen im Sinne von (6.32, 6.33), obwohl 

er rein formal der externen Bindung unterliegt. Innerhalb derselben Programmdatei kann 

jedoch beliebig auf ihn zugegriffen werden, und zwar sowohl von Stellen außerhalb als auch 

von Stellen innerhalb des unbenannten Namensbereichs. 

In (8.25) wird gezeigt, wie ein unbenannter Namensbereich benutzt wird. 

(b) Interne Bindung 

Ein globaler Name erhält interne Bindung: 

Funktionsname Definition static NormaleFunktionsDefinition 

Deklaration static NormaleFunktionsDeklaration 

Variablenname Definition static DefinitionGlobaleVariableOhneSpklassenSpez ⋆ 

Deklaration ⊙ static VariablenDeklaration 

Konstanten- Definition const DefinitionKonstanteMitInitialisiserung 

name (ohne Spezifizierer extern) 

– vgl. auch (8.22 ↑↑2) – 

⋆ i. a. mit Initialisierung 

↑↑ Genauere Regeln s. (Cpp/5.3) 

⊙ selten vorkommend


Das Beispiel (8.26) zeigt diese Verwendung von static. 

Das Schlüsselwort static ist sehr schillernd, es hat (leider) verschiedene Bedeutungen. Es 

kann statische Speicherklasse bedeuten (8.12) oder auch interne Bindung. Um diese Doppelbedeutung 

nicht mehr zu unterstützen, sollte static nur noch in der Bedeutung statische 

Speicherklasse und nicht mehr in der Bedeutung interne Bindung benutzt werden. Das 

letztere gilt daher in C++(neu) als missbilligt (Str3/Kap. B.2.3). An dessen Stelle sollte man daher 

einen unbenannten Namensbereich (a) nehmen. 

(c) ↑↑ Namensbereiche C++(neu) 

Ein Namensbereich dient der logischen Gruppierung von Namen. Zur Vermeidung von Namenskonflikten 

und damit der ” globale“ Namensbereich (alle Namen mit externer Bindung über alle 

Programmdateien hinweg) nicht überfrachtet wird, kann man eine Gruppe von Namen in einem 

Namensbereich ablegen. 

40 NamensbereichDefinition namespace NamensbereichNameopt { 10 Deklaration0..n } 

Auf Namen eines Namensbereiches kann innerhalb des Bereichs direkt zugegriffen werden, außerhalb 

durch explizite Spezifizierung mit dem Operator :: Op1b 

NamensbereichName :: Bezeichner 

Statt der expliziten Spezifizierung können durch eine using-Direktive sämtliche Namen eines Namensbereiches 

zugreifbar gemacht werden, und zwar für den Geltungsbereich, in dem die Direktive 

steht. (Bei Namenskonflikten hat der Name des Geltungsbereichs Vorrang vor dem aus dem Namensbereich; 

hier hilft dann nur die explizite Spezifizierung.) 

UsingDirektive using namespace NamensbereichName ; 

Alle Namen der Standardbibliotheken sind neuerdings im Namensbereich std abgelegt, daher die 

Direktive ” using namespace std;“. Beim Compiler MS Visual C ++ 6.0 sind in den Headerdateien 

ohne .h diese Namen in std abgelegt, bei denen mit .h im globalen Namensraum. 

Wenn man NamensbereichName in der Namensbereichdefinition weglässt ( ” unbenannter Namensbereich“, 

s. (a)), setzt der Compiler einen eigenen eindeutigen Namensbereich-Namen ein, dazu 

eine UsingDirektive für diesen Namen des Namensbereichs. Da für den Programmierer dieser Name 

nicht bekannt ist, kann außerhalb der Programmeinheit auf darin deklarierte Namen nicht zugegriffen 

werden. Diese Eigenschaft wird entspr. (a) zum Verbergen von Namen benutzt. 

(8.24) Headerdateien 

(a) Es ist sehr sinnvoll, die Deklarationen für Namen mit externer Bindung von den zugehörigen 

Definitionen zu trennen: Headerdatei 〈header file〉 und Programmdatei 〈program file〉. Erstere 

hat meist die Dateinamenerweiterung .H oder .h, letztere meist die Erweiterung .CPP 

oder .cpp, auch .CXX oder .cxx. 

Der wichtigste Grund dafür ist die Konsistenz zwischen Deklaration und Definition: Da 

in der Praxis die Programme ” leben“, d. h. immer wieder verändert werden, kann bei einer 

Änderung des Namens oder der Signatur einer Funktion vergessen werden, die (ggf. an vielen 

Stellen vorhandenen) Deklarationen der neuen Definition anzupassen. Der Linker bemerkt 

solche Änderungen nicht immer, so dass sich sehr schwer handhabbare Fehler einschleichen 

können. Viel besser ist es daher – zudem auch verbunden mit wesentlich weniger Aufwand 

–, genau eine Deklaration in genau eine Headerdatei zu schreiben und diese Datei überall 

einzuschließen, wo die Deklaration benötigt wird. Sehr wichtig ist es dann, dass diese Headerdatei 

auch in die Programmdatei eingeschlossen wird, die die Definition enthält, damit 

der Compiler die Konsistenzprüfung durchführen kann! 

(b) Empfehlung: 

• Bei nur wenigen Programmdateien (Praxis: bis zu etwa fünf Dateien) genügt es meist, 

die Deklarationen aller Programmdateien in eine einzige Headerdatei zusammenzufassen 

und diese überall einzuschließen. 

• Sonst ist es üblich, je Programmdatei eine Headerdatei (gleicher Dateinamen, Erweiterung 

.H oder .h) zu erstellen; diese wird dann, wo nötig, eingeschlossen. 

• Manche Bestandteile einer Headerdatei (z. B. Klassendefinitionen (9.11)) dürfen nicht 

mehrfach in derselben Übersetzungseinheit eingeschlossen sein. Wenn jedoch eine Headerdatei 

eine andere einschließt (z. B. wegen benötigter Typendefinition), kann es leicht 

zu einem (indirekten) Doppeleinschluss kommen. Durch die Möglichkeiten der bedingten 

Kompilierung kann man jedoch leicht einen Include-Wächter einfügen; Näheres s. 

(5.75c) und die Beispiele (8.25a) und (9.31a).


• Grundsätzliche Aufteilung, Näheres s. (c): 

◦ Deklarationen, die in mehreren Programmdateien benötigt werden, z. B. Deklarationen 

von Funktionen mit externer Bindung, sollen in genau einer Headerdatei 

erscheinen, 

◦ die Definitionen dieser Funktionen müssen in genau einer Programmdatei geschehen, 

◦ jedoch Funktionen in einem unbenannten Namensraum (oder solche mit interner 

Bindung) – die ja nur in einer einzigen Programmdatei bekannt sein sollen – dürfen 

nicht in einer Headerdatei erscheinen, die Deklaration und die Definition geschieht 

in einer Programmdatei. 

(c) Auftrennung in Header- und Programmdatei: 

(1) Headerdatei: 

• Einschluss anderer (Standard- oder eigener) Headerdateien – jedoch aus Übersichtlichkeitsgründen 

nur der Dateien, die für diese Headerdatei direkt benötigt werden 

• Deklaration von Funktionen mit externer Bindung 

• Deklaration von Variablen mit externer Bindung 

• Folgende Definitionen, soweit sie in mehr als einer Programmdatei benötigt werden 

(wenn dagegen nur in einer einzigen: s. (2)): 

◦ Typdefinitionen (typedef) (5.62) 

◦ Klassen (9.11) 

◦ Makros (5.72, 5.73, 10.11b, 10.12b) 

◦ (ggf.) Konstanten (10.11a) 

◦ inline-Funktionen (10.12a) 

• Nie: Definition eines unbenannten Namensbereichs (8.23b) 

• Nie: Definitionen von Funktionen (außer inline) 

• Nie: Definitionen von globalen Variablen 

• Daran denken: Sinnvoll ist eine Verriegelung gegen Mehrfacheinschluss durch einen 

Include-Wächter (5.75c)! 

(2) Programmdatei: 

• Einschluss der (Standard- und eigenen) Headerdateien, die in dieser Programmdatei 

benötigt werden 

• Wichtig: Einschluss der zu dieser Programmdatei gehörigen Headerdatei (Konsistenzprüfung 

durch Compiler!) 

• Deklaration von Funktionen und von Variablen jeweils mit interner Bindung 

• Definition eines unbenannten Namensbereichs (8.23b) 

• Definition von Funktionen 

• Definition von Klassenelementen, z. B. Elementfunktionen (soweit sie nicht inline 

(10.12a) sein sollen) 

• Definition von globalen Variablen 

• Folgende Definitionen, soweit sie nur in einer einzigen Programmdatei benötigt 

werden (wenn dagegen in mehreren: s. (1)): 

◦ Typdefinitionen (typedef) (5.62) 

◦ Makros (5.72, 5.73, 10.11b, 10.12b) 

◦ (ggf.) Konstanten (10.11a) 

◦ inline-Funktionen (10.12a) 

↑↑ Häufig werden die beiden Begriffe Programmdatei und Übersetzungseinheit als synonym angesehen. 

Die genauere Definition: Eine Programmdatei ist eine von Programmierer geschriebene 

Datei mit Quelltext; durch den Präprozessorlauf (Kap. 5.7, im wesentlichen Einfügen 

der Einschlüsse (#include) und Makroerweiterungen (#define)) entsteht daraus die Übersetzungseinheit, 

die dem Compiler angeboten wird. 

(8.25) C++(neu) Beispiel Kellerspeicher, ähnlich (6.34): drei Dateien: (a,b,c). Hier wird die Benutzung 

des unbenannten Namensbereichs vorgestellt. Das gleiche Programm wird in (8.26) mit 

der älteren Form des Verbergens von Namen in einer Programmdatei durch interne Bindung 

(static) gezeigt. 

(a) // Beispieldatei D08-25A.H 

#ifndef D08_25A_H_ // Verriegelung gegen Mehrfacheinschluss


#define D08_25A_H_ 

// Kellerspeicher-Zugriffsfunktionen: 

void schiebe(int wert); 

int hole(); 

#endif 

(b) // Beispieldatei D08-25B.CPP 

#include // wegen cout-Benutzung in fehler...-Funktionen 


(c) 

// Deklarationen dieser Datei: Einbindung hier zur Konsistenzprüfung!! 

#include "d08-25a.h" 

namespace { // unbenannter Namensbereich 

void fehlerSchieben(); 

void fehlerHolen(); 

} 

const int maxanz=100; 

int speich[maxanz], 

zaehler=0; 

void schiebe(int wert) 

{ 

if (zaehler==maxanz) fehlerSchieben(); // Fehler 

else speich[zaehler++]=wert; 

} 

int hole() 

{ 

if (zaehler) return speich[--zaehler]; 

} 

fehlerHolen(); // Fehler 

return 0; // damit definierter Wert 

namespace { // Fortsetzung unbenannter Namensbereich 

void fehlerSchieben() 

{ 

cout


} 

schiebe(i); 

schiebe(-23); // Fehler 

cout


eine in C ++ kompilierte Funktion in C ++ und entsprechend eine in C kompilierte Funktion 

in C aufgerufen werden kann. 

In C ++ sieht die Headerdatei folgendermaßen aus: 

// C++-Headerdatei 

extern "C" DeklarationCCppFunktion 

extern "C" { 

DeklarationCCppFunktion1..n 

} 

// Anm.: obigen Block { ... } nennt man Bindungsblock 〈linkage block〉 

Die C ++-Programmdatei sieht so aus (normale Funktionsdefinition): 

// C++-Programmdatei 

#include "C ++-Headerdatei " 

DefinitionCppFunktion // wie in C++ üblich 

In C ist folgendes zu tun (Headerdatei): 

// C-Headerdatei 

extern DeklarationCCppFunktion // auch ohne "extern" möglich 

// ggf. weitere Male: DeklarationCCppFunktion 

Anm Hier unbedingt auf (7.23Anm4) achten, d. h. bei parameterloser Funktion void als Parameter! 

Die C-Programmdatei sieht so aus: 

// C-Programmdatei 

#include "C-Headerdatei " 

DefinitionCFunktion // wie in C üblich 

Die obigen Zusätze für C ++ sind in oder auch den anderen C-Headerdateien bereits 

enthalten.


9 Objektorientierte Programmierung: 

Kapselung von Daten und Funktionen mit Zugriffskontrolle 


Die Ideen für die Objektorientierte Programmierung sind – sprachunabhängig – in (Kap. 

6.4) näher beschrieben. Das aktuelle Kapitel dient dazu, diese Ideen nach C ++ zu übertragen. 

Unterkapitel 1 zeigt, wie Klassen (in C ++ als Datentypen) und Objekte (Variable eines solchen 

Klassentyps) erzeugt und benutzt werden. Bestimmte Methoden, nämlich Konstruktoren, 

werden benötigt, ein Objekt zur Laufzeit zu erzeugen (Unterkapitel 2). Daher kann 

(für Sie als Teilnehmer dieses Kurses: muss) man Konstruktoren zur sinnvollen Initialisierung 

bauen. In Unterkapitel 3 wird ein ausführliches Beispiel gezeigt, dazu wird dort die 

Forderung begründet, Datenelemente einer Klasse immer zu verbergen. 

9.1 Klassen und Objekte 

(9.10) Übb Eine Klasse dient der Kapselung von Daten und (Zugriffs-)Funktionen mit der 

Möglichkeit der expliziten Zugriffskontrolle (VERBORGEN oder ÖFFENTLICH). In C ++ ist 

die Klasse ein (Daten-)Typ. Dieser muss dem Compiler in seiner internen Struktur bekanntgegeben 

werden. (9.11) erläutert, wie diese Klassendefinition durchgeführt wird. Der Punkt 

(9.12) befasst sich mit dem Gültigkeitsbereich der Klassenelemente und des Klassennamens. 

(9.11) 

(a) 

Variable des Typs Klasse werden Objekte genannt. Punkt (9.13) zeigt, wie Objekte in C ++ 

gebildet und benutzt werden. 

Die Klasse ist in C ++ ein Typ, s. (2.25a2), (3.20) und (5.60, 5.61), und zwar ein benutzerdefinierter 

Typ; der Typ wird durch den Benutzer selbst definiert. Im Gegensatz zu 

den ” eingebauten“ Typen – wie z. B. int, double – kennt der Compiler von sich aus 

nicht den internen Aufbau einer Klasse; daher muss ihm der Aufbau mitgeteilt werden. 

Dieses geschieht durch die Klassendefinition. 

Anm Andere benutzerdefinierte Typen sind beispielsweise Arrays (Kap. 5.4), da der Benutzer selbst 

den Komponententyp und die Anzahl der Komponenten angibt. 

10,11,12,14,21 Klassen(Typ)Definition [NV] 

class KlassenName { 

 

- 

22 ZugriffsSpezifizierer : 

ElementDeklaration 

22 ZugriffsSpezifizierer [NV] private | 

| public 

Bsp siehe unter (b). 

 

- 0..n } ; 

↑↑ Da der Compiler mit obiger Klassenbeschreibung die gesamte Information zum Aufbau von 

Variablen dieses Typs erhält, handelt es sich tatsächlich um eine Definition, vgl. (7.21). Diese 

Definition muss allen Übersetzungseinheiten zur Verfügung stehen, in denen die Klasse 

gebraucht wird, daher sollte sie in einer Headerdatei stehen (8.24c1). Trotz des (durch 

Einschluss implizit) mehrfachen Vorhandenseins der Klassendefinition in den verschiedenen 

Übersetzungseinheiten gilt die ODR (8.21d); sich gleichende Definitionen derselben Klasse in 

verschiedenen Übersetzungseinheiten gelten als eine einzige. 

(b) Eine Klassendefinition besteht demnach aus: 

• KlassenName – er gibt den Namen der Klasse (Typnamen) an. 

• Folge von ElementDeklarationen; diese Elemente können sein: 

◦ Datenelemente – syntaktisch wie Variablendefinitionen, 

◦ Elementfunktionen (Funktionen, die i. a. etwas mit den Datenelementen tun) – 

syntaktisch meist Funktionsdeklarationen,


(9.12) 

◦ dazu weitere Deklarationen, beispielsweise Typen. 

• Optional beliebig oft ZugriffsSpezifizierer: (mit Doppelpunkt), und zwar private: 

(dann sind die nachfolgenden Elemente verborgen) und public: (dann sind sie öffentlich); 

steht direkt hinter der öffnenden geschweiften Klammer kein Spezifizierer, so wird 

dort implizit private: gesetzt. 

Natürlich müssen die Elementfunktionen – zumindest wenn sie irgendwo benutzt werden – 

zusätzlich noch definiert werden; dieses geschieht i. a. außerhalb der Klassendefinition, und 

zwar in der zur Klasse gehörigen Programmdatei. 

Anm1 Eine Funktionsdefinition innerhalb der Klassendefinition ist auch erlaubt; in der Praxis wird 

dieses nur bei sehr kleinen Funktionsblöcken gemacht. Hierbei fasst der Compiler die Funktion 

als inline (10.12a, 11.11b) auf. 

Anm2 Statt des Schlüsselworts class ist auch das Schlüsselwort struct erlaubt, Näheres dazu s. 

(11.11c). 

Bsp – siehe auch (9.12 Bsp, 9.13 Bsp, 9.21 Bsp) – 

class Komplex { 

double re, im; 

public: 

// "Markierung" für Konstruktoren, s. Punkt (21) 

void setzKompl(double realT, double imagT); 

double real() { return re; } // Dekl. und Definition von real() 

double imag(); // Deklaration von imag() 

}; 

(a) Der Gültigkeitsbereich 〈scope〉 der Klassenelemente ist der Bereich der gesamten Klasse 

(genauer: jeweils ab Deklarationspunkt), jedoch nicht außerhalb der Klasse. Um jedoch 

z. B. bei der Definition einer Elementfunktion, wenn sie (so der Normalfall!) außerhalb der 

Klassendefinition erfolgt, den Klassen-Gültigkeitsbereich zu öffnen, muss man den Bereichsauflösungsoperator 

:: (Op1b) benutzen: 

KlassenName::ElementName 

Hierbei gilt der gesamte Funktionsblock – dazu auch die Parameterliste – ebenfalls als 

zum Klassen-Gültigkeitsbereich zugehörig; hier braucht man den Bereichsauflösungsoperator 

nicht zu benutzen. Innerhalb dieses Bereichs darf auf jedes Klassenelement zugegriffen 

werden – unabhängig von einer Zugriffsbeschränkung. 

↑↑1 Auch bei Definition von Elementfunktionen innerhalb der Klassendefinition (9.11b Anm1) kann 

im Funktionsblock auf alle Elementnamen zugegriffen werden, auch auf solche, die in der 

Klassendefinition erst folgen. 

↑↑2 Es ist erlaubt, auch innerhalb des Funktionsblocks von Elementfunktionen den Bereichsauflösungsoperator 

zu benutzen (KlassenName::ElementName); dies ist eine der Möglichkeiten, 

ggf. Namenskonflikte aufzulösen. Eine andere ähnliche Möglichkeit ist die Benutzung 

des this-Zeigers (this->ElementName), s. (11.13). 

(b) Klassennamen haben immer externe Bindung, s. (8.22). 

(9.13) 

Bsp – zu (9.11 Bsp), siehe auch (9.13 Bsp, 9.21 Bsp) – 

// Definition von Elementfunktionen der Klasse Komplex: 

void Komplex::setzKompl(double realT, double imagT) 

{ re=realT; im=imagT; } 

double Komplex::imag() 

{ return im; } 

Ein Objekt ist in C ++ eine Variable eines Klassentyps. Die Anweisung zur Erzeugung 

eines solchen Objekts (einer solchen Variablen) erfolgt genauso wie bei Variablen 

von eingebauten Typen (z. B. bei int) durch eine Variablendefinition. 

Allgemeine Variablendefinition: Typ VariablenName ; 

Spezielle Variablendefinition (Objekt): KlassenName ObjektName ;


Näheres zur Initialisierung von Objekten s. (9.21). 

Der Zugriff auf ein Element einer Klasse (Datenelement oder Elementfunktion) kann i. a. 

nur über ein zu dieser Klasse gehöriges Objekt, d. h. über eine Variable dieses Klassentyps 

geschehen; dieser Zugriff erfolgt mit dem Operator . (Op2d), wie schon in (5.23) für Elementfunktionen 

erläutert: 

ObjektName.ElementName 

Anm1 Anders innerhalb von Elementfunktionen selbst: diese können direkt auf die Elemente zugreifen, 

da sie ja beim Aufruf implizit mit einem Objekt verbunden sind. 

Anm2 Zum Öffnen des Klassen-Scopes bei der Definition von Elementfunktionen s. (9.12a). 

↑↑ Es gibt auch Zugriffe ohne ein Objekt, und zwar bei sog. statischen Elementen. Diese werden 

erst in (Kap. 11.5) besprochen. 

Bsp – zu (9.11 Bsp, 9.12 Bsp), siehe auch (9.21 Bsp) – 

Komplex z; z.setzKompl(-1.7,4.2); 

cout


(9.23) 

// Beispiel D09-22.CPP 

#include 


class Test { 

int x, y; 

public: 

Test(); // Standardkonstruktor (kein Par.) 

Test(int zahl); // Konstruktor mit 1 Parameter 

Test(int zahlX,int zahlY); // Konstruktor mit 2 Parametern 

int gibX(); // Auslesen x 

int gibY(); // Auslesen y 

}; 

Test::Test() { x=y=0; } // Def. Std.-Konstr. 

Test::Test(int zahl) { x=y=zahl; } // Def. Konstr. 1 Par. 

Test::Test(int zahlX,int zahlY) { x=zahlX; y=zahlY; } // Def. K. 2 Par. 

int Test::gibX() { return x; } // Rückgabe Datenelement x 

int Test::gibY() { return y; } // Rückgabe Datenelement y 

int main() 

{ // SYNTAX FÜR KONSTRUKTORAUFRUFE je nach Anzahl der Parameter 

// (0): Standardkonstruktor, (1): Konstr. 1 Par., (2): Konstr. 2 Par. 

// Empfehlung: jeweils erste Form jeder Zeile 

// impliziter, expliziter, impliziter Konstruktoraufruf 

Test a; Test b=Test(); // (0) 

Test c(4); Test d=Test(4); Test e=4; // (1) 

Test f(1,3); Test g=Test(1,3); // (2) 

} 

Test h(3,4),i,j=2,k=Test(0,-1),l(3),m=Test(),n=Test(5); 

// VarName KonstrAnzahlPar: h 2; i 0; j 1; k 2; l 1; m 0; n 1 

cout


class Keller { 

public: 

Keller(); // Standardkonstruktor 

~Keller(); // Destruktor 

void schiebe(int wert); 

int hole(); 

private: 

void fehlerSchieben(); 

void fehlerHolen(); 

enum { maxanz=100 }; // Konstante mit Klassen-Scope (12.21) 

int speich[maxanz], 

zaehler; 

}; 

#endif 


#include 


#include "d09-31a.h" // Klassendefinition Keller 

(c) 

Keller::Keller() // Standardkonstruktor 

{ 

zaehler=0; // wichtige Erstbelegung!! 

} 

// Nur zum Demonstrieren des Konstruktors - NICHT FÜR DIE PRAXIS! 

cout


#include "d09-31a.h" // Klassendefinition Keller 

int main() 

{ 

Keller kellerVar; 

int zahl; 

} 

cin >> zahl; 

kellerVar.schiebe(zahl); 

cout


}; 

int gibJahr() { return jahr; } // s. Punkt (11b Anm.1) in ds. Kap. 

// ... 

Eine Änderung der internen Repräsentation der Daten muss die Schnittstelle nicht ändern. 

Wenn oft die Anzahl Tage zwischen zwei Datumwerten desselben Jahres ausgerechnet werden 

muss (z. B. mit der Elementfunktion differenz(Datum &anderTag) im Beispiel unten oder 

als Differenz datum1-datum2, empfiehlt sich die Datumdarstellung in Form TagDesJahres 

statt Tag und Monat (dazu die Jahreszahl): 

class Datum { 

int tagJahr; // statt: int tag; int monat; 

int jahr; 

}; 

public: 

Datum(); 

Datum(int t,int m, int j); 

~Datum() {} // leerer Destruktor 

int gibTag(); // muss jetzt berechnet werden: Def. El.-Fkt. woanders 

int gibMonat(); // muss jetzt berechnet werden: Def. El.-Fkt. woanders 

int gibJahr() { return jahr; } 

// jetzt neue Funktion differenz (Anzahl Tage zu anderTag): 

int differenz(Datum &anderTag); 

// ... 

Wenn dagegen sehr häufig Datumdifferenzen als Anzahl Tage über noch größere Zeiträume 

berechnet werden sollen (Astronomie), empfiehlt sich die interne Repräsentation als ” Julianisches 

Datum“ (JD, nach Julius Caesar Scaliger, 16. Jh., it. Naturforscher und Humanist): 

gezählt werden die Tage seit dem 01.01.4713 v. Chr. (Nullpunkt um 12 Uhr Weltzeit) – 

oder das Modifizierte Julianische Datum (MJD) mit dem Nullwert am 17.11.1858 um 0 Uhr 

Weltzeit. Der 01.01.2000 0 Uhr UT entspricht 51 544 MJD bzw. 2 451 544,5 JD. 

(9.33) Weitere wichtige Möglichkeiten der Objektorientierung werden in (Kap. 11) besprochen.


10 Einige C ++-Ergänzungen, Zeigertyp, Freispeicher 


In diesem Kapitel werden einige wenige Ergänzungen in C ++ eingeschoben, die sinnvoll sind, 

um sich vertieft mit der Objektorientierung (Kap. 11) befassen zu können. Die weiteren sinnvollen 

C ++-Vertiefungen, die dazu nicht unbedingt notwendig sind, sind auf (Kap. 12) verschoben. 

Die hier vorgestellten Ergänzungen sind wichtig für das Verständnis der Folgekapitel. 

Unterkapitel 1 stellt zusammen, wie symbolische Konstanten gebildet werden können und 

wie die Benutzung sehr kurzer Funktionen für die Laufzeit beschleunigt wird. 

In Unterkapitel 2 wird der Datentyp Zeiger genauer erläutert. Dazu werden wichtige Regeln 

für die Interpretation zusammengesetzter Typen, ferner die Benutzung des const vorgestellt. 

Den in der Praxis sehr häufig anzutreffenden Umgang mit dem Freispeicher (oder dynamischen 

Speicher) stellt Unterkapitel 3 vor. 

10.1 Symbolische Konstanten, Makros und inline-Funktionen 

(10.10) Übb Dieses Unterkapitel zeigt zunächst, wie ein Programm für Programmierer lesbarer 

gemacht werden kann: statt wörtliche Konstanten ( ” Literale“) zu benutzen, sollen symbolische 

Konstanten (d. h. Namen) genommen werden. Ebenso werden Hinweise gegeben, wie 

die Ausführung kurzer Funktionen zur Laufzeit effizienter gemacht werden kann. 

(10.11) Symbolische Konstanten statt ” magischer Zahlen“ sind für eine gute Programmierung 

sehr wichtig, wie schon früher in (4.72) und (5.44) erwähnt wurde. Folgende Möglichkeiten 

bestehen hierbei: 

(a) C++ Konstante – häufig mit eigenem Speicherplatz, 

z. B. const Typ KonstantenName = Initialisierer ; 

Solche Konstanten haben globalen, lokalen oder Klassen-Gültigkeitsbereich – ja nach Definitionsort. 

In C bereits bekannt, jedoch erst in C++ auch als Indexgrenzen o. ä. erlaubt, 

d. h. als Bestandteil eines konstanten Ausdrucks. 

↑↑ In C++(alt) bei Klassen als statische Konstanten etwas schwierig handhabbar, in C++(neu) bei 

integralen Typen besser, da übersichtlichere Initialisierungsmöglichkeit und bessere Verwendbarkeit. 

(b) C/C++ Makros ohne Parameter (5.72) (sollten in C ++ vermieden werden). 

Nachteil: ” dummer“ Textersatz, kein Block- oder Klassen-Gültigkeitsbereich, kaum mit Debugger 

zu bearbeiten, da Ersetzung bereits durch Präprozessor. 

(c) C++ Aufzählungskonstanten, Näheres s. (12.21) 

Auch hier globaler, lokaler oder Klassen-Gültigkeitsbereich; auch diese Konstanten sind für 

konstante Ausdrücke zugelassen, z. B. als Arraydimensionierung. 

(10.12) Funktionen ohne Funktionsaufruf-Überbau, generische Funktionen 

(a) C++ inline-Funktionen 

Durch den 15 FunktionsSpezifizierer inline erhält der Compiler einen Hinweis, dass er jeden 

Aufruf der Funktion durch Einfügen des entsprechenden Funktionsblock-Codes ersetzen 

soll. Der Compiler darf diesen Hinweis ignorieren. Ein inline ist in der Regel nur bei sehr 

einfachen Funktionen sinnvoll, da sonst bei häufigem Funktionsaufruf der Codeumfang beträchtlich 

erhöht wird. Zum Einsatz in Klassen s. (11.11b). 

Im Gegensatz zu Makros (a) gibt es hier keine ” unerwarteten“ Effekte bei Parametern mit 

Seiteneffekten. 

Der Nachteil gegenüber Makros (a), dass nämlich für jeden Typ eine eigene Funktion geschrieben 

werden muss (z. B. MAX für int, für double usw.), wird bei (c) behoben. 

(b) ↑↑ C/C++ Makros mit Parameter 

#define Name( ParameterListe ) Textersatz mit Parametern


Bsp #define MAX(a,b) ((a)>(b)?(a):(b)) 

MAX(a+2,4)*12 wird ” erweitert“ zu: . . . (s. Vorlesung). 

Dieses Makro kann typunabhängig zur Maximumbestimmung für sämtliche arithmetischen Typen benutzt 

werden. Diese kann bequem sein, ist jedoch auch gefährlich, insbesondere wenn die Parametertypen 

verschieden sind. 

Anm1 Zwischen Name und der öffnenden Klammer der Parameterliste darf kein Zwischenraumzeichen 

stehen, da sonst Interpretation als Makro ohne Parameter. 

Anm2 Zeilenfortsetzung möglich, s. (5.71). 

Anm3 Die Textersetzung des Präprozessors wird ” Makroerweiterung“ genannt. 

Anm4 Wichtig: Klammerung sowohl der formalen Parameter als auch des Gesamtausdrucks, damit 

intuitiv angenommene Vorrangregeln beachtet werden: 

Bsp #define SUM SCHLECHT(x,y) x+y 

#define SUM GUT(x,y) ((x)+(y)) 

Führen Sie die Makroerweiterung der Ausdrücke SUM(6,x)*3 und SUM((a>=0)?a:-a,z) 

für SUM als SUM SCHLECHT und als SUM GUT durch! Unterschied? Achten sie auf die Operator- 

Hierarchiestufen! 

△! Sehr gefährlich ist eine Makrobenutzung, wenn Parameter Seiteneffekte haben; diese 

Seiteneffekte werden dann ggf. mehrfach durchgeführt, da der Präprozessor nur ” dummen“ 

Textersatz vornimmt ( ” unerwartete“ Effekte). 

Ein Makro mit Parameter wird durch den Präprozessor erweitert, der keine Kenntnisse von 

der Sprache C ++ hat; daher geschieht eine Typprüfung durch den Compiler erst beim schon 

erweiterten Programmtext – vgl. auch Bemerkung in Bsp oben. 

In C ++ gibt es bessere Konstrukte, nämlich (b,c), die diese Nachteile vermeiden und trotzdem 

typsicher sind. 

(c) ↑↑ C++(neu) 

” Generische“ Funktionen (für viele Typen eine gemeinsame Definition): 

Parametrisierte Funktionen (Template-Funktionen). 

10.2 Datentyp Zeiger, Typinterpretation, Array und Zeiger 

(10.20) Übb In Fortsetzung zu (Kap. 5.6) wird hier der Datentyp Zeiger genauer erläutert (10.21 bis 

10.24). In der Praxis werden Zeiger sehr häufig benutzt. Der sinnvolle Einsatz eines solchen 

Typs wird später in diesem Kurs dargestellt. 

In diesem Zusammenhang werden in (10.25) sehr allgemeine Regeln erläutert, wie komplizierter 

zusammengesetzte Typen zu interpretieren sind. Diese Regeln werden später auf komplexe 

Typen angewendet. Die Kenntnis dieser im Grunde sehr einfachen Regeln erleichtert 

das Verständnis für zusammengesetzte Datentypen sehr! 

(10.26) gibt eine für C ++/C typische Umwandlungsregel von Arraynamen in Zeiger an; diese 

Kenntnis ist grundlegend für das nähere Verständnis im Umgang mit Arrays. 

Durch die Einführung von Zeigern wird die Benutzung von const etwas komplizierter. Das 

Nähere erläutert (10.28). 

Da der Zugriff auf Elementfunktionen in der Praxis sehr häufig über Zeiger auf Objekte 

geschieht, macht die in (10.29) eingeführte abkürzende Operator-Schreibweise Programmtext 

übersichtlicher. 

(10.21) Datentyp Zeiger 〈pointer〉, vgl. Kurzerläuterung in (5.65) 

(a) Der Datentyp Zeiger ist dadurch charakterisiert, dass sein Wert als Adresse einer anderen 

Variablen interpretiert wird, der Zeiger ” zeigt“ auf einen anderen Speicherplatz. 

ZeigerVariablenDefinition [NV] Typ *ZeigerName ; 

Hierbei ist ZeigerName eine Zeigervariable, sie soll auf eine Variable des Typs Typ zeigen. 

(b) Zwei neue Operatoren in Zusammenhang mit Zeigern (unär präfix, Op3gh): 

& Adressoperator, berechnet die Speicheradresse des Operanden 

* Inhalts- oder Verweisoperator, betrachtet Operanden als Adresse und gibt Wert der 

Variablen, die sich an dieser Adresse befindet, zurück. 

(c) Möglichkeiten der gültigen Wertbelegung von Zeigern:


• Zuweisen der Adresse einer bereits vorhandenen Variablen mit z. B. &Variable 

• Zuweisen des Werts einer bereits gültig belegten Zeigervariable gleichen Typs 

• Zuweisen einer typrichtigen Adresse aus dem Freispeicher mit dem Operator new, s. (Kap. 

10.3) 

• Zeiger 0, s. (10.23) 

(10.22) △! bei Umgang mit Zeigern: im allgemeinen müssen zwei Speicherplätze reserviert werden, 

da zwei Variable zu unterscheiden sind: 

(1) Speicherplatz für die Zeigervariable selbst (Wert: Adresse) – geschieht meist durch Variablendefinition. 

(2) Speicherplatz für Variable, auf die der Zeiger zeigt, die sog. ” dereferenzierte Variable“: 

dieser Speicherplatz muss i. a. extra bereitgestellt werden, s. (10.21c). 

(10.23) Häufig ist eine Wertbelegung eines Zeigers sinnvoll, die abfragbar ist, aber die Bedeutung 

hat: ” nicht belegt“ oder ” zeigt auf nichts“. Dieses geschieht mit 

C++ Zeiger 0 oder 

C (C++) Zeiger NULL (als Makro). 

Es ist garantiert, dass diese Adresse nie gültiger Daten- oder Code-Speicherplatz ist. 

Da die Adresse 0 nie eine valide Adresse ist, darf der Zeiger 0 (bzw. ein beliebiger Zeigerausdruck 

mit Wert Adresse 0) nie dereferenziert werden. 

char *zeiger=0; // Zuweisung Adresse 0: OK 

// Fehler, NICHT erlaubt: 

*zeiger=’j’; // weder ein schreibender Zugriff auf Adresse 0 ... 

cout


(10.25) 

(a) 

(b) 

Allgemeine Regeln für die Interpretation von Typen bei Deklarationen: 

VariablenDefinition [NV] Typ Deklarator [- , Deklarator ]- 0..n ; 

Typ (hier) 12 DeklSpezifizierer1..n 

30 Deklarator [NV] 32 DirekterDeklarator 

| 

| 

31 - * & 

32DirekterDeklarator Bezeichner (d. h. Name) 

32DirekterDeklarator[KonstAusdropt] 

- 30 Deklarator 

| 

| ( 30Deklarator ) | 

| 

• (Ohne Referenz-Deklarationsoperator &:) 

Tritt der Deklarator nach dem Deklarationspunkt auf, so ist er vom angegebenen 

” Typ“. 

• (Bei Vorhandensein des Referenz-Deklarationsoperators &:) 

Tritt der Deklarator (OHNE den &-Deklarationsoperators) nach dem Deklarationspunkt 

auf, so ist er vom Typ ” Referenz auf Typ“. 

Regeln zur Bestimmung des Typs eines Namens innerhalb eines Deklarators: 

Je Stufe wird genau einer der Deklarationsoperatoren (* bzw. [ ] [NV] ) weggelassen, und 

zwar immer der Operator mit der augenblicklich niedrigsten Bindung. Es gelten dabei folgende 

Regeln: 

• Ist *A vom Typ ” T“, so ist A vom Typ ” Zeiger auf T“. 

• Ist A[KonstAusdropt] vom Typ ” T“, so ist A vom Typ ” Array, bestehend aus Komponenten 

des Typs T“ (Anzahl der Komponenten entspr. KonstAusdr; wenn fehlend, 

dann unbestimmte Anzahl). 

Regel zur Unterscheidung zwischen Typ und Deklarator (zweite Zeile in obigem Kasten): 

Man beginne hinten beim Semikolon und finde, falls vorhanden, das vorderste Komma (bis 

dahin: nur Deklaratoren). Nun gehe man weiter nach links und suche und überspringe, falls 

vorhanden: 

• einen Namen (ggf. vorhandene eckige Klammernpaare überspringen), 

• dann ein oder mehrere Zeichen * oder & (mit ggf. dazwischenliegenden const’s, s. (10.28)), 

• dann, falls runde schließende Klammern übersprungen wurden, die zugehörigen öffnenden 

Klammern. 

Jetzt ist man an dem Trennpunkt zwischen Typ und Deklarator. 

Bei einer Definition wird nicht Speicherplatz für den Deklarator, sondern für den 

Namen reseviert. 

In ähnlicher Weise wird eine ggf. vorhandene Initialisierung auf den Namen (der den 

Speicherplatz erhält) angewendet, nicht auf den Deklarator. 

Bsp char *zeig=0; // zeig (d. h. Zeiger auf char) wird initialisiert mit 0, nicht *zeig. 

(10.26) Wichtige Regel zum Umgang mit Arrays (Zusammenhang zwischen Array und Zeiger) – 

bereits in (5.65b, 7.46 ↑↑) erwähnt: 

Ein Arrayname bzw. eine Arraybezeichnung ( ” Array, bestehend aus Elementen des 

Typs T“) wird durch den Compiler automatisch umgewandelt in ” Zeiger auf T“, und 

zwar die Adresse des ersten Elements (Element mit Index 0). 

Implizit wird demnach ArrayBezeichnung umgewandelt in &ArrayBezeichnung[0] 

Insbesondere findet diese Umwandlung immer bei formalen und bei aktuellen Funktionsparametern 

statt. 

Die (wesentlichen) Ausnahmen von obiger Regel sind:


&ArrayBezeichnung Adresse des Arrays 

sizeof ArrayBezeichnung Speicherbedarf des Arrays 

(wichtige Bedeutungsänderung dieses Ausdrucks 

bei formalem Funktionsparameter s. (12.44d)) 

Zusätzliche Einzelheiten s. (12.32). Wichtige Folgerungen für Funktionsparameter s. (12.44). Da 

hierbei ” Array aus Elementen T“ und ” Zeiger auf T“ äquivalente Typen sind, wird bei Arrays 

als Funktionsparameter meist der Zeigertyp genommen, z. B. statt char arr[anzahl] 

oder (äquivalent) char arr[] wird meist – ohne Bedeutungsänderung – char *arr geschrieben. 

(10.27) Den Typ einer Variablen erhält man, indem man die Variablendeklaration nimmt und – 

unter Beibehaltung ggf. vorhandener Klammern – den Variablennamen weglässt. 

Bsp Deklaration Typ: In Worten: 

(ohne schließendes Semikolon): 

char a[17] char[17] Array mit 17 char-Komponenten 

char *b char* Zeiger auf char 

Näheres zu den beiden folgenden Typen s. a. (12.71, 12.72): 

int *c[3] int*[3] Array mit 3 Zeigern auf int 

int (*d)[3] int(*)[3] Zeiger auf Array mit 3 int-Komponenten 

Zwischen den einzelnen Token können beliebig Zwischenraumzeichen gesetzt werden; folgende Typen sind 

beispielsweise gleich: 

int * [3] oder int *[3] oder int* [3] oder int*[3] 

(10.28) Zur Interpretation des Schlüsselwortes const: 

Steht const vor dem Deklarator (d. h. als DeklSpezifizierer 12,14,25 ), so ist der Deklarator 

konstant. Ist const Bestandteil des Deklarators ( 30,31,25 ), so ist nur der hinter diesem const 

stehende Deklaratorteil konstant. In beiden Fällen denkt man sich zur Bestimmung des 

konstanten Deklator(teil)s alle ggf. vorhandenen weiteren consts als gestrichen. 

Bsp const char *zeig Deklarator *zeig ist konstant, d. h. das char, worauf zeig zeigt 

char const *zeig dto. 

char *const zeig Deklaratorteil zeig ist konstant, d. h. der Zeiger zeig selbst 

const char *const zeig sowohl *zeig als auch zeig sind konstant 

char const *const zeig dto. 

Die zugehörige Typen lauten (in der gleichen Reihenfolge): 

const char* 

char const* 

char *const 

const char *const 

char const *const 

Auch hier können zwischen den Token beliebig Zwischenraumzeichen gesetzt werden; nur zwischen 

Schlüsselwörtern/Namen muss mindestens ein Zwischenraumzeichen stehen. Daher jeweils gleichwertig: 

const char * const zeig 

const char* const zeig 

const char *const zeig 

const char*const zeig 

Nicht erlaubt beispielsweise, da Schlüsselwörter nicht trennbar: constchar . . . 

(10.29) Beim Zugriff auf Klassen/Objekte über Zeiger gibt es die abkürzende Schreibweise mit dem 

Operator -> (Op2e), vgl. Operator . (Op2d) (9.13): 

KlassenZeigerVariable->ElementName 

Es gilt: a->b 

ist äquivalent zu (*a).b 

10.3 Freispeicher 

(10.30) Übb Die in (8.11c) kurz erläuterte dritte Speicherklasse dynamisch-kontrolliert wird 

hier näher erläutert. Der hierfür vom Laufzeitsystem benutzte sog. Freispeicher (dynamischer 

Speicher, Heap) ist ein gesonderter Speicherbereich. In der Praxis geschieht die 

Reservierung von Freispeicher und dessen Freigabe, wenn er nicht mehr benötigt wird, sehr 

häufig. Hierdurch wird erstmals die dynamische Speicheranforderung ermöglicht, d. h. die


(10.31) C++ 

Anforderung von Speicherplatz, dessen genaue Größe erst zur Laufzeit feststeht, z. B. Arrays 

mit erst zur Laufzeit feststehender Anzahl Elemente. Dagegen muss bei der statischen 

und automatischen Speicherklasse die Größe des zu reservierenden Speicherplatzes schon zur 

Kompilationszeit feststehen. 

Reservierung und Freigabe erfolgt nur durch ausdrückliche Anweisung durch den Programmierer; 

beides ist nicht an Blockgrenzen gebunden. In C ++ wird diese Speicherklasse durch 

die Operatoren new und delete (10.31, 10.32, 10.33) direkt unterstützt, in C nur über Bibliotheksfunktionen 

(10.34). 

(a) FreispeicherReservierungsAusdruck [NV] new Typ 

Bedeutung dieses Ausdrucks mit dem Operator new Op3k : 

• Seiteneffekt: Laufzeitsystem reserviert Speicherplatz, und zwar (mindestens) so viel, wie 

für Typ benötigt wird. Dieser Speicherplatz ist bei einem eingebauten Typ nicht initialisiert; 

bei einem KlassenTyp wird der Standardkonstruktor aufgerufen. Eine explizite 

Initialisierung ist mit anderer Syntax möglich, s. (b). 

• Haupteffekt (Wert): Die (Anfangs-)Adresse des reservierten Speicherplatzes, und zwar 

typrichtig als ” Zeiger auf Typ“ 

• Wenn nicht genügend Speicherplatz vorhanden ist: 

◦ C++(alt) Rückgabe der Adresse 0, s. (10.23); es ist garantiert, dass diese Adresse nie 

gültiger Daten- oder Code-Speicherplatz ist. 

◦ C++(neu) Auswerfen einer Ausnahme des Typs bad alloc (wird hier nicht besprochen). 

Das Verhalten von C++(alt) kann jedoch imitiert werden durch Hinzufügen von 

(nothrow), d. h. durch Ersetzen von new durch new(nothrow); hierbei muss zusätzlich 

der Header eingefügt werden. 

• Eine Klammerung innerhalb eines komplizierteren Typs (z. B. in (12.71, 12.72)) wird aus 

Gründen von Vorrangregeln falsch interpretiert; in diesem Fall müssen zusätzlich Gesamtklammern 

gesetzt werden: new ( Typ ). 

(b) Andere Form des FreispeicherReservierungsAusdrucks: 

new Typ ( Initialisierer-LISTEopt ) 

• Ist Typ ein eingebauter Typ, so darf die Liste nur ein Element enthalten oder leer 

sein. Der Speicherplatz wird reserviert und, wenn vorhanden, mit dem angegebenen 

Wert initialisiert. Ein leeres Klammernpaar wirkt wie fehlende Klammern (s. (a)): keine 

Initialisierung. 

• Ist Typ eine Klasse, so wird der zugehörige Konstruktor aufgerufen, im Fall des leeren 

oder auch fehlenden (s. (a)) Klammernpaares der Standardkonstruktor. 

(10.32) C++ FreispeicherFreigabeAusdruck delete Zeiger 

Bedeutung dieses Ausdrucks mit dem Operator delete Op3l : 

• Seiteneffekt: Speicherplatz, auf den Zeiger zeigt, wird wieder freigegeben. (Das Laufzeitsystem 

” weiß“, wieviel Speicherplatz zu dieser Adresse gehört.) 

△! Der Speicherplatz MUSS vorher mit new reserviert worden sein! 

△! Dieser Speicherplatz darf NICHT mehrmals freigegeben werden! 

• Aufruf mit Adresse 0 (10.23) ist unschädlich; daher Empf (dringende Empfehlung): nach 

Freigabe Zuweisung Adresse 0 an Zeiger, wenn Zeiger noch länger in Gebrauch ist. 

• Haupteffekt: keiner (void) 

(10.33) C++ Reservierung und Freigabe von Speicherplatz für eindimensionale Arrays: 

new Typ [ GanzzahlAusdruck ] 

delete [ ] Zeiger 

Bedeutung:


• Reservierung: GanzzahlAusdruck gibt die Anzahl Elemente des Arrays an, für die 

Speicherplatz reserviert wird. Der Typ des ErgebnisAusdrucks ist ” Zeiger auf Typ“ – 

wie bei Array üblich (10.26), aber auch wie bei Reservierung für Nicht-Array (10.31). 

GanzzahlAusdruck braucht erst zur Laufzeit auswertbar zu sein, d. h. darf Variable 

enthalten (dynamisches Array) – im Gegensatz zu bisheriger Arraydefinition (Kap. 

5.4), dort muss Speicherplatzbedarf bereits zur Kompilationszeit feststehen! 

Im Gegensatz zur Form (10.31b) darf und kann hier keine Initialisiererliste angegeben 

werden; im Falle eines Klassentyps muss daher ein expliziter oder impliziter (9.21b) Standardkonstruktor 

existieren (und zugreifbar sein); dieser Standardkonstruktor wird für 

jede Arraykomponente aufgerufen. 

• Freigabe: Wie bereits oben erwähnt, kann der Compiler bei der Angabe von Zeiger 

nicht entscheiden, ob es sich hierbei um einen Zeiger auf genau ein Element Typ im 

Sinne von (10.31) oder um einen Zeiger auf das erste Element eines Arrays, bestehend 

aus Typ-Komponenten, im Sinne von (10.33) handelt, da beidesmal Zeiger den Typ Typ* 

hat, d. h. Zeiger auf Typ. 

Daher ist bei der Freigabe die Angabe wichtig, dass es sich um Array-Speicherplatz 

handelt (d. h. [ ] nicht vergessen!); sonst kann das Programm zur Laufzeit ggf. zusammenbrechen. 

Der Compilerhersteller darf nämlich die Implementation von ” new Typ“ 

und von ” new Typ[...]“ so unterschiedlich machen, dass ein Verwechseln von ” delete“ 

und ” delete[ ]“ in einer Katastrophe endet. Außerdem – im Falle von Objekten eines 

Klassentyps – ist es nämlich häufig wichtig, dass für jede Arraykomponente der Destruktor 

aufgerufen wird – und das kann nur geschehen, wenn der Compiler weiss, dass 

es sich um ein Array handelt. 

Der Zugriff auf ein Arrayelement geschieht genauso wie bei anderen Arrays; der Name des 

Zeigers, dem der new-Ausdruck zugewiesen wurde, wird als Arrayname betrachtet: 

ArrayName[ElementNummer]. 

(10.34) ↑↑ zu C : 

Bsp int anz=25; 

int *p= new int[anz]; // Erzeugung eines Arrays aus anz (hier: 25) int’s 

p[12]=27; // Zuweisung an Element Nummer 12 (d. h. an das 13. Element) 

↑↑ Zur Erzeugung dynamischer mehrdimensionaler Arrays s. (12.74). 

↑↑1 Für den Umgang mit dem dynamischen Speicher stehen u. a. die Bibliotheksfunktionen 

malloc und free () zur Verfügung. Sie sind zwar auch in C ++ verfügbar, sollten 

aber wegen der fehlenden Typsicherheit nicht genommen werden. 

↑↑2 △! Auf keinen Fall in C++ die Freispeicherverwaltung mit den genannten Bibliotheksfunktionen 

und die mit den Operatoren new/delete vermischen!!


11 Objektorientierung: 

Ergänzungen, Vererbung, Polymorphie, statische Klassenelemente 


Dieses Kapitel vertieft die Einführung in die Objektorientierung (Kap. 9). Nach einigen ergänzenden 

Bemerkungen in Unterkapitel 1 (Freund-Konzept, this-Zeiger, Kopier-Konstruktor) 

wird die sehr hilfreiche Möglichkeit aufgezeigt, wie die formale Benutzung und die Bedeutung 

( ” Syntax“ und ” Semantik“) der in C ++ vorhandenen Operatoren auf Klassentypen (oder 

andere benutzerdefinierte Typen) ausgedehnt werden können (Unterkapitel 2). 

Unterkapitel 3 beschreibt das äußerst mächtige Konzept der Vererbung, der Möglichkeit, 

Ähnlichkeiten zwischen Klassen zu beschreiben. Ohne dieses wäre die Objektorientierung 

kaum wichtig geworden. Im Folgekapitel wird die Polymorphie eingeführt. Sie erlaubt es, 

Funktionen mit derselben Signatur zu redefinieren, so dass der auszuführende Programmcode 

trotz gleichen Namens je nach Objekttyp verschieden sein kann. Dieses ist insbesondere 

in Zusammenhang mit später Bindung von großer Bedeutung; es erlaubt, die auszuführende 

Aktion (den zugehörigen Funktionscode) erst zur Laufzeit zu bestimmen, und zwar in 

Abhängigkeit vom dann erst feststehenden Objekttyp. 

Unterkapitel 5 beschreibt die Einführung statischer Klassenelemente. Statische Datenelemente 

sind pro Klasse genau einmal vorhanden, und zwar unabhängig von der Existenz von 

Objekten. 

11.1 Klassen und Objekte: Ergänzungen 

(11.10) Übb Nach einigen Vorbemerkungen (11.11) wird die Möglichkeit des gezielten Aufbrechens 

der Kapselung von Klassen über friend gezeigt (11.12). Dieses ist normalerweise unerwünscht, 

in (seltenen!) Spezialfällen aber sinnvoll. 

(11.11) 

Da der Code von Elementfunktionen zur Laufzeit nur einmal pro Klasse (und nicht in jedem 

Objekt) vorhanden ist, muss die Elementfunktion wissen, mit welchem Objekt (d. h. mit 

welchem Datensatz) sie aufgerufen wurde. Dieses geschieht durch die implizite Übergabe des 

Zeigers this (11.13). Die Kenntnis über diesen Mechanismus ist im folgenden Unterkapitel 

unbedingt nötig (Operator-Überladung, und zwar als Elementfunktion). 

Nach der kurzen Erläuterung der Initialisiererliste (11.14) wird der Kopier-Konstruktor eingeführt 

(11.15). Die explizite Definition eines solchen Konstruktors ist wichtig, wenn man statt 

einer ” flachen Kopie“ (Standardverhalten: die einzelnen Elemente eines Objekts werden kopiert) 

eine ” tiefe Kopie“ erzeugen muss: hierbei werden, wenn Zeiger (oder auch Referenzen) 

vorhanden sind, zusätzlich auch Kopien von den Daten erzeugt, auf die diese Zeiger (oder 

Referenzen) zeigen. 

(a) Das Erzeugen eines Objekts einer Klasse heißt manchmal auch Instantiierung, ein Objekt 

wird auch Instanz oder Exemplar 〈instance〉 einer Klasse genannt. 

(b) Wenn eine Elementfunktion schon innerhalb der Klassendefinition definiert (nicht nur deklariert) 

wird, so wird diese Definition implizit als inline (10.12a) aufgefasst, vgl. Hinweis in 

(9.11b Anm). 

(c) Wird ein Klassentyp statt mit class mit dem Schlüsselwort struct eingeleitet, so ist die 

Voreinstellung für die Zugriffsspezifizierung public. Wegen (6.13c) sollte daher struct i. a. 

nicht genommen werden, damit private als das ” Normale“ nicht vergessen wird. 

↑↑ In C gibt es nur das struct, hier sind als Elemente nur Daten möglich, keine Funktionen 

und keine Zugriffsspezifizierer. Manchmal benutzt man auch in C ++ solche structs, z. B. 

wegen der einfacheren konstanten Initialisierung. Weitere Gründe s. Vorlesung InfHaupt. 

Außerdem ist in C der Name hinter struct kein Typname, sondern ein sog. Etikett 〈tag〉. 

Zur Typnennung ist daher die Kombination struct mit Etikett nötig, oder man definiert 

mit typedef einen Typnamen (5.62). Dieses ist in C ++ jedoch nicht nötig.


(11.12) Freunde 

Globale Funktionen (11.13), Elementfunktionen oder auch alle Elemente einer Klasse können 

Freund einer Klasse sein, d. h. den Zugriff auf alle Bestandteile erhalten. 

Der Ort der 12 friend-Spezifizierung ist beliebig innerhalb der Klassendefinition wählbar, er 

ist unabhängig von Zugriffsspezifizierern: 

class TeilOffen { 

// Deklaration von Elementen 

// ... 

friend void ansicht(); 

friend double AndereKlasse::zugriff(int a); 

friend class Neugierig; 

// ggf. Fortsetzung der Elementdeklarationen 

// ... 

}; 

Semantik: 

Auf alle Elemente dieser Klasse TeilOffen – unabhängig von Zugriffsbeschränkungen – 

dürfen zugreifen: 

die (globale, d. h. nicht einer Klasse angehörige) Funktion ansicht, 

die Elementfunktion zugriff der Klasse AndereKlasse, 

alle Elemente der Klasse Neugierig. 

Anm1 Das Auftreten von friend deutet wegen des Aufbrechens des Geheimnisprinzips meist einen 

Entwurfsfehler an. Es gibt nur wenige Fälle, in denen ein friend sinnvoll und gerechtfertigt 

ist, s. z. B. (Kap. 11.2). Es ist wichtig, dass man sehr sparsam mit dieser Möglichkeit umgeht 

und zunächst immer überlegt, ob man nicht auch ohne friend auskommen kann. 

Anm2 Die Spezifizierung friend ist nicht symmetrisch. Zum obigen Beispiel: 

Damit die Klasse TeilOffen auch auf verborgene Elemente der Klasse Neugierig zugreifen 

kann, muss sie in Neugierig als Freund eingetragen sein. 

Anm3 Die Spezifizierung friend ist auch nicht transitiv. Zum obigen Beispiel: 

Ist die Klasse Weiter ein Freund von Neugierig (d. h. in Neugierig als Freund eingetragen), 

so ist nicht automatisch Weiter ein Freund von TeilOffen. 

Anm4 Die Spezifizierung friend wird auch nicht vererbt. 

Anm5 Zum obigen Beispiel: Die Klasse AndereKlasse mit der Elementfunktion zugriff muss dem 

Compiler an der Stelle der friend-Deklaration bekannt sein. 

Anm6 Zum obigen Beispiel: Falls Neugierig als Klassenname bekannt ist, kann man das Schlüsselwort 

class weglassen, es genügt folgende Angabe: 

friend Neugierig; 

Anm7 Zum Umgang des Compilers MS Visual C ++ 6.0 mit friend-Operatorfunktionen s. (11.23d). 

(11.13) Zeiger this 

(a) Eine Elementfunktion erhält bei jedem Aufruf als impliziten zusätzlichen ersten Parameter 

einen Zeiger auf das Objekt, zu dem sie aufgerufen wird. Dieser Zeiger hat den Namen this. 

Ist das Objekt, deren Elementfunktion aufgerufen wird, vom Typ T, so ist this vom Typ 

T *const, 

d. h. der Zeiger this zeigt auf T und ist konstant, vgl. (10.28, 10.25). Eine Änderungserlaubnis 

von this ergäbe auch keinen Sinn. 

(b) Wegen (a) muss genau zwischen Elementfunktionen und globalen Funktionen unterschieden 

werden: erstere können nur in Zusammenhang mit einem Objekt aufgerufen werden 

(auf das der implizite Zeiger this zeigt), die zweiten ohne Objekt.


Deklaration 

(ggf. auch Def.) 

Impliziter 

zusätzlicher 

Parameter 

Elementfunktion 

– nichtstatisch, s. (e) – 

Globale Funktion 

– auch Freundfunktion, s. (Anm) – 

innerhalb der Klassendefinition außerhalb einer Klasse 

– als Freund auch innerhalb – 

this (an erster Stelle) kein impliziter Parameter 

Bsp – T sei zugehörige Klasse – 

Funktionskopf Programmtext (in Klassendef.): 

Typ fkt(TypPar namePar) 

Abänderung durch Compiler: 

Typ fkt(T *const this, 

TypPar namePar) 

Aufruf Programmtext: 

objektName.fkt(par) 

Abänderung durch Compiler: 

T::fkt(&objektName, par) 

Typ fkt(TypPar namePar) 

fkt(par) 

Anm friend-Funktionen erscheinen zwar in der Klassendefinition, sind aber ” normale“ globale 

Funktionen (ohne this-Zeiger), die allerdings unbeschränkten Zugriff auf die Klassenelemente 

haben (11.12). Elementfunktionen anderer Klassen, die friend-Funktionen sind, haben 

ebenfalls keinen this-Zeiger auf ein Objekt dieser Klasse, statt dessen (natürlich) einen Zeiger 

zu einem Objekt der anderen Klasse, s. Beispielcode (11.12): die Elementfunktion zugriff 

hat keinen this-Zeiger auf ein Objekt der Klasse TeilOffen, wohl aber auf AndereKlasse. 

(c) Den Zeiger this darf der Programmierer in der Definition der Elementfunktion benutzen: 

this->element ist beispielsweise äquivalent zu element 

falls der Name element nicht verdeckt ist (Bedeutung des Operators -> s. (10.29)). Im 

Falle der Verdeckung kann über den this-Zeiger trotzdem darauf zugegriffen werden. Eine 

andere Möglichkeit (Bereichsauflösungsoperator ::) war in (9.12a) vorgestellt worden. 

(d) Soll das Objekt, zu dem eine Elementfunktion aufgerufen wird, innerhalb dieser Funktion 

als konstant behandelt werden, d. h. soll *this konstant sein, so muss this vom Typ 

const T *const 

sein (10.28). Dieses zusätzliche const kann der Benutzer jedoch nicht direkt benennen, da 

er this nicht selbst einträgt. Statt dessen muss er dieses const hinter die Parameterliste 

stellen, vgl. (Cpp/Kap. 1, 32 DirektorDeklarator, 3. Zeile). 

Bsp (Nichtkonstantes Objekt) Benutzer: Typ fkt(TypPar namePar) 

– vgl. Tabelle oben – Compiler: Typ fkt(T *const this, TypPar namePar) 

(Konstantes Objekt) Benutzer: Typ fkt(TypPar namePar) const 

Compiler: Typ fkt(const T *const this, TypPar namePar) 

Beispiel Programmtext: Elementfunktion text in (11.15a) 

(e) Werden hier Elementfunktionen erwähnt, sind immer nichtstatische Elementfunktionen 

gemeint. Statische Elementfunktionen haben keinen this-Zeiger; Näheres s. (Kap. 11.5). 

(11.14) Initialisiererliste bei der Definition eines Konstruktors 

(a) Einfache Datenelemente eines Objekts können beim Konstruktoraufruf direkt initialisiert 

werden, anstatt im Konstruktorrumpf (ZusammengesetzteAnweisung) entsprechende Zuweisungen 

auszuführen. Diese Initialisierungen werden bei der Konstruktordefinition gesetzt. 

Syntax (Cpp/Kap. 1, 33 FunktionsDefinition, 2. Zeile, vereinfacht/angepasst): 

KonstruktorName ( ParameterDeklarations-LISTEopt ) 

: ElementName(Initialisierer) [- , ElementName(Initialisierer) ]- 0..n 

54 ZusammengesetzteAnweisung 

Auf die gleiche Weise ist es in der Initialisiererliste möglich, Elemente, die selbst Objekte 

sind, durch einen Konstruktoraufruf zu initialisieren; ohne eine solche (explizite) Initialisierung 

wird vor Eintritt in den Konstruktorblock jeweils der zugehörige Standardkonstruktor


aufgerufen. Näheres s. (11.34). 

Bsp1 

class BspElem { 

float elem; 

public: 

BspElem(); // Standardkonstruktor 

BspElem(float el); // Konstruktor mit einem Parameter 

}; 

BspElem::BspElem() : elem(0) { } 

// statt: BspElem::BspElem() { elem=0; } 

BspElem::BspElem(float el) : elem(el) { } 

// statt: BspElem::BspElem(float el) { elem=el; } 

Bsp2 – hierbei Benutzung der Klasse BspElem des obigen Beispiels – 

class Beispiel { 

int x,y; 

double d; 

BspElem bspElem; 

public: 

Beispiel(int parY, float bsp); // Konstruktor mit zwei Parameter 

// ... 

}; 

Beispiel::Beispiel(int parY, float bsp) 

: x(30), y(parY), d(3.14159), // Initialis.-Liste f. eingeb. Typen 

bspElem(bsp) // .. und f. Objekt (Konstr. 1 Par.) 

{ } // im Konstruktorrumpf bleibt hier nichts mehr zu tun, daher leer 

Bsp3 s. (11.15), Definition des Standardkonstruktors; dort auch Gegenüberstellung zu Zuweisungen. 

(b) Hat man in einer Klasse konstante Elemente (const . . . ), so lassen sich diese nicht mehr 

durch Zuweisung im Konstuktorrumpf mit einem definierten Wert belegen (dann sind die 

Speicherplätze nämlich schon erzeugt), sie müssen in der Initialisiererliste belegt werden 

(sonst Compilerfehler!). 

(11.15) Kopier-Konstruktor 

(a) Wenn ein Objekt mit einem schon bestehenden Objekt desselben Typs initialisiert wird, so 

geschieht dieses normalerweise automatisch durch elementweises Kopieren. Dies kann große 

Probleme verursachen: 

// Datei D11-151.CPP 

#include // wegen strlen, strcpy 

#include 


class Zeile { 

int deflen; 

char *txt; 

public: 

Zeile(); 

Zeile(const char *str); 

~Zeile(); 

const char *text() const; 

// ... 

}; 

Zeile::Zeile() : deflen(0), txt(0) {} 

// Ähnlich, nur ohne Initialisiererliste, sondern mit Zuweisungen: 

// Zeile::Zeile() { deflen=0; txt=0; }


Zeile::Zeile(const char *str) 

{ 

deflen=strlen(str)+1; 

txt=new char[deflen]; // zu new bei Arrays s. (10.33) 

// beides zusammen in einer Zeile: 

// txt=new char[deflen=strlen(str)+1]; 

} 

strcpy(txt,str); 

Zeile::~Zeile() { delete [] txt; } // ein "delete 0;" wäre unschädlich, 

// zu delete [] s. (10.33) 

const char *Zeile::text() const 

{ 

const static char null[]="[leer]"; 

return (txt)?txt:null; 

} 

int main() 

{ 

Zeile leer, // Std-Konstruktor (oh. Parameter) 

gefuellt("Teststring"); // Konstruktor mit Parameter char* 

} 

{ 

Zeile problem1(gefuellt), // Problem! 

// Initialisierungszeile ggf. auskommentieren (zum Testen!) 

problem2 

=(gefuellt) // Und noch ein Problem! 

; // Anm.: beide Initialisierungsarten sind gleichwertig 

cout


Anm Ein ähnliches Problem ergibt sich bei einer Zuweisung eines Objekts des Typs Zeile an ein 

Objekt desselben Typs; Lösung dafür: Überladen des Zuweisungsoperators, s. (11.24b). 

(b) Ein Kopier-Konstruktor steuert die Initialisierung eines Objektes mit einem bereits bestehenden 

Objekt derselben Klasse; ist ein solcher Konstruktor nicht definiert, werden die 

Daten elementweise kopiert ( ” flache Kopie“). In vielen Fällen reicht dieses aus. In einigen 

Fällen kann dieses Verhalten jedoch unerwünscht sein, vgl. Beispiel in (a); dort benötigt man 

eine ” tiefe Kopie“. Reicht die Erzeugung einer flachen Kopie nicht aus, muss ein Kopier- 

Konstruktor definiert werden, in dem das gewünschte Verhalten festgelegt wird, z. B. eine 

tiefe Kopie. 

(11.16) 

FunktionskopfKopierKonstruktorKlasseT T(const T&) 

d. h. Initialisierung eines Objekts der Klasse T mit der konstanten Referenz auf ein bereits 

bestehendes Objekt dieser Klasse. 

Ein Kopier-Konstruktor für das Beispiel in (a): 

// Teil aus Datei D11-152.CPP 

// ... 

class Zeile { 

int deflen; 

char *txt; 

public: 

// ... 

Zeile(const Zeile &z); // Kopier-Konstruktor 

// ... 

}; 

Zeile::Zeile(const Zeile &z) 

{ 

txt=new char[deflen=z.deflen]; // eigener Speicherplatz! 

strcpy(txt,z.txt); 

} 

// ... 

(a) Ein Konstruktoraufruf kann dazu benutzt werden, eine temporäre Variable ohne eigenen 

Namen zu erzeugen: Nutzung beispielsweise bei Parametern einer Funktion bzw. bei 

Operanden eines Operators. 

Bsp Zu Beispiel (11.15a); folgende Ausgabezeile ist möglich: 

cout


↑↑ △! Manchmal kann eine solche implizite Typkonversion unerwünscht sein. Sie kann unterbunden 

werden durch den 15 FunktionsSpezifizierer explicit C++(neu) (nur in der Funktionsdeklaration 

innerhalb der Klassendefinition, nicht noch einmal bei einer Funktionsdefinition 

außerhalb zu wiederholen). Explizite Typkonversion ist dann weiterhin noch möglich. 

(c) ↑↑ Auch die umgekehrte Typkonversion – von dem vorgegebenen Klassentyp in einem 

beliebigen Typ – kann definiert werden durch eine sog. Typkonversionsfunktion; dieses ist 

in (Cpp/Kap. 1, 32 DirekterDeklarator, 5. Zeile) unter KonversionsFunktionsName angedeutet. 

11.2 Überladen von Operatoren 

(11.20) Übb Um benutzerdefinierte Typen den eingebauten Typen gleichzustellen, gibt es in C ++ 

das äußerst mächtige Mittel, Operatoren zu überladen, d. h. ihnen in Zusammenhang mit 

einem (oder zwei) benutzerdefinierten Typen eine sinnvolle Bedeutung zu geben. Dadurch 

ist es beispielsweise möglich, sich einen Typ Komplex (vgl. (9.11Bsp)) zu definieren und dann 

wie in der Mathematik üblich die Gültigkeit der binären Operatoren +, -, *, / auf die 

Addition, Subtraktion, Multiplikation und Division solcher komplexer Zahlen auszudehnen. 

Diese Überladung kann die übliche Bedeutung der Operatoren in Zusammenhang mit eingebauten 

Typen nicht verändern, sondern nur für neue benutzerdefinierte Typen (d. h. in 

der Praxis für Klassen und/oder für Aufzählungstypen (12.21)). 

(11.21) 

Um die Überladung zu definieren, wird für Operatoren eine Funktionsschreibweise eingeführt 

(11.22), d. h. der Funktions- ” Name“ mit Parametern und Rückgabetyp (Ergebnistyp der Operation). 

Diese Funktion kann als globale Funktion eingeführt werden (11.23). Dieses wird beispielsweise 

häufig für den Eingabeoperator >> und den Ausgabeoperator


Anm Die Überladung bei Operator-Elementfunktionen s. (11.24a). 

(a) Für einen Operatorausdruck (Operatoraufruf) wird in den Fällen, in denen eine solche Überladung 

definiert ist (11.23), optional eine Funktionsschreibweise eingeführt. 

Bsp a+34 wird zu operator+(a,34) 

!tt wird zu operator!(tt) 

cout


int main() 

{ 

Zeile zeil1("Dieses "), 

zeil2("ist ein "), 

zeil3("Teststring."); 

} 

cout


Zeile &operator=(const Zeile &z); // Zuweisungsoperator 

// ... 

}; 

Zeile &Zeile::operator=(const Zeile &z) 

{ 

if(this!=&z) { // Verriegelung gegen Selbstzuweisung: wichtig! 

delete [] txt; 

txt=new char[deflen=z.deflen]; 

strcpy(txt,z.txt); 

} 

return *this; 

} 

// ... 

int main() 

{ 

Zeile zeil1("Dieses "), 

zeil2("ist ein "), 

zeil3("Teststring."); 

} 

cout


Darstellung der Vererbung in UML, vgl. (1.34a): 

Oberklasse 

❅ 

Unterklasse 

Die Vererbung ist ein sehr mächtiges Instrument der Objekttechnologie. Die logische Beziehung 

von der Ober- zur Unterklasse ist eine Spezialisierung 〈specialization〉, die von 

der Unter- zur Oberklasse eine Generalisierung 〈generalization〉. Erst durch Einführung 

einer solchen Spezialisierungs- bzw. Generalisierungshierarchie wird es möglich, die reale 

Welt einfach zu modellieren. Es kommt der Eigenart des menschlichen Denkens sehr entgegen 

(Denken in Hierarchien), dass Beziehungen in Form solcher Abhängigkeiten formuliert 

werden können. 

(b) Eine Unterklasse kann wiederum Oberklasse für andere Klassen sein. Auf diese Weise wird 

eine Klassen-Vererbungshierarchie aufgebaut. 

(c) Die Modellierung kann sogar so weit gehen, dass Ähnlichkeiten zwischen Klassen (reale Welt: 

Mengen von gleichartigen Objekten) ausgelagert und für alle ähnliche Klassen gemeinsam 

formuliert werden, und zwar in der Art, dass es zu der gemeinsamen Klasse in der realen 

Welt keine Objekte gibt bzw. geben kann. Man spricht hierbei von einer sog. abstrakten 

Klasse 〈abstract class〉. Zur Unterscheidung davon nennt man eine Klasse, zu der Objekte 

erzeugt werden können, konkrete Klasse 〈concrete class〉. Zur Definition einer abstrakten 

Klasse in C ++ s. (11.43). 

Bsp Bei der Modellierung von Mann und Frau gibt es viele Gemeinsamkeiten (weite Teile der Anatomie, des 

Stoffwechsels usf.). Diese können ausgelagert werden in eine Klasse Mensch. Hiervon erben die Klassen 

Mann und Frau und fügen ihre geschlechtspezifischen Merkmale hinzu. In der realen Welt gibt es jedoch 

kein Objekt der Klasse Mensch, sondern immer nur Objekte der Klasse Mann oder Frau. 

(d) Man kann in der Modellierung auch eine sog. Mehrfachvererbung 〈multiple inheritance〉 

zulassen: hierbei erbt eine Unterklasse gleichzeitig die Eigenschaften von mehreren Oberklassen. 

Diese Art der Beziehung kann, sparsam eingesetzt, ein gutes Hilfsmittel zur Beschreibung 

der realen Welt sein. 

Bsp Ein Amphibienfahrzeug erbt die Bewegungsmöglichkeit auf dem Land vom Landfahrzeug, die auf dem 

Wasser vom Wasserfahrzeug. 

Nicht alle objektorientierten Sprachen unterstützen die Mehrfachvererbung. Die Sprache C ++ 

unterstützt sie zwar; dennoch soll sie im Rahmen dieser Vorlesung nicht bespochen werden. 

Zur Unterschiedung von der Mehrfachvererbung nennt man die Vererbung von nur einer 

Oberklasse einfache Vererbung oder Einfachvererbung 〈single inheritance〉. 

(e) Ein weiteres mächtiges Werkzeug, bei den meisten Sprachen in Verbindung mit der Vererbung 

eingesetzt, ist die Polymorphie oder der Polymorphismus 〈polymorphism〉. Hierfür 

ist ein eigenes Unterkapitel eingerichtet (Kap. 11.4). 

(f) In der Sprache C ++ wird die Vererbung meist Ableitung 〈derivation〉 genannt. Man nennt 

hier die Oberklasse – ohne Bedeutungsveränderung – Basisklasse 〈base class〉, die Unterklasse 

abgeleitete Klasse 〈derived class〉. 

(11.32) Im Rahmen der Vererbung wird – zusätzlich zu private (verborgen) und public (öffentlich) 

(9.11a) und (Kap. 6.4) – ein dritter Zugriffsspezifizierer eingeführt: protected (geschützt). Er 

nimmt eine gewisse Mittelstellung zwischen verborgen und öffentlich ein: 

• Auf ein private-Element dürfen nur die Elementfunktionen der eigenen Klassen und 

Freunde (11.12) direkt zugreifen. 

• Auf ein protected-Element dürfen zusätzlich die Elementfunktionen von abgeleiteten 

Klassen und deren Freunde zugreifen. 

• Auf ein public-Element kann von überall zugegriffen werden.


Anm Hiermit wird nur die Zugriffs-Erlaubnis beschrieben. Zusätzlich muss natürlich der Name 

auch im Gültigkeitsbereich liegen (ggf. Klassenspezifizierer angeben). 

(11.33) Syntax zur Beschreibung der Ableitung: 

DefinitionAbgeleiteteKlasse [NV] 

class KlassenName : 22 ZugriffsSpezifiziereropt BasisKlasse 

{ BeschreibungZusätzeUndÄnderungenGegenüberBasisklasse } ; 

Normalerweise sollte der ZugriffsSpezifizierer für die Basisklasse public sein. Allgemein kann 

er – wie ein Zugriffsspezifizierer innerhalb der Klassendefinition, d. h. für Klassenelemente 

– einer der drei Spezifizierer private, protected oder public sein. Wenn er fehlt, wird 

private angenommen. Dieser Zugriffsspezifizierer gibt an, wie innerhalb der abgeleiteten 

Klasse auf Elemente der Basisklasse zugegriffen werden darf: 

Element- Bei dem Basisklassen-Zugriffsspezifizierer 

Zugriffsspezifizierer public protected private 

in der erhalten die Elemente der Basisklasse 

Basisklasse bei Zugriff aus der abgeleiteten Klasse heraus 

folgende Element-Zugriffsspezifikation: 

public public protected private 

protected protected protected private 

private – kein Zugriff – – kein Zugriff – – kein Zugriff – 

Im Rahmen dieser Vorlesung wird als Basisklassenspezifizierer immer public genommen, 

wie bereits oben erwähnt. 

↑↑ Bei dem Schlüsselwort struct (11.11c) wird standardmäßig die public-Vererbung genommen. 

(11.34) Definition von Konstruktoren abgeleiteter Klassen 

Die Initialisiererliste (11.14) kann bei einer abgeleiteten Klasse zusätzlich einen Konstruktoraufruf 

für die Basisklasse aufnehmen. Dieses ist häufig sogar sinnvoll. 

Die Reihenfolge der Durchführung der Initialisierungen hängt nicht von der Reihenfolge in 

der Initialisiererliste ab, sondern obliegt folgenden Regeln: 

• Zuerst wird die Basisklasse initialisiert – falls kein Konstruktoraufruf in der Initialisiererliste 

vorhanden, mit dem Standardkonstruktor. 

↑↑ Bei Mehrfachvererbung: Initialisierung aller direkten Basisklassen, und zwar in der Reihenfolge 

der Angabe in der Basisklassenliste. Eine Abweichung von dieser Reihenfolgeregel gibt 

es bei sog. virtueller Vererbung; hier wird zunächst die virtuelle Basisklasse initialisiert. 

• Nun geschieht die Initialisierung der Elemente der abgeleiteten Klasse, und zwar der Elemente, 

die in der Initialisiererliste vorhanden sind, dazu, falls vorhanden, der Elemente, 

die selbst wiederum Objekte sind (Initialisierung mit jeweiligem Standardkonstruktor, 

falls für sie in der Initialisiererliste kein expliziter Konstruktoraufruf angegeben ist). Die 

Reihenfolge der Initialisierung richtet sich nur nach der Reihenfolge des Auftreten der 

Elemente in der Klassendefinition. 

• Danach wird der Funktionsrumpf des aktuellen Konstruktors ausgeführt. 

Bei Vererbung über mehrere Stufen werden diese Regeln rekursiv angewendet, so dass immer 

zuerst die Elemente der ersten (obersten) Klasse in einer Vererbungshierarchie initialisiert 

werden. 

Beim Zerstören eines Objekts wird in genau umgekehrter Reihenfolge vorgegangen: zuerst 

wird der Destruktor der eigenen Klasse aufgerufen, danach der Destruktor der Basisklasse 

usf. 

↑↑ Dass die Initialisierungsreihenfolge nur von der Reihenfolge der Elemente in der Klassendefinition 

abhängt, hängt mit der Regel zusammen, dass bei Zerstörung eines Objekts die zugehörigen 

Destruktoren immer in umgekehrter Reihenfolge wie die Konstruktoren aufgerufen 

werden. Eine Erlaubnis zur Reihenfolgeänderung hätte zur Folge, dass für jedes Objekt diese 

Reihenfolge zur Laufzeit dokumentiert werden müsste, damit die Destruktor-Reihenfolge 

konsistent dazu sein kann. 

(11.35) Die abgeleitete Klasse darf Elemente (Daten, Funktionen) durch Elemente gleichen Namens 

redefinieren. Das jeweils zugehörige Element der Basisklasse wird dadurch verdeckt. Sind in


der Basisklasse überladene Funktionen gleichen Namens vorhanden, so werden sie alle verdeckt 

△! . Diese verdeckten Elemente sind noch vorhanden; auf sie kann – Zugriffserlaubnis 

vorausgesetzt – mit der Spezifizierung durch den Basisklassen-Namen zugegriffen werden 

(BasisKlassenName::ElementName). 

class Basis { 

public: // public hier nur zur Verdeutlichung (vereinfachter Zugriff) 

int a; 

void fkt(int i); 

void fkt(double d); 

void aktion(); 

}; 

class Ableitung : public Basis { 

float a; // überdeckt Basis::a 

int fkt(char *str); // überdeckt Basis::fkt(int) und Basis::fkt(double) 

void aktion(); // überdeckt Basis::aktion() 

}; 

Innerhalb der Klasse Ableitung kann auf das a der Klasse Basis durch volle Spezifizierung 

Basis::a zugegriffen werden, auf die überdeckten Funktionen z. B. durch Basis::fkt(16), 

Basis::fkt(1.0) oder Basis::aktion(). 

Anm1 Die Verdeckung und der Zugriff auf die Basisklasse durch Spezifizierung liefe genauso ab, 

wenn das Datenelement der abgeleiteten Klasse den gleichen Typ hätte: int a; 

Anm2 Die Verdeckung geschieht auch dann, wenn kein Zugriff möglich wäre, beispielsweise bei 

private-Zugriffsspezifizierer in der Basisklasse (Bsp.: private: int a; in Klasse Basis.) 

Diese Regel soll sicherstellen, daß die Bedeutung von Namen in abgeleiteten Klassen unabhängig 

von der Zugriffsspezifikation in einer Basisklasse ist. 

Anm3 Die Verdeckung geschieht nur mit dem Namen. In einer abgeleiteten Klasse kann man daher 

keine Elementfunktion der Basisklasse überladen △! . Wie schon oben erwähnt, werden 

alle Elementfunktionen gleichen Namens verdeckt, vgl. auch (EffCpp/Kap. 50). Dieses ist auch 

sinnvoll, da sich sonst bei einer großen Klassenhierarchie leicht Fehler einschleichen könnten. 

Anm4 Diese Verdeckung geschieht sinngemäß auch bei Operatoren. Beispiele: Ein Präfix-Inkrementoperator 

aus einer Basisklasse wird durch die Definition des Postfix-Inkrementoperators in 

einer abgeleiteten Klasse verdeckt (oder umgekehrt); ein unärer Operator * aus einer Basisklasse 

wird durch Definition des binären Operators * in einer abgeleiteten Klasse verdeckt 

(oder umgekehrt). 

(11.36) Operator-Elementfunktionen (11.24) werden normal vererbt mit Ausnahme des Zuweisungsoperators. 

Wird das Standardverhalten dieses Operators (flache Kopie, s. (11.24b)) nicht 

gewünscht, muss er für jede Klasse überladen werden. 

11.4 Polymorphie 

(11.40) Übb Die Polymorphie vervollständigt das Konzept der Vererbung. Die Möglichkeit, Methoden 

in untergeordneten Klassen zu redefinieren, kommt dem menschlichen Denken sehr 

entgegen. Wir sind es gewohnt, Aktionen, die im Detail sehr unterschiedlich sein können, 

den gleichen Namen zu geben, wenn das Ergebnis ähnlich oder vergleichbar ist, wie z. B. die 

Aktion Schreiben oder Malen trotz unterschiedlicher Schreib- oder Malwerkzeuge mit sehr 

unterschiedlichen physikalisch-chemischen Einzelheiten. Die korrekte Aktion wird anhand 

des Objekttyps bestimmt (im Beispiel: des Werkzeugtyps). 

Dieses Konzept wird insbesondere im Zusammenhang mit der späten Bindung sehr mächtig 

und für die Praxis außerst wichtig. Es wird möglich, ” generischen“ Programmcode zu schreiben, 

dessen eigentliche Ausführung zur Kompilationszeit noch gar nicht feststeht. Hierdurch 

kann zur Laufzeit in Abhängigkeit vom (manchmal erst dann feststehenden) tatsächlichen 

Objekttyp die zugehörige Aktion ausgewählt werden. 

Punkt (11.41) beschreibt die Polymorphie näher, auch in Zusammenhang mit später Bindung. 

In (11.42) wird gezeigt, wie die späte Bindung in C ++ eingeführt wird. Abschließend beschreibt


Punkt (11.43), wie in C ++ abstrakte Klassen erzeugt werden (d. h. Klassen, die nur für die 

Klassenhierarchie von Bedeutung sind, da sie selbst keine Objekte haben können). 

(11.41) Die Polymorphie (dt. ” Vielgestaltigkeit“) oder der Polymorphismus ist in der Informatik 

ein sehr schillernder Begriff. Es wird je nach Autor Unterschiedliches darunter verstanden. 

Allgemein bedeutet die Polymorphie, dass verschiedenen Aktionen die gleichen Namen gegeben 

werden können; die Bindung des Namens an die tatsächlich auszuführende Aktion 

hängt vom Zusammenhang (Kontext) ab. 

(11.42) 

Ein sehr einfacher Fall der Polymorphie in C ++ wäre schon die Überladungsmöglichkeit 

von Funktionsnamen: je nach Kontext (Signatur des Aufrufs) wird die tatsächliche Aktion 

ausgewählt. 

Häufiger wird unter Polymorphie die Möglichkeit verstanden, dass Methoden verschiedener 

Klassen denselben Namen für ihre – unterschiedlichen – Aktionen vergeben dürfen (diese 

Aktionen sollten aber aus Übersichtlichkeitsgründen ähnliche Bedeutung haben). Innerhalb 

einer Ableitungshierarchie besteht die Möglichkeit, Funktionen der Basisklasse zu redefinieren, 

beispielsweise wenn eine bestimmte Aktion für Objekte der abgeleiteten Klassen 

(zumindest teilweise) anders durchzuführen ist. 

Insbesondere ist dieses Mittel in Zusammenhang mit der späten Bindung (oder dynamischen 

Bindung) 〈late binding, dynamic binding〉 sehr ausdrucksstark: hierbei findet die 

Bindung des Namens an die tatsächlich durchzuführende Aktion erst zur Laufzeit statt. Bei 

einer frühen Bindung (oder statischen Bindung) 〈early binding, static binding〉 wird 

die Bindung bereits durch den Compiler oder Linker festgelegt. 

Bei getypten Sprachen (z. B. C ++) ist aus Gründen der Fehlerminimierung Polymorphie mit 

später Bindung nur innerhalb einer Klassen-Ableitungshierarchie erlaubt; andere Sprachen 

erlauben sie beliebig (z. B. Smalltalk). 

Bsp Die Aktion schreibe(Buchstabe) ist je nach Schreibmittel sehr verschieden: beim Bleistift Abrieb von 

Graphit, beim Kugelschreiber Abrollen einer Kugel mit Farbe, beim Filzstift Wirkung von Kapillarkräften 

auf farbige Flüssigkeit usf. Die Aktion bleistift.schreibe(’B’) kann schon frühzeitig an das Graphitabreiben 

gebunden werden, der Befehl schreibstift.schreibe(’B’) kann jedoch erst dann an eine 

spezielle Aktion gebunden werden, wenn entschieden ist – ggf. erst zur Laufzeit –, welcher Art der Schreibstift 

ist. 

(a) Bei getypten Sprachen steht der Speicherplatzbedarf für das Erzeugen eines (einzelnen) Objekts 

schon zur Kompilationszeit fest; bei der Erzeugung ist immer der richtige Konstuktor 

bekannt. Werden dann die Aktionen (Elementfunktionen) mit dem zugehörigen Objektnamen 

aufgerufen, kann schon der Compiler entscheiden, welche Aktion stattfindet ( ” frühe 

Bindung“). 

(b) In C ++ ist es erlaubt, einem Zeiger einer Basisklasse die Adresse eines Objekts einer abgeleiteten 

Klasse zuzuweisen – entsprechend auch bei einer Referenz. 

Fortsetzung Beispiel aus (11.35): 

Basis *zeigBasis; 

Ableitung abl; 

zeigBasis=&abl; // erlaubt 

Basis &refBasis=abl; // ebenfalls erlaubt 

Hierbei ist unbedingt zu unterscheiden: 

• der statische Typ des Zeigers bzw. der Referenz 

(angegebenes Beispiel: zeigBasis/refBasis sind Zeiger/Referenz auf Basis) 

• und der dynamische Typ 

(angegebenes Beispiel: zeigBasis/refBasis sind Zeiger/Referenz auf Ableitung); 

dieser dynamische Typ steht letzlich erst zur Laufzeit fest. 

In diesem Fall ist es wichtig, wann die Bindung an eine Aktion geschieht: 

Welche Aktion wird beim Aufruf 

zeigBasis->aktion() bzw. refBasis.aktion() 

durchgeführt: Basis::aktion() oder Ableitung::aktion()?


Aus Effektivitätsgründen hat sich der Erfinder von C ++ entschlossen, zunächst dem statischen 

Typ den Vorrang zu geben. Dadurch kann schon der Compiler bzw. der Linker die 

Bindung vornehmen (frühe Bindung). Es wird demnach Basis::aktion() aufgerufen. 

Um eine Aktion in Abhängigkeit vom dynamischen Typ durchzuführen, d. h. um die späte 

Bindung einzuführen, muss der Programmierer in C ++ bei der Definition einer Klasse diese 

Möglichkeit ausdrücklich angeben: eine Aktion, deren Elementfunktion in der Basisklasse 

” virtuell“ (15 FunktionsSpezifizierer virtual) genannt wird, obliegt der späten Bindung. 

△! Die späte Bindung wird jedoch nur bei gleicher Signatur auch in den abgeleiteten 

Klassen vorgenommen! Eine andere Signatur führt zu einer Verdeckung (11.35) ohne 

späte Bindung. 

Bsp.: Hätte die Definition in der Basisklasse gelautet: 

virtual void aktion(); 

so würde bei den Aufrufen 

zeigBasis->aktion() bzw. refBasis.aktion() 

zur Laufzeit Ableitung::aktion() ausgeführt. 

↑↑1 Eine virtuelle Funktion muss in der Basisklasse auch definiert sein, selbst wenn sie nicht 

benutzt wird. Ausnahme: rein virtuelle Funktion (11.43). 

↑↑2 Auch Operatorfunktionen können virtuell sein. 

↑↑3 Die Elementfunktionen der Streams (darunter z. B. auch die Ein-/Ausgabeoperatoren >> 

und


} 

Die zugehörige Ausgabe an cerr ergibt beim obigen Programm: 

Konstr. Basis ** Destr. Basis ** 

Marke1 

Konstr. Basis ** Konstr. Ableit ** Destr. Ableit ** Destr. Basis ** 

Marke2 

Marke3 

Konstr. Basis ** Destr. Basis ** 

Marke4 

Konstr. Basis ** Konstr. Ableit ** Destr. Basis ** 

Dieses ist im Falle der Zerstörung des Objekts hinter Marke4 nicht richtig, da der Destruktor von 

Ableit nicht aufgerufen wird. Bei später Bindung (Destruktor in der Basisklasse virtuell) ergibt 

sich das korrekte Verhalten (hier nur Teil ab Marke4 angegeben): 

Marke4 

Konstr. Basis ** Konstr. Ableit ** Destr. Ableit ** Destr. Basis ** 

(11.43) Um dem C ++-Compiler anzugeben, dass eine Klasse abstrakt (11.31c) sein soll, ist in der 

Deklaration mindestens einer der Elementfunktionen hinter dem Deklarator der Spezifizierer 

” = 0“ hinzuzufügen. Dieses soll sozusagen andeuten, dass diese Funktion keine (eigentliche, 

echte) Implementierung hat (die Adresse 0 ist nie eine gültige Codeadresse). Die zugehörige 

Elementfunktion nennt man rein virtuelle Funktion 〈pure virtual function〉. 

DeklarationReinVirtuelleFunktion 12 DeklSpezifizierer1..n 30 Deklarator = 0 ; 

Deklarator [NV] 32 DirekterDeklarator ( ParameterDeklarations-LISTEopt ) 

Zu einer abstrakten Klasse kann es kein Objekt geben (11.31c); der Compiler verhindert das 

Erzeugen eines solchen Variablen. Auch die abgeleiteten Klassen sind abstrakt, solange (auf 

dem Ableitungsweg dorthin, ggf. über mehrere Ableitungsstufen) nicht alle rein virtuellen 

Funktionen redefiniert worden sind. 

Diese rein virtuellen Funktionen müssen auch virtuell sein, d. h. den FunktionsSpezifizierer 

virtual (11.42) haben. Dadurch können sie polymorph benutzt werden. Die Definition eines 

Zeigers oder einer Referenz auf eine abstrakte Klasse ist nämlich erlaubt; von dieser Möglichkeit 

wird in der Praxis häufig Gebrauch gemacht. Jedoch ist eine valide Belegung des Zeigers 

(außer mit dem Zeiger 0) bzw. eine Initialisierung der Referenz nur möglich mit einem Objekt 

einer abgeleiteten (und natürlich nur konkreten) Klasse. Damit eine solche Belegung 

sinnvoll ist, muss späte Bindung für die rein virtuelle Funktion(en) garantiert sein. 

↑↑ Zu einer rein virtuellen Funktion darf eine Implementierung, d. h. eine Definition, gehören, 

muss es aber nicht. Diese Definition wird aber für diese Klasse selbst nicht gebraucht. Auf 

sie kann aber in einer abgeleiteten Klasse – durch Angabe der vollständigen Spezifizierung 

BasisKlassenName::ElementFunktionsName – zugegriffen werden. 

11.5 Statische Klassenelemente 

(11.50) Übb Nach den bisherigen Erläuterungen in diesem Kurs sind Attribute (Datenelemente) 

einer Klasse in jedem Objekt individuell vorhanden, jedes Objekt hat seinen eigenen 

Datensatz. Diese zugehören Elemente werden ” objekteigen“ genannt, da sie in jedem Objekt 

vorhanden sind. Manchmal ist es sinnvoll, zusätzlich Attibute anlegen zu können, die 

pro Klasse genau einmal vorhanden sind, und zwar unabhängig von der Existenz von Objekten. 

Diese ” klasseneigenen“ Elemente werden in C ++ statische Elemente genannt. (11.51) 

beschreibt dieses allgemeine Konzept, (11.52) zeigt die Realisierung in C ++. Ein ausführliches 

Beispiel zeigt (11.53). Im letzten Punkt werden einige Besonderheiten diskutiert. 

(11.51) Sprachunabhängige Betrachtungen: 

(a) Manchmal ist es sinnvoll, die Existenz bestimmter Attribute nicht an die Objekte einer Klasse 

zu binden, sondern an die Klasse selbst, z. B. wenn der Wert dieses Attributes für alle 

Objekte der Klasse gleichermaßen gelten soll. Wir wollen diese Attribute sprachunabhängig


klasseneigene Attribute nennen – im Gegensatz zu den bisher besprochenen objekteigenen 

Attributen. 

Wenn man klasseneneigene Attribute zulässt, sollten sie nicht von dem Vorhandensein von 

Objekten dieser Klasse abhängen. Sie existieren demnach, bevor irgendein Objekt dieser 

Klasse erzeugt wird oder auch nachdem alle Objekte zerstört sind. 

Bsp Bei einer Klasse SparBuch gibt es objekteigene Attribute wie kontoStand, kontoNummer. Wenn sich 

jedoch der Zinssatz ändert, so wird er sich für alle Sparbücher ändern. Daher ist es sinnvoll, zinsSatz als 

klasseneigenes Attribut einzurichten. Sonst hätte man für jedes Objekt SparBuch eine zinsSatz-Änderung 

durchzuführen. 

Darüber hinaus ist es durchaus sinnvoll, einen Zinssatz für Sparbücher festzulegen, selbst wenn noch kein 

einzige Sparkonto eröffnet wurde. Auch dieser Grund spricht für ein klasseneigenes Attribut. 

(b) Erweitert man die Gedanken aus (a), sollten Elementfunktionen, die sich nur auf klasseneigene 

Attribute beziehen (Wert setzend, lesend, ändernd), unabhängig von der Existenz von 

Objekten der Klasse aufgerufen werden können. Folglich muss man dann auch bei Funktionen 

die Unterscheidung machen zwischen klasseneigenen und objekteigenen Elementfunktionen. 

(11.52) 

Bsp Zu dem Beispiel in (a): Es ist sinnvoll, Elementfunktionen wie gibZinsSatz() oder setzZinsSatz(...) 

unabhängig von der Existenz von Sparkonten aufzurufen. 

(a) Das erwähnte Konzept von klasseneigenen Attributen wird von C ++ unterstützt, und zwar 

durch sog. statische Datenelemente. In der Klassendefinition werden sie durch den Speicherklassen-Spezifizierer 

static charakterisiert, vgl. statische Variablen (8.12). 

Da der zugehörige Speicherplatz unabhängig von der Existenz von Objekten reserviert werden 

muss, muss ein statisches Klassenelement außerhalb der Klasse genau einmal definiert 

werden (dieses jedoch ohne den static-Spezifizierer, der sonst die Bedeutung ” interne Bindung“ 

geben würde (8.23a)). Dieses geschieht sinnvollerweise in der zur Klassendefinition 

gehörigen .CPP-Datei. Hierbei sollte es auch geeignet initialisiert werden, da sonst die Regeln 

über das implizite Initialisieren von statischen Variablen greifen (8.12). Ein ausführliches 

Beispiel s. (11.53). 

Jede Elementfunktion, auch ein Konstruktor oder Destruktor, dürfen auf statische Datenelemente 

zugreifen, unabhängig von deren Zugriffsspezifizierung (public, protected, 

private). 

(b) Natürlich unterstützt C ++ auch das Konzept der klasseneigenen Elementfunktionen, die 

statischen Elementfunktionen. Auch sie werden in der Klassendefinition durch den 

Speicherklassen-Spezifizierer static charakterisiert. Der Compiler wacht darüber, dass in 

der Definition dieser Funktion (dort ohne den Spezifizierer static) entweder keine Datenelemente 

der Klasse oder nur statische Datenelemente benutzt werden. 

Diese statischen Elementfunktionen können in der üblichen Syntax über ein beliebiges Objekt 

der Klasse aufgerufen werden. Dieses ist jedoch normalerweise nicht zu empfehlen, da 

ein solcher Aufruf für den menschlichen Leser implizieren kann, die Funktion habe mit dem 

aufgerufenen Objekt zu tun. Wesentlich klarer ist die Syntax, die für den Leser mehr die 

Klassenzugehörigkeit betont: 

KlassenName :: ElementFunktionsName(. . . ) 

Für die Studierenden dieses Kurses ist diese Schreibweise mit dem Klassennamen zwingend. 

Ein ausführliches Beispiel wird in (11.53) gegeben. 

↑↑ Die Syntax des Elementfunktions-Aufrufs mit dem Bereichsauflösungs-Operator Op1b wurde 

in anderem Zusammenhang bereits in (9.12a), insbesondere dort (↑↑2) erwähnt. 

(c) Da die statischen Elementfunktionen nicht mit einem Objekt verknüpft werden (selbst wenn 

sie mit einem Objekt aufgerufen werden), haben sie keinen this-Zeiger, was schon in (11.13e) 

erwähnt wurde. 

Eine solche Funktion darf auf alle statischen Elemente der Klasse zugreifen, unabhängig von 

der Zugriffsspezifizierung (public, protected, private). Ferner kann sie auf alle klasseninternen 

Typdefinitionen und enum-Konstanten zugreifen. 

(11.53) Beispiel für statische Klassenelemente in C ++ (Daten und Funktionen): 

(a)


// Beispieldatei D11-53A.H 

#ifndef D11_53A_H_ 

#define D11_53A_H_ 

class Test { 

static int statVar; 

static const int statKonst; 

int normalVar; 

public: 

Test(); 

void ausgabe(); 

void setzNormalVar(int wert); 

static void setzStatVar(int wert); 

static void ausgabeStat(); 

}; 

#endif 


#include 



// NOTWENDIGE Definitionen; wenn fehlend, dann Linker-Fehlermeldung; 

// Hier KEIN "static" wiederholen!! 

// Folgende Zeile auch OHNE Inititalisierer "=90" erlaubt 

// (dann Initialisierung mit 0 - sollte nicht so gemacht werden): 

int Test::statVar=90; 

// Folgende Zeile OHNE Inititalisierer "=-10" nicht erlaubt: 

const int Test::statKonst=-10; 

Test::Test() 

: normalVar(2) 

{ 

// beliebige Setzungen, auch z. B. statVar, NICHT jedoch statKonst! 

} 

// Hier KEIN "static" wiederholen!!! 

void Test::setzStatVar(int wert) 

{ 

// Bsp.: Übernahme nur, wenn positiv 

if (wert>0) statVar=wert; 

} 

void Test::setzNormalVar(int wert) 

{ 

normalVar=wert; 

} 

void Test::ausgabe() 

{ 

cout


(c) 

} 

// NICHT möglich: Ausgabe von Datenelement normalVar 

// Beispieldatei D11-53C.CPP 

#include 



int main() 

{ 

// VOR Erzeugung eines Objekts: 

Test::ausgabeStat(); 

Test::setzStatVar(99); 

Test::ausgabeStat(); 

cout


keine Gedanken zu machen. Zusätzlich ist garantiert, dass diese Konstante keinen (Daten-) 

Speicherplatz belegt. Diese sehr einfache Möglichkeit wird jedoch von manchen Autoren als 

” Enum-Hack“ betrachtet (12.21Anm) (Doch warum?). 

Bsp Hier werden eine Konstante maxAufzaehl und eine Konstante maxStatisch deklariert, in der Klasse 

initialisiert und als Arrayindexgrenzen benutzt – nicht mit MS VC++ 6.0 kompilierbar!. 

// Headerdatei 

class Test { 

public: 

enum { maxAufzaehl=20 }; 

static const int maxStatisch=20; 

private: 

char arr1[maxAufzaehl], 

arr2[maxStatisch]; 

}; 

// CPP-Datei 

const int Test::maxStatisch; // Definition oh. Initialisierung, 

// Def. darf nicht vergessen werden 

// (sonst Linker-Fehler!) 

// KEINE Extra-Definition für Test::maxAufzaehl!! 

// (Diese ist bereits in der enum-Definition enthalten!)


12 Operatoren, Typen, Ergänzungen zu Zeiger, Binärdateien 


In diesem Kapitel werden zunächst noch einmal die Operatoren vorgestellt (Unterkapitel 1). 

Das Folgekapitel führt den Aufzählungtyp ein und erläutert Einzelheiten der impliziten und 

expliziten Typumwandlungen. 

Unterkapitel 3 zeigt, dass es eine günstige Zeigerarithmetik gibt, die für effektive (Low- 

Level-)Programmierung unerlässlich ist. Da Arraybezeichnungen meist in Zeiger umgewandelt 

werden, gilt dieses auch für Arrays. Das Folgekapitel befasst sich damit, wie Zeiger als 

Funktionsparameter zu handhaben sind. Dieses ist für C sehr wichtig, aber auch in C ++, 

insbesondere in Zusammenhang mit Arraybezeichnungen (als Zeiger). 

Unterkapitel 5 zeigt einige Beispiele von Low-Level-Programmierung mit Zeigern und Arrays. 

Beim Umgang mit Binärdateien sind einige wichtige Besonderheiten zu beachten, die in 

Unterkapitel 6 ausführlich beschrieben sind. Binärdateien werden häufig dazu benutzt, um 

Objekte zu speichern und zu lesen. Ferner werden das Positionieren in Dateien und die 

Portierbarkeit von Binär- und Textdateien betrachtet. 

Kompliziertere Arraystrukturen sowie die zugehörigen Zeiger werden in Unterkapitel 7 vorgestellt. 

Dazu gehört auch die Behandlung von Kommandozeilenparametern. 

Das letzte Unterkapitel führt kurz in typlose Zeiger ein (in C häufig verwendet), dazu in die 

wichtigsten Bibliotheksfunktionen von C, die teilweise auch in C ++ benutzt werden. 

12.1 Operatoren 

(12.10) Übb In diesem Unterkapitel werden alle C ++-Operatoren angesprochen, teilweise auch zum 

erstenmal erläutert (12.11); die zugehörige Tabelle s. (5.11) oder (Cpp/Kap. 2). In (12.12) werden 

einige wichtige Eigenschaften von Ausdrücken zusammengefasst. 

(12.11) ↙ NEU Operatoren: 

s. (Cpp/Kap. 2) und die Tabelle in (5.11) 

– Die Nummern/Buchstaben geben die Hierarchiestufen/Unterscheidungskennung an – 

1 a :: C++ global: unär präfix (7.52) 

b :: C++ Bereichsauflösung: binär infix z. B. (9.12a) 

2 a [ ] Index: Übergang von Array zu Arraykomponente (5.41, 5.42) 

b ( ) Funktionsaufruf: Übergang von Funktionsname zum Funktionsaufruf-Ausdruck 

(7.12) 

c ( ) C++ △! explizite Typumwandlung 〈type cast〉 in Funktionsschreibweise; 

diese Art der Typumwandlung sollte nicht mehr benutzt 

werden, s. a. (5.64) 

Syntax: TypName( Ausdruck ) 

Bedeutung: Ausdruck wird explizit in den Typ TypName umgewandelt. 

Im Gegensatz zu Op3i muss hier ein Typname vorliegen. 

– Zur Problematik der Typumwandlungen s. (Kap. 12.2) – 

d . Zugriff auf Klassenelement, s. (9.13) 

e -> Zugriff auf Klassenelement über Zeiger, s. (10.29) 

fg ++ -- Inkrement, Dekrement postfix (Stellung präfix s. Op3ab): 

Seiteneffekt unabhängig von Stellung präfix oder postfix 

Haupteffekt bei postfix: alter Wert, s. (3.32e) 

h-k ... cast C++ neue Operatoren zur sichereren Typumwandlung, s. (5.64), zu 

reinterpret cast s. a. (12.63a, 12.64a).


3 ab ++ -- Inkrement, Dekrement präfix (Stellung postfix s. Op2fg): 

Seiteneffekt unabhängig von Stellung präfix oder postfix, 

Haupteffekt bei präfix: neuer Wert, s. (3.32e) 

c ∼ 

NEU Bitinversion des Ganzzahl-Operanden 

d ! logische Negation, s. (4.24) 

ef + - Identität und Vorzeichenumkehr 

gh & * Adresse und Inhalt/Verweis, s. (10.21b) 

i ( ) △! explizite Typumwandlung 〈type cast〉; diese Art der Typumwandlung 

sollte nicht mehr benutzt werden, s. a. (5.64) 

Syntax: ( Typ ) Ausdruck 

Bedeutung: wie Op2c; hier braucht Typ nicht unbedingt ein Name 

zu sein 

– Zur Problematik der Typumwandlungen s. (Kap. 12.2) – 

j sizeof Speicher-Größenangabe des Operanden in Anzahl Bytes (Typ des 

ErgebnisAusdrucks vorzeichenlos), s. (5.14). 

k 

l 

new 

delete 

C++ Freispeicherreservierung und -freigabe, s. (Kap. 10.3) 

5 ab * / Multiplikation und Division; 

wenn beide Operanden Ganzzahl-Ausdrücke, ist Ergebnis ein 

Ganzzahl-Typ, sonst ein Gleitkommatyp 

c % Teilerrest – nur Ganzzahl-Operanden 

6 ab + - Addition und Subtraktion 

7 a NEU dto. Bitverschiebung nach rechts: 

• bei vorzeichenlosem GanzzahlAusdruck1 werden 0-Bits nachgeschoben, 

– entspricht Division durch 2 Ausdruck2 

< >= 

• △! bei vorzeichenbehaftetem GanzzahlAusdruck1 werden 

bei positivem Wert 0-Bits nachgeschoben (Division w. o.), 

bei negativem Wert 0- oder 1-Bits je nach Implementation 

(bei Zweierkomplementdarstellung wird bei negativem Wert 

meist 1 nachgeschoben, dann ebenfalls Division w. o.) 

Vergleich (4.22) 

9 ab == != Test auf Gleichheit bzw. Ungleichheit (4.22), und zwar in geringerer 

Hierarchiestufe als die Vergleichsoperatoren Op8 

Anm △! VORSICHT bei der Hierarchie bei Ausdrücken mit den 

Bit-Operatoren Op10,11,12: die Ausdrücke müssen bei Test auf 

Gleichheit bzw. Ungleichheit geklammert werden (Hierarchie Op9 

ungünstig!).


10 & NEU Bitweiser Und-Operator 

Syntax (z. B.): GanzzahlAusdruck & Maske 

Anwendung: 

• Wert des gesamten Ausdrucks ist GanzzahlAusdruck mit einzelnen 

gelöschten Bits, und zwar den Bits, zu denen positionsgleich 

0-Bits in Maske vorhanden sind, 

• Abfrage, ob bestimmte Bits gesetzt sind, und zwar an der 

Position der 1-Bits in Maske: Test auf 

(GanzzahlAusdruck & Maske)!=0 

– △! Hierarchie, s. Anm bei Op9 – 

11 ∧ NEU bitweiser Exklusiv-Oder-Operator, 

Anwendung: Invertieren einzelner Bits, und zwar an der Position 

der 1-Bits in Maske, vgl. Op10 


12 | NEU bitweiser Inklusiv-Oder-Operator, 

Anwendung: Setzen einzelner Bits, und zwar an der Position der 

1-Bits in Maske, vgl. Op10 


13 && logischer Und-Operator, Kurzschlussverfahren ist garantiert, s. 

(4.24) 

14 || logischer (Inklusiv-)Oder-Operator, Kurzschlussverfahren ist garantiert, 

s. (4.24) 

15 ? : Bedingungsoperator, ternär, s. (5.12) 

Syntax: Ausdruck1 ? Ausdruck2 : Ausdruck3 

Bedeutung textuell: 

WENN Ausdruck1 DANN Ausdruck2 SONST Ausdruck3 

Durchführung: 

• zuerst Bewertung Ausdruck1 einschließlich Ausführung aller 

Seiteneffekte (garantiert), 

• dann Bewertung 

◦ entweder Ausdruck2, wenn Ausdruck1 im Booleschen 

Sinne wahr, s. (Kap. 4.2), 

◦ oder Ausdruck3, wenn Ausdruck1 falsch; 

• Wert des gesamten Ausdrucks (Haupteffekt): Wert von Ausdruck2 

oder Ausdruck3, je nachdem, welcher Ausdruck bewertet 

wurde. 

16 a = Zuweisung 

b-k op= zusammengesetzter Zuweisungsoperator (3.27) 

a op= b ist äquivalent zu a = a op ( b ) 

– mit dem Unterschied, dass a nur einmal bewertet wird 

17 , Kommaoperator, s. (5.13) 

Syntax: Ausdruck1 , Ausdruck2 

Bedeutung: 

• zunächst Bewertung von Ausdruck1 einschließlich Ausführung 

aller Seiteneffekte (garantiert), 

• Haupteffekt von Ausdruck1 wird verworfen (darf fehlen), 

• dann Bewertung von Ausdruck2 einschließlich Ausführung aller 

Seiteneffekte, 

• Wert des gesamten Ausdrucks: Haupteffekt von Ausdruck2 

Anwendung: mehrere Ausdrücke an Stellen, an denen syntaktisch 

nur einer stehen darf, z. B. bei Initialisierung und Reinitialisierung 

der for-Anweisung, s. (4.43)


(12.12) Zus zu Ausdrücken: 

(a) Der Haupteffekt von Ausdrücken ist unwichtig (wird verworfen) bei: 

• 51 AusdruckAnweisung, s. (3.32a) 

• erster Operand beim Kommaoperator Op17, s. (12.11) und (5.13) 

• Initialisierung und Reinitialisierung einer 72 for-Anweisung, s. (4.43) 

Bei unwichtigem Haupteffekt ist z. B. Funktionsaufruf ohne Rückgabewert (void) möglich. 

(b) In einem Ausdruck ist i. a. nicht festgelegt, in welcher Reihenfolge die Teilausdrücke bewertet 

werden und ggf. Seiteneffekte ausgeführt werden. Diese Regel der freien Bewertungsreihenfolge 

widerspricht nicht den Operatoreigenschaften Hierarchiestufe und Assoziativität (dieses: 

Reihenfolge beim Zusammenfassen von Teilausdrücken). 

Bsp liesZahl() lese eine Zahl von der Tastatur ein. Die Programmzeile 

cout > Variable, 

• Ausgabe auf dem Bildschirm, z. B. cout


Ein direktes Einlesen von Aufzählungswerten ist nicht möglich; ggf. muss ein Ganzzahlwert 

eingelesen und nach Bereichsprüfung explizit in den Aufzählungstyp umgewandelt werden. 

Sinn des Aufzählungstyps (z. B.): 

• C/C++ Definition selbstdokumentierender Namen für Konstanten einer zusammengehörigen 

Menge. 

• C++ Konstantendefinition innerhalb von Klassen mit Gültigkeitsbereich Klasse ohne 

Anlegung von Speicherplatz. 

Anm Es gibt Autoren, die die Meinung vertreten, dass Aufzählungskonstanten nur für eine zusammenhängende 

Konstantenmenge – d. h. für ” Aufzählungen“ – genommen werden sollten. 

Die Definition beliebiger (später in der Programmentwicklung änderbarer) Konstanten, insbesondere 

ohne einen Typnamen (dann ja keine Variablen dieses Typs bildbar), bezeichnen 

sie als ” enum-Hack“. Man kann darüber sicher verschieden philosophieren. In der Benutzung 

jedoch sind Aufzählungstypen einfacher – und zwar insbesondere innerhalb Klassen, hier 

sind andere (statische) Konstanten wesentlich umständlicher zu handhaben, vgl. (11.54c)! Sie 

belegen auch garantiert keinen Extra-Speicherplatz. Selbst in (Str3/Kap. 4.8) werden sie ohne 

Wertung auch ohne Typnamen vorgestellt, in (Str3/Kap. 5.4) wird auf sie verwiesen. 

Bsp Definition eines Aufzählungstyps und einer Variablen: 

enum WTag {mon,die,mit,don,fre,sam,son}; 

WTag wochenTag; // wochenTag Variable des Typs WTag 

Dieses ist gleichbedeutend mit: 

enum WTag {mon,die,mit,don,fre,sam,son} wochenTag; 

Auch ohne Typname, wenn er nicht benötigt wird: 

enum {mon,die,mit,don,fre,sam,son} wochenTag; 

Oder ohne Variablendefinition, wenn nur Konstantenwerte wichtig sind mit impliziter Umwandlung in 

Ganzzahltyp (was einige Autoren ” enum-Hack“ nennen, s. o. Anm): 

enum {mon,die,mit,don,fre,sam,son}; 

// Werte der Konstanten: mon 0, die 1,..., son 6 

Besser für bürgerliche Zählung in Deutschland (mon 1,. . . ,son 7): 

enum WTag {mon=1,die,mit,don,fre,sam,son}; 

Auch möglich, wenn auch wohl unsinnig: 

enum WTag {mon,die=0,mit,don=6,fre,sam=5,son}; 

// Werte: mon 0, die 0, mit 1, don 6, fre 7, sam 5, son 6 

↑↑ zu C : 

↑↑1 Der optionale Name ist ein sog. Etikett 〈tag〉; nur die Kombination 

enum Name 

benennt einen Typ. Diese Syntax ist auch in C ++ möglich, aber nicht notwendig. 

Ausnahme davon (d. h. auch in C ++ diese Syntax nötig) s. (Cpp/Kap. 5.1 Anm.) 

↑↑2 Man definiert daher in C häufig einen Typnamen: 

typedef enum Nameopt { . . . } TypName ; 

In C ++ ist dieses nicht nötig, da der optionale Name bereits ein Typname ist. 

↑↑3 In C ist eine Aufzählungskonstante vom Typ int. 

↑↑4 Die Typumwandlung GanzahlTyp → AufzählungsTyp geschieht in C, wenn nötig, auch implizit 

– im Gegensatz zu C ++. 

(12.22) In C galt vor der ANSI-Normierung innerhalb von Ausdrücken: 

• Umwandlung aller schmaleren Ganzzahltypen in Typ int 

• Gleitkommaarithmetik mindestens mit Genauigkeit double 

• Umwandlung vorzeichenloser Ganzzahlen in vorzeichenbehaftete Ganzzahlen: 

möglichst lange Beibehaltung des unsigned-Charakters; 

jetzt (C/C ++): möglichst Beibehaltung des Werts 

(12.23) Die in (Cpp/Kap. 7.1-4) beschriebenen Umwandlungen werden in folgenden Fällen implizit angewendet 

(jeweils nur, wenn nötig). Diese impliziten Umwandlungen laufen so ab, als ob eine 

passende explizite Typumwandlung (5.64) gefordert wäre; auch diese läuft nach den gleichen 

Regeln (Cpp/Kap. 7.1-4) ab. 

• Operand eines binären Operators, wenn nicht passend: 

Regeln der ” arithmetischen Umwandlungen“ (Cpp/Kap. 7.1) 

• Umwandlung rechter Operand in Typ des linken Operanden beim Zuweisungsausdruck 

• Umwandlung aktueller Funktionsparameter in Typ des formalen Parameters 

• Umwandlung Rückgabewert einer Funktion (Ausdruck in return-Anweisung (7.11b)) in 

Rückgabetyp der Funktion


• ↑↑ Typumwandlung bei Parametern einer Funktion: 

◦ C/C++ aktuelle Parameter bei beliebig vielen zusätzlichen Parametern entsprechend 

” ...“, da kein Typ für formale Parameter vorhanden 

◦ C Funktionsdeklaration ” alten Stils“ (explizit oder implizit) 

◦ C formaler Funktionsparameter bei Funktionsdefinition ” alten Stils“ 

In diesen Fällen Umwandlung der aktuellen Funktionsparameter in folgender Weise: 

◦ float wird in double umgewandelt 

◦ jeder Ganzzahltyp unterliegt der ” ganzzahligen Typangleichung“ (Cpp/Kap. 7.2) 

△! Merken: Gefährlich ist die Umwandlung von vorzeichenlosen und vorzeichenbehafteten 

Ganzzahltypen ineinander. Beachten: sizeof (5.14) und strlen() (5.53c) haben vorzeichenlose 

Typen! 

12.3 Zeigerarithmetik 

(12.30) Übb Um mit Zeigern effektiv arbeiten zu können, ist das Verständnig für die Arithmetik 

mit Zeigern wichtig. Hiermit lässt sich sehr effektiver (Low-Level-)Programmcode schreiben. 

Da Array-Bezeichungen (fast) immer in Zeiger umgewandelt werden, hat dieses auch 

Auswirkungen auf dem Umgang mit Arrays. Insbesondere die Konsequenzen auf Arrays als 

Funktionsparameter (Unterkapitel 4) sind für den Programmierer wichtig. 

(12.31) Adressarithmetik bei Zeigern: 

(12.32) 

Z sei Zeigerausdruck, 

T sei zugehöriger Typ (d. h. Z Zeiger auf T), 

I sei eine beliebiger Ganzzahlausdruck. 

Z+I ist die um I Objektbreiten des Typs T vergrößerte Adresse; dieser Zeiger zeigt auf 

ein T, welches um (I*sizeof(T)) zu Z verschoben ist. 

Z-I wie oben, nur subtrahiert 

Z1-Z2 Anzahl Objekte (als Ganzzahl) des Typs T zwischen den Adressen Z1 und Z2; 

notwendig: Z1, Z2 müssen Zeiger vom selben Typ sein. 

Voraussetzung für die Richtigkeit der Adressarithmetik: Alle Adressen müssen auf Elemente 

desselben Arrays zeigen, und zwar bestehend aus Elementen des Typs T. Sonst ist das 

Verhalten undefiniert. 

Anm1 Die Array-Komponenten sind adress-aufwärtssteigend gespeichert. 

Anm2 Erlaubt ist die Zeigerbildung zur fiktiven Folgekomponente des Arrays (dadurch manchmal 

Schleifenbedingungen leichter formulierbar); dieser Zeiger darf jedoch nicht dereferenziert 

werden. 

(a) Ein Ausdruck der Form A[I] 

wird immer automatisch umgewandelt in den Ausdruck *(A+I). 

Hierbei ist A ein Array oder ein Zeiger, I ein Ganzzahlausdruck. 

Daher gelten folgende Äquivalenzen 

(links: in Praxis sehr häufig benutzte Schreibweise, rechts: zunächst wohl einsichtigere Schreibweise): 

arr sei ein Array (Array-Name/-Bezeichnung). 

Der Ausdruck: ist äquivalent zu: 

arr &arr[0] 

arr+1 &arr[1] 

arr+n &arr[n] 

*arr arr[0] 

*(arr+1) arr[1] 

*(arr+n) arr[n] 

(b) Ein Arrayname ist synonym zu einem konstanten Zeiger auf Element Nummer 0, vgl. 

(10.26). Für diesem Arraynamen ist daher keine Wertzuweisung erlaubt,


z. B. falsch: arr++, arr=.... 

Dagegen zu Funktionsparametern s. (12.44c). 

12.4 Zeiger als Funktionsparameter 

(12.40) Übb In diesem Unterkapitel wird gezeigt, wie man Zeiger als Funktionsparameter einsetzen 

kann. Dieses ist in C die einzige Möglichkeit, so etwas wie eine Referenzübergabe 

programmtechnisch zu imitieren. Für C ++-Programmierer ist dieser Aspekt nicht mehr ganz 

so wichtig, da es den Referenztyp gibt. Jedoch auch in C ++ sollte man Folgerungen kennen, 

zumal ja Arraybezeichnungen als Parameter nichts anderes als Zeiger sind. 

(12.41) Parameterübergabearten bei Funktionen, vgl. (Kap. 7.4): 

• CALL BY VALUE C/C++ : Der Wert des aktuellen Parameters wird auf den formalen 

Parameter kopiert. 

• CALL BY REFERENCE C++ : Der formale Parameter ist während des Funktionsdurchlaufs 

ein Synonym des aktuellen Parameters. 

(12.42) Zeiger als Funktionsparameter: 

C/C++ Auch mit Hilfe des CALL BY VALUE ist die Nachahmung eines CALL BY REFE- 

RENCE möglich, nämlich durch explizite Übergabe von Zeigern. 

Der aktuelle Parameter (Adresse einer Variablen) wird kopiert auf den formalen Parameter 

(CALL BY VALUE); diese kopierte Adresse zeigt jedoch auf denselben Speicherplatz wie die 

Originaladresse, d. h. die Funktion kann über diesen Zeiger Variable des rufenden Programms 

verändern. 

Bsp vgl. (7.45), Vertauschen hier mit Zeigern (tausch1) verwirklicht, zusätzlich zu Referenzen (tausch2) wie 

dort: 

void tausch1(int *wert1, int *wert2) 

{ int merk; 

merk=*wert1; 

*wert1=*wert2; 

*wert2=merk; 

} 

void tausch2(int &wert1, int &wert2) 

{ 

int merk; 

merk=wert1; 

wert1=wert2; 

wert2=merk; 

} 

// Aufrufe (innerhalb einer anderen Funktion): 

int i=14,j=2; 

cout


tausch(i, j); // Aufruf tausch(int&, int&) 

(12.43) Die Syntax eines Funktionsaufrufs lässt leider nicht erkennen, ob eine Wert- oder Referenzübergabe 

geschieht; das ist nur bei der Funktionsdeklaration oder -definition ersichtlich 

– vgl. auch die Ausführungen in (7.44). 

Daher ist die Übersichtlichkeit und Nachvollziehbarkeit am Ort des Funktionsaufrufs nicht 

gegeben, wenn man nicht weiß, ob die aktuellen Parameter durch den Funktionsaufruf 

geändert werden können – es sei denn, der aktuelle Parameter ist nicht oder nicht nur eine 

Variable (dann keine änderbare Referenz möglich). Es gibt daher Autoren, die folgendes 

empfehlen (mit Anmerkung von Bartning zu Punkt (2)): 

(1) Wenn keine Wertänderung durch den Funktionsaufruf geschieht: normale Wertübergabe, 

keine Zeiger. Da der Parameter eine lokale Kopie des aktuellen Parameters ist, kann 

auch keine Wertänderung am Aufrufort geschehen. 

Anm Diese Wertübergabe ist bei eingebauten Typen die normale Übergabeart; bei Objekten 

dagegen nimmt man normalerweise konstante Referenz, s. (3). 

(2) Wenn Wertänderung am Aufrufort benötigt wird: Übergabe von Zeigern (diese per 

Wert). Durch die Syntax (Zeiger) ist deutlich, dass die zugehörige deferenzierte Variable 

geändert werden kann. 

DAGEGEN (Anm. von Bartning): Diese Empfehlung ist für Programmierer mit C- 

Erfahrung sicher sehr gewichtig; für Programmierer nur mit C ++-Kenntnissen ist sie 

nicht ganz so wichtig, da sie sich wohl an die Möglichkeit nichtkonstanter Referenzübergabe 

gewöhnt haben und daher aufpassen. Daher für Studierende dieses Kurses: auch 

bei Wertänderung ist eine Referenzübergabe sinnvoll. 

↑↑ Pascalprogrammierer sind ebenfalls an dieselbe Problematik gewöhnt, dass am Aufrufort 

keine Unterscheidung zwischen Wert- und Referenzübergabe möglich ist. 

(3) C++ Wenn bei Variablen mit großer Speicherbelegung aus Effizienzgründen (Speicherplatz, 

Rechenzeit) keine Wertübergabe geschehen soll, aber trotzdem die Nichtänderung 

garantiert sein soll, ist eine konstante Referenz sinnvoll. Der Compiler garantiert die 

Nichtänderung, Näheres s. (7.44b). Bei Objekten (Variablen eines Klassentyps) ist dieses 

die normale Übergabeart, wenn Konstantheit möglich ist (eine Wertübergabe würde 

Aufrufe von Kopierkonstruktor und Destruktor bedeuten). 

Anm Dieses ist auch – nicht nur in C – bei Zeigerübergabe möglich durch ein const für die 

dereferenzierte Variable, vgl. (10.28): 

14/25 const Typ *Zeiger 

Dagegen konstanter Zeiger, d. h. Nichtänderbarkeit des Zeigers selbst: 

Typ * 31/25 const Zeiger 

Beides konstant: 

14/25 const Typ * 31/25 const Zeiger 

(12.44) Folgerungen aus (10.26) für formale Funktionsparameter, vgl. Bemerkungen (7.46): 

(a) Ist ein formaler Funktionsparameter vom Typ ” Array aus T“, wird auch er nach (10.26) durch 

den Compiler automatisch in ” Zeiger auf T“ umgewandelt. Eine Dimensionierung des Arrays 

wird demnach völlig ignoriert; daher ist hierbei eine Arraykennzeichnung ohne Dimension 

erlaubt, d. h. nur mit leerem Klammernpaar [ ]. Üblich ist jedoch statt dessen die direkte 

(explizite) Zeigerschreibweise. 

Drei äquivalente Deklarationen eines formalen Parameters (üblich: letzte Form): 

Typ Name[Anzahl] 

Typ Name[ ] 

Typ *Name 

Wegen (12.32a) ist innerhalb der Funktion – unabhängig vom Deklarator als Array oder Zeiger 

– die Array- und die Zeigerschreibweise erlaubt. 

(b) Ein Array-Parameter scheint daher die Übergabeart CALL BY REFERENCE zu haben; in 

Wirklichkeit liegt jedoch ein CALL BY VALUE eines Zeigers vor. Aus diesem Grund können 

Funktionen mit Array-Parametern die Originalarrays direkt verändern (Beispiele: strcpy, 

strcat).


Ein echtes CALL BY VALUE eines Arrays (mit Erzeugung einer lokalen Kopie) gibt es in 

C ++/C nicht; eine indirekte Möglichkeit besteht durch die Einbindung des Arrays in eine 

Klasse/Struktur. 

(c) Ein formaler Parameter mit Arraytyp (eigentlich: Zeigertyp) ist – wegen des CALL BY 

VALUE des Zeigers – im Gegensatz zu (12.32b) kein konstanter Zeiger, er kann in der Funktion 

verändert werden, z. B. zum Hochzählen innerhalb des Arrays. 

(d) Da ein formaler Array-Parameter in Wirklichkeit ein Zeiger ist, wird durch den Ausdruck 

sizeof(ParameterArrayName) 

bei allen drei Deklarationsformen aus (a) immer nur 

sizeof(Typ*) 

berechnet (Speichergröße des Zeigers) – und nicht der Speicherbedarf des Arrays. Innerhalb 

von Funktionen muss daher bei formalem Array-Parameter 

statt sizeof(ArrayName) immer sizeof(ArrayTyp) 

(Typ in Arrayschreibweise mit Dimensionierung!) genommen werden. 

Dieses ist auch der tiefere Grund, weswegen es in C ++/C bei Arrays innerhalb von Funktionen 

völlig unmöglich ist, die Entdeckung einer Bereichsüberschreitung zu programmieren. Nur 

mit einem zusätzlichen Größenparameter kann dieses geschehen. 

12.5 Anwendungen 

(12.50) Übb Die Anwendungen (kurze Programmfragmente) sollen die Möglichkeiten aufzeigen, 

die die Sprachen C ++/C bieten, wenn man im Low-Level-Bereich mit Arrays und Zeigern 

programmiert: von manchen Programmierern gehasst, von anderen wiederum wegen der eleganten 

Möglichkeiten geliebt (als Gipfel: Stringkopieren (12.52 Version (d)). Es wird an Beispielen 

gezeigt, wie man mit Arrays, insbesondere mit Strings, umgehen kann. (12.53) zeigt außerdem, 

wie das System Stringkonstanten handhabt. Vorsicht bei der Rückgabe von (scheinbaren) 

Arrays aus Funktionen (12.54)! 

(12.51) Bsp Berechnung der Stringlänge 

Mögliche äquivalente Funktionsköpfe (in der Praxis meist zweite Version): 

int strlen_neu(char s[]); // Parameter in Array-Schreibweise 

int strlen_neu(char *s); // Parameter als Zeiger 

Mögliche Implementationen für die Funktionsblöcke, zunächst mit Benutzung der Array- 

Schreibweise: 

// Version (a) 

{ 

int i=0; 

while (s[i]!=’\0’) ++i; 

return i; 

} 

// Version (b) 

{ 

int i=0; 

while (s[i]) ++i; 

return i; 

} 

// Version (c) 

{ 

int i=0; 

while (s[i++]); 

return i-1; 

} 

Implementationen unter Benutzung der Zeigerschreibweise:


// Version (d) 

{ 

int i=0; 

while (*s!=’\0’) { 

++s; ++i; 

} 

return i; 

} 

// Version (e) 

{ 

int i=0; 

while (*s++) ++i; 

return i; 

} 

// Version (f) 

{ 

char *merk=s; 

while (*s++); 

return s-merk-1; 

} 

Anm Wie schon in (12.44a) erwähnt, sind alle Versionen (a) bis (f) untereinander austauschbar – 

völlig unabhängig von der Art der Parameterdeklaration (Array oder Zeiger). 

(12.52) Bsp String-Kopierfunktionen 

(a) Mögliche Funktionsköpfe: 

void strcpy_neu(char ziel[],char quell[]); // Array-Schreibweise 

void strcpy_neu(char *ziel,char *quell); // Zeiger (meistens so) 

Mögliche Implementationen für die Funktionsblöcke, zunächst mit Benutzung der Array- 

Schreibweise: 

// Version (a) 

{ 

int i=0; 

while (quell[i]!=’\0’) { 

ziel[i]=quell[i]; 

++i; 

} 

ziel[i]=’\0’; 

} 

Implementationen unter Benutzung der Zeigerschreibweise: 

// Version (b) 

{ 

while (*quell!=’\0’) { 

*ziel=*quell; 

++ziel; 

++quell; 

} 

*ziel=’\0’; 

} 

// Version (c) 

{ 

while (*quell) 

*ziel++=*quell++; 

*ziel=’\0’;


} 

// Version (d) - C-typisch!! 

{ 

while (*ziel++=*quell++); 

} 

(b) Üblich ist es, solchen Funktionen einen Rückgabewert zu geben (d. h. nicht void), und zwar 

den (ursprünglichen) Wert des Zeigers ziel; dadurch ist eine Schachtelung von solchen 

Funktionsaufrufen möglich. 

char *strcpy_NEU(char *ziel,char *quell); 

// Funktionsblock zu Version (a) 

{ 

int i=0; 

while (quell[i]!=’\0’) { 

ziel[i]=quell[i]; 

++i; 

} 

ziel[i]=’\0’; 

return ziel; // wie: return &ziel[0]; 

} 

// Funktionsblock zu Version (d) 

{ 

char *merk=ziel; 

while (*ziel++=*quell++); 

return merk; 

} 

Auch die String-Bibliotheksfunktionen haben als Rückgabewert den Zeiger ziel, außerdem 

kann mit dem Quellzeiger das Quellarray nicht verändert werden, vgl. (10.28): 

char *strcpy(char *ziel, const char *quell); 

char *strcat(char *ziel, const char *quell); 

Bsp für die Ausnutzung der Rückgabewerte: 

char str1[]="String", str2[]="fortsetzung", 

puffer[30]; 

cout


str1[0]=’P’; // (eigentlich) nicht erlaubt 

str2[0]=’P’; // erlaubt: Ptring2 

*str3=’P’; // erlaubt: PTRing3 

str1=str2; // erlaubt; jetzt STRING1 jedoch nicht mehr zugänglich! 

str2=str3; // nicht erlaubt (12.32b) 

(12.54) Ein ” beliebter“ Fehler im Zusammenhang mit der Rückgabe von Strings aus Funktionen ist 

die Rückgabe der Adresse von automatischem Speicher. 

// SEHR schwerwiegender Fehler: 

char *wotag(int ord) 

{ 

char str[20]; 

switch(ord) { 

case 1: strcpy(str,"Montag"); break; 

// ... 

case 7: strcpy(str,"Sonntag"); break; 

} 

return str; // FALSCH! 

} 

Es bieten sich mehrere Lösungsmöglichkeiten für die Implementation des Funktionsblocks 

an: 

// Version (a) - jedoch NACHTEIL?? 

{ 

static char str[20]; 

switch(ord) { 

// ... (wie oben) ... 

} 

return str; 

// NICHT abgefangen: ord außerhalb des erlaubten Bereichs 

} 

// Version (b), besser: 

{ 

char *str; 

switch(ord) { 

case 1: str="Montag"; break; 

// ... 

case 7: str="Sonntag"; break; 

default: str="TagUnbekannt"; 

} 

return str; 

} 

// Version (c), ebenfalls besser: 

{ 

switch(ord) { 

case 1: return "Montag"; 

// ... 

case 7: return "Sonntag"; 

} 

// Statt "default" ggf. besser hier (zur Befriedigung des Compilers): 

return "TagUnbekannt"; 

}


12.6 Umgang mit Binärdateien 

(12.60) Übb Als Erweiterung zu (Kap. 5.3), wo der Umgang mit Textdateien dargestellt wurde, werden 

diese Kenntnisse auf Binärdateien erweitert. Hier sind einige wichtige Besonderheiten 

zu beachten, insbesondere muss man die beiden Elementfunktionen write und read anwenden 

können (12.63, 12.64). Zum Überladen des Ausgabe- und Eingabeoperators wird die 

Ableitungshierachie dargestellt (12.62). Punkt (12.65) erläutert das Positionieren in Dateien 

(auch in Textdateien). Ein ausführliches Beispiel (12.66) rundet das Unterkapitel ab. Wenn 

man Dateien auf andere Plattformen portieren möchte, ist zudem es wichtig, diesbezügliche 

Unterschiede zwischen Text- und Binärdateien zu kennen (12.67). 

(12.61) Binärdateien 

Beim Umgang mit Dateien muss man zwei Arten Dateien unterscheiden: Textdateien und 

Binärdateien. Der Unterschied ist bereits in (5.31) erläutert worden. 

Der Umgang mit Textdateien ist in (Kap. 5.3) beschrieben. Hier in diesem Unterkapitel werden 

i. w. nur die Besonderheiten für Binärdateien betrachtet. 

Wie bei Textdateien geschieht der Umgang in drei Schritten: 

• Öffnen der Datei, 

• Schreiben und/oder Lesen, 

• Schließen der Datei. 

(a) Das Öffnen (d. h. Eröffnen des Zugangs zur Datei implizit über das Betriebssystem) geschieht 

genau so wie bei Textdateien (5.33), jedoch muss hierbei unbedingt der Modus Binärzugang 

(ios::binary) angegeben werden. Da durch die Angabe des Modus die Standardvorgaben 

gelöscht werden, sollte die Art des Dateizugriffs (ios::out schreibend, ios::in 

lesend) zusätzlich angegeben werden. Die Verknüpfung geschieht über den Operator ” |“ 

Op12. 

Öffnen zum Schreiben (die Streamobjektnamen sind nach C ++-Konvention für Variablennamen 

wählbar): 

ofstream SchreibStreamName; 

SchreibStreamName.open(DateiName,ios::binary|ios::out); 

oder (beides in einer Anweisung): 

ofstream SchreibStreamName(DateiName,ios::binary|ios::out); 

Öffnen zum Lesen: 

ifstream LeseStreamName; 

LeseStreamName.open(DateiName,ios::binary|ios::in); 

oder (beides in einer Anweisung): 

ifstream LeseStreamName(DateiName,ios::binary|ios::in); 

Weitere Modi und sonstige Informationen, z. B. Lesen und Schreiben gemischt, siehe in 

(5.33b). 

(b) Zum Schreiben oder Lesen können nicht die üblichen Elementfunktionen genommen werden. 

Der Ausgabeoperator > können nur dann benutzt werden, 

wenn sie passend überladen sind (11.23c). Dazu ist die Kenntnis der Ableitungshierarchie der 

Streams sinnvoll; sie ist im Folgepunkt (12.62) kurz beschrieben. 

Am sinnvollsten ist die Benutzung der Elementfunktionen write und read. Näheres ist in 

den beiden Punkten (12.63) und (12.64) beschrieben. 

(c) Das Schließen (Beenden des Zugriffs mit impliziter Signalisierung an das Betriebssystem, 

dass Abschlussarbeiten möglich sind) geschieht wie bei Textdateien mit der Elementfunktion 

close (5.34). Implizit wird ein Stream auch durch seinen Destruktoraufruf geschlossen. Sie 

sollten sich jedoch angewöhnen, einen Stream explizit zu schließen, sobald der Dateizugriff 

nicht mehr benötigt wird. 

(12.62) Im folgenden ist die Vererbungshierarchie der Streams abgebildet. Gemäß UML (2.14b ↑↑) 

zeigt das hohle Dreieck jeweils auf die Oberklasse(n). Die Hierarchie ist in Wirklichkeit – 

insbesondere in C++(neu) – wesentlich komplizierter. Daher ist hier nur ein kleiner Auszug 

beschrieben, der für das Selbstschreiben von Funktionen (z. B. Ausgabeoperator- und 

Eingabeoperator-Funktionen) hilfreich ist.


❅ 

ios {abstrakt} 

❅ ❅ 

ostream istream 

❅ ❅ 

iostream 

❅ 

❅ 

ofstream fstream ifstream 

Die Klassen, zu denen die Standard-Streamobjekte cout, cerr, cin gehören (ferner auch 

clog, dieses nur in C++(neu)) sind je nach C++(neu) und C++(alt) verschieden: 

• C++(neu) 

cout, cerr, clog sind vom Typ ostream, 

cin ist vom Typ istream. 

• C++(alt) 

cout, cerr sind vom Typ ostream withassign 

(ostream withassign ist von ostream abgeleitet, ähnlich wie ofstream), 

cin ist vom Typ istream withassign 

(istream withassign ist von istream abgeleitet, ähnlich wie ifstream). 

(12.63) Funktionen zum Schreiben 

(a) Sinnvoll ist die Benutzung der Elementfunktionen write. Diese ist folgendermaßen durch 

die Bibliothek vorgegeben: 

ostream& ostream::write(const char* ZeigerAufPuffer, int AnzBytes); 

Wirkungsweise: 

• Die Funktion liest genau AnzBytes Bytes ( ” Zeichen“) aus dem angegebenen Puffer ab 

der Adresse ZeigerAufPuffer und schreibt sie in die Ausgabedatei (Typ ostream oder 

abgeleiteter Typ, z. B. ofstream). Hierbei wird jedes Byte gelesen und geschrieben. 

Ein eventuell vorhandenes Nullbyte erhält keine Sonderbehandlung, es gilt als normales 

Byte. 

Für AnzBytes sollten nie eine direkte Zahl angegeben werden, sondern die Größe sollte 

immer durch den Compiler mit dem sizeof-Operator Op3j (5.14) berechnet werden. 

• Es ist nötig, die Anfangsadresse dessen, was geschrieben werden soll (z. B. Anfangsadresse 

eines Objekts, d. h. Zeiger auf Klassentyp), nach const char* zu konvertieren: 

Parameter ZeigerAufPuffer. Das ist nicht mit einem static cast (5.64a) möglich, sondern 

nur mit dem Operator reinterpret cast, s. Op2k/(10.24Anm4). Ersatzweise kann 

auch die ” missbilligte“ Typkonvertierung (char*) bzw. (const char *) genommen 

werden, s. Op3i/(5.64b). 

• Der Rückgabewert ist der Stream im Zustand nach dem Schreiben. Im Fehlerfall wird 

meist badbit gesetzt. 

Bsp s. (12.66). 

↑↑ Angegeben ist für AnzBytes der Typ aus C++(alt) (int); in C++(neu) ist der Typ streamsize. 

(b) Manchmal kann die Funktion 

ostream& ostream::flush() 

nützlich sein; sie leert den Ausgabepuffer, so dass der Inhalt tatsächlich geschrieben wird.


Sonst wird er Ausgabepuffer automatisch geleert, wenn er voll ist oder wenn der Stream 

geschlossen wird. Problematisch kann ein noch teilweise gefüllter Puffer sein, wenn das Programm 

wegen eines Fehlers außerplanmäßig abbricht. 

(12.64) Funktionen zum Lesen 

(a) Die Deklaration der read-Funktion, dem Äquivalent zur write-Funktion: 

istream& istream::read(char* ZeigerAufPuffer, int AnzBytes); 

Wirkungsweise: 

• Die Funktion liest genau AnzBytes Bytes ( Zeichen“) aus der Eingabedatei (Typ 

” 

istream oder abgeleiteter Typ, z. B. ifstream) und schreibt sie in den angegebenen 

Puffer ab der Adresse ZeigerAufPuffer. Hierbei wird jedes Byte gelesen und geschrieben. 

Ein eventuell vorhandenes Nullbyte erhält keine Sonderbehandlung, es gilt als normales 

Byte. 

• Wie schon ähnlich bei der write-Funktion beschrieben, ist es nötig, die Anfangsadresse 

dessen, wohin gelesen werden soll (z. B. Anfangsadresse eines Objekts, d. h. Zeiger auf 

Klassentyp) nach char* zu konvertieren: Parameter ZeigerAufPuffer. Das ist nur mit 

dem Operator reinterpret cast, s. Op2k (10.24Anm4) möglich. Ersatzweise kann auch die 

” missbilligte“ Typkonvertierung (char*) genommen werden, s. Op3i/(5.64b). 

• Der Rückgabewert ist der Stream im Zustand nach dem Lesen. Im Fehlerfall (Erreichen 

des Dateiendes) werden eofbit und failbit gesetzt. Wenn EOF Probleme verursachen 

könnte: s. (b). 

Bsp s. (12.66). 

↑↑ Angegeben ist für AnzBytes der Typ aus C++(alt) (int); in C++(neu) ist der Typ streamsize. 

(b) C++(neu) Falls das Erreichen des Dateiendes Probleme verursacht, kann statt der read- 

Funktion die Funktion readsome genommen werden: 

streamsize istream::readsome(char* ZeigerAufPuffer, streamsize AnzBytes); 

Hierbei werden ggf. weniger Zeichen gelesen, falls vorher EOF erreicht wird. Es wird kein 

Fehlerbit infolge Erreichen von EOF gesetzt. Der Rückgabewert der Funktion gibt die Anzahl 

tatsächlich gelesener Bytes an. 

(12.65) Positionieren bei Dateien (Binär- und Textdateien) 

Jeder Stream hat jeweils einen Schreib- bzw. Lesezeiger. Streams, die beschrieben und gelesen 

werden sollen, haben beides, die Positionen sind jedoch i. a. gleich. Bei Schreibdateien 

kann man i. a. nur mit dem Schreibzeiger, bei Lesedateien nur mit dem Lesezeiger arbeiten. 

Dieser Zeiger zeigt die nächste zu beschreibende/lesende Dateiposition an. Bei fortlaufendem 

Schreiben oder bei fortlaufendem Lesen benötigt man keinen direkten Zugriff auf diese 

Zeiger, da sie sich automatisch jeweils um die geschriebenen/gelesenen Bytes vorwärts bewegen. 

In manchen Fällen benötigt man jedoch gezielten Zugriff auf eine bestimmte Dateiposition: 

(a) Das Abfragen der aktuellen Zeigerposition geschieht mit einer tellx-Elementfunktion 

(mit x=p 〈put〉 beim Schreibzeiger, x=g 〈get〉 beim Lesezeiger). 

streampos tellp(); 

streampos tellg(); 

↑↑ streampos ist ein vorzeichenbehafteter Ganzzahltyp aus C++(alt); in C++(neu) lautet der Typ 

ios::pos type. Jedoch ist auch in C++(neu) der Typ streampos i. a. bekannt. 

(b) Das Setzen des Zeigers geschieht mit einer der seekx-Elementfunktionen (ebenfalls mit 

x=p 〈put〉 beim Schreibzeiger, x=g 〈get〉 beim Lesezeiger). 

ostream& seekp(streamoff Offset, ios::seek dir Bezug); 

ostream& seekp(streampos Position); 

istream& seekg(streamoff Offset, ios::seek dir Bezug); 

istream& seekg(streampos Position); 

↑↑ Angegeben sind die Typnamen aus C++(alt): streamoff, streampos, ios::seek dir; die 

beiden ersten sind vorzeichenbehaftete Ganzzahltypen. In C++(neu) lauten die Typnamen: 

ios::off type, ios::pos type, ios::seekdir (letzter: ohne Unterstrich). Jedoch sind 

auch in C++(neu) die Typen aus C++(alt) i. a. bekannt.


(12.66) Beispiel: 

Das Positionieren (Setzen des Dateizeigers) kann relativ oder absolut geschehen: 

• Funktion mit zwei Parametern: relative Positionierung, und zwar bezogen entweder 

auf den Dateianfang, auf die aktuelle Position oder auf das Dateiende, anzugeben durch 

den zweiten Parameter in Form von einer der drei Aufzählungskonstanten: 

ios::beg 〈begin〉: relativ zum Dateianfang, 

ios::cur 〈current〉: relativ zur aktuellen Position, 

ios::end 〈end〉: relativ zum Dateiende. 

Der erste Parameter der seekx-Funktion gibt den Offset an. Grundsätzlich ist es nicht 

erlaubt, vor den Dateianfang oder hinter das Dateiende zu positionieren, daher gilt 

Offset 0 bei Bezug auf Dateianfang, Offset 0 bei Dateiende. 

• Funktion mit einem Parameter: absolute Positionierung, d. h. das Positionieren 

bezogen auf den Dateianfang (wirkt wie ios::beg als zweiter Parameter). 

Der Zahlenwert von Position oder Offset bedeutet bei Binärdateien Anzahl Bytes. Bei Textdateien 

ist die Interpretation schwieriger, da die Betriebssystem-Darstellung und die C ++- 

Darstellung beispielsweise des Zeilenendes unterschiedlich sein kann, siehe (5.31). Bei Textdateien 

sollte daher i. a. nur ein vorher gemerkter tellx-Wert als Parameter für absolute 

Positionierung genommen werden (Wiederauffinden einer vorher gemerkten Position). Bei 

Binärdateien ist das Positionieren problemloser; am besten setzt man die gesuchte Stelle 

unter Zuhilfenahme des sizeof-Operators Op3j (5.14), vgl. Beispiel (12.66); dadurch benötigt 

man keine Kenntnisse über die interne Repräsentation der Daten. 

Bsp Zurück zum Dateianfang bei Lesedatei: 

LeseStreamName.seekg(0); 

Zum Dateiende bei Schreibdatei: 

SchreibStreamName.seekp(0,ios::end); 

Positionieren auf letztes Objekt des Typs T beim Lesen (die Typkonversion in einen vorzeichenbehafteten 

Ganzzahltyp – hier long – ist notwendig, da sizeof vorzeichenlos ist): 

LeseStreamName.seekg(-long(sizeof(T)),ios::end); 

Ignorieren des folgenden Objekts des Typs T beim Lesen: 

LeseStreamName.seekg(sizeof(T),ios::cur); 

// Beispieldatei D12-66.CPP 

// (eigentlich wie angedeutet in drei Dateien aufzuteilen) 

#include 

#include 


// ***** Headerdatei für Klasse Datum ***** 

class Datum { 

int tag, monat, jahr; 

public: 

Datum(int t=1, int monat=1, int jahr=2000); 

void setzDatum(int t, int m, int j); 

int gibTag() const {return tag; } 

int gibMonat() const {return monat; } 

int gibJahr() const {return jahr; } 

}; 

// Überladung des Eingabeoperators für Lesen eines Datums aus 

// Textstrom wie z. B. Standardeingabe (Format: 3 Ganzzahlen) 

istream& operator>> (istream &ein, Datum &d); 

// Überladung des Ausgabeoperators für Schreiben eines Datums in 

// Textstrom wie z. B. Standardausgabe 

ostream& operator> (ifstream &ein, Datum &d);


// Überladung des Ausgabeoperators für binäres Schreiben 

// eines Datums in eine Datei 

ofstream& operator> (istream &ein, Datum &d) 

{ 

int t, m , j; 

ein >> t >> m >> j; 

d.setzDatum(t,m,j); 

return ein; 

} 

ostream& operator


} 

Datum d; 

cout > d; 

aus dAnf; 

cout


zessorabhängige Byte-Reihenfolge low/high oder high/low). Daher sind Binärdateien nicht 

immer zwischen verschiedenen Plattformen portabel. Legt man größeren Wert auf Portabilität, 

empfiehlt sich die Abspeicherung von Zahlen als Text (als Ziffernfolgen), da Textdateien 

portabel sind (nach ggf. Umformen von unterschiedlichen Zeilenende-Repräsentationen 

beispielsweise zwischen DOS/Windows und Unix). Zu beachten ist hier jedoch unbedingt, 

dass zwischen zwei Zahlen mindestens ein Zwischenraumzeichen (Leerzeichen, Tab-Zeichen 

oder Zeilenendezeichen) gesetzt wird, damit die Zahlen beim Lesen getrennt wahrgenommen 

werden. 

Das obige Beispiel würde als Textdatei nur ein anderes Überladen des Ausgabeoperators 

benötigen. Der für cin überladene Eingabeoperator könnte auch für die Textdatei genommen 

werden; jedoch kann ein Extra-Überladen aus Performanzgründen sinnvoll sein (s. Kommentar 

im Beispiel). Im folgenden sind die zum Verständnis wichtigsten Teile abgedruckt, 

der vollständige Programmtext ist im Internet verfügbar. Die für Dateien überladenen Operatoren 

sind hier als Freunde von Datum deklariert, damit sie direkten Zugriff auf die Datenelemente 

haben. 

// Beispieldatei D12-67.CPP 

// (eigentlich wie angedeutet in drei Dateien aufzuteilen) 

// ACHTUNG, andere Headerdateien als üblich, Erläuterung s. Skript (11.23d) 

#include 

#include 

// ***** Headerdatei für Klasse Datum ***** 

class Datum { 

// ... 

// Überladung des Eingabeoperators für Lesen eines Datums 

// aus einer Textdatei 

friend ifstream& operator>> (ifstream &ein, Datum &d); 

// Überladung des Ausgabeoperators für Schreiben eines Datums 

// in eine Textdatei 

friend ofstream& operator> (ifstream &ein, Datum &d) 

{ 

// Gültigkeitsprüfung über setzDatum() nicht nötig, 

// da gültiges Datum beim Schreiben 

ein >> d.tag >> d.monat >> d.jahr; 

return ein; 

} 

ofstream& operator


} 

return aus; 

// ***** Programmdatei für Hauptprogramm ***** 

int main() 

{ 

ofstream aus("DATEN.TXT"); 

} 

// ... (weiter wie D12-66.CPP) 

ifstream ein("DATEN.TXT"); 

// ... (weiter wie D12-66.CPP) 

// Suchen und Ausgeben des letzten Datums: 

// nicht ohne weiteres möglich, da Textdatei 

// ... 

In diesem Fall ist die Datei DATEN.TXT mit dem Editor klartextlesbar; sie lautet nach dem 

Programmlauf (mit der Eingabezeile ” 2 8 1999“): 

5 5 2005 

1 1 2000 

2 8 1999 

12.7 Mehrdimensionale Arrays und zugehörige Zeiger, 

Kommandozeilenparameter 

(12.70) Übb Die Kenntnisse aus den vorangegangenen Unterkapiteln werden hier auf kompliziertere 

Arraystrukturen angewendet. Die Typeigenschaften einschließlich der zum Array kompatiblen 

Zeiger scheinen zunächst sehr verwirrend zu sein. Es gelten aber auch hier die schon 

vorher eingeführten Typ-Regeln, sie müssen nur konsequent angewendet werden. (12.73) zeigt 

als Anwendung daraus, wie Kommandozeilenparameter verarbeitet werden können. 

(12.71) Die Typinterpretatationsregeln (10.25) gelten auch bei komplizierteren Typen, z. B. bei mehrdimensionalen 

Arrays oder bei Arrays aus Zeigern. 

(a) Auch bei komplizierteren Arraytypen werden die Arraybezeichnungen nach (10.26) in Zeiger 

auf ihren Komponententyp umgewandelt. Diese Arrays sind demnach zu Variablen, die den 

Typ eines Zeigers auf den Komponententyp haben, zuweisungskompatibel. 

int a[15][20], *b[10], (*c)[10]; 

// kompatible Zeigertypen: 

int (*aa)[20], **bb; // c ist bereits Zeiger 

// Zuweisung und Inkrementierung: 

aa=a; ++aa; 

bb=b; ++bb; 

// c sei geeignet initialisiert, Inkrementierung: 

++c; 

Erläuterungen: 

– Annahme für Speicherplatzberechnungen: sizeof(int) 2 Byte, sizeof(Zeiger) 4 Byte –


Namen a und aa: 

a[...][...] ist int 

a[...] ist Array aus 20 int 

a ist Array, bestehend aus 15 Arrays, jedes bestehend aus 20 int 

– Name wird meist umgewandelt in Zeiger auf Array, bestehend aus 20 int 

SpPl: 15 · 20 · 2 Byte 

(*aa)[...] ist int 

*aa ist Array aus 20 int 

aa ist Zeiger auf Array, bestehend aus 20 int 

SpPl: 4 Byte 

Nach obiger Zuweisung, vor der Inkrementierung: 

aa zeigt auf das erste 20-int-Array, d. h. auf a[0] 

Nach der Inkrementierung: 

aa zeigt auf das nächste 20-int-Array, d. h. auf a[1] 

Namen b und bb: 

*b[...] ist int 

b[...] ist Zeiger auf int 

b ist Array, bestehend aus 10 Zeigern auf int 

– Name wird meist umgewandelt in Zeiger auf Zeiger auf int 

SpPl: 10 · 4 Byte 

**bb ist int 

*bb ist Zeiger auf int 

bb ist Zeiger auf Zeiger auf int 

SpPl: 4 Byte 

Nach obiger Zuweisung, vor der Inkrementierung: 

bb zeigt auf den ersten int-Zeiger, d. h. auf b[0] 

Nach der Inkrementierung: 

bb zeigt auf den nächsten (zweiten) int-Zeiger, d. h. auf b[1] 

Name c: 

(*c)[...] ist int 

*c ist Array aus 10 int 

c ist Zeiger auf Array, bestehend aus 10 int 

SpPl: 4 Byte 

Nach obiger Inkrementierung (zuvor passende Zuweisung): 

c zeigt auf ein nächstes (ggf. fiktives) 10-int-Array 

(b) Umwandlungsregel Arraytyp in äquivalenten Zeigertyp: 

Aus name[dim] wird *name – wenn aus Vorrangregeln nötig (nämlich bei mindestens einer 

weiteren zusätzlichen Arraydimensionierung), dann unbedingt zusätzlich geklammert, d. h. 

(*name). 

Bsp name[dim] → *name 

name[dim][mehrDim] → (*name)[mehrDim] 

*name[dim] → **name 

*name[dim][mehrDim] → *(*name)[mehrDim] 

(c) Die (innerste) Dimension dim kann in folgenden Fällen weggelassen werden, d. h. es genügt 

statt dessen ein leeres Klammernpaar [ ]: 

• bei einem formalem Parameter, da der Ausdruck dim sowieso ignoriert wird, 

• bei einer Array-Deklaration, die keine Definition ist, 

• bei einer Array-Definition mit Initialisierern, da der Compiler anhand der Anzahl der 

Initialisierer die Dimension selbst setzt. 

Nicht erlaubt ist es, evtl. noch weitere vorhandenen Dimensionen (in (b) mehrDim genannt) 

wegzulassen; diese werden z. B. für die Zeigerarithmetik benötigt. 

Passen bei einer Array-Definition mit Initialisierer die (innerste) Dimension nicht mit der 

Anzahl der Initialisierer überein, so gilt folgendes: 

• Ist die Dimensionsangabe zu groß, werden fehlende Komponenten mit zugehörigen Nullwerten/Standardkonstruktoraufrufen 

aufgefüllt. 

• Ist sie zu klein, erzeugt der Compiler einen Fehler. 

Beispiel: 

char *monatAZ[] = {"Ungültig","Januar","Februar","März",


"April","Mai","Juni","Juli","August", 

"September","Oktober","November","Dezember" 

}, 

monatAA[][10] = {"Ungültig","Januar","Februar","März", 

"April","Mai","Juni","Juli","August", 

"September","Oktober","November","Dezember" 

}; 

cout


// Version (c), nur Funktionsblock: 

{ 

while (argc-->0) 

cout


} 

double *const *const matrixReservierung(int anzZeil, int anzSpalt) 

{ 

double **matrix = new double *[anzZeil]; 

for (int zeil=0; zeil


(12.82) ↑↑ 

• Auch in C ++: ” low-level“-Programmierung △! 

Die wichtigsten Bibliotheksfunktionen in C 

– Auswahl sehr eng und willkürlich (i. w. aus K&R2/, und zwar ANSI-C) – 

(a) Ein- und Ausgabe 

Anm In C ++ gibt es bessere Möglichkeiten, und zwar mit Hilfe der Streams. 

FILE ist ein Strukturtyp, in dem die intern benötigten Informationen über die 

Dateihandhabung abgelegt werden. 

Kennzeichnung, welche Datei gemeint ist: mit Hilfe eines Zeigers vom Typ 

FILE* (richtig belegt durch fopen()). 

Name Standardeingabeeinheit: stdin (Typ FILE*) - entspricht cin in C++, 

Name Standardausgabeeinheit: stdout (Typ FILE*) - entspricht cout in C++. 

FILE *fopen(const char *filename, const char *mode); 

Öffnen Datei filename (in betriebssystemspezifischer Schreibweise) im Modus: 

mode = "r" Lesen (Fehler, wenn nicht vorhanden) 

"w" Schreiben (vorher Löschen, wenn vorhanden, sonst Erzeugen) 

"a" Anhängen, Schreiben (ggf. Erzeugen) 

"r+" Lesen und Schreiben (Fehler, wenn nicht vorhanden) 

"w+" Lesen und Schreiben (vorher Löschen, falls vorhanden, 

sonst Erzeugen) 

"a+" Anhängen, Lesen und Schreiben (ggf. Erzeugen) 

Zusätzlich "b" (nicht als 1. Zeichen) möglich ("binär", ohne Übersetzung 

CR/LF (DOS) ’\n’ (C), unter UNIX i.a. unnötig), sonst "Textmodus" 

(dann ASCII 26 als EOF!) 

Rückgabewert: != NULL -> Zeiger auf Struktur, unter der Datei anzusprechen ist, 

== NULL -> Fehler 

int fclose(FILE *stream); 

Schließen, Rückgabewert 0 -> in Ordnung, EOF -> Fehler 

int printf(const char *format, ...); 

int fprintf(FILE *stream, const char *format, ...); 

int sprintf(char *s, const char *format, ...); 

Formatierte Ausgabe entsprechend format, 

Rückgabewert: >= 0: Anzahl ausgegebene Zeichen (bei sprintf() ohne Nullbyte), 

< 0: Fehler 

Ziel: stdout (printf), Datei stream (fprintf), 

String s mit Nullabschluss (sprintf). 

int scanf(const char *format, ...); 

int fscanf(FILE *stream, const char *format, ...); 

int sscanf(char *s, const char *format, ...); 

Formatierte Eingabe entsprechend format, 

Rückgabewert: >= 0: Anzahl gelesene/umgewandelte Parameter, 

EOF bei Dateiende (zu Anfang) oder Fehler 

Quelle: stdin (scanf), Datei stream (fscanf), String s (sscanf). 

VORSICHT bei scanf()! 

int getchar(void); Quelle: stdin, ggf. als Makro 

int getc(FILE *stream); Quelle: Datei stream, ggf. als Makro 

int fgetc(FILE *stream); Quelle: Datei stream, als Funktion 

Einlesen eines Zeichens, 

Rückgabe: (int)(unsigned char)Zeichen oder EOF (bei Dateiende/Fehler) 

char *gets(char *s); 

Einlesen aus stdin bis einschl. ’\n’, Ablegen in s (’\n’ -> ’\0’) 

char *fgets(char *s, int n, FILE *stream); 

Einlesen aus stream, Anzahl Zeichen: MIN(n-1, Anz. Zeichen bis einschl. ’\n’), 

’\n’ bleibt, falls vorhanden, zusätzl. Nullabschluss 

Beide Funkionen: Rückgabewert s -> in Ordnung, NULL -> Dateiende oder Fehler


int putchar(int c); Ziel: stdout, ggf. als Makro 

int putc(int c, FILE *stream);Ziel: Datei stream, ggf. als Makro 

int fputc(int c, FILE *stream);Ziel: Datei stream, als Funktion 

Ausgabe c als (unsigned char)c 

Rückgabewert (int)(unsigned char)c -> in Ordnung, EOF -> Fehler. 

int puts(const char *s); Ziel: stdout 

int fputs(const char *s, FILE *stream); Ziel: Datei stream 

Ausgabe String ohne Nullbyte (bei puts(): zusätzl. ’\n’-Abschluss), 

Rückgabewert >= 0 -> in Ordnung, EOF -> Fehler. 

size_t fwrite(const void *p,size_t size,size_t nobj,FILE *stream); 

size_t fread ( void *p,size_t size,size_t nobj,FILE *stream); 

schreibt aus p in stream/liest aus stream in p, 

und zwar max. nobj Objekte der Größe size. 

Rückgabe: Anzahl der gelesenen/geschriebenen Objekte (ggf. < nobj). 

Bei Lesen meist Untersuchung von stream mit feof() bzw. ferror() nötig. 

long ftell(FILE *stream); 

Rückgabewert: Position Dateizeiger von stream, -1L bei Fehler 

int fseek(FILE *stream, long offset, int origin); 

Dateizeiger von stream setzen. 

Binärdatei: auf offset Zeichen , beginnend ab origin; hierbei: 

origin = SEEK_SET Dateianfang, SEEK_CUR augenbl. Stand, SEEK_END Dateiende 

Textdatei: erlaubt nur offset==0L (dann obige Konstanten für origin) 

oder offset==ftell-Wert (dann origin == SEEK_SET) 

Rückgabewert != 0 -> Fehler. 

void rewind(FILE *stream); 

rewind(fp) ist äquivalent zu fseek(fp,0L,SEEK_SET); clearerr(fp) 

int feof(FILE *stream); != 0 -> Dateiende-Indikator ist gesetzt 

int ferror(FILE *stream); != 0 -> Fehler-Indikator ist gesetzt 

void clearerr(FILE *stream);Löschen Fehler- und EOF-Indikator für stream 

int-Variable errno (in deklariert) 

kann mehr Information über Fehlerart liefern. 

(b) String-Funktionen 

Anm Diese Funktionen können manchmal auch in C ++ nützlich sein. 

Stringfunktionen mit Beachtung Nullbyte: 

Hier Abkürzung für Parameter: 

s Typ char *; cs, ct Typ const char *; n Typ size_t; c Typ int (-> char); 

bei Vergleichsfunktionen: Argumente behandelt als Arrays von unsigned char 

char *strcpy(s,ct); Kopieren 

char *strncpy(s,ct,n); dto., max. n Zeich., ggf. Auffüllen mit 

’\0’ oder auch kein Nullabschluss (!) 

char *strcat(s,ct); Anhängen 

char *strncat(s,ct,n); dto., max. n Zeichen, Nullabschluss 

int strcmp(cs,ct); Vergleich: 0 -> gleich, < 0 -> cs 0 -> cs>ct 

int strncmp(cs,ct,n); dto., max. n Zeichen 

size_t strlen(cs); Stringlänge ohne Nullbyte 

Ohne Beachtung eines Nullbytes: 

Hier Abkürzung für Parameter: 

s Typ void *; cs, ct Typ const void *; n Typ size_t; c Typ int (-> char); 

bei Vergleichsfunktionen: Argumente behandelt als Arrays von unsigned char 

void *memcpy(s,ct,n); Kopieren n Zeichen 

void *memmove(s,ct,n); dto., aber richtig auch bei Überlappung der Bereiche 

int memcmp(cs,ct,n); Vergleich n Zeichen, Ergebnis wie strcmp() 

void *memset(s,c,n); n-mal Zeichen c ab Adresse s setzen 

(c) Verschiedene Hilfsfunktionen


Umwandeln ASCII-Zeichenfolge in Zahl: atof(), atoi(), atol() u.v.a. 

Anm In C ++ gibt es wesentlich bessere Funktionen zur Speicherverwaltung mit den Operatoren 

new und delete. Auf keinen Fall mit den hier vorgestellten Funktionen mischen! 

void *malloc(size_t size); 

Allokierung von (mind.) size_t Bytes, Rückgabe Zeiger zu Speicherplatz, 

wenn == NULL, dann kein Platz vorhanden. 

void *calloc(size_t nobj, size_t size); 

Allokierung Platz für nobj Objekte der Größe size, reservierter Platz ist 

mit Nullbytes gelöscht, Rückgabe wie malloc() 

void *realloc(void *p, size_t size); 

Vergrößert oder verkleinert Speicherplatz, zu p gehörig (bereits allokiert), 

so dass neue Größe size Bytes; behält bish. Inhalt bei, soweit size nicht 

größer, sonst Speicherbereich uninitialisiert, Rückgabe ähnlich malloc() 

void free(void *p); 

gibt Speicherplatz frei, der vorher auf p mit m/c/realloc() allokiert wurde 

char *getenv(const char *name); 

Rückgabe: Inhalt Umgebungsvariable name, NULL, wenn nicht vorhanden 

void qsort(void *base, size_t n, size_t size, 

int (*cmp)(const void *arg1,const void *arg2)); 

Quicksort-Algorithmus, sortiert das Array base, und zwar die Komponenten 

base[0]...base[n-1] (Komponentengröße size) in aufsteigender Reihenfolge. 

Sortierkriterium ist die Funktion cmp (muss negativen Wert liefern bei 

arg1arg2); diese Funktion 

wird intern auf die base-Komponenten angewendet. 

void exit(int status); ordentliches Programmende 

Funktion ist kaum sinnvoll bei allgemein zu verwendenden Funktionen; 

besser: Rückgabe eines Fehlerwertes, wenn z. B. Abbruch einer Operation nötig 

(d) Implementationsdefinierte Grenzen , 

Grenzen als Konstanten, z.B. max./min. int-, long-, char-, float, double-Wert u.a.

Vorlesungsskript - Hochschule Emden/Leer

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?