Systemprogrammierung Teil 1: Einführung

Systemprogrammierung 

Teil 1: Einführung 

Prof. Dr. H. Drachenfels Version 3.0 

Hochschule Konstanz 26.7.2013 

Systemsoftware versus Anwendungssoftware 

Systemsoftware dient dem Betrieb von Rechnern 

• Verwaltung der Hardware-Ressourcen und Steuerung der internen Abläufe 

Prozessor- und Speicherverwaltung, Kommunikation mit angeschlossenen Geräten usw. 

• Bereitstellen einer komfortablen Ablaufumgebung für Anwendungssoftware 

Verbergen von speziellen Hardware-Eigenschaften usw. 

• Beispiele: 

Betriebssysteme, Datenbanksysteme, Firmware, JVM (Java Virtual Machine), ... 

Anwendungssoftware stellt Funktionalität für Endbenutzer eines Rechners bereit 

• Verwaltung und Verarbeitung von Anwenderdaten 

• Bereitstellen komfortabler Bedienoberflächen 

• Beispiele: 

Browser, Textverarbeitung, Computerspiele, ... 

Die Grenze zwischen Systemsoftware und Anwendungssoftware ist fließend. 

Prof. Dr. H. Drachenfels Systemprogrammierung 1-1 

Hochschule Konstanz

Systemsoftware und Hardware 

Prozessor 

(CPU) 

Hauptspeicher 

(RAM) 

• Systemsoftware muss 

die Hardware-Ressourcen 

möglichst optimal nutzen 

E/A-Geräte 

• Tastatur (Keyboard) 

• Maus 

• Bildschirm (Display) 

• Netzwerkanschluss 

• ... 

Bus 

Peripherie-Geräte 

Hintergrundspeicher 

• Festplatte (Disk) 

• CD-ROM 

• USB-Stick 

• ... 

sie muss insbesondere die 

Begrenztheit der Ressourcen 

beachten 

• die Programmiersprache 

darf deshalb nicht zu stark 

von der Hardware abstrahieren 

das gilt insbesondere 

für die Ressource Speicher 


Hochschule Konstanz 

Systemsoftware und Programmiersprachen 

Ursprünglich wurde Systemsoftware vollständig in Assemblersprachen erstellt: 

• eine Assemblersprache bietet lediglich lesbare Namen für Maschinenbefehle 

• Software ist dadurch an den Befehlssatz einer Prozessorfamilie gekoppelt 

• Programmierung mühsam und fehleranfällig 

Heute wird Systemsoftware überwiegend in der Hochsprache C erstellt: 

• übersichtliche Sprache mit sehr guter Werkzeugunterstützung 

• in den 1970er-Jahren als Programmiersprache von Unix entstanden 

1978: Kernighan & Ritchie - "The C Programming Language" 

1989: ANSI-C, bis heute der am breitesten unterstützte Standard 

1990: C90, ISO-Standard, der bis auf Kleinigkeiten ANSI-C entspricht 

1995: C95, kleinere Ergänzungen 

1999: C99, Angleichungen an C++ und einige Erweiterungen 

2011: C11, unter anderem bessere Unicode-Unterstützung, Bibliothekserweiterungen 


Hochschule Konstanz

Systemprogrammierung: Inhalt der Lehrveranstaltung 

Einführung in die Sprache ANSI-C 

• Sprachkonzepte: Datentypen, Anweisungen, Funktionen, Übersetzungseinheiten 

• Standardbibliothek: Speicherverwaltung, Ein-/Ausgabe, Dateien, ... 

Werkzeuge 

• Compiler: gcc 

• Debugger: ddd, valgrind 

• Automatisierung der Programmerstellung: make 

Programmorganisation 

• statische und dynamische Bibliotheken 

• ausführbare Dateien 

• Archive 

• Prozesse 


Hochschule Konstanz


Teil 2: ANSI-C Daten 

Literale, Variablen, Typen 



ANSI-C Literale: Ganze Zahlen 

Schreibweisen für ganze Zahlen (Integers): 

• dezimal 1 23 456 7890 

• oktal 01 023 045670 

• hexadezimal 

0x1 0x23 0x456 0x789a 0xbcdef0 

Typ des Literals ist je nach Schreibweise der jeweils kleinste passende Typ: 

• dezimal 

• oktal oder 

hexadezimal 

• mit Suffix L 

z.B. 12345L 

• mit Suffix U 

z.B. 12345U 

int, long int, unsigned long int 

int, unsigned int, long int, unsigned long int 

long int, unsigned long int 

unsigned int, unsigned long int 

Nicht vergessen: der Compiler wandelt alle Schreibweisen in Binärzahlen! 


Hochschule Konstanz

Beispiel-Programm Zahlen-Literale 

• Quellcode 

#include 

int main() 

{ 

printf("%x\n", 12); 

} 

printf("%d\n", 012); 

printf("%o\n", 0x12); 

return 0; 

%x ist hexadezimales Format 

%d ist dezimales Format 

%o ist oktales Format 

\n ist Zeilenwechsel 

Konsolenausgabe 

des Programms: 

c 

10 

22 



ANSI-C Literale: Gleitkomma-Zahlen 

Schreibweisen für Gleitkomma-Zahlen (Floating Point Numbers): 

• nur dezimal 1. .23 0.456 78.9 .789e2 789e-1 

.789e2 steht für 0,789 ⋅ 10 2 

Typ des Literals abhängig vom Suffix: 

• ohne Suffix 

double 

• mit Suffix L 

z.B. 1.2345L 

• mit Suffix F 

z.B. 1.2345F 

long double 

float 

Nicht vergessen: Gleitkomma-Zahlen sind ungenau! 

Auch bei Gleitkomma-Literalen wandelt der Compiler alle Schreibweisen in ein Binärformat 

(je nach Zielhardware z.B. IEEE 754) 


Hochschule Konstanz

Beispiel-Programm Gleitkomma-Literale 

• Quellcode: 

#include 

int main() 

{ 

printf("%g\n", (1e-30 + 1e30) - 1e30); 

} 

printf("%g\n", 1e-30 + (1e30 - 1e30)); 

printf("%f\n", 12.3456789); 

printf("%f\n", 1234567.89); 

printf("%e\n", 12.3456789); 

printf("%e\n", 1234567.89); 

return 0; 



%g ist Fest- oder Gleitkommaformat nach Bedarf 

%f ist Festkommaformat 

%e ist Gleitkommaformat 

0 

1e-30 

12,345679 

1234567,890000 

1.234568e+01 

1.234568e+06 

Ausgabe bei %f und %e 

standardmäßig mit 

6 Nachkommastellen 



ANSI-C Literale: Einzelzeichen (1) 

Schreibweisen für Einzelzeichen (Characters): 

• in Einfach-Hochkommas 

'a' 'A' '1' '.' ' ' Buchstaben, Ziffern, Satzzeichen, Leerstelle, ... 

'\0' das NULL-Zeichen (Code-Nummer 0) 

'\ooo' Codenummer oktal (1 bis 3 Oktalziffern o) 

'\xhh' Codenummer hexadezimal (mindestens eine Hex-Ziffer h) 

'\c' Ersatzdarstellung für Steuerzeichen (c ist a, b, f, n, r oder t) 

'\'' 

'\"' 

'\\' 

das Einfach-Hochkomma 

das Doppel-Hochkomma 

der Backslash 

Typ des Literals abhängig vom Präfix: 

• ohne Präfix char 

• mit Präfix L wchar_t 

z.B. L'x' 

Der Compiler wandelt alle Schreibweisen 

in binäre Zeichencode-Nummern 

(je nach Plattform z.B. ASCII). 


Hochschule Konstanz

ANSI-C Literale: Einzelzeichen (2) 

• Bedeutung der Ersatzdarstellungen für Steuerzeichen: 

'\a' Alarm 

'\b' Rückschritt (Backspace) 

'\f' Seitenvorschub (Formfeed) 

'\n' Zeilenende (Newline) 

'\r' Wagenrücklauf (Carriage-Return) 

'\t' Horizontal-Tabulator 

'\v' Vertikal-Tabulator 

Nicht vergessen: der Compiler wandelt alle Schreibweisen 

in binäre Zeichencode-Nummern (je nach Plattform z.B. ASCII) 



ANSI-C Literale: Zeichenketten 

Schreibweise für Zeichenketten (Strings): 

• in Doppel-Hochkommas 

"Hallo" 

"" leerer String 

• nur durch Zwischenraum (Whitespace) getrennte Zeichenketten 

fasst der Compiler zu einer Zeichenkette zusammen: 

"Hal" "lo" 

das gleiche wie "Hallo" 

zwischen den Doppelhochkommas sind 

alle Schreibweisen für Einzelzeichen erlaubt, 

wobei die Einfach-Hochkommas entfallen, 

z.B. "Hallo\n" 

Typ des Literals abhängig vom Präfix: 

• ohne Präfix 

• mit Präfix L 

z.B. L"Hallo" 

char* 

wchar_t* 


Hochschule Konstanz

Beispiel-Programm Zeichen-Literale 


#include 

int main() 

{ 

printf("%s\n", "Hallo"); 

} 

printf("%s\n", "Hal" "lo"); 

printf("Hallo\n"); 

printf("%c%c%c%c%c\n", 'H', 'a', 'l', 'l', 'o'); 

return 0; 

%s ist Zeichenkettenausgabe 

%c ist Einzelzeichenausgabe 



Hallo 

Hallo 

Hallo 

Hallo 



ANSI-C Literale: Symbolische Konstanten 

Der ANSI-C-Präprozessor erlaubt es, symbolische Namen für Literale zu vergeben. 

• Definition einer symbolischen Konstanten: 

#define Name Literal 

Präprozessor-Anweisungen sind Zeilen, die mit # beginnen 

der Name sollte nur aus Großbuchstaben bestehen 

(und eventuell Ziffern und Unterstriche, allerdings nicht als erstes Zeichen) 

• Benutzung einer symbolischen Konstanten: 

nach der Definition kann der Name anstelle des Literals geschrieben werden 

der Name wird beim Übersetzen vom Präprozessor durch das Literal ersetzt 

• Beispiel: 

#define PI 3.14159265358979323846 


Hochschule Konstanz

ANSI-C Literale: Vergleich mit Java 

Schreibweise der Literale ist in ANSI-C und Java weitgehend gleich 

Wichtige Unterschiede bei ANSI-C: 

• es gibt ganze Zahlen ohne Vorzeichen 

• der Zeichensatz ist nicht Unicode 

• Verkettung von String-Literalen ohne + 

• keine Literale true und false 

• symbolische Namen für Literale 



ANSI-C Literale: Empfehlungen 

Zahlen-Literale: 

• echte Zahlen immer dezimal schreiben 

• Bitmuster immer oktal oder noch besser hexadezimal schreiben 

Zeichen-Literale: 

• die oktale und hexadezimale Angabe von Code-Nummern (ausser '\0') vermeiden 

Es drohen sonst Überraschungen auf Rechnern mit verschiedenen Zeichencodes. 

symbolische Konstanten: 

• Literale in der Regel nur zum Initialisieren von Variablen verwenden, 

ansonsten symbolische Konstanten bevorzugen 

Kommt ein bestimmtes Literal an mehreren Stellen vor, ist nicht erkennbar, 

ob zwischen diesen Stellen ein logischer Zusammenhang besteht 


Hochschule Konstanz

ANSI-C Variablen: Eigenschaften 

Variablen dienen dazu, Werte im Hauptspeicher abzulegen und anzusprechen. 

• eine Variable hat einen Namen: 

Besteht aus Buchstaben, Ziffern und Unterstrichen. 

Darf nicht mit einer Ziffer beginnen und darf kein ANSI-C Schlüsselwort sein. 

• eine Variable hat einen Typ: 

Legt fest, welche Art von Werten die Variable aufnehmen kann (z.B. nur ganze Zahlen). 

Legt fest, welche Operationen erlaubt sind (z.B. Addition usw.). 

• eine Variable hat einen Wert: 

Steht in binärer Zahlendarstellung im Hauptspeicher. 

• eine Variable hat eine Adresse: 

Die Anfangsadresse des Werts im Hauptspeicher. 

• eine Variable hat einen Platzbedarf: 

Anzahl Bytes, die der Wert im Hauptspeicher belegt. Hängt vom Typ ab. 



ANSI-C Variablen: Syntax 

• Variablen-Definition legt Typ und Name fest: 

Erst nach ihrer Definition ist eine Variable benutzbar Typ Name; 

Definition lokaler Variablen nur am Anfang eines {}-Blocks 

• Wert: 

definierter Anfangswert nur mit Initialisierung 

Typ Name = Wert; 

Wertänderung per Zuweisung 

Name = Wert; 

bei Konstanten Initialisierungspflicht und keine Zuweisung const Typ Name = Wert; 

• Adresse: 

der Adressoperator liefert die Adresse einer Variablen &Name 

i.d.R. müssen Variablen eine durch sizeof (Typ) teilbare Adresse haben ( Alignment ) 

• Platzbedarf: 

der sizeof-Operator liefert den Platzbedarf einer Variablen sizeof Name 

bzw. den Platzbedarf eines Typs. 

sizeof (Typ) 


Hochschule Konstanz

ANSI-C Datentypen: Übersicht 

Grundtypen (elementare Datentypen) 

• Arithmetische Typen 

Ganzzahlige Typen: char, int, ... 

Gleitkommatypen: float, double, ... 

Einen logischen Typ 

(boolean) gibt es nicht! 

• Anonymer Typ: 

void 

Abgeleitete Typen 

• Zeiger: * 

• Felder: [] 

Benutzerdefinierte Typen 

• Aufzählungen: enum 

• Strukturen: struct, union 



ANSI-C Grundtypen: int 

• Variablen-Definition: int zahl = 123; 

short int zahl = 123; 

long int zahl = 123L; 

unsigned int bytefolge = 0xffffffffU; 

unsigned short int bytefolge = 0xffffU; 

unsigned long int bytefolge = 0xffffffffUL; 

Kurzschreibweise: hinter short, long und unsigned kann int weggelassen werden 

• Wert: 

ganze Zahl mit Vorzeichen 

mit Zusatz unsigned Bitmuster (ganze Zahl ohne Vorzeichen). 

• Platzbedarf je nach Rechner bzw. Compiler: 

sizeof (short) ≤ sizeof (int) ≤ sizeof (long) 

typisch: 

2 Byte für short 

4 Byte für int und long (ILP32-Rechner) 

8 Byte für long (LP64- Rechner) 

Zusatz unsigned 

ist ohne Einfluss 

auf den Platzbedarf 


Hochschule Konstanz

Beispiel-Programm int-Variablen 


#include 

int main() 

{ 

int n = 0; 

int m = 1; 

} 

/* print variable values */ 

printf("n = %d\n", n); 

printf("m = %d\n", m); 

/* print variable addresses */ 

printf("&n = %p\n", (void*) &n); 

printf("&m = %p\n", (void*) &m); 

/* print type and variable sizes */ 

printf("sizeof (int) = %lu\n", (unsigned long) sizeof (int)); 

printf("sizeof n = %lu\n", (unsigned long) sizeof n); 

return 0; 



n = 0 

m = 1 

&n = 0x22efc4 

&m = 0x22efc0 

sizeof (int) = 4 

sizeof n = 4 



ANSI-C Grundtypen: float und double 

• Variablen-Definition: 

• Wert: 

bei float 

bei double 

float zahl = 3.14F; 

double zahl = 3.14; 

long double zahl = 3.14L; 

einfach genaue Gleitkommazahlen (single precision) 

doppelt genaue Gleitkommazahlen (double precision) 

bei long double erweitert genaue Gleitkommazahlen (extended precision) 


sizeof (float) ≤ sizeof (double) ≤ sizeof (long double) 

typisch: 

4 Byte für float 

8 Byte für double 

16 Byte für long double 


Hochschule Konstanz

ANSI-C Grundtypen: char 

• Variablen-Definition: char zeichen = 'a'; 

wchar_t zeichen = L'a'; 

signed char byte = –1; 

unsigned char byte = 0xff; 

• Wert: 

bei char 

Einzelzeichen im Standard-Zeichensatz (normalerweise ASCII) 

bei wchar_t 

Einzelzeichen in einem größeren Zeichensatz (z.B. Unicode) 

bei signed char ganze Zahl mit Vorzeichen 

bei unsigned char Bitmuster (ganze Zahlen ohne Vorzeichen) 


1 ≡ sizeof (char) ≤ sizeof (wchar_t) ≤ sizeof (long) 

1 ≡ sizeof (signed char) ≡ sizeof (unsigned char) 



ANSI-C Grundtypen: void 


• Wert: 

entfällt — es gibt keine Variablen vom Typ void 

entfällt 


entfällt — sizeof-Operator auf void nicht anwendbar 

Verwendung des Typs void: 

• zur Definition abgeleiteter Typen 

void* Zeiger auf "irgendwas" 

• bei Funktions-Definitionen 

void f(void); Funktionen ohne Rückgabewert bzw. ohne Parameter 


Hochschule Konstanz

ANSI-C Grundtypen: Vergleich mit Java 

Grundtypen und Schreibweise der Variablen-Definition 

sind in ANSI-C und Java sehr ähnlich 

Wichtige Unterschiede bei ANSI-C: 

• kein Grundtyp boolean 

• es gibt ganze Zahlen ohne Vorzeichen 

• Platzbedarf und Speicheradresse von Variablen 

lassen sich mit Operatoren sizeof bzw. & ermitteln 

• Platzbedarf und damit Wertebereiche der Grundtypen sind plattformabhängig 



ANSI-C Grundtypen: Empfehlungen 

• vorzugsweise die Grundtypen char, int, double verwenden 

Die anderen Grundtypen nur verwenden, wenn es einen zwingenden Grund gibt. 

• Zusatz const verwenden, wenn eine Variable ihren Wert 

nach der Initialisierung nicht mehr ändern soll: 

const double pi = 3.14159265358979323846; 

• Achtung: 

Die Mischung unterschiedlich großer Zahltypen 

sowie von Zahltypen mit und ohne Vorzeichen 

kann zu überraschenden Ergebnissen führen. 

double x = 8.5 + 1 / 2; // setzt x auf 8.5 statt 9 

unsigned a = 1; 

int b = -2; 

if (a + b > 0) ... // Summe ist 4 294 967 295 statt -1 


Hochschule Konstanz

ANSI-C Abgeleitete Typen: Zeiger (1) 

Zu jedem Typ kann ein Zeigertyp (Pointertyp) abgeleitet werden, indem man 

in der Variablen-Definition einen Stern ∗ vor den Variablen-Namen schreibt. 


• Wert: 


Typ ∗Zeigername_1 = &Name; 

Typ ∗∗Zeigername_2 = &Zeigername_1; 

Die Adresse eines Speicherbereichs (Wert 0 bedeutet, der Zeiger zeigt nirgendwohin) 


sizeof (int) ≤ sizeof (Typ ∗) 

• Grafische Darstellung: 

typisch: 4 Byte 

Zeigername_2 Zeigername_1 Name 

& Zeigername_1 & Name Wert 

Kästchen stehen für 

Speicherbereiche 

Pfeile stehen für Adresswerte 




• Zeiger auf konstanten Wert: 

const Typ Name = Wert; 

Typ ∗Zeigername = &Name; // Fehler 

const Typ ∗Zeigername = &Name; 

• konstanter Zeiger: 


Typ ∗ const Zeigername = &Name; 

• konstanter Zeiger auf konstanten Wert: 

const Typ ∗ const Zeigername = &Name; 

• Inhaltsoperator ∗ macht vom Zeiger adressierten Speicherbereich zugreifbar: 

∗Zeigername 

Achtung: Programm-Absturz, wenn der Zeiger den Wert 0 hat 

Inhaltsoperator ist Gegenstück zum Adressoperator: 

∗&Name ist das gleiche wie Name 

Der Wert einer Konstanten kann 

auch auf dem Umweg über Zeiger 

nicht geändert werden. 

Ein konstanter Zeiger zeigt 

während des ganzen Programmlaufs 

auf denselben Speicherbereich. 


Hochschule Konstanz


void-Pointer 



void ∗void_pointer = &Name; 

• Wert: 

Adresse eines Speicherbereichs beliebigen Typs (aber Inhalt nicht zugreifbar) 


wie andere Zeiger auch 

• Typecast-Operator (T ) wandelt einen void-Pointer in einen konkreten Pointer: 

Typ ∗typ_pointer = (Typ ∗) void_pointer; 

Achtung: chaotische Laufzeitfehler, wenn der void-Pointer 

nicht auf einen Speicherbereich des angegeben Typs zeigt 




Verwendung von Zeigern z.B. bei dynamischer Spreicherverwaltung: 

• die Funktion malloc reserviert Speicher für Werte eines Typs 

und liefert die Adresse des Speicherbereichs: 

Typ ∗Zeigername = (Typ*) malloc(sizeof (Typ)); 

if (Zeigername == NULL) 

{ 

Anzahl benötigte Bytes 

... /* Fehlerbehandlung */ malloc hat Rückgabetyp void* 

} 

malloc liefert die ungültige Adresse 0 (wird oft NULL geschrieben), 

wenn die angeforderte Menge Speicher nicht verfügbar ist. 

Achtung: malloc reserviert nur Speicher, initialisiert ihn aber nicht 

• mit der Funktion free kann (und sollte!) per malloc reservierter Speicher 

irgendwann wieder freigegeben werden: 

#include erforderlich, 

free(Zeigername); 

damit malloc und free bekannt sind 


Hochschule Konstanz

Beispiel-Programm Zeiger-Variable 


#include 

int main() 

{ 

int n = 3082; 

int *p = &n; 

} 

/* print pointer value */ 

printf("p = %p\n", (void*) p); 

/* print pointer address */ 

printf("&p = %p\n", (void*) &p); 

/* print pointer size */ 

printf("sizeof p = %lu\n", (unsigned long) sizeof p); 

/* print dereferenced pointer value */ 

printf("*p = %d\n", *p); 

return 0; 



p = 0x22efc4 

&p = 0x22efc0 

sizeof p = 4 

*p = 3082 



ANSI-C Abgeleitete Typen: Felder (1) 

Zu jedem Typ kann ein Feldtyp (Arraytyp) abgeleitet werden, indem man 

in der Variablen-Definition eine Feldgröße in Klammern [] angibt. 

• Variablen-Definition: Typ Feldname[Feldgröße] = {Wert_1, Wert_2, ...}; 

Kurzschreibweise: Die Feldgröße kann entfallen, wenn eine Initialisierung angegeben ist 

• Wert: 


Folge von Werten gleichen Typs 

(Zugriff nur elementweise mit Indexoperator) 

sizeof Feldname ≡ Feldgröße ∗ sizeof (Typ) 


Feldname[] 

[0] = Wert_1 

[1] = Wert_2 

: 

[Feldgröße - 1] = Wert_N 


Hochschule Konstanz


• Indexoperator [] macht die Feld-Elemente zugreifbar: 

Feldname[Index] 

Der Index muss ganzzahlig sein und zwischen 0 und Feldgröße - 1 liegen. 

Indices außerhalb dieses Bereichs führen zu undefinierten Laufzeitfehlern! 

der Feldname ohne [] ist Kurzschreibweise für die Adresse des ersten Feldelements: 

Feldname ist das gleiche wie &Feldname[0] 

Der Feldname ist also keine Name für den Speicherbereich des Felds, 

sondern ein Name für die Anfangsadresse des Felds! 

• der Indexoperator ist Kurzschreibweise für Inhaltsoperator und Zeigerarithmetik: 

Zeigername[Index] ist das gleiche wie ∗(Zeigername + Index) 

Zeigerarithmetik arbeitet mit der Einheit sizeof (Typ): 

Zeigername + Index bedeutet Adresse + Index ∗ sizeof (Typ) 




Felder und dynamischer Spreicherverwaltung: 

• die Funktion calloc reserviert Speicher für ein Feld von Werten eines Typs 

und liefert die Adresse des Speicherbereichs: 

Typ ∗Zeigername = (Typ*) calloc(Feldgröße, sizeof (Typ)); 

if (Zeigername == NULL) 

{ 

... /* Fehlerbehandlung */ 

} 

• calloc initialisiert den reservierten Speicher mit 0 

wird die Initialisierung nicht gebraucht, kann malloc verwendet werden: 

Typ ∗Zeigername = (Typ*) malloc(Feldgröße * sizeof (Typ)); 

• Speicher auch bei calloc mit free wieder freigegeben: 

free(Zeigername); 


Hochschule Konstanz

Beispiel-Programm Feld-Variable 


#include 

int main() 

{ 

int a[] = {3421, 3442, 3635, 3814}; 

const int n = (int)(sizeof a / sizeof (int)); 

int i; 

} 

/* print array values and addresses */ 

printf("a = %p\n", (void*) a); 

for (i = 0; i < n; ++i) 

{ 

printf("%d: %p %d\n", i, (void*) &a[i], a[i]); 

} 

/* print array size */ 

printf("sizeof a = %lu\n", (unsigned long) sizeof a); 

return 0; 

Was gibt das Programm auf der Konsole aus? 



Beispiel-Programm Feld-Zeiger (1) 


#include 

#include /* calloc, malloc, free, ... */ 

#include /* NULL, size_t, ... */ 

int main() 

{ 

oder ohne Initialisierung mit 0: 

const int n = 4; int *a = (int*) malloc(n * sizeof (int)); 

int i; 

int *a = (int*) calloc((size_t) n, sizeof (int)); 

if (a == NULL) 

{ 

printf("Speicherreservierung fehlgeschlagen!\n"); 

return 1; 

} 

a[0] = 3421; 

a[1] = 3442; 

a[2] = 3635; 

a[3] = 3814; 


Hochschule Konstanz

Beispiel-Programm Feld-Zeiger (2) 

• Fortsetzung Quellcode: 

... 

} 

/* print array values and addresses */ 

printf("&a = %p\n", (void*) &a); 

printf("a = %p\n", (void*) a); 

for (i = 0; i < n; ++i) 

{ 

printf("%d: %p %d\n", i, (void*) &a[i], a[i]); 

} 

/* print array size */ 

printf("sizeof a = %lu\n", (unsigned long) sizeof a); /* pointer size */ 

printf("%d * sizeof *a = %lu\n", n, (unsigned long) n * sizeof *a); 

free(a); 

return 0; 



ANSI-C Abgeleitete Typen: String (1) 

Ein String ist ein Feld von Einzelzeichen mit '\0' als letztem Zeichen. 

Strings werden über Zeiger-Variablen benutzt. 


• Wert: 

const char ∗s = "Hallo"; 

const, weil 

String-Literal 

nicht änderbar! 

Anfangsadresse eines Strings (d.h. die Adresse seines ersten Zeichens) 


sizeof "Hallo" ≡ 6 (Anzahl Zeichen incl. '\0') 

sizeof s ≡ sizeof (char∗) 

• Grafische Darstellung: s 

oder einfacher: 

s 

[0] = 'H' 

[1] = 'a' 

[2] = 'l' 

[3] = 'l' 

[4] = 'o' 

[5] = '\0' 

"Hallo" 

Zeichen '\0' 

dient in C als 

Endemarkierung 

von Strings 


Hochschule Konstanz


String-Literale sind als Feld-Initialisierer verwendbar 


char s[] = "Hallo"; 

Kurzschreibweise für: 

char s[] = {'H', 'a', 'l', 'l', 'o', '\0'}; 

• Wert: 



Folge der Zeichen (Kopie des String-Literals einschließlich '\0') 

sizeof s ≡ 6 (Anzahl Zeichen einschl. '\0') 

s[] 

[0] = 'H' 

[1] = 'a' 

[2] = 'l' 

[3] = 'l' 

[4] = 'o' 

[5] = '\0' 




• Manipulation von C-Strings mit Bibliotheks-Funktionen: 

char ∗strcpy(char ∗s1, const char ∗s2); 

kopiert den String s2 in den Speicherbereich s1 und liefert s1 als Rückgabewert 

char ∗strcat(char ∗s1, const char ∗s2); 

hängt den String s2 an den String s1 an und liefert s1 als Rückgabewert 

int strcmp(const char ∗s1, const char ∗s2 ); 

Vergleicht die Strings s1 und s2 und liefert 0, wenn die Strings gleich sind, 

eine Zahl größer 0 bei s1 > s2 bzw. eine Zahl kleiner 0 bei s1 < s2 

size_t strlen(const char ∗s); 

liefert die Länge des Strings s ohne '\0' 

... /* noch einige weitere str-Funktionen */ 


Hochschule Konstanz

Beispiel-Programm String-Variablen (1) 


#include 

#include 

#include 

#include 

Was gibt das Programm auf der Konsole aus? 

damit die strxxx-Funktionen bekannt sind 

int main() 

{ 

char a[] = "halli"; 

const char *s = "hallo"; 

char *t = NULL; 

/* compare, copy and concatenate strings */ 

if (strcmp(a, s) < 0) 

{ 

t = (char*) malloc(sizeof a + strlen(s)); 

if (t == NULL) ... /* error handling */ 

} 

... 

strcat(strcpy(t, a), s); /* or: strcpy(t, a); strcat(t, s); */ 

strcpy und strcat 

allokieren keinen Speicher 

deshalb zuerst mit malloc 

genug Speicher reservieren 



Beispiel-Programm String-Variablen (2) 


... 

/* print string values and addresses */ 

printf("a = %p %s\ns = %p %s\nt = %p %s\n", 

(void*) a, a, (void*) s, s, (void*) t, t); 

printf("sizeof a = %lu\n", (unsigned long) sizeof a); /* 6 */ 

printf("sizeof s = %lu\n", (unsigned long) sizeof s); /* 4 bzw. 8 */ 

printf("sizeof t = %lu\n", (unsigned long) sizeof t ); /* 4 bzw. 8 */ 

printf("strlen(a) = %lu\n", (unsigned long) strlen(a)); /* 5 */ 

printf("strlen(s) = %lu\n", (unsigned long) strlen(s)); /* 5 */ 

printf("strlen(t) = %lu\n", (unsigned long) strlen(t )); /* 10 */ 

} 

s = a; /* copies the address, not the string */ 

/* a = s; syntax error */ 

free(t); 

return 0; 


Hochschule Konstanz

ANSI-C Abgeleitete Typen: Felder von Feldern 

Mehrdimensionale Felder am Beispiel einer 2x3-Matrix 

• Variablen-Definition: int matrix[2][3] = {{10, 11, 12}, {20, 21, 22}}; 

• Wert: 

zeilenweise Folge der Matrix-Elemente 

(Zugriff nur elementweise mit Indizierungs-Operatoren) 

• Platzbedarf: sizeof matrix ≡ 2 * 3 * sizeof (int) 

• Indizierung: matrix[i][j] ≡ ∗(*(matrix + i ) + j) 


matrix[][] 

[0][0] = 10 

[0][1] = 11 

[0][2] = 12 

1. Zeile 

Recheneinheit 

sizeof (int) 

Recheneinheit 

sizeof (int[3]) 

[1][0] = 20 

[1][1] = 21 

2. Zeile 

[1][2] = 22 



Beispiel-Programm Matrix-Zeiger (1) 


#include 

#include 

#define M 3 /* number of columns */ 

int main() 

{ 

/* allocate and initialize memory for 2x3 matrix */ 

const int n = 2; /* number of lines */ 

int i, j; 

int (*matrix)[M] = (int(*)[M]) malloc(n * M * sizeof (int)); 

if (matrix == NULL) ... /* error handling */ 

matrix[0][0] = 10; 

matrix[0][1] = 11; 

matrix[0][2] = 12; 

matrix[1][0] = 20; 

matrix[1][1] = 21; 

matrix[1][2] = 22; 

... 

Spaltenanzahl muss bereits zur 

Übersetzungszeit feststehen 


Hochschule Konstanz

Beispiel-Programm Matrix-Zeiger (2) 


... 

/* print matrix addresses and values */ 

printf("&matrix = %p\n", (void*) &matrix); 

printf("matrix = %p\n", (void*) matrix); 

for (i = 0; i < n; ++i) 

{ 

printf("[%d] %p: %p\n", i, (void*) &matrix[i], (void*) matrix[i]); 

for (j = 0; j < M; ++j) 

{ 

printf(" [%d] %p: %d\n", j, (void*) &matrix[i][j], matrix[i][j]); 

} 

} 

} 

/* print matrix size */ 

printf("sizeof matrix = %lu\n", (unsigned long) sizeof matrix); 

printf("%d * sizeof *matrix = %lu\n", n, (unsigned long) n * sizeof *matrix); 

free(matrix); 

return 0; 



ANSI-C Abgeleitete Typen: Felder von Zeigern 

Felder von Zeigern am Beispiel einer 2x3-Matrix 

• Variablen-Definition: int line_0[3] = {10, 11, 12}; 

int line_1[3] = {20, 21, 22}; 

int ∗matrix[2] = {line_0, line_1}; 

• Wert: 

Folge von Zeilen-Adressen 

• Platzbedarf: sizeof matrix ≡ 2 ∗ sizeof (int∗) 

• Indizierung: matrix[i][j] ≡ ∗(∗(matrix + i) + j) 

Recheneinheit 

sizeof (int) 


line_0[] 

matrix[] [0] = 10 

[0] = line_0 [1] = 11 

[1] = line_1 [2] = 12 

line_1[] 

[0] = 20 

[1] = 21 

[2] = 22 

Recheneinheit 

sizeof (int*) 


Hochschule Konstanz

Beispiel-Programm Matrix-Doppelzeiger (1) 


#include 

#include 

int main() 

{ 

/* allocate and initialize memory for 2x3-matrix */ 

const int n = 2; /* number of lines */ 

const int m = 3; /* number of columns */ 

int i, j; 

int **matrix = (int**) malloc(n * sizeof (int*)); 

if (matrix == NULL) ... /* error handling */ 

for (i = 0; i < n; ++i) 

{ 

matrix[i] = (int*) malloc(m * sizeof (int)); 

if (matrix[i] == NULL) ... /* error handling */ 

} 

... 

sowohl Zeilen- als auch Spaltenanzahl 

müssen erst zur Laufzeit feststehen 



Beispiel-Programm Matrix-Doppelzeiger (2) 


... 

matrix[0][0] = 10; 

... 

matrix[1][2] = 22; 

wie Feld von Feldern (Folie 2-39) 

/* print matrix addresses and values */ 

... 

wie Feld von Feldern (Folie 2-40), 

aber m statt M 

} 

/* free matrix memory */ 

for (i = 0; i < n; ++i) 

{ 

free(matrix[i]); 

} 

free(matrix); 

return 0; 


Hochschule Konstanz

ANSI-C Abgeleitete Typen: Vergleich mit Java 

Bei abgeleiteten Typen kaum Gemeinsamkeiten zwischen ANSI-C und Java: 

• ANSI-C Zeiger bieten sehr viel mehr Möglichkeiten als Java Referenzen 

in Java nur Referenzen auf Objekte im Heap 

in ANSI-C Zeiger auf jeden beliebigen Speicherbereich, auch auf dem Stack 

• ANSI-C kennt keinen echten Feld-Typ 

der Indexoperator ist nur eine Kurzschreibweise für Adressarithmetik 

und kann auf jede beliebige Adresse angewendet werden 

die Feldlänge wird nicht im Feld hinterlegt, 

deshalb beim Feldzugriff keine automatische Überwachung der Indexgrenzen 

in Java Felder nur im Heap, in ANSI-C auch auf dem Stack 

Felder von Feldern gibt es in Java nicht 

• ANSI-C kennt keinen echten String-Typ 

nur Felder von Zeichen mit ungültigem Zeichen '\0' als Endemarkierung 



ANSI-C Abgeleitete Typen: Empfehlungen 

• Zeiger-Typen sind ein zentrales Konzept von ANSI-C 

• Feld-Typen sind verkappte Verwandte der Zeiger 

der Name einer Feld-Variablen ist kein Name für einen Speicherbereich, 

sondern ein Name für die Adresse eines Speicherbereichs 

an Stelle von Feld-Variablen besser Zeiger auf mit calloc bzw. malloc 

dynamisch reservierten Speicher verwenden (free nicht vergessen!) 

an Stelle der Felder von Feldern besser Felder von Zeigern verwenden 

• Strings sind Felder von Einzelzeichen 

Speicher per Feld-Variable (vermeiden) oder besser dynamisch per malloc reservieren 

beim Speicherplatzbedarf das abschließende '\0'-Zeichen nicht vergessen! 


Hochschule Konstanz

ANSI-C Benutzerdefinierte Typen: enum 

Eine Aufzählung (Enumeration) definiert Namen für int-Literale. 

• Typ-Deklaration: 

Vorsicht: 

die Namen der 

Enumeratoren 

sind nicht lokal 

zur Typdeklaration! 

enum Enumname 

{ 

Enumerator_1 = Wert_1, 

Enumerator_2 = Wert_2, 

... 

Enumerator_N = Wert_N 

}; 

Die Angabe der 

Enumerator-Werte 

ist optional. 

Default-Wert für den 

ersten Enumerator ist 0, 

für die anderen der 

Vorgängerwert plus 1. 


• Wert: 


enum Enumname Name = Enumerator; 

einer der Enumerator-Werte 

Enumerator-Werte können überall verwendet werden, 

wo int-Werte verwendet werden können. 

sizeof (enum Enumname) ≡ sizeof (int) 



Beispiel-Programm enum-Variable 


#include 

enum month {jan = 1, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec}; 

int main() 

{ 

/* enum month aMonth = 3; funktioniert bei C, aber nicht bei C++ */ 

enum month aMonth = mar; 

} 

/* print variable value */ 

printf("aMonth = %d\n", aMonth); 

/* print variable address */ 

printf("&aMonth = %p\n", (void*) &aMonth); 

/* print variable size */ 

printf("sizeof aMonth = %lu\n", (unsigned long) sizeof aMonth); 

return 0; 



aMonth = 3 

&aMonth = 0x22efc4 

sizeof aMonth = 4 


Hochschule Konstanz

ANSI-C Benutzerdefinierte Typen: struct (1) 

Eine Struktur fasst Werte beliebiger Typen zusammen. 


struct Strukturname 

{ 

Typ_1 Komponente_1; 

... 

Typ_N Komponente_N; 

}; 


struct Strukturname Name = {Wert_1, ..., Wert_N}; 

• Wert: 


Folge der Komponenten-Werte. 

N 

∑ 

i = 1 


sizeof (Typ_i) ≤ sizeof(struct Strukturname) 

wegen Alignment der Komponenten 

Name 

Komponente_1 = Wert_1 

: 

Komponente_N = Wert_N 



ANSI-C Benutzerdefinierte Typen: struct (2) 

• Komponentenauswahl-Operatoren (Punkt und Pfeil): 

Name.Komponente_1 

Zeigername–>Komponente_1 

• Adresse einer Komponente: 

& Name . Komponente_1 

& Zeigername –> Komponente_1 

• Verkettete Strukturen enthalten einen Zeiger auf den eigenen Strukturtyp: 

struct int_list 

{ 

struct int_list ∗next; /* Verkettung */ 

int n; 

}; 

struct int_list last = {NULL, 10}; 

struct int_list first = {&last, 20}; 

Pfeil ist Kurzschreibweise für 

(∗Zeigername).Komponente_2 

Adresse der ersten Komponente 

ist Adresse der Struktur insgesamt 

first 

next = 

n = 20 

last 

next = NULL 

n = 10 


Hochschule Konstanz

Beispiel-Programm struct-Variable 


#include 

struct date 

{ 

int day; 

const char *month; 

int year; 

}; 

... 

... 

int main() 

{ 

struct date d = {1, "September", 2000}; 

} 

/* print variable value */ 

printf("%d. %s %d\n", d.day, d.month, d.year); 

/* print variable address */ 

printf("&d = %p\n", (void*) &d); 

printf("&d.day = %p\n", (void*) &d.day); 

printf("&d.month = %p\n", (void*) &d.month); 

printf("&d.year = %p\n", (void*) &d.year); 

/* print variable size */ 

printf("sizeof d = %lu\n", 

(unsigend long) sizeof d); 

return 0; 



ANSI-C Benutzerdefinierte Typen: union (1) 

Eine Variante ist eine Struktur, bei der alle Komponenten dieselbe Adresse haben. 


union Unionname 

{ 

Typ_1 Variante_1; 

... 

Typ_N Variante_N; 

}; 

zu einer Zeit kann 

nur eine der Varianten 

gespeichert sein 

nur die erste Variante 

kann initialisiert werden 


union Unionname Name = {Wert_1}; 

• Wert: 

der Wert einer der Varianten 

• Platzbedarf: sizeof (union Unionname) ≡ MAX sizeof (Type_i ) 

N 

i = 1 


Name 

Variante_1 = Wert_1 


Hochschule Konstanz

ANSI-C Benutzerdefinierte Typen: union (2) 

• Variantenauswahl-Operatoren (Punkt und Pfeil): 

Name.Variante_2 

Zeigername–>Variante_2 

• unbenannte Varianten: 

enum int_or_string {type_int, type_string}; 

struct struct_with_union 

{ 

enum int_or_string u_type; 

union 

{ 

hier kein Unionname 

int i; 

char ∗s; 

} u; 

}; 

struct struct_with_union x; 

x.u_type = type_int; 

x.u.i = 1; 

x.u_type = type_string; 

x.u.s = "Hallo"; 



ANSI-C Benutzerdefinierte Typen: typedef 

Eine typedef-Deklaration definiert lediglich einen Aliasnamen für einen Typ. 

• Deklaration: 

typedef Typname Aliasname; 


Typname Name; 

Aliasname Name; 

beide Definitionen 

sind gleichwertig 

• besonders nützlich bei enum-, struct und union-Typen: 

struct date 

{ 

int day; 

}; 

const char *month; 

int year; 

typedef struct date date; 

date ist Aliasname für struct date 

(gleicher Bezeichner für struct und Alias 

ist erlaubt und übliche Konvention) 

date d = {1, "September", 2000}; /* statt struct date d ... */ 


Hochschule Konstanz

ANSI-C Benutzerdefinierte Typen: Vergleich mit Java 

Bei den benutzerdefinierten Typen große Unterschiede zwischen ANSI-C und Java: 

• enum-Typen sind sehr viel primitiver realisiert als in Java 

in ANSI-C eigentlich nur eine nette Schreibweise für ganzzahlige Konstanten 

• struct-Typen sind eine primitive Vorstufe der Java-Klassen 

nur öffentliche Instanzvariablen 

keine Methoden und Konstruktoren 

keine Vererbung 

auch Wert-Variablen möglich (in Java nur Speicherreservierung mit new) 

• union-Typen gibt es in Java nicht 

in Java wegen Vererbung und Polymorphie überflüssig 



ANSI-C Benutzerdefinierte Typen: Empfehlungen 

• enum-Typen sind nützlich für die Codierung nicht-numerischer Information. 

Verarbeitung oft mit switch-Anweisungen 

• struct-Typen sind das zentrale Konzept für benutzerdefinierte Typen 

verkettete Strukturen sind oft ein guter Ersatz für Felder 

• union-Typen gefährden die Typsicherheit 

vorzugsweise innerhalb eines struct-Typs als unbenannte Variante 

zusammen mit einer Typ-Komponente verwenden 

• typedef-Aliasnamen sind eine nützliche Schreibvereinfachung 

können Programme änderungsfreundlicher machen 


Hochschule Konstanz

ANSI-C Daten: Lernzettel 

#define Adresse Adressoperator Alignment Array calloc char const double 

enum Feld Feld von Feldern Feld von Zeigern float free Indexoperator 

Inhaltsoperator int Literal long malloc Pointer short signed sizeof size_t 

strcat strcmp strcpy strlen struct symbolische Konstante typedef union 

unsigned Variable void wchar_t Zeiger Zeigerarithmetik 


Hochschule Konstanz


Teil 3: ANSI-C Anweisungen 

Ausdrücke / Operatoren / Ablaufsteuerung 



ANSI-C Anweisungen: Übersicht 

Ein Programm besteht aus Anweisungen (Statements): 

• Variablen-Definitionen 

Typ Name = Ausdruck; /* nur global oder am Anfang eines Anweisungsblocks */ 

• Ausdrücke mit darauf folgendem Semikolon 

Ausdruck; /* besteht aus Literalen, Namen und Operatoren */ 

; /* Spezialfall leere Anweisung */ 

• Anweisungsblöcke in geschweiften Klammern 

{Anweisung Anweisung ...} 

{ } /* Spezialfall leere Anweisung */ 

• Anweisungen zur Ablaufsteuerung (Kontrollstrukturen) 

Verzweigungen: if-else switch-case-default 

Schleifen: 

Sprünge: 

while do-while for 

break continue return goto 


Hochschule Konstanz

ANSI-C Operatoren: Übersicht (1) 

• Operatoren mit einem Operanden: 

1 

2 

3 

Operator Name Stelligkeit Assoziativität Vorrang 1 

++, -- Postfix-Inkrement/Dekrement unär – 2 1 

. Komponente Auswahl unär – 2 1 

-> Komponente Inhalt mit Auswahl unär – 2 1 

[ Index ] Indizierung unär 3 – 2 1 

( Parameterliste ) Methodenaufruf unär 3 – 2 1 

++, -- Präfix-Inkrement/Dekrement unär – 2 2 

+, - Vorzeichen Plus/Minus unär – 2 2 

! Logische Negation unär – 2 2 

~ Bitweise Invertierung unär – 2 2 

* Inhalt unär – 2 2 

& Adresse unär – 2 2 

(Typ ) Typanpassung unär – 2 2 

sizeof Speicherplatzbedarf unär – 2 2 

Sortierung vom höchsten Vorrang 1 bis niedrigstem Vorrang 15. 

Einstellige Operatoren haben keine Assoziativität. Sie werden von innen nach außen berechnet. 

In ( ) oder, [ ] geklammerte Parameter der Operatoren bleiben bei der Stelligkeit unberücksichtigt. 




• Operatoren mit zwei Operanden: 

Operator Name Stelligkeit Assoziativität Vorrang 

∗ Multiplikation binär links 3 

/ Division binär links 3 

% Modulo binär links 3 

+ Addition / Konkatenation Binär links 4 

- Subtraktion binär links 4 

> Rechts-Shift binär links 5 

< kleiner binär links 6 

größer binär links 6 

>= größer-gleich binär links 6 

== Gleichheit binär links 7 

!= Ungleichheit Binär links 7 

& bitweises Und binär links 8 

^ bitweises XOR binär links 9 

| bitweises Oder binär links 10 


Hochschule Konstanz


• weitere Operatoren mit zwei Operanden, bzw. in einem Fall mit drei Operanden: 

Operator Name Stelligkeit Assoziativität Vorrang 

&& Logisches Und binär links 11 

|| Logisches Oder binär links 12 

? : Bedingung ternär rechts 13 

= Zuweisung binär rechts 14 

+= Additions-Zuweisung binär rechts 14 

-= Subtraktions-Zuweisung binär rechts 14 

∗= Multiplikations-Zuweisung binär rechts 14 

/= Divisions-Zuweisung binär rechts 14 

%= Modulo-Zuweisung binär rechts 14 

&= Bitweise-XOR-Zuweisung binär rechts 14 

^= Bitweise-Oder-Zuweisung binär rechts 14 

|= Bitweise-Und-Zuweisung binär rechts 14 

= Rechts-Shift-Zuweisung binär rechts 14 

, Sequenz binär links 15 



ANSI-C Operatoren: Komma 

Der Komma-Operator bildet eine Ausdrucks-Sequenz 

• Syntax: 

Ausdruck1, Ausdruck2 

• der Datentyp des Ausdrucks insgesamt 

ist der Datentyp des Ausdrucks hinter dem Komma 

• der Wert des Ausdrucks insgesamt 

ist der Wert des Ausdrucks hinter dem Komma 

• Achtung: nicht jedes Komma in einem C-Programm ist ein Komma-Operator ! 

int i, tmp; 

kein Komma-Operator 

(tmp = i, ++i, tmp); /* entspricht i++; */ 

Komma-Operator 


Hochschule Konstanz

ANSI-C Operatoren: Logik und Vergleiche 

Logische Operatoren ! && || verknüpfen Werte mit Zahl- und Zeigertypen. 

Ein Zahl- oder Zeigerwert 0 wird dabei als false interpretiert. 

Jeder Zahl- oder Zeigerwert ungleich 0 wird dabei als true interpretiert. 

• der Datentyp eines logischen Ausdrucks ist int 

• der Wert eines logischen Ausdrucks ist 0 oder 1 

Achtung: Durch den fehlenden Typ boolean können die logischen Operatoren && und || 

leicht mit den arithmetischen Bitoperatoren & und | verwechselt werden! 

Die Vergleichs-Operatoren < >= == != 

prüfen eine Relation zwischen zwei Werten. 

• der Datentyp eines Vergleichs-Ausdrucks ist int 

• der Wert eines Vergleichs-Ausdrucks ist 1, wenn die Relation zutrifft, sonst 0 

Achtung: Durch den fehlenden Typ boolean kann in Bedingungen 

leicht der Gleichheitstest == mit der Zuweisung = verwechselt werden! 



ANSI-C Operatoren: Vergleich mit Java 

Bei den Operatoren gibt es wenig Unterschiede zwischen ANSI-C und Java: 

• der Sequenz-Operator , fehlt in Java 

• der Rechts-Shift ohne Vorzeichen >>> fehlt in ANSI-C 

• die Operatoren für Zeiger und Zeigerarithmetik &, *, ->, sizeof 

sind in Java überflüssig 

• der Typabfrage instanceof ist in ANSI-C überflüssig 

• in ANSI-C gibt es logisches Und/Oder nur als && bzw. || mit fauler Auswertung 

In Java haben die Operatoren & und | je nach Operandentyp eine andere Bedeutung: 

im Fall von boolean sind es logische Operatoren mit voller Auswertung beider Operanden 

im Fall von ganzen Zahlen sind es wie bei ANSI-C arithmetische Bitoperatoren 


Hochschule Konstanz

ANSI-C Ausdrücke: Auswertungs-Reihenfolge (1) 

• Die Auswertungs-Reihenfolge der Operatoren eines Ausdrucks 

wird bestimmt von Vorrang, Assoziativität und Klammerung: 

a = ( b + ~ c ++ + d ) ∗ (double) e + f [i] 

14 ( ( 4 2 1 ) 4 ) 3 2 4 1 

• eindeutig darstellbar als Auswertungsbaum: 

a b c d e f i 

Reihenfolge 

++ 

wegen Vorrang [i] 

~ (double) 

+ 

+ 

= 

Reihenfolge 

wegen Links- 

Assoziativität 

∗ 

Reihenfolge 

wegen 

Klammerung 

+ 

Reihenfolge 

in jedem Ast 

von oben nach unten 

Reihenfolge 

zwischen den Ästen 

in der Regel beliebig 



ANSI-C Ausdrücke: Auswertungs-Reihenfolge (2) 

• Die Auswertungs-Reihenfolge der Operanden eines Operators 

ist in der Regel Compiler-abhängig. 

Man kann insbesondere nicht erwarten, dass 

ein Ausdruck von links nach rechts abgearbeitet wird. 

Beispiel: i = 0, v[i] = ++i 

Der Compiler darf Code erzeugen, 

der v[i] vor oder nach ++i auswertet. 

Je nachdem wird v[0] oder v[1] auf 1 gesetzt! 

• nur bei den folgenden vier Operatoren ist verbindlich festgelegt, 

dass der linke Operand vor dem rechten ausgewertet wird: 

Komma , 

Bedingung ?: 

Logisches Und && 

Logisches Oder || 

Bei den Operatoren && bzw. || 

wird der rechte Operand gar nicht ausgewertet, 

wenn der linke 0 bzw. ungleich 0 ist 

(Lazy Evaluation) 


Hochschule Konstanz

ANSI-C Ausdrücke: Makros 

Der ANSI-C-Präprozessor erlaubt es, 

häufig benötigte Ausdrücke als Makro zu definieren. 

• Definition eines Makros: 

#define Name(Parameterliste) Ausdruck 

die Parameterliste besteht nur aus durch Komma getrennten Namen ohne Typen 

• Benutzung eines Makros: 

nach der Definition kann ein Makro wie eine Funktion "aufgerufen" werden 

das Makro wird beim Übersetzen vom Präprozessor expandiert, 

d.h. durch den Ausdruck mit eingesetzten Argumenten ersetzt 

• Beispiel: 

#define max(a, b) ((a) > (b) ? (a) : (b)) 

m = 2 * max(x + y, z); /* Benutzung des Makros */ 

Achtung: unbedingt 

den ganzen Ausdruck 

und jeden Parameter 

klammern! 

m = 2 * ((x + y) > (z) ? (x + y) : (z)); /* expandiertes Makro */ 



ANSI-C Ausdrücke: Vergleich mit Java 

Bei den Ausdrücken gibt es wichtige Unterschiede zwischen ANSI-C und Java: 

• in ANSI-C gibt es im Gegensatz zu Java mehrdeutige Ausdrücke 

• in ANSI-C gibt es keine echten logischen Ausdrücke 

dadurch Verwechslungsgefahr zwischen Arithmetik und Logik, 

(speziell zwischen Zuweisung = und Test auf Gleichheit == 

sowie zwischen logischem Und/Oder und bitweisem Und/Oder) 

• in Java gibt es keine Makros 

dafür expandiert die Java Virtuelle Maschine zur Laufzeit automatisch 

häufig durchlaufene Aufrufe einfacher Methoden wie ein Makro 


Hochschule Konstanz

ANSI-C Ablaufsteuerung: Verzweigung 

Eine Verzweigung ermöglicht optionale und alternative Anweisungen. 

• Syntax: 

if (Bedingung) Anweisung /* falls Bedingung erfüllt */ 

if (Bedingung) 

Anweisung1 /* falls Bedingung erfüllt */ 

else 

Anweisung2 /* falls Bedingung nicht erfüllt */ 

if (Bedingung1) 

Anweisung1 /* falls Bedingung1 erfüllt */ 

else if (Bedingung2) 

Anweisung2 /* falls nur Bedingung2 erfüllt */ 

else 

Anweisung3 /* falls keine Bedingung erfüllt */ 

Eine Bedingung ist ein Ausdruck 

mit arithmetischem Typ oder Zeigertyp. 

Vorsicht bei 

geschachtelten 

Verzweigungen: 

Ein else-Teil gehört 

immer zum letzten 

noch offenen if. 

Eine andere Zuordnung 

muss mit geschweiften 

Klammern erzwungen 

werden: 

if (Bedingung1) { 

if (Bedingung2) ... 

} else { 

... 

} 



Beispielprogramm Verzweigung 

#include 

int main() 

{ 

int m, n; 

} 

printf("Zwei Zahlen eingeben: "); 

if (scanf("%d%d", &m, &n) < 2) 

{ 

fprintf(stderr, "Eingabefehler !\n"); 

} 

else if (m > n) 

{ 

printf("Maximum: %d\n", m); 

} 

else 

{ 

printf("Maximum: %d\n", n); 

} 

return 0; 

Liest zwei ganze Zahlen ein und 

gibt deren Maximum aus. 


Hochschule Konstanz

ANSI-C Ablaufsteuerung: Fallunterscheidung 

Die Fallunterscheidung ist eine spezielle Schreibweise für Mehrfachverzweigungen. 

• Syntax: switch (Ausdruck) { 

case Wert1: 

Anweisung1 

break; 

case Wert2: 

Anweisung2 

break; 

default: 

Anweisung3 

} 

Im Prinzip gleichbedeutend mit: 

if (Ausdruck == Wert1) 

Anweisung1 

else if (Ausdruck == Wert2) 

Anweisung2 

else 

Anweisung3 

Der Ausdruck muss einen ganzzahligen Typ haben. 

Die case-Werte müssen dazu passende ganzzahlige Konstanten (bzw. enum-Werte) sein. 

Der default-Fall wird ausgeführt, wenn der Ausdruck keinen der case-Werte hat. 

Mit break wird die Fallunterscheidung verlassen. 

Ohne break z.B. hinter Anweisung1 würde 

nach Anweisung1 die Anweisung2 ausgeführt 



Beispielprogramm Fallunterscheidung (1) 

#include 

int main() 

{ 

int month; 

printf("Monat eingeben [1-12]: "); 

if (scanf("%d", &month) < 1) 

{ 

month = 0; 

} 

switch (month) 

{ 

case 2: 

printf("28 oder 29 Tage\n"); 

break; 

case 4: 

case 6: 

case 9: 

case 11: 

printf("30 Tage\n"); 

break; 

Gibt die Anzahl der Tage 

eines Monats aus. 


Hochschule Konstanz

Beispielprogramm Fallunterscheidung (2) 

/* Fortsetzung ... */ 

} 

} 

case 1: 

case 3: 

case 5: 

case 7: 

case 8: 

case 10: 

case 12: 

printf("31 Tage\n"); 

break; 

default: 

fprintf(stderr, "Eingabefehler!\n"); 

return 0; 



ANSI-C Ablaufsteuerung: Schleifen (1) 

Eine Schleife ermöglicht die wiederholte Ausführung einer Anweisung. 

• Syntax der while-Schleife: 

while (Bedingung) 

Anweisung 

Wiederholt die Anweisung, solange die Bedingung gilt. 

• Syntax der do-Schleife: 

do 

Anweisung 

while (Bedingung); 

Führt die Anweisung aus und wiederholt sie dann, 

solange die Bedingung gilt. 

Gleichbedeutend mit: 

{ 

Anweisung 


Anweisung 

} 

Eine Bedingung ist wie gehabt ein Ausdruck mit arithmetischem Typ oder Zeigertyp. 


Hochschule Konstanz

ANSI-C Ablaufsteuerung: Schleifen (2) 

Die for-Schleife ist eine spezielle Schreibweise für Schleifen mit Laufvariablen. 

Die Laufvariable muss vor der Schleife definiert werden. 

for-Schleifen werden häufig benutzt, um Felder oder Listen (allgemein: Aggregate) abzulaufen. 

Dabei werden die aggregierten Elemente über eine Laufvariable angesprochen. 

• Syntax der allgemeinen for-Schleife: 

for (Initialisierung; Bedingung; Fortschaltung) 

Anweisung 

Die Initialisierung ist ein Ausdruck, der die Laufvariable 

auf das erste Element des Aggregats setzt. 

Die Fortschaltung ist eine Ausdruck, der die Laufvariable 

auf das nächst folgende Element des Aggregats setzt. 


{ 

Initialisierung; 


{ 

Anweisung 

Fortschaltung; 

} 

} 

Die Bedingung prüft, ob alle Elemente besucht wurden. 



Beispielprogramm while-Schleife 

#include 

int main () 

{ 

int sum = 0; 

int n; 

Liest ganze Zahlen ein und 

gibt deren Summe aus. 

printf("Zahlen eingeben (Ende mit Strg-d): "); 

while (scanf("%d", &n) == 1) 

{ 

sum += n; 

} 

printf("Summe: %d\n", sum); 

} 

return 0; 


Hochschule Konstanz

Beispielprogramm do-Schleife 

#include 

int main() 

{ 

int n = 0; 

/* Dezimalzahl einlesen */ 

do 

{ 

printf("Zahl zwischen 0 und 255 eingeben: "); 

} 

while (scanf("%d", &n) == 1 

&& (n < 0 || n > 255)); 

... 

} 

... 

Liest eine ganze Zahl ein und 

gibt sie in Binärdarstellung aus. 

/* Binaerzahl ausgeben */ 

printf(" "); /* 7 Leerzeichen */ 

do 

{ 

printf("%d\b\b", n % 2); 

n /= 2; 

} 

while (n > 0); 

printf("\n"); 

return 0; 



Beispielprogramm for-Schleife 

#include 

Gibt Feldelemente aus. 

int main() 

{ 

int an_array[] = {3082, 3101, 3275, 3436}; 

const int array_size = (int) (sizeof an_array / sizeof *an_array); 

int i; /* Laufvariable */ 

for (i = 0; i < array_size; ++i) 

{ 

printf("%d\n", an_array[i]); 

} 

} 

return 0; 


Hochschule Konstanz

ANSI-C Ablaufsteuerung: Sprünge (1) 

• Eine break-Anweisung springt hinter 

die umgebende Fallunterscheidung / Schleife: 

while (...) 

{ 

... 

if (Bedingung) break; 

... 

} 

... /* break springt hier hin */ 


int stop = 0; 

while (... && !stop) 

{ 

... 


stop = 1; 

else 

... 

} 

• Eine continue-Anweisung springt zum 

nächsten Schleifen-Durchlauf: 

while (...) 

{ 

if (Bedingung) continue; 

... 

} 


while (...) 

{ 

if (!Bedingung) 

{ 

... 

} 

} 




• Eine goto-Anweisung springt zu einer markierten Anweisung: 

for (...) { 

for (...) { 

if (Bedingung) goto ende; 

... 

} 

} 

ende: 

... 

verlässt in einem Schritt die beiden 

ineinander geschachtelten Schleifen 

goto-Anweisung sollten vermieden werden 

den obigen Schleifenabbruch kann man ohne goto lösen, indem man 

die Schleifen in eine Funktion verlegt und diese per return verlässt 


Hochschule Konstanz


Eine return-Anweisung springt an die Aufrufstelle einer Funktion zurück. 

Genaueres später bei den Funktionen. 

• Innerhalb von main beendet return das Programm: 

int main() { 

... 

if (Bedingung) return 1; 

... 

return 0; 

} 

Ein Rückgabewert 0 gilt als normales Programmende, 

ein Rückgabewert ungleich 0 gilt als Fehlerabbruch 



Beispielprogramm Sprünge (1) 

#include 

#include 

Liest ganze Zahlen ein und 

gibt deren Summe aus. 

int main() 

{ 

int sum = 0; 

int n; 

printf("Zahlen eingeben (Ende mit Strg-D): "); 

while (1) /* Endlos-Schleife, alternativ auch for (;;) */ 

{ 

int i = scanf("%d", &n); 

if (i == EOF) /* Strg-D ? */ 

{ 

fprintf(stderr, "*** Eingabeende\n"); 

break; /* hinter die Schleife springen */ 

} 

... 


Hochschule Konstanz

Beispielprogramm Sprünge (2) 

} 

} 

... 

else if (i == 0) 

{ 

char c; 

} 

fprintf(stderr, "*** Eingabe ist keine ganze Zahl: "); 

while ((c = getchar()) != EOF && !isspace(c)) 

{ 

putc(c, stderr); 

} 

putc('\n', stderr); 

continue; /* zum naechsten Schleifendurchlauf springen */ 

sum += n; 

printf("Summe: %d\n", sum); 

return 0; /* normales Programmende */ 



ANSI-C Anweisungen: Empfehlungen (1) 

• Leerzeichen machen Ausdrücke lesbarer, unnötige Klammern nicht unbedingt: 

a + b ∗ c a+(b*c) /* Klammern unnötig */ 

(a + b) ∗ c (a+b)*c /* Klammern notwendig */ 

• Ausdrücke mit Seiteneffekten vermeiden: 

a = b + c++; /* Seiteneffekt auf c */ 

a = b + c; /* Aufteilung meistens besser */ 

++c; 

• Nur eine Anweisung pro Zeile schreiben, Kontrollstrukturen mehrzeilig schreiben. 


{ 

if (Bedingung) Anweisung; 

Anweisung; 

} 

Vereinfacht erheblich die Fehlersuche und Qualitätssicherung mit Werkzeugen 

wie Compiler, Debugger usw. 


Hochschule Konstanz

ANSI-C Anweisungen: Empfehlungen (2) 

• Durch Zwischenraum (Whitespace), Klammerung und Einrückung 

die Blockstruktur der Ablaufsteuerung verdeutlichen: 

if (Bedingung1) 

{ 

Anweisung1 

Anweisung2 

} 

while (Bedingung2) 

{ 

Anweisung3 

} 

Einrückung in geklammerten Blöcken 

(üblicherweise 4 Leerzeichen) 

Leerzeile zwischen geklammerten Blöcken 

öffnende und schließende Klammer linksbündig 



ANSI-C Anweisungen: Vergleich mit Java 

Bei den Anweisungen gibt es einige Unterschiede zwischen ANSI-C und Java: 

• in ANSI-C Variablen-Definitionen nur am Anfang eines Blocks 

• in ANSI-C keine Ausnahmebehandlung mit try/catch/throw 

• in ANSI-C keine vereinfachte for(T element : alleElemente)-Schleife 

außerdem kann die Laufvariable einer for-Schleife nicht erst im Schleifenkopf, 

sondern muss vor der Schleife definiert werden 

• in ANSI-C gibt es die Sprünge break und continue nur ohne Marke 

Marken können nur mit goto angesprungen werden, was aber vermieden werden sollte 


Hochschule Konstanz

ANSI-C Anweisungen: Lernzettel 

Anweisung Auswertungsreihenfolge break case default continue do else 

for goto if Kommaoperator Makro Statement switch while 


Hochschule Konstanz


Teil 4: ANSI-C Programme 

Funktionen / Übersetzungseinheiten / Bibliotheken 



ANSI-C Programme: Aufbau 

Ein C-Programm ist technisch eine Sammlung von Funktionen und globalen Daten. 

• genau eine der Funktionen muss main heissen 

Bei main beginnt die Ausführung des Programms. 

Ein C-Programm ist organisatorisch eine Sammlung von Übersetzungseinheiten. 

• eine Übersetzungseinheit enthält Definitionen 

einiger logisch zusammengehöriger Funktionen und Daten 

• Übersetzungseinheiten dienen dazu, Programme überschaubar zu gliedern 

• logisch zusammengehörige Übersetzungseinheiten 

werden wiederum in Bibliotheken zusammengefasst. 

größere Programme enthalten leicht hunderte Übersetzungseinheiten 

und tausende Funktionen, von denen viele nicht selbst implementiert sind, 

sondern aus (gekauften) Bibliotheken stammen. 


Hochschule Konstanz

ANSI-C Funktionen: Eigenschaften 

Funktionen (Unterprogramme, Prozeduren) 

fassen Folgen von Anweisungen zusammen, die immer wieder gebraucht werden. 

• eine Funktion hat einen Namen: 

Namens-Konvention wie bei Variablen 

• eine Funktion kann Parameter und einen Rückgabewert haben: 

dienen der Übergabe von zu verarbeitenden Werten und zu liefernden Ergebnissen 

• eine Funktion hat einen Typ: 

legt Anzahl und Typen der Parameter sowie den Typ des Rückgabe-Werts fest 

• eine Funktion hat einen Rumpf: 

enthält Variablen-Definitionen und Anweisungen. 

• eine Funktion hat eine Adresse: 

die Anfangsadresse ihres ausführbaren Codes im Hauptspeicher 



ANSI-C Funktionen: Syntax (1) 

• Funktions-Prototyp (Funktions-Deklaration): 

Typ Name(Parameterliste); 

void Name(Parameterliste); /* ohne Rückgabewert */ 

Typ Name(void); /* ohne Parameter */ 

Erst nach ihrer Deklaration ist eine Funktion benutzbar. 

Die Parameterliste besteht aus durch Komma getrennten Typnamen. 

Zusätzlich können (und sollten) Parameternamen angegeben werden. 

• Beispiel: 

Parameter-Namen(dürfen auch fehlen) 

int max(int a, int b); 

Rückgabetyp 

Funktions-Name 

Parameter-Typen 


Hochschule Konstanz

ANSI-C Funktionen: Syntax (2) 

• Funktions-Definition: 

Rückgabetyp Name(Parameterliste) 

{ 

Anweisungen 

} 

Der Kopf muss genau dem Prototyp entsprechen, aber Parameternamen sind Pflicht. 

Der Rumpf enthält mindestens eine return-Anweisung: 

return Rückgabewert; /* Typ des Werts muss zum Rückgabetyp passen */ 

return; /* bei void-Funktionen (darf am Ende des Rumpfs auch fehlen) */ 

• Beispiel: int max(int a, int b) 

{ 

if (a > b) return a; 

return b; 

} 

Kopf 

Rumpf 

Funktion mit Wert a verlassen 

Funktion mit Wert b verlassen 



ANSI-C Funktionen: main 

Jedes Programm muss genau eine Funktion mit dem Namen main enthalten. 

• es gibt eine Variante mit und eine ohne Parameter: 

int main(int argc, char *argv[]) 

{ 

} 

... 

Erklärung der Parameter: 

argv 

argc + 1 

Feld von String-Pointern (argument vector). 

Feldgröße (argument count). 

int main() 

{ 

... 

} 

argv[0] 

argv[1] 

argv[argc – 1] 

argv[argc] 

Programm-Name (Kommando) 

erstes Kommandozeilen-Argument 

letztes Kommandozeilen-Argument 

0 (NULL-Pointer) 


Hochschule Konstanz

Beispiel-Programm main 


#include 


{ 

int i; 

for (i = 0; i

ANSI-C Funktionen: Aufruf 

• der Aufruf-Operator () veranlasst die Ausführung einer Funktion 

und liefert den Rückgabe-Wert der Funktion: 

Name(Argumentliste) 

Zeigernname(Argumentliste) 

Die Argumentliste besteht aus durch Komma getrennten Ausdrücken. 

Die Parameter der Funktion werden mit den Werten der Argumentliste initialisiert. 

• Beispiel: 

Aufruf über Funktions-Name 

int z = max(7, 8); /* setzt z auf 8 */ 

Aufruf über Funktions-Zeiger 

int (∗maximum)(int , int ) = max; 

int z = maximum(7, 8); /* setzt z auf 8 */ 



ANSI-C Funktionen: globale und lokale Variablen 

• Globale Variablen 

Definition außerhalb der Funktionsrümpfe (dann in vielen Funktionen benutzbar) 

oder static-Definition innerhalb eines Funktionsrumpfs (dann funktions-privat) 

Lebensdauer: 

Speicherort: 

Programmlauf 

Daten-Segment 

• Lokale Variablen (automatische Variablen) 

Definition innerhalb eines Funktionsrumpfs am Anfang eines Anweisungsblock {}, 

dadurch nur innerhalb dieses Anweisungsblocks benutzbar 

Lebensdauer: 

Speicherort: 

• Parameter 

Ausführung des Anweisungsblocks 

Stack-Segment 

spezielle lokale Variablen, Definition im Funktionskopf, 

Initialisierung mit den Argumenten des Funktionsaufrufs 

Lebensdauer: 

Speicherort: 

Ausführung der Funktion 

Stack-Segment 


Hochschule Konstanz

Beispiel-Programm globale und lokale Variablen 


int function(int param); 

int global = 1; 

int main() 

{ 

int local = 1; 

local = function(local); /* local wird 4 */ 

local = function(global); /* local wird 7 */ 

return 0; 

} 

int function(int param) 

{ 

static int private_global = 1; 

} 

int local = param + 1; 

private_global++; 

global = param + 2; 

return local + private_global; 

Funktions-Prototyp 

Funktions-Definition (Implementierung) 



ANSI-C Funktionen: Hauptspeicherbelegung (1) 

main: 

PC 

function: 

SB 

& global: 

& private_global: 

Code-Segment 

Daten-Segment 

Der Prozessor merkt sich 

• die Adresse des 

nächsten Befehls im 

Program Counter PC 

• das aktuelle Ende des 

Stack-Segments im 

Stack Pointer SP 

Heap-Segment 

der Übersichtlichkeit 

wegen weggelassen 

Der Prozessor adressiert 

• globale Daten relativ zur 

Static Base SB 

SP 

FP 

& local: 

Stack-Segment 

• lokale Daten relativ zum 

Frame Pointer FP 


Hochschule Konstanz

ANSI-C Funktionen: Hauptspeicherbelegung (2) 

main: 

function: 

PC 

SB 

& global: 

& private_global: 

Code-Segment 

Daten-Segment 

Ein Funktions-Aufruf 

benutzt den Stack: 

• zum Speichern von 

Argumenten 

(hier: param) 

• zum Speichern der 

Rückkehrinformation 

(alter PC und FP) 

SP 

FP 

& local: 

& param: 

& local: 

FP 

PC 

Stack-Segment 

der Rückgabewert wird 

in einem Prozessorregister 

oder auf dem Stack geliefert 

(hier nicht gezeigt) 

• zum Reservieren von Platz 

für die lokalen Variablen 

(hier: local) 



ANSI-C Funktionen: Eingabe-Parameter 

Mit Eingabe-Parametern übergibt ein Aufrufer Werte an eine Funktion: 

• bei Grundtyp-Parametern Übergabe per Wertkopie 

void funktion(int zahl); 

• bei Zeiger- und Feld-Parametern Übergabe per Adresskopie 

void funktion(const int ∗zeiger); 

void funktion(int feldlaenge, const int feld[]); 

• bei Strukturtyp-Parametern Übergabe per Adresskopie 

Wertkopie ist bei großen Strukturen zu ineffizient 

struct struktur { ... }; 

void funktion(const struct struktur *s); 

const verwenden, 

damit die Funktion 

nur Lesezugriff 

auf den Speicher 

des Aufrufers hat 


Hochschule Konstanz

ANSI-C Funktionen: Ausgabe-Parameter 

Mit Ausgabe-Parametern übergibt eine Funktion Werte an ihren Aufrufer: 

• Adresskopie verwenden 

void funktion(int ∗zeiger); 

void funktion(int feldlaenge, int feld[]); 

void funktion(struct struktur *s); 

kein const, 

damit die Funktion 

Schreibzugriff 

auf den Speicher 

des Aufrufers hat 

• Funktionen mit Ausgabe-Parametern bezeichnet man 

auch als Funktionen mit Seiteneffekten. 

Nach der reinen Lehre sollten Funktionen als Ergebnis 

nur einen Rückgabe-Wert liefern (return-Anweisung). 



ANSI-C Funktionen: Vergleich mit Java 

Bei den Funktionen gibt es deutliche Unterschiede zwischen ANSI-C und Java: 

• die ANSI-C Funktionen entsprechen im Prinzip den Java Klassenmethoden 

und ANSI-C globale Variablen entsprechen den Java Klassenvariablen 

weil es keine umschließenden Klassen gibt, liegen anders als bei Java 

die Namen aller Funktionen und globalen Variablen in einem gemeinsamen Namensraum 

• ANSI-C Funktionen können nicht überladen werden 

der Funktionsname muss ohne Betrachtung der Parametertypen eindeutig sein 

• Ausgabeparameter gibt es in Java nicht 

es gibt lediglich Seiteneffekte auf per Eingabeparameter übergebene Objekte 


Hochschule Konstanz

ANSI-C Übersetzungseinheiten: Aufbau 

Ein C-Programm wird in Module gegliedert, die sich getrennt übersetzen lassen 

(Übersetzungseinheiten). 

• jede Übersetzungseinheit besteht aus einer .h-Datei und einer .c-Datei: 

Name.h 

Name.c 

Header-Datei 

Implementierungs-Datei 

beim Hauptprogramm (Übersetzungseinheit mit nur der Funktion main ) 

entfällt die Header-Datei 

• die Header-Dateien werden mit Präprozessor-Anweisungen 

in Implementierungs-Dateien oder andere Header-Dateien hineinkopiert, 

immer wenn Deklarationen daraus verwendet werden: 

#include "Name.h" 

• nur die Implementierungs-Dateien werden mit dem Compiler übersetzt 



ANSI-C Übersetzungseinheiten: Header-Dateien 

Eine Header-Datei enthält die Schnittstelle der Übersetzungseinheit, d.h. 

Deklarationen von Namen, die in anderen Übersetzungseinheiten sichtbar sein sollen 

• benutzerdefinierte Typen: 

struct date 

{ 

int day, month, year; 

}; 


• symbolische Konstanten und Makros: 

#define MAXDAY 31 

• globale Variablen (extern-Deklaration ohne Initialisierung): 

extern date epoch; /* wegen extern keine Speicherreservierung */ 

• Funktions-Prototypen: 

void print_date(const date *d); 

wenn die Strukturkomponenten 

privat sein sollen: 


dann in anderen Übersetzungseinheiten 

nur date-Zeiger möglich 


Hochschule Konstanz

ANSI-C Übersetzungseinheiten: Implementierungs-Dateien 

Eine Implementierungs-Datei enthält die Implementierung der Schnittstelle. 

• Kopie der eigenen Schnittstelle (und ggf. der verwendeten Schnittstellen): 

#include "date.h" 

• Definition der Schnittstellenvariablen (ohne extern und mit Initialisierung): 

date epoch = {1, 1, 1970}; /* Start der Unix Zeitrechnung */ 

• Definition der Schnittstellen-Funktionen: 

void print_date(const date *d) 

{ 

printf("%d.%d.%d\n", d->day, d->month, d->year); 

} 

• private Deklarationen und Definitionen 

Typen, symbolische Konstanten, Makros, globale Variablen, Funktionen, 

die nur innerhalb der Übersetzungseinheit verwendet werden 

private globale Variablen und Funktionen werden mit static markiert 



ANSI-C Übersetzungseinheiten: Präprozessor-Anweisungen 

Der Präprozessor des C-Compilers 

nimmt vor der eigentlichen Übersetzung Textersetzungen vor. 

• Präprozessor-Anweisungen stehen in Zeilen, die mit # beginnen 

• eine #include-Anweisung muss immer verwendet werden, 

wenn in einer Datei (egal, ob Header- oder Implementierungs-Datei) 

ein Name aus einer anderen Übersetzungseinheit verwendet wird 

#include "Name.h" 

ersetzt der Präprozessor rekursiv durch den Inhalt von Name.h 

• #ifndef/#define/#endif-Anweisungen in allen Header-Dateien sorgen dafür, 

dass deren Inhalte auch bei verschachtelten #include-Anweisungen 

höchstens einmal in jede Implementierungs-Datei kopiert werden 

#ifndef NAME_H 

#define NAME_H 

... /* Inhalt der Header-Datei Name.h */ 

#endif 

if not defined : 

beim ersten #include ist 

NAME_H noch nicht definiert, 

ab dem zweiten #include wird 

der #ifndef-Block übersprungen 


Hochschule Konstanz

Beispiel-Programm Übersetzungseinheiten (1) 

Globale Variable als getrennte Übersetzungseinheit (siehe zum Vergleich Folie 4-10) 

• Header-Datei: 

/* global.h */ 

#ifndef GLOBAL_H 

#define GLOBAL_H 

extern int global; 

• Implementierungs-Datei: 

/* global.c */ 

#include "global.h" 

int global = 1; 

#endif 

#ifndef / #define / #endif 

verhindert mehrfaches Kopieren 

in dieselbe Implementierungs-Datei 

die Implementierungs-Datei 

einer Übersetzungseinheit enthält 

immer die eigene Header-Datei 




Funktion als getrennte Übersetzungseinheit (siehe zum Vergleich Folie 4-10) 


/* function.h */ 

#ifndef FUNCTION_H 

#define FUNCTION_H 

int function(int param); 

#endif 

die Funktion benutzt einen Namen 

aus der Übersetzungseinheit global 

(deshalb #include "global.h") 


/* function.c */ 

#include "function.h" 


int function(int param) 

{ 

static int private_global = 1; 

int local = param + 1; 

private_global++; 

global = param + 2; 

return local + private_global; 

} 


Hochschule Konstanz


Hauptprogramm als getrennte Übersetzungseinheit (siehe zum Vergleich Folie 4-10) 


entfällt 

das Hauptprogramm 

benutzt Namen aus den 

Übersetzungseinheiten 

function und global 


/* localglobalvar.c */ 

#include "function.h" 


int main() 

{ 

int local = 1; 

} 

local = function(local); /* local wird 2 */ 

global = function(local); /* global wird 3 */ 

local = function(global); /* local wird 4 */ 

return 0; 



ANSI-C Übersetzungseinheiten: Compiler und Linker-Aufrufe (1) 

Compiler/Linker-Aufrufe bei Programmen mit mehren Übersetzungseinheiten: 

• jede Übersetzungseinheit getrennt übersetzen: 

gcc -c –I. function.c 

gcc -c –I. global.c 

gcc -c –I. localglobalvar.c 

die Option -I. gibt an, dass die Header-Dateien 

im lokalen Verzeichnis zu suchen sind 

(mehrere Optionen -IVerzeichnisname möglich) 

• dann den Objektcode der Übersetzungseinheiten (Endung .o) 

zu einem ausführbaren Programm binden: 

gcc localglobalvar.o function.o global.o -o localglobalvar 

das ausführbare Programm nennt man üblicherweise so 

wie die Übersetzungseinheit mit dem Hauptprogramm main 


Hochschule Konstanz

ANSI-C Übersetzungseinheiten: Compiler und Linker-Aufrufe (2) 

Die Übersetzungsschritte im Einzelnen: 

Übersetzungssschritt Eingabe Ergebnis Aufruf 

Präprozessor 

function.c 

function.h 

global.h 

function.i gcc -E 

Compiler function.i function.s gcc -S 

Assembler function.s function.o gcc -c 

• üblicherweise alle Übersetzungsschritte mit einem Aufruf: 

gcc -c function.c 

die obigen Zwischenschritte sind aber manchmal bei der Fehlersuche hilfreich 



ANSI-C Übersetzungseinheiten: Bibliotheken 

Bibliotheken fassen mehrere Übersetzungseinheiten in einer Datei zusammen: 

• Statische Bibliothek (unter Linux Präfix lib und Endung .a für Archiv) 

ar rs libbeispiel.a function.o global.o 

Eine statische Bibliothek ist eine Sammlung von Objekt-Dateien. 

• Dynamische Bibliothek (unter Linux Präfix lib und Endung .so für Shared Object) 

gcc -shared function.o global.o -o libbeispiel.so 

Eine dynamische Bibliothek ist quasi ein gebundenes Programm ohne Hauptprogramm. 

Beim Binden ersparen Bibliotheken das Aufzählen aller Übersetzungseinheiten: 

gcc localglobalvar.o -L. –lbeispiel -o localglobalvar 

Mit -L wird das Verzeichnis und mit -l der Name ohne Präfix der Bibliothek angegeben. 

Eine statische Bibliothek wird nach dem Binden nicht mehr gebraucht. 

Eine dynamische Bibliothek muss zur Laufzeit des Programms zugreifbar sein 

(dazu Verzeichnis in der Umgebungsvariablen LD_LIBRARY_PATH angeben). 


Hochschule Konstanz

ANSI-C Programme: Deployment 

Archive fassen mehrere Dateien in einer Datei zusammen. 

Sie erleichtern das Deployment (Distribution von Programmen auf Zielrechner) 

• Linux-Beispiel: tar-Kommando 

tar czf beispiel.tar.gz localglobalvar libbeispiel.so 

erzeugt ein mit gzip komprimiertes Archiv beispiel.tar.gz, 

das die Dateien localglobalvar und libbeispiel.so enthält 

tar xzf beispiel.tar.gz 

extrahiert die im Archiv enthaltenen Dateien wieder 



ANSI-C Übersetzungseinheiten: Vergleich mit Java 

Bei den Übersetzungseinheiten unterscheiden sich ANSI-C und Java erheblich: 

• bei Java sind Klassen zugleich Übersetzungseinheiten 

da Methoden und Variablen immer in Klassen enthalten sind, kann der Compiler 

über den qualifizierten Klassennamen immer die richtige Übersetzungseinheit finden 

• bei ANSI-C ist der Name einer Übersetzungseinheit unabhängig vom Inhalt 

weil es weder Klassen noch Pakete gibt, kann der Compiler einem Namen nicht ansehen, 

in welcher Übersetzungseinheit er definiert ist 

deshalb ist eine Aufteilung in Header- und Implementierungs-Dateien notwendig, 

und die Header-Dateien müssen explizit in die Implementierungs-Dateien kopiert werden 

• static in ANSI-C entspricht eher private in Java 

static markierte Funktionen und globale Variablen 

sind nur innerhalb der Implementierungs-Datei zugreifbar, in der sie definiert sind 

static markierte Variablen innerhalb einer Funktionen (gibt es in Java nicht) 

haben die Lebensdauer einer globalen Variablen, 

sind aber nur innerhalb der Funktion zugreifbar 


Hochschule Konstanz

ANSI-C Standard-Bibliothek: Überblick 

Die Schnittstelle der Standard-Bibliothek ist (teilweise etwas beliebig) 

in diverse Header-Dateien aufgeteilt: 

• Grundlegendes zur Sprachunterstützung (NULL, size_t, malloc, calloc, free, ...) 

 

• Ein-/Ausgabe 

 

• Umgang mit Zeichen und Zeichenketten 

 

• Umgang mit Zahlen: 

 

• Umgang mit Datum und Zeit 

 

• Umgang mit Fehlern und Ausnahmesituationen 

 



ANSI-C Standard-Bibliothek: (1) 

• Speicherverwaltung: 

void* calloc(size_t n, size_t size); 

void* malloc(size_t size); 

Was tun die Funktionen? 

void free(void* p); 

void* realloc(void* p, size_t size); 

• Programmende und Interaktion mit der Ablaufumgebung: 

void abort(void); 

int atexit(void (*exit_handler)(void)); 

void exit(int status); /* status: EXIT_FAILURE oder EXIT_SUCCESS */ 

char* getenv(const char* name); /* Umgebungsvariable abfragen */ 

int system(const char* s); /* Kommando ausführen */ 

• Umwandlung von Zeichenketten in Zahlen, Zufallszahlen, etc.: 

double atof(const char* s); 

int atoi(const char* s); 

int rand(void); /* Zufallszahlengenerator */ 

void srand(unsigned int seed); /* Anfangswert für Zufallszahlen */ 

... 


Hochschule Konstanz

ANSI-C Standard-Bibliothek: (2) 

• Suchen und Sortieren: 

void *bsearch(const void* key, const void* p, size_t n, size_t size, 

int (*cmp)(const void*, const void*)); 

void qsort(void* p, size_t n, size_t size, 

int (*cmp)(const void*, const void*)); 

• Beispiel: 

#include /* damit bsearch und qsort bekannt sind */ 

int intcmp(const void ∗, const void ∗); /* Vergleichsfunktion */ 

... 

int a[4] = {40, 20, 10, 30}; 

int n = 50, *p; 

qsort(a, 4, sizeof (int), intcmp); /* sortiert a aufsteigend */ 

p = (int*) bsearch(&n, a, 4, sizeof (int), intcmp); /* sucht 50 in a */ 

Wie sieht die Implementierung von intcmp aus? 



ANSI-C Standard-Bibliothek: 

• Prüfen der Zeichenart (Ziffer, Buchstabe, Zwischenraum usw.): 

int isalnum(int c); 

int isalpha(int c); 

int iscntrl(int c); 

int isdigit(int c); 

int isgraph(int c); 

int islower(int c); 

int isprint(int c); 

int ispunct(int c); 

int isspace(int c); 

int isupper(int c); 

int isxdigit(int c); 

• Wandeln in Klein- / Großbuchstaben: 

int tolower(int c); 

int toupper(int c); 

• Beispiel: 

#include /* damit isdigit bekannt ist */ 

... 

if (isdigit('9')) printf("9 ist eine Ziffer\n"); 


Hochschule Konstanz


• Kopieren, Verarbeiten, Vergleichen von Zeichenketten: 

Beispiele siehe Teil 2 

• Vergleichen, Kopieren, Initialisieren usw. von Speicherbereichen: 

int memcmp(const void *cs, const void *ct, size_t n); 

void ∗memcpy(void ∗p1, const void ∗p2, size_t n); 

void ∗memset(void ∗p, int c, size_t n); 

... 

• Beispiel: 

#include /* damit memset und memcpy bekannt sind */ 

... 

int a[4]; 

int b[4]; 

memset(a, 0, sizeof a); /* initialisiert Speicherbereich von a mit 0 */ 

memcpy(b, a, sizeof a); /* kopiert Inhalt von von a nach b */ 




• Symbolische Konstanten für Zahlenbereich und Genauigkeit 

von Gleitkommazahlen () und ganzen Zahlen (): 

DBL_DIG 

Genauigkeit von double in Anzahl Dezimalstellen 

DBL_EPSILON kleinste double-Zahl x mit 1.0 + x != 1.0 

DBL_MAX 

größte double-Zahl 

DBL_MIN 

kleinste normalisierte double-Zahl 

... 

INT_MAX 

INT_MIN 

... 

größte int-Zahl 

kleineste int-Zahl 

• Mathematische Funktionen (): 

double sqrt(double x); Quadratwurzel 

double sin(double x); Sinus 

... 

• Beispiel: #include /* damit sqrt bekannt ist */ 

double d = sqrt(9.0); /* setzt d auf 3.0 */ 


Hochschule Konstanz

ANSI-C Programme: Empfehlungen 

• Getrennte Übersetzungseinheiten zur Modularisierung verwenden. 

Hauptprogramm als eigene Übersetzungseinheit ohne Header-Datei 

• Variablen-Definitionen immer so lokal wie möglich 

globale Variablen vermeiden 

• ANSI-C Standard-Bibliothek gegenüber Eigenimplementierungen bevorzugen: 

z.B. qsort verwenden, statt selbst ein Sortierverfahren zu programmieren 



ANSI-C Programme: Lernzettel 

#endif #ifndef #include Archiv argc argv Aufrufoperator binden Compiler 

dynamische Bibliothek extern frame pointer Funktion Funktionskopf 

Funktionsprototyp Funktionsrumpf Funktionszeiger gcc globale Variable 

Header-Datei Implementierungsdatei Linker lokale Variable main memcpy 

memset Parameter Präprozessor program counter qsort return Rückgabewert 

Seiteneffekt stack pointer Standardbibliothek static statische Bibliothek 

übersetzen Übersetzungseinheit 


Hochschule Konstanz


Teil 5: Werkzeuge 

Programmerstellung, Fehlersuche 



Programmierwerkzeuge 

Einsatzgebiete: 

• Erstellen von Programmen 

• Verwalten von Programmen 

• Prüfen von Programmen 

Nutzen: 

• Ermöglichung 

• Automatisierung 

• Optimierung 

• Qualitätssicherung 

Wie komme ich zu einem lauffähigen Programm? 

Woraus besteht ein gegebenes Programm und 

wann wurde was hinzugefügt / entfernt / geändert? 

Hat ein gegebenes Programm alle 

funktionalen und nicht funktionalen Eigenschaften, 

die von ihm erwartet werden? 

ein Vorgehen überhaupt erst möglich machen 

weniger Handarbeit 

weniger Aufwand 

weniger Mängel 


Hochschule Konstanz

Werkzeuge: Erstellen von Programmen (1) 

Was ist zu tun? 

• Bearbeiten von Quellcode 

Schreiben von neuem Quellcode 

Ändern von vorhandenem Quellcode 

• Transformieren von Quellcode in ausführbaren Code 

je nach Programmiersprache mehrere Transformationsschritte erforderlich 

bei aus vielen Teilen bestehenden Programmen 

Transformationsschritte pro Programmteil wiederholen 



Werkzeuge: Erstellen von Programmen (2) 

Wozu Werkzeuge? 

• Ermöglichung 

Werkzeug Texteditor unverzichtbar zum Bearbeiten von Quellcode (z.B. kwrite) 

Werkzeug Compiler unverzichtbar zur Transformation von Quellcode (z.B. gcc) 

• Automatisierung 

bei aus vielen Teilen bestehenden Programmen sehr viele Arbeitsschritte, 

die Arbeitsschritte automatisch veranlassen (z.B. mit Werkzeug make). 

• Optimierung 

bei Programmänderungen nur die notwendigen Arbeitsschritte durchführen, 

unnötige Arbeitsschritte automatisch weglassen (z.B. mit Werkzeug make) 

• Qualitätssicherung 

Mängel im Quellcode und bei Transformationsschritten entdecken / vermeiden 

(z.B. Formatierungsmängel beseitigen mit Werkzeug astyle). 


Hochschule Konstanz

Bearbeiten von Quellcode: Formatierung 

astyle – ein "Beautifier" für C / C++ / C# / Java-Quellcode 

Aufruf-Möglichkeiten: 

astyle [Optionen] Quelldatei ... 

ursprünglicher Code wird nach 

Quelldatei.orig gerettet. 

astyle [Optionen] < hässliche_Datei > verschönerte_Datei 

• Optionen: 

Festlegung des Formatierungsstils 

(Einrückung und Klammerung von Blöcken, Platzierung von Zwischenraum, ...): 

z.B. --style=ansi Einrückungs- und Klammerungsstil nach ANSI 

z.B. -p 

Leerstellen um Operatoren herum 

Festlegungen der Quellsprache (bei Aufruf mit Dateiumlenkung): 

z.B. –-mode=c 

• Funktionsweise: 

korrigiert die Formatierung in den angegebenen Quelldateien 



Bearbeiten von Quellcode: Suchen und Vergleichen 

Bearbeiten von Quellcode bedeutet vor allem korrigieren, ändern und erweitern. 

Dazu müssen die relevanten Stellen im vorhandenen Code gefunden werden. 

• Dateien suchen mit den Unix-Kommandos find und grep: 

find original/ -mtime 0 -name *.c -print 

liefert die Namen aller .c-Quelldateien im Verzeichnisbaum unter original/, 

die innerhalb der letzten 24 Stunden geändert wurden 

grep -rl "gruessen()" original/ 

liefert die Namen aller Dateien im Verzeichnisbaum unter original/, 

die die Zeichenkette gruessen() enthalten 

• Dateien und Dateibäume vergleichen mit dem Unix-Kommando diff: 

diff -rq original/ backup/ 

liefert die Namen aller Dateien, die sich inhaltlich unterscheiden 

oder nur in einem der beiden Verzeichnisbäume vorhanden sind 

diff original/hallo.c backup/hallo.c 

liefert alle Zeilen aus den beiden Dateien, die sich unterscheiden 


Hochschule Konstanz

Transformation von C-Quellcode: gcc 

gcc – der GNU Präprozessor / Compiler / Assembler / Linker für C 

• Aufruf: 

gcc [Option ...] Eingabedatei ... 

• Optionen: 

[-E|-S|-c] Transformationsschritte einschränken 

[-Dmacro[=definition] ...][-Umacro ...][-Idir ...] Präprozessor steuern 

[-std=standard][-pedantic][-Wwarn ...] "Strenge" des Compilers steuern 

[-g][-pg] Debuggen und Vermessen vorbereiten 

[-Olevel] Code-Optimierung steuern 

[-Ldir ...] [-lname ...] Linker steuern 

[-o outfile] Name der Ergebnisdatei angeben 

... insgesamt über 1000 Optionen, ca. 650 Seiten Dokumentation 

• empfohlene Optionen zur Qualitätssicherung des Quellcodes: 

-W -Wall -ansi -pedantic 

vor potenziellen 

Fehlern warnen 

Einhaltung des ANSI-C-Sprachstandards überwachen 



Übersetzungseinheiten: Beispiel 

Einfaches C-Programm mit zwei Übersetzungseinheiten: 

/* hallo.c */ 

#include "gruss.h" 

int main() 

{ 

gruessen(); 

return 0; 

} 

/* gruss.h */ 

#ifndef GRUSS_H 

#define GRUSS_H 

void gruessen(void); 

#endif 

/* gruss.c */ 

#include "gruss.h" 

#include 

void gruessen(void) 

{ 

printf("Hallo\n"); 

} 

• Global sichtbare Namen im Header-Datei (Endung .h) deklarieren. 

• Header-Datei per #include in die Implementierungs-Datei (Endung .c) kopieren. 


Hochschule Konstanz

Übersetzungseinheiten: Compiler und Linker-Aufrufe 

Compiler/Linker-Aufrufe bei Programmen mit mehren Übersetzungseinheiten: 

• jede Übersetzungseinheit getrennt übersetzen: 

gcc -c –I. hallo.c 

gcc -c –I. gruss.c 

Der Präprozessor kopiert gruss.h jeweils in hallo.c bzw. gruss.c hinein. 

Option(en) -I geben an, wo Header-Dateien anderer Übersetzungseinheiten liegen. 

• dann den Objektcode der Übersetzungseinheiten (Endung .o) binden: 

gcc hallo.o gruss.o -o hallo 

Das ausführbare Programm nennt man üblicherweise so wie die Übersetzungseinheit 

mit dem Hauptprogramm main. 



Transformation von Quellcode: Probleme 

Manueller Aufruf von Compiler und Linker zu aufwändig: 

• bei Programmen mit vielen Übersetzungseinheiten viele Aufrufe notwendig 

• eventuell viele Optionen pro Aufruf 

Manueller Aufruf von Compiler und Linker zu fehlerträchtig: 

• nach Programmänderungen Vergessen notwendiger Aufrufe 

• ungünstige oder falsche Optionen bei den Aufrufen 

Abhilfe durch 

Automatisierung 


Hochschule Konstanz

Automatisierung der Programmerstellung 

Kommando-Prozedur 

• zur Programmerstellung erforderliche Kommandofolge in eine Datei schreiben 

• die Datei ausführen, um die Kommandofolge zu wiederholen 

Auch nach kleinen Programmänderungen werden alle Kommandos ausgeführt. 

Das kann bei Programmen mit vielen Übersetzungseinheiten sehr lange dauern 

und im Fehlerfall unnötige Folgefehler produzieren. 

Build-Werkzeug 

• die Abhängigkeiten zwischen den zu erstellenden Endergebnissen, 

Zwischenergebnissen und Quellen sowie die erforderlichen Kommandos 

in einem Bauplan festhalten 

• für den Bauplan das Build-Werkzeug aufrufen, um Zwischen- und 

Endergebnisse inkrementell erstellen bzw. aktualisieren zu lassen 

Es werden immer nur die laut Bauplan erforderlichen Kommandos ausgeführt. 



Kommando-Prozedur: Linux Shell-Script (1) 

• eine Linux-Shell ist ein Programm, mit dem Benutzer Linux über Kommandos 

bedienen können (Kommandointerpretierer) 

Es gibt verschiedene Implementierungen, die wichtigsten unter Linux sind: 

sh 

bash 

Bourne Shell (für Kommando-Prozeduren üblich) 

Bourne Again Shell (Standard für die interaktive Benutzung) 

• ein Shell-Script ist eine Datei mit einer Folge von Linux-Kommandos: 

#!/bin/sh 

gcc -c hallo.c 

gcc -c gruss.c 


• Shell-Script ausführen: 

sh Dateiname 

./Dateiname 

bei der zweiten Variante muss bei der Datei 

das Ausführungsrecht gesetzt sein 


Hochschule Konstanz

Kommando-Prozedur: Linux Shell-Script (2) 

• die Bourne-Shell kennt auch Variablen, Verzweigungen und Schleifen: 

#!/bin/sh 

for s in hallo.c gruss.c ; do 

compile_command="gcc -c $s" # Variable mit Initialisierung 

echo $compile_command 

# Wert der Variablen ausgeben 

eval $compile_command 

if [ $? -ne 0 ] ; then 

echo build failed 

exit 1 

fi 

done 

link_command="gcc -o hallo hallo.o gruss.o" 

echo $link_command 

eval $link_command 

if [ $? -ne 0 ] ; then 

echo build failed 

exit 1 

fi 

echo build successful 

# Wert der Variablen als Kommando ausführen 

# Rückgabewert des Kommandos prüfen 



Build-Werkzeug: make 

make – das Build-Programm unter Linux (Unix, ...) 

Aufruf: 

make [-f Bauplan] [Ziel] ... 

• fehlt die Option –f Bauplan, wird makefile oder Makefile verwendet 

Üblicherweise wird der Bauplan Makefile genannt, 

in speziellen Fällen werden auch Dateinamen mit Endung .mak oder .mk verwendet 

• Ziel ist eine zu erstellende Datei oder der Name einer Regel 

fehlt das Ziel, wird das im Bauplan als erstes genannte Ziel bearbeitet, 

üblicherweise heißt das erste Ziel im Bauplan all 

• sind mehrere Ziele angegeben, werden diese nacheinander bearbeitet 


Hochschule Konstanz

make: Beispiel (1) 

• einfacher Bauplan für das Programm hallo: 

# Makefile 

hallo: hallo.o gruss.o 


hallo.o: hallo.c gruss.h 


gruss.o: gruss.c gruss.h 

gcc -c gruss.c 

Tabulator vor dem Kommando nicht vergessen 

• Aufruf zum Erstellen bzw. Aktualisieren des Programms: 

make -f Makefile hallo 

Abhängigkeit 

(hallo abhängig von zwei Objektdateien) 

Kommando 

(erzeugt hallo aus 

zwei Objektdateien) 

make # tut das gleiche, weil Makefile Standardname und hallo erstes Ziel ist 



make: Beispiel (2) 

Abhängigkeiten ( ) steuern das inkrementelle Erstellen ( ): 

• Aufruf nach Änderung von gruss.c 

hallo.o 

hallo 

gruss.o 

hallo.c 

gruss.h 

gruss.c 

hallo.o wird 

nicht neu erstellt, 

weil unabhängig 

von gruss.c 

• Aufruf nach Änderung von gruss.h 

hallo.o 

hallo 

gruss.o 

hallo.c 

gruss.h 

gruss.c 

alles wird 

neu erstellt, 

weil abhängig 

von gruss.h 


Hochschule Konstanz

Makefile: Regeln 

• explizite Regeln: 

Ziel 

abhängig von 

hallo.o: hallo.c 


Quelle 

• implizite Regeln: beziehen sich auf Dateiendungen 

Kommando (muss mit Tabulator eingerückt sein) 

Quelle 

etwas.c 

.c.o: 

gcc -c $< 

Ziel etwas.o 

$< ist die Quelle, 

auf die die Regel 

angewendet wird 

• Musterregeln: explizite Regeln mit Platzhalter % für beliebige Zeichenfolgen 

Ziel 

etwas.o 

%.o: %.c 

gcc -c $< 

Quelle etwas.c 

$< ist die Quelle, 

auf die die Regel 

angewendet wird 



Makefile: explizite Regeln (1) 

Ziel ...: Quelle ... 

Kommando 

... 

Anwendung auf Dateien: 

• Ziel ist eine Datei, die mit der Regel erzeugt wird. 

Meist ein Ziel pro Regel, es sind aber auch mehrere erlaubt. 

• Quelle ist eine Datei, die zum Erstellen des Ziels gebraucht wird. 

Keine, eine oder viele Quellen pro Regel. 

• Kommando ist ein Befehl, der Zieldatei(en) aus Quelldatei(en) erzeugt. 

Meist kein (→ Sonderformen) oder ein Kommando pro Regel, 

auch komplizierte Kommandos in Shell-Skript-Syntax möglich. 

Liefert ein Kommando einen Fehlerstatus, beendet sich make automatisch. 


Hochschule Konstanz


Sonderform Abhängigkeitsregel: 

• Eine Abhängigkeitsregel ist eine explizite Regel ohne Kommando: 

hallo.o: hallo.c gruss.h 

gruss.o: gruss.c gruss.h 

Abhängigkeitsregeln sind die in der Praxis 

am häufigsten verwendete Form 

der expliziten Regel 

• Abhängigkeitsregeln brauchen zur Ergänzung implizite oder Musterregeln, 

die die Kommandos festlegen, z.B.: 

%.o: %.c 

gcc -c $< 

• Abhängigkeitsregeln kann gcc automatisch aus den C-Quellen erzeugen, 

indem er die #include-Anweisungen auswertet: 

gcc -MM hallo.c gruss.c > depend 

schreibt die Regeln mittels Umlenkung der Standardausgabe in die Datei depend, 

die Datei depend kann dann per include in das Makefile integriert werden 




Sonderform mit Pseudoziel: 

• Ein Pseudoziel ist keine Datei, sondern ein beliebiger Name, 

der nur dazu dient, bestimmte Arbeitsschritte gezielt aufrufbar zu machen: 

make Pseudoziel 

• Aufzählung der Pseudoziele im Makefile mit einer .PHONY-Regel: 

.PHONY: all clean install uninstall 

Pseudoziele all, clean, install, uninstall 

haben sich als Quasistandard eingebürgert 

• Die all-Regel zählt alle Endergebnisse des Makefiles auf: 

all: hallo Die all-Regel sollte immer die erste Regel im Makefile sein! 

• Die clean-Regel löscht alle Zwischen- und Endergebnisse, 

die mit dem Pseudoziel all erzeugt werden: 

clean: 

rm -f hallo hallo.o gruss.o 


Hochschule Konstanz

Makefile: implizite Regeln (1) 

.Quellendung.Zielendung: 

Kommando 

Anwendung auf Dateitypen, wobei die Dateiendung den Typ bestimmt: 

• Alle Endungen müssen beim eingebauten Ziel .SUFFIXES genannt sein: 

.SUFFIXES: .c .o 

• .Quellendung legt den Dateityp der Quelle fest, den die Regel benötigt. 

Der Name der Quelle Name.Quellendung muss mit dem 

Namen der Zieldatei übereinstimmen, für die die Regel ausgeführt wird. 

• .Zielendung legt den Dateityp fest, auf den die Regel anwendbar ist. 

Die Regel wird für beliebige Zieldateien Name.Zielendung ausgeführt, 

falls es für die Datei keine explizite Regel mit Kommando gibt. 

• Kommando ist ein Befehl, der die Zieldatei aus der Quelldatei erzeugt. 



Makefile: implizite Regeln (2) 

make hat für die wichtigsten Dateitypen vordefinierte implizite Regeln, z.B.: 

• Übersetzen und binden eines C-Programms mit nur einer Quelldatei: 

Zielendung ist leer (ausführbare Programme unter Unix ohne Endung) 

.c: 

$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $< 

make hallo erzeugt aus hallo.c das ausführbare Programm hallo 

• Übersetzen einer C-Quelle: 

.c.o: 

$(CC) $(CFLAGS) $(CPPFLAGS) -c $< 

make hallo.o erzeugt aus hallo.c die Objektdatei hallo.o 

• Kommandos in vordefinierten Regeln sind mit Variablen definiert, 

um sie leicht an unterschiedliche Plattformen anpassen zu können: 

CC=gcc 

Präprozessor-Optionen (hier leer) 

CPPFLAGS= 

CFLAGS= 

Compiler-Optionen (hier leer) 

LDFLAGS= 

Linker-Optionen (hier leer) 


Hochschule Konstanz

Makefile: Musterregeln 

Zielmuster: Quellmuster 

Kommando 

Ziel- und Quellmuster enthalten % als Platzhalter für beliebige Zeichenkette: 

• Übersetzen und binden eines C-Programms mit nur einer Quelldatei: 

%: %.c 

$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $< 

z.B. ausführbares Programm hallo aus der C-Quelle hallo.c erzeugen 

• Übersetzen einer C-Quelle: 

%.o: %.c 

$(CC) $(CFLAGS) $(CPPFLAGS) -c $< 

z.B. Objektdatei hallo.o aus der C-Quelle hallo.c erzeugen 

• Musterregeln wurden als flexiblerer Ersatz für implizite Regeln eingeführt 



Makefile: Variablen (1) 

Mit Variablen können häufig wiederkehrende Bestandteile von Makefiles 

zusammengefasst und parametrisiert werden. 

• Variablendefinition: 

Variable = Wert 

oder mehrzeilig 

Variable üblicherweise in Großbuchstaben 

Wert ist eine beliebige Zeichenkette 

• Variablenbenutzung: 

$(Variable) 

$(Variable:suffix=ersetzung) 

Variable = \ 

Wert \ 

Fortsetzung 

Textersetzung von $(Variable) durch den Wert der Variablen 

bzw. durch den am Ende modifizierten Wert der Variablen. 

Wenn eine Variable nicht definiert ist, wird ihr Wert als leer angenommen. 

Rekursives Expandieren: enthält der Wert wiederum Variablenbenutzungen, 

wird darauf erneut die Textersetzung angewendet, usw. 

Zeilenwechsel 

müssen mit \ 

maskiert werden 


Hochschule Konstanz


Sonderfall automatische Variablen: 

• vordefinierte Variablen, die bei jeder Regelanwendung 

einen neuen Wert erhalten, z.B.: 

$@ Das Ziel, auf das die Regel gerade angewendet wird 

$< Die erste Quelle zum aktuellen Ziel 

$^ Alle Quellen zum aktuellen Ziel 

• die automatischen Variablen sind in impliziten Regeln und Musterregeln 

unentbehrlich, z.B.: 

.c: 

$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $< 

bzw. 

%: %.c 

$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $< 




Vordefinierte Variablen als Parametrierung eingebauter impliziter Regeln: 

• Kommandos sind in impliziten Regeln indirekt mit Variablen formuliert: 

$(KOMMANDO) Wert ist der zu verwendende Befehl 

$(KOMMANDOFLAGS) Wert ist zunächst leer 

Beispiele: 

CC=gcc 

der C-Compiler (mit Optionen $(CFLAGS)) 

RM=rm -f 

der Löschbefehl für Dateien 

• die Werte der Variablen können nach Bedarf überschrieben werden: 

in der Aufrufumgebung export CC="gcc -g" 

im Makefile CC = gcc -g 

beim Aufruf von make make "CC=gcc -g" 

Wert bei Aufruf überschreibt Wert in Makefile überschreibt Wert aus Aufrufumgebung 


Hochschule Konstanz

Makefile: Rekursion 

Große Softwaresysteme bestehen aus vielen Paketen, 

die Paket für Paket mit make erstellt werden müssen. 

• Pakethierarchie wird im Dateisystem als Verzeichnishierarchie abgebildet, 

z.B: 

Softwaresystem hallohallo 

hallohallo/ Makefile 

mit Paketen hallo und hallo2 

hallo/ Makefile hallo.c 

hallo2/ Makefile hallo.c gruss.h gruss.c 

• Makefile des Softwaresystems ruft make rekursiv für die Pakete auf: 

# Makefile fuer Softwaresystem hallohallo 

PACKAGES=hallo hallo2 

.PHONY: all clean 

all clean: 

for p in $(PACKAGES); do \ 

(cd $$p && $(MAKE) $@); \ 

done 



Makefile: C-Beispiel hallo (1) 

# Makefile 

# Kommando-Variablen 

CC = gcc 

CFLAGS = -W -Wall -ansi -pedantic 

CPPFLAGS = -I. 

RM = rm -f 

# Hilfsvariablen 

TARGET = hallo 

OBJECTS = gruss.o 

SOURCES = $(TARGET).c $(OBJECTS:.o=.c) 

HEADERS = $(OBJECTS:.o=.h) 

Variablen für die vordefinierten 

C-Übersetzungsregeln 

Include-Dateien im aktuellen Verzeichnis suchen 

die C-Übersetzungsregel ist vordefiniert und 

# Musterregeln 

braucht deshalb nicht angegeben zu werden 

%.o: %.c 

$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@ 

... 


Hochschule Konstanz

Makefile: C-Beispiel hallo (2) 

... 

# Standardziele 

Pseudoziele 

.PHONY: all clean 

all: $(TARGET) 

clean: 

$(RM) $(TARGET) $(TARGET).o $(OBJECTS) depend 

depend: $(SOURCES) $(HEADERS) 

$(CC) $(CPPFLAGS) -MM $(SOURCES) > $@ 

# Ziele zur Programmerstellung 

$(TARGET): $(TARGET).o $(OBJECTS) 

$(CC) $(CFLAGS) $(LDFLAGS) $^ -o $@ 

# Abhaengigkeiten 

include depend 



Makefile: Empfehlungen (1) 

Variablen: 

• für jedes in einer Regel verwendete Kommando eine Variable definieren 

bei komplexen Kommandos zusätzliche Variable für Optionen 

• für die Liste der Übersetzungseinheiten / Quelldateien Hilfsvariablen definieren 

• in Regeln, wo immer möglich, automatische Variablen verwenden 

Regeln: 

• wo immer möglich, Musterregeln statt expliziter Regeln verwenden 

• immer zumindest die Pseudoziele all und clean vorsehen 

all muss das erste Ziel im Makefile sein 

clean muss alles beseitigen, was all erzeugt 

• Abhängigkeitsregeln möglichst automatisch erzeugen 

mit einem Ziel depend eine gleichnamige Datei erzeugen und per include einbinden 


Hochschule Konstanz

Makefile: Empfehlungen (2) 

Vorgehen beim Erstellen: 

• mit der all-Regel beginnen 

all: Endergebnis 

Endergebnis ist die zu erstellende Datei 

(bei Bedarf auch mehrere Dateien) 

• für jede bei all als Endergebnis genannte Datei eine Regel erstellen, 

für jede darin als Zwischenergebnis genannte Datei wiederum eine Regel, 

usw. bis nur noch Abhängigkeiten von Quelldateien auftreten: 

Endergebnis: Zwischenergebnisse 

Kommando 

... 

Zwischenergebnis: Quelldateien 

Kommando 

• eine clean-Regel erstellen 

clean: 

$(RM) Endergebnis Zwischenergebnisse 

• mit Variablen und Musterregeln die mehrfache Wiederholung von Dateinamen 

und Kommandos verhindern 



Prüfen von Programmen: Fehlersuche (1) 

Einige wichtige Arten von Laufzeitfehlern: 

• Absturz 

unerwartetes Programmende, z.B. wegen Speicherzugriffsfehler 

• Endlosschleife 

das Programm scheint zu "hängen", aber es läuft und läuft und läuft ... 

• Speicherüberlauf 

der ganze Rechner wird langsam, 

weil das Programm sämtlichen Speicher belegt hat 

• Fehlverhalten 

das Programm tut nicht, was es tun soll, liefert z.B. falsche Ergebnisse 


Hochschule Konstanz

Prüfen von Programmen: Fehlersuche (2) 

Vorgehen bei der Suche von Laufzeitfehlern: 

• Fehler reproduzieren 

einen Testfall erstellen, bei dem der Fehler auftritt 

oft schwierig bei Programmen mit vielfachen Abhängigkeiten von der Umgebung 

(Benutzer, andere Programme, Zeit, Daten in Dateien oder Datenbanken, Netzwerk, ...) 

• Fehler isolieren 

mögliche Fehlerursachen schrittweise eingrenzen 

Hypothesen aufstellen und prüfen 

Programmteile gezielt weglassen oder abändern 

feststellen, ob ältere Programmversionen den Fehler auch zeigen 

schrittweises Ausführen im Debugger 



Fehlersuche: Debugger 

Debugger erlauben es, den Programmablauf zu beobachten und zu beeinflussen, 

ohne den Code dafür aufwändig und fehlerträchtig abzuändern. 

Funktionalitäten: 

• Programm kontrolliert ausführen 

Zeile für Zeile, bis Funktionsende, bis zum nächsten Haltepunkt, ... 

• Programm unter bestimmten Bedingungen anhalten lassen 

unbedingte und bedingte Haltepunkte ("Break-Points", "Watch-Points") 

• Zustand des angehaltenen Programms untersuchen 

Aufruf-Stack anzeigen, Speicherinhalte anzeigen, ... 

• Zustand des angehaltenen Programms verändern 

Speicherinhalte ändern, Anweisungen überspringen, ... 


Hochschule Konstanz

Debugger: Nutzen 

Mit einem Debugger lässt sich meist schnell klären: 

• wo ein Programm abstürzt 

Programm mit gleichen Eingaben im Debugger laufen lassen 

oder core-Datei untersuchen 

(Unix legt bei einem Programmabsturz den gesamten Programmzustand 

in einer Datei core ab, einzuschalten mit: ulimit -c unlimited ). 

• wo ein Programm eine Endlosschleife enthält 

Programm im Debugger unterbrechen 

oder Programm "abschießen" (kill -6 ...), um untersuchbare core-Datei zu erhalten 

• ob eine Hypothese zur Fehlerursache stimmt 

gezielt Haltepunkte setzen und Programmzustand analysieren 

die Hypothese selbst findet man nur durch Nachdenken! 



Debugger: ddd 

ddd – der GNU Data-Display-Debugger, eine graphische Benutzeroberfläche 

für den kommandozeilen-orientierten GNU-Debugger gdb. 

Aufruf: 

ddd Programm [Core-Datei | Prozessnummer] 

• Programm: 

Die volle Funktionalität des Debuggers steht nur zur Verfügung, 

wenn das Programm mit der gcc-Option -g übersetzt wurde. 

es wird dann Information in den Code eingebettet, die dem Debugger 

den Rückschluss von Adressen auf Variablen und Zeilen im Quellcode erlaubt. 

• Core-Datei: 

nur beim nachträglichen Untersuchen eines abgestürzten Programms 

("Post-Mortem-Debugging"). 

• Prozessnummer: 

zum nachträglichen Ankoppeln des Debuggers an ein laufendes Programm 


Hochschule Konstanz

Speicherfehler suchen: valgrind 

valgrind – ein Heapdebugger für x86-Linux 

Aufruf: 

valgrind [Optionen] Programm [Argumente] 

• Funktionsweise: 

interpretiert x86-Maschinencode (virtueller Prozessor) und 

führt dabei Buch über die Heapnutzung des Programms. 

Das Programm läuft dadurch wesentlich langsamer und braucht mehr Speicher. 

• Fehlererkennung: 

Lesezugriff auf nicht initialisierten Heapspeicher 

Lese- oder Schreibzugriff auf nicht reservierten Heapspeicher 

Feldgrenzen-Überschreitung für separat auf dem Heap allokierte Felder 

Speicherlecks (malloc/calloc ohne zugehöriges free) 

doppeltes Freigeben von reserviertem Speicher (mehrfaches free) 



Werkzeuge: Lernzettel 

$< $@ $^ Abhängigkeitsregel Absturz all astyle automatische Variable 

Breakpoint clean ddd Debugger diff Endlosschleife explizite Regel 

Fehlverhalten find gcc grep Heap-Debugger implizite Regel 

Kommandoprozedur make Makefile Musterregel Programmierwerkzeuge 

Pseudoziel Post-Mortem-Debugging shell-Script Speicherüberlauf valgrind 

Variable Watchpoint 


Hochschule Konstanz


Teil 6: Ein-/Ausgabe 

Dateizugriff, Elementare Ein-/Ausgabe 



ANSI-C Ein-/Ausgabe: (1) 

Bei den Ein-/Ausgabefunktionen der ANSI-C Standard-Bibliothek werden die 

Eingabe-Quellen und Ausgabe-Ziele mit einem FILE-Zeiger angegeben: 

• FILE ist ein (Alias-)Name für eine Struktur, 

die den Zustand einer Eingabe-Quelle bzw. eines Ausgabe-Ziels verwaltet 

zum Zustand gehören Puffer, Lese-/Schreibposition, aufgetretene Fehler, ... 

• vordefinierte globale Variablen für die Standard-Ein-/Ausgabe: 

extern FILE *stdin; 

Hinweis: stdin, stdout und stderr 

extern FILE *stdout; 

können auch Präprozessor -Makros sein 

extern FILE *stderr; 

• fopen liefert Zeiger auf weitere FILE-Objekte: 

FILE *fopen(const char *dateiname, char *mode); 

mode "r" für reinen Lesezugriff, "w" für reinen Schreibzugriff, ... 

• fclose schließt nicht mehr benötigte Eingabe-Quellen und Ausgabe-Ziele: 

int fclose(FILE *fp); 


Hochschule Konstanz


• Ein-/Ausgabe von Einzelzeichen: 

int fgetc(FILE *fp); 

liefert das nächste Zeichen (umgewandelt in int) oder EOF bei Eingabeende / Fehler 

int fputc(int c, FILE *fp); 

schreibt das Zeichen c und liefert c oder bei Fehler EOF 

... 

• Ein-/Ausgabe von Zeichenketten: 

char *fgets(char *s, int n, FILE *fp); 

liefert in s die nächsten maximal n - 1 Zeichen einer Zeile 

und gibt s zurück, bzw. NULL bei Eingabeende / Fehler 

int fputs(const char *s, FILE *fp); 

schreibt die Zeichenkette s und liefert nicht-negativen Wert bzw. bei Fehler EOF 

... 




• formatierte Ein-/Ausgabe: 

int fscanf(FILE *fp, const char *format, ...); 

versucht die in format genannten Lücken zu füllen 

und liefert die Anzahl der gefüllten Lücken oder EOF bei Eingabeende 

int fprintf(FILE *fp, const char *format, ...); 

schreibt die Zeichenkette format inklusive der mit Werten gefüllten Lücken 

und liefert die Anzahl der insgesamt geschriebenen Bytes oder bei Fehler EOF 

... 

• Ein-/Ausgabe von Binärdaten: 

size_t fread(void *p, size_t size, size_t n, FILE *fp); 

liefert in p maximal n Portionen von size Byte 

und gibt die Anzahl der tatsächliche gelesenen Portionen zurück 

size_t fwrite(const void *p, size_t size, size_t n, FILE *fp); 

schreibt maximal n Portionen von size Byte aus p 

und gibt die Anzahl der tatsächliche geschriebenen Portionen zurück 


Hochschule Konstanz


• Fehlerbehandlung: 

int feof(FILE *fp); 

liefert einen von 0 verschiedenen Wert, wenn das Eingabeende erreicht wurde 

int ferror(FILE *fp); 

liefert einen von 0 verschiedenen Wert, wenn ein Fehler aufgetreten ist 

void perror(const char *prefix); 

gibt prefix gefolgt von der Fehlermeldung des aktuellen Fehlers auf stderr aus 

void clearerr(FILE *fp); 

Setzt den Eingabeende- und Fehlerzustand zurück 



Beispiel-Programm 

#include /* fopen, fgetc, fclose */ 


{ 

FILE *fp; 

int i, n; 

Zählt die Zeichen in Dateien 

for (i = 1; i < argc; ++i) 

{ 

fp = fopen(argv[i], "r"); 

if (fp == NULL) ... /* Fehlerbehandlung */ 

n = 0; 

while (fgetc(fp) != EOF) ++n; 

printf("%s: %d Zeichen\n", argv[i], n); 

} 

fclose(fp); 

} 

return 0; 


Hochschule Konstanz

POSIX Ein-/Ausgabe: Übersicht 

POSIX (Portable Operating System Interface) 

ist ein Standard für die Programmierschnittstelle von Betriebssystemen. 

• der Standard legt C-Systemaufrufe und die zugehörigen Header-Dateien fest: 

über 80 Header-Dateien mit über 1000 Funktionen und Makros 

(dabei teilweise Überlappungen mit dem ANSI-C-Standard) 

Die meisten UNIX-Varianten und viele weitere Betriebssysteme 

halten sich ganz oder zumindest weitgehend an diesen Standard. 

• wichtige Header-Dateien im Zusammenhang mit Ein-/Ausgabe: 

und 

kein Schreibfehler! 

Umgang mit Dateien und Datenströmen (creat, open, read, write, close) 

und 

Umgang mit Verzeichnissen (stat, mkdir, opendir, readdir, closedir) 

 

Fehlerzustand und symbolische Namen für Fehlernummern (errno) 



POSIX Ein-/Ausgabe: Elementare Ein-/Ausgabe (1) 

Bei den elementaren Ein-/Ausgabefunktionen nach POSIX-Standard werden 

Eingabe-Quellen und Ausgabe-Ziele über einen Dateideskriptor angesprochen: 

• ein Dateideskriptor ist eine nicht-negative ganze Zahl 

bei der ANSI-C Ein-/Ausgabe in der FILE-Struktur gespeichert 

• vordefinierte Dateideskriptoren für die Standard-Ein-/Ausgabe: 

0 Standardeingabe 

1 Standardausgabe 

2 Standardfehlerausgabe 

• open liefert einen Dateideskriptor für eine Datei: 

int open(const char *dateiname, int flags); /* */ 

liefert den kleinsten nicht belegten Dateideskriptor oder bei Fehler -1 

• close schließt nicht mehr benötigte Eingabe-Quellen und Ausgabe-Ziele: 

int close(int fd); /* */ 

liefert 0 oder bei Fehler -1 


Hochschule Konstanz

POSIX Ein-/Ausgabe: Elementare Ein-/Ausgabe (2) 

• Ein-/Ausgabe von Bytes: 

ssize_t read(int fd, void *p, size_t n); /* */ 

liefert in p maximal n Byte und gibt die Anzahl der tatsächliche gelesenen Bytes zurück, 

0 bei Eingabeende, -1 bei Fehler 

ssize_t write(int fd, const void *p, size_t n); /* */ 

schreibt maximal n Byte aus p und gibt die Anzahl der tatsächliche geschriebenen Bytes 

oder bei Fehler -1 zurück 

ssize_t /* */ 

Aliasname für einen ganzzahligen Typ mit Vorzeichen (int oder long) 

• Fehlerbehandlung: 

extern int errno; /* , errno kann auch ein Makro sein */ 

POSIX-Funktionen weisen errno im Fehlerfall eine Fehlernummer ungleich 0 zu 

für die Fehlernummern sind symbolische Konstanten definiert 

(z.B: EACCES für fehlendes Zugriffsrecht auf eine Datei) 



Beispiel-Programm Dateien (1) 

#include /* fprintf */ 

#include /* strerror */ 

#include /* open, O_RDONLY, O_WRONLY, O_CREAT, O_EXCL */ 

#include /* mode_t, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH */ 

#include /* read, write */ 

#include /* errno */ 


{ 

mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; /* Zugriffsrechte */ 

int in, out; /* Dateideskriptoren */ 

int n; 

unsigned char byte; 

if (argc != 3) 

{ 

fprintf(stderr, "Aufruf: %s Quelle Ziel\n", argv[0]); 

return 1; 

} 

... 

Kopiert eine Datei 


Hochschule Konstanz

Beispiel-Programm Dateien (2) 

... 

in = open(argv[1], O_RDONLY); 

if (in == -1) ... /* Fehlerbehandlung */ 

out = open(argv[2], O_WRONLY | O_CREAT | O_EXCL, mode); 

if (out == -1) ... /* Fehlerbehandlung */ 

while (read(in, &byte, 1) > 0) 

{ 

n = write(out, &byte, 1); 

if (n != 1) ... /* Fehlerbehandlung */ 

} 

close(out); 

close(in); 

} 

return 0; 



POSIX Ein-/Ausgabe: Verzeichnisse 

Nach POSIX-Standard werden Verzeichnisse über DIR-Zeiger angesprochen: 

• opendir liefert einen DIR-Zeiger für ein Verzeichnis: 

DIR *opendir(const char *verzeichnisname); /* */ 

liefert NULL bei Fehler 

• closedir beendet den Verzeichniszugriff: 

int closedir(DIR *dirp); /* < dirent.h> */ 


• readdir liefert einen Zeiger auf den nächsten ungelesenen Verzeichniseintrag: 

struct dirent *readdir(DIR *dirp); /* < dirent.h> */ 

der Verzeichniseintrag enthält unter d_name einen Dateinamen 

liefert NULL bei Verzeichnisende oder Fehler 

• stat liefert Statusinformation zu einer Datei (Dateityp, Zugriffsrechte, ...): 

int stat(const char *dateiname, struct stat *buf); /* < sys/stat.h> */ 


Ausgabeparameter 


Hochschule Konstanz

Beispiel-Programm Verzeichnisse (1) 

#include /* fprintf, printf */ 

#include /* strerror */ 

Listet Verzeichnisse auf 

#include /* struct stat, S_IFMT, S_IFDIR */ 

#include /* DIR, struct dirent, opendir, readdir */ 

#include /* errno */ 


{ 

struct stat s; /* Dateistatus */ 

DIR *d; /* geoeffnetes Verzeichnis */ 

struct dirent *e; /* gelesener Verzeichniseintrag */ 

int i; 

... 



Beispiel-Programm Verzeichnisse (2) 

} 

... 

for (i = 1; i < argc; ++i) 

{ 

/* Datei vorhanden? */ 

if (stat(argv[i], &s) == -1) ... /* Fehlerbehandlung */ 

} 

/* Dateityp Verzeichnis? */ 

if ((s.st_mode & S_IFMT) != S_IFDIR) ... /* Fehlerbehandlung */ 

d = opendir(argv[i]); 

if (d == NULL) ... /* Fehlerbehandlung */ 

while ((e = readdir(d)) != NULL) 

{ 

printf("%s/%s\n", argv[i], e->d_name); 

} 

closedir(d); 

return 0; 

mit Präprozessor-Option 

-D_XOPEN_SOURCE 

übersetzen, damit 

S_IFMT und S_IFDIR 

definiert sind 


Hochschule Konstanz

ANSI-C Ein-/Ausgabe: Lernzettel 

 

clearerror close closedir Dateideskriptor DIR errno fclose feof ferror 

fgetc fgets FILE fopen fprintf fputs fread fscanf fwrite open opendir 

perror POSIX read readdir ssize_t stat stderr stdin stdout 

struct dirent struct stat write 


Hochschule Konstanz


Teil 7: Einführung in C++ 

Referenzen, Operator-Overloading, 

Namensräume, Klassen 



C++: Überblick 

C++ ist eine von Bjarne Stroustrup entwickelte Erweiterung von C: 

• Namensräume 

• Referenzen 

• Ausnahmebehandlung 

• Überladen von Funktionen und Operatoren 

• Klassen, Vererbung, Polymorphie, dynamische Bindung 

• Templates 

• objektorientierte und Template-basierte Erweiterungen der Standardbibliothek 

(u.a. Ein-/Ausgabe-Klassen, String-Klasse, Vector-Klasse) 


Hochschule Konstanz

C++ Ein-/Ausgabe: Streams und Operatoren 

In C++ dienen Stream-Objekte als Eingabe-Quellen und Ausgabe-Ziele. 

Ein-/Ausgabe-Anweisungen werden mit den Operatoren > formuliert: 

#include // std::cout, std::cin, std::hex, std::endl, operator 

int main() 

{ 

std::cout > zahl; 

std::cout

C++ Referenzen: Definition und Verwendung 

Eine Referenz definiert einen Aliasnamen für einen Speicherbereich. 



Typ &Aliasname = Name; // & kennzeichnet eine Referenz-Variable 

• Verwendung: 

als Parameter- und Rückgabetyp von Funktionen (insbesondere überladene Operatoren) 

der Compiler realisiert Referenz-Parameter mit Zeigern: 

void function(const int &n) 

{ 

int m = n; 

... 

} 

... 

int k = 1; 

function(k); 

void function(const int *n) 

{ 

int m = *n; 

... 

} 

... 

int k = 1; 

function(&k); 



C++ Operator-Overloading: Beispiel 

C++ erlaubt das Überladen von Operatoren für benutzerdefinierte Typen 

(wird unter anderem in der Ein-/Ausgabebibliothek verwendet). 

Beispiel: 

#include 

enum jahreszeit {fruehling, sommer, herbst, winter}; 

std::ostream& operator

C++ Namensräume: Syntax 

Namensräume (Namespaces) verringern das Risiko von Namenskonflikten: 

• Namensraum-Deklaration: 

namespace Namensraumname 

{ 

Deklarationen ... 

} 

namespace 

{ 

Deklarationen ... 

} 

• Qualifizierung von Namen mit Scope Resolution Operator: 

Namensraumname::EinName 

Java-Entsprechung: 

package Paketname; 

definiert neuen Namensraum oder 

erweitert bestehenden Namensraum 

um weitere Deklarationen 

unbenannter Namensraum macht Deklarationen 

für andere Übersetzungseinheit unsichtbar 

• mit Using-Direktive auch Kurzschreibweise ohne Namensraumname: 

using namespace Namensraumname; 

Java-Entsprechung: 

EinName 

import Paketname.*; 



Beispiel-Programm Namensraum 

• Übersetzungseinheit Month 

(besteht nur aus Header-Datei): 

// Month.h 

#ifndef MONTH_H 

#define MONTH_H 

namespace htwg 

{ 

enum Month 

{ 

jan = 1, feb, mar, 

apr, may, jun, 

jul, aug, sep, 

oct, nov, dec 

}; 

} 

#endif 

• Hauptprogramm 

(besteht nur aus Implementierungs-Datei): 

// enumvar.cpp 

#include "Month.h" 

using namespace htwg; 

#include 

using namespace std; 

int main() 

{ 

Month m = htwg::oct; 

} 

cout

C++ Klassen: Eigenschaften 

C++Klassen fassen die C-Konzepte Struktur (struct) und Funktion zusammen 

• eine Klasse ist ein Bauplan für Objekte: 

die Klasse legt fest, welche Daten ihre Objekte enthalten 

und welche Funktionen Zugriff auf diese Daten haben (Kapselung). 

Die Daten heißen auch Attribute, Member-Daten oder Instanzvariablen. 

Die Funktionen heißen auch Operationen, Methoden oder Member-Funktionen. 

Zu den Funktionen zählen auch die Konstruktoren und der Destruktor. 

• jede Klasse hat mindestens einen Konstruktor: 

jedes neue Objekt wird garantiert mit einem Konstruktor-Aufruf intialisiert 

• jede Klasse hat genau einen Destruktor: 

bei jedem Objekt wird vor seiner Zerstörung (= Freigabe des Speichers) 

garantiert als letztes der Destruktor aufgerufen. 

Der Destruktor muss allen Speicher frei geben, der innerhalb der Klasse zusätzlich für das 

betreffende Objekt allokiert worden ist. 



C++ Klassen: Syntax (1) 

• Klassen-Deklaration (meist in einer Header-Datei Klassenname.h ): 

class Klassenname 

{ 

public: 

Klassenname(); 

// Default-Konstruktor 

~Klassenname(); 

// Destruktor 

Klassenname(const Klassenname&); 

// Copy-Konstruktor 

Klassenname& operator=(const Klassenname&); // Zuweisungsoperator 

Rückgabetyp_1 Methode_1(...); 

... 

Rückgabetyp_N Methode_N(...); 

private: 

Datentyp_1 Instanzvariable_1; 

... 

Datentyp_M Instanzvariable_M; 

}; 

Copy-Konstruktor, Destruktor, 

Zuweisungsoperator und 

eventuell den Default-Konstruktor 

ergänzt automatisch der Compiler, 

wenn sie fehlen 


Hochschule Konstanz


• Methoden-Definitionen (meist in Implementierungsdatei-Datei Klassenname.cpp ): 

vor den Methodennamen muss Klassenname:: stehen 

Rückgabetyp_1 Klassenname::Methode_1(...) 

{ 

... // Rumpf 

} 

... 

• die Funktionen einer Klasse haben implizit einen zusätzlichen Parameter this: 

Klassenname ∗ const this // konstanter Zeiger auf das Objekt des Aufrufs 

• Zugriff auf die private Instanzvariablen über this: 

this->Instanzvariable_1 // Kurzschreibeweise ohne this-> möglich 




• Objekt-Erzeugung 

durch Variablen-Definition mit Klasse als Typ: 

Klassenname Objektname; 

oder per Operator new auf dem Heap: 

Klassenname ∗Objektzeiger = new Klassenname; 

• Objekt-Benutzung: 

Aufruf der öffentlichen Funktionen der zugehörigen Klasse 

mit Komponentenauswahl- und Methodenaufruf-Operator 

Objektname.Methode_1(...) 

Objektzeiger–>Methode_1(...) 

der Compiler wandelt die obigen Schreibweisen in einfache Funktionsaufrufe 

mit erstem Argument zum Initialisieren von this: 

Klassenname::Methode_1(&Objektname, ...) 

Klassenname::Methode_1(Objektzeiger, ...) 


Hochschule Konstanz

C++ Klassen: Konstruktoren (1) 

Konstruktoren sind diejenigen Funktionen einer Klasse, die Objekte initialisieren. 

• ein Konstruktor hat als Name den Klassennamen und hat keinen Rückgabetyp 

eine Klasse darf mehrere Konstruktoren haben, wenn sie unterschiedliche Parameter haben 

• ein parameterloser Konstruktor wird als Default-Konstruktor bezeichnet: 

Klassenname() 

wird eine Klasse ganz ohne Konstruktoren deklariert, 

erzeugt der Compiler implizit einen Default-Konstruktor, 

der für alle Instanzvariablen mit Klassen-Typ deren Default-Konstruktor aufruft 

• ein Konstruktor mit genau einem Parameter 

vom Typ konstante Referenz der Klasse wird als Copy-Konstruktor bezeichnet: 

Klassenname(const Klassenname &) 

initialisiert neues Objekt als Kopie eines bestehenden Objekts 

wird eine Klasse ohne Copy-Konstruktor deklariert, 

erzeugt der Compiler implizit einen, der die Daten komponentenweise kopiert 




Für Konstruktor-Implementierungen gibt es zwei Stile: 

• Initialisierungsliste im Methodenkopf (bevorzugter Stil) 

Klassenname::Klassenname() 

: Instanzvariable_1(Wert_1), ..., Instanzvariable_M(Wert_M) 

{ ... } 

• Zuweisungen im Methodenrumpf (funktioniert nicht bei const-Variablen) 

Klassenname::Klassenname() 

{ 

Instanzvariable_1 = Wert_1; 

... 

Instanzvariable_M = Wert_M; 

} 

• Konstruktoren sollten unbedingt eine Ausnahme werfen, 

wenn sie ein Objekt nicht konsistent initialisieren können 


Hochschule Konstanz


Ein Konstruktor-Aufruf findet automatisch statt 

• beim Gültigwerden einer Variablen mit Klassen-Typ: 

Klassenname objektname; 


Klassenname objektname(einArgument); // Konstruktor mit Parameter 

Klassenname objektname = anderesObjekt; // Copy-Konstruktor 

globale Variablen sind gültig von Programmstart bis -ende 

lokale Variablen sind gültig vom Durchlaufen ihrer Definition 

bis zum Verlassen des umschließenden Anweisungsblocks 

• bei new mit einem Klassen-Typ: 

Klassenname ∗objektzeiger = new Klassenname; 

Klassenname ∗objektzeiger = new Klassenname(einArgument); 

• bei Wertparameter-Übergabe und Wert-Rückgabe von Funktions-Aufrufen: 

aFunction(objektname); 

return objektname; 



C++ Klassen: Destruktoren 

Ein Destruktor ist diejenige Funktion einer Klasse, 

die Objekte vor ihrer Zerstörung (Speicherfreigabe) aufräumt. 

• ein Destruktor hat als Name den Klassen-Namen mit vorangestellter Tilde 

und hat weder Parameter noch einen Rückgabetyp: 

~Klassenname() 

jede Klasse hat genau einen Destruktor 

wird eine Klasse ohne Destruktor deklariert, erzeugt der Compiler implizit einen Destruktor, 

der für alle Instanzvariablen mit Klassen-Typ deren Destruktor aufruft 

Ein Destruktor-Aufruf findet automatisch statt 

• beim Ungültigwerden einer Variablen mit Klassen-Typ: 

{ 

Klassenname objektname; 

... 

} // objektname wird ungültig 

• jedem delete für einen Zeiger mit Klassen-Typ: 

delete objektzeiger; 


Hochschule Konstanz

Beispiel-Programm Klasse (1) 

• Quellcode Klassendeklaration (Date.h): 

class Date 

{ 

public: 

Date(); 


Date(int d, int m, int y); // Konstruktor mit Parametern 

Date(const Date &d); 

// Copy-Konstruktor 

~Date(); 

Date &operator=(const Date &d); 

void print() const; 

private: 

int day; 

int month; 

int year; 

}; 

// Destruktor 




• Quellcode Objektbenutzung: 

#include "Date.h" 

#include // std::cerr ... 

#include // std::invalid_argument 

int main() 

{ 

try { 

Date d1; 

// Aufruf Default-Konstruktor 

Date d2(1, 9, 2000); // Aufruf Konstruktor mit Parametern 

Date d3 = d1; 

// Aufruf Copy-Konstruktor: Date d3(d1); 

d3 = d2; 

// Aufruf Zuweisungsoperator: d3.operator=(d2); 

d3.print(); 

// Aufruf Date::print 

} // Destruktor-Aufrufe: d3.~Date(); d2.~Date(); d1.~Date(); 

catch (std::invalid_argument &) { 

std::cerr


• Quellcode Konstruktoren (Date.cpp): 

Date::Date() // heimlicher Parameter: Date * const this 

{ 

std::time_t t = std::time(0); 

std::tm ∗p = std::localtime(&t); 

} 

this->day = p->tm_mday 

this->month = p->tm_mon + 1; 

this->year = p->tm_year + 1900; 

Date::Date(int d, int m, int y) 

: day(d), month(m), year(y) 

{ 

if (d < 1 || d > 31 || m < 1 || m > 12) throw std::invalid_argument(); 

} 

Date::Date(const Date &d) 

: day(d.day), month(d.month), year(d.year) 

{ } 

Objekt werfen, 

nicht Objektadresse, 

deshalb ohne new 

diese Implementierungen 

des Copy-Konstruktors 

würde der Compiler auch 

automatisch erzeugen 




• Quellcode Destruktor, Zuweisung und Zugriffsfunktion (Date.cpp): 

Date::~Date() 

{ /∗ nichts zu tun ∗/ } 

Date& Date::operator=(const Date &d) 

{ 

if (this != &d) { // keine Selbstzuweisung? 

this->day = d.day; 

this->month = d.month; 

this->year = d.year; 

} 

return ∗this; 

} 

diese Implementierungen von 

Destruktor und Zuweisung 

würde der Compiler auch 

automatisch erzeugen 

void Date::print() const 

{ 

std::cout year 

C++ Klassen: Standard-Bibliothek (1) 

Ausschnitt aus der Klasse string (nach ISO-Standard noch komplizierter): 

class string 

{ 

public: 

string(); 

// Konstruktoren 

string(const string& str) ; 

string(const char ∗s); 

~string(); 

// Destruktor 

}; 

string& operator=(const string& str); // Zuweisungen 

string& operator=(const char ∗s ); 

string& operator+=(const string& str); 

string& operator+=(const char ∗s); 

const char ∗c_str() const; 

unsigned length() const; 

// Datenabfragen 

const char& operator[](unsigned pos) const ; 

char& operator[](unsigned pos); 

... 




Operatoren außerhalb der Klasse string (nach ISO-Standard noch komplizierter): 

// Verknüpfungen 

string operator+(const string& s1, const string& s2); 

... 

// Vergleiche 

bool operator==( const string & s1 , const string& s2 ); 

... 

// Ein-/Ausgabe 

istream& operator>>(istream& is, string& s); 

ostream& operator buffer; // Risiko eines Pufferüberlaufs 

std::string s; 

std::cin >> s; 

// string-Objekt und operator>> sorgen für genug Speicher 


Hochschule Konstanz


Ausschnitt aus der Template-Klasse vector (nach ISO-Standard noch komplizierter): 

template class vector 

{ 

public: 

Template-Parameter 

vector(); 

vector(unsigned n, const T& value = T()); 

vector(const vector& v); 

~vector(); 

vector& operator=(const vector& v); 

unsigned size() const; 

void resize(unsigned n, T c = T()); 

T& operator[](unsigned i); 

T& at(unsigned i); 

... 

}; 

template 

bool operator==(const vector& v, const vector& w); 

... 




• zu fast jedem Typ kann ein Vektortyp abgeleitet werden: 

#include // damit std::vector bekannt ist 

// Vektor von vier ganzen Zahlen, alle mit 0 initialisiert: 

std::vector iv(4); 

// Vektor von zwei Strings, mit Leerstrings initialisiert: 

std::vector sv(2); 

• ein Vektor kennt im Gegensatz zum Feld seine Länge: 

for (int i = 0; i < iv.size(); i++) ... 

• Vektorzugriff per [] ohne oder per .at() mit Indexprüfung: 

iv[2] = 1; // std::vector::operator[](&iv, 2) = 1; 

iv.at(2) = 1; // std::vector::at(&iv, 2) = 1; 

• ein Vektor kann im Gegensatz zum Feld 

per Zuweisungs-Operator kopiert und per Vergleichsoperatoren verglichen werden 


Hochschule Konstanz

Beispiel-Programm: std::string 

#include 

#include 

int main() 

{ 

std::string a = "halli"; // a("halli") 

std::string s = "hallo"; // s("hallo") 

std::string t; // leerer String 

// compare, copy and concatenate strings 

if (a < s) // operator

C++ Vererbung: Syntax 

• Unterklassen-Deklaration: 

class Unterklassenname : public Oberklassenname 

{ 

public: 

// zusätzliche und überschriebene Methoden ... 

private: 

// zusätzliche Daten ... 

}; 

• Definition von Unterklassen-Konstruktoren: 

bei einer public-Ableitung 

sind alle öffentlichen Methoden 

der Oberklasse auch in der 

Unterklasse öffentlich 

(entspricht Java extends) 

Unterklassenname::Unterklassenname() 

: Oberklassenname() 

{ 

in der Initialisierungsliste muss ein 

... 

} 

Oberklassen-Konstruktor aufgerufen werden 

(fehlt der Aufruf, ergänzt der Compiler 

einen Aufruf des Oberklassen-Defaultkonstruktors) 

(entspricht Java super() ) 



C++ Vererbung: Polymorphie und dynamische Bindung 

• nur Variablen vom Typ Zeiger auf Klasse oder Klassenreferenz 

können in C++ polymorph sein: 

Klassenname *Objektzeiger; 

Klassenname &Objektreferenz; 

• nur Methoden, die virtual markiert sind, 

können mit dynamischer Bindung aufgerufen werden: 

class Klassenname 

{ 

... 

}; 

virtual Rückgabetyp Methode(...); 

... 

erlauben auch Umgang mit 

Objekten einer Unterklasse 

zu Instanzmethoden ohne virtual gibt es in Java keine Entsprechung 


Hochschule Konstanz

C++ Vererbung: Schnittstellen (1) 

C++ macht leider keinen prinzipiellen Unterschied 

zwischen Klassen und Schnittstellen (beides class). 

• Schnittstellen-Deklaration: 

class Schnittstellenname 

{ 

public: 

virtual ~Schnittstellenname() { } 

}; 

virtual Rückgabetyp1 Methode1(...) = 0; 

... 

virtual RückgabetypN MethodeN(...) = 0; 

entspricht Java 

interface 

der Destruktor und die Methoden müssen public und virtual deklariert sein 

(nur virtual-Methoden werden mit dynamischer Bindung aufgerufen) 


der Destruktor muss eine leere Implementierung haben: { } 

abstract 

die Methoden haben keine Implementierung (pure virtual function): = 0 



C++ Vererbung: Schnittstellen (2) 

• Schnittstellen implementiert man per Vererbung mit abgeleiteten Klassen: 

class Klassenname : public virtual Schnittstellenname 

{ 

public: 

// Konstruktoren, Destruktor usw. nach Bedarf 

Rückgabetyp1 Methode1( ... ); 

... 

RückgabetypN MethodeN( ... ); 

private: 

... 

}; 


implements 

die Klassen-Deklaration wiederholt alle Methodensignaturen der Schnittstelle ohne = 0, 

wobei der Zusatz virtual fehlen darf 


Hochschule Konstanz

Beispiel-Programm Schnittstelle (1) 

• Quellcode Schnittstellendeklaration (Date.h): 

class Date 

{ 

public: 

virtual ~Date() { } 

virtual void get(int *d, int *m, int *y) const = 0; 

}; 

• Implementierungsdatei (Date.cpp) entfällt 




• Quellcode Implementierungsklasse (CurrentDate.h): 

class CurrentDate : public virtual Date 

{ 

public: 

void get(int *d, int *m, int *y) const; 

}; 

• Quellcode weitere Implementierungsklasse (FixedDate.h): 

class FixedDate : public virtual Date 

{ 

public: 

FixedDate(int d, int m, int y); 

void get(int *d, int *m, int *y) const; 

private: 

const int day; 

const int month; 

const int year; 

}; 


Hochschule Konstanz


• Quellcode Implementierungsklasse (CurrentDate.cpp): 

#include "CurrentDate.h" 

#include 

void CurrentDate::get(int *d, int *m, int *y) const 

{ 

std::time_t t = std::time(0); 

std::tm *p = std::localtime(&t); 

} 

*d = p->tm_mday; 

*m = p->tm_mon + 1; 

*y = p->tm_year + 1900; 




• Quellcode Implementierungsklasse (FixedDate.cpp): 

#include "FixedDate.h" 

#include 

FixedDate::FixedDate(int d, int m, int y) 

: day(d), month(m), year(y) 

{ 

if (d < 1 || d > 31 || m < 1 || m > 12) 

{ 

throw std::invalid_argument("Falsches Datum"); 

} 

} 

void FixedDate::get(int *d, int *m, int *y) const 

{ 

*d = day; 

*m = month; 

*y = year; 

} 


Hochschule Konstanz


• Quellcode Objektbenutzung: 

#include "CurrentDate.h" 

#include "FixedDate.h" 

#include 

#include 

void printDate(Date *d) 

{ 

int day; 

int month; 

int year; 

} 

... 

Polymorphie 

dynamische 

Bindung 

d->get(&day, &month, &year); 

std::cout

C++: Lernzettel 

C++ class Copy-Konstruktor Default-Konstruktor delete delete[] 

Destruktor Initialisierungsliste Klassendeklaration Methodendefinition 

Namensraum namespace new Operator-Overloading operator> private: public: pure virtual function Referenz 

Schnittstellendeklaration std::cin std::cout std::string std::vector Stream 

Unterklassendeklaration using virtual 


Hochschule Konstanz

Systemprogrammierung Teil 1: Einführung

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?