Skript Programmierung C/C++

private Vorlesungsmitschrift (nicht offiziell) 

Programmieren in C / C++ 

Kurs WS1999 – SS2001, Prof. F. Mehner 

Fachhochschule Südwestfalen 

- Campus Iserlohn - 

Frauenstuhlweg 31 

58644 Iserlohn 

Dieses Skript wurde in der Vorlesung „Programmieren in C/C++“ bei Prof. Mehner von mir 

getippt; der Inhalt wurde nicht durch Professoren geprüft und enthält ggf. einige syntaktische 

Fehler. Fehler, die Sie entdecken, teilen Sie mir bitte einfach per Kontaktformular auf 

www.ChristianSchlueter.de mit. Danke im Voraus, 

Christian Schlüter 

Stand: 2003-07-10 

1

Inhaltsverzeichnis 

Seite 

Kap. Inhalt, Titel 

1 .................. -- Deckblatt 

2 .................. -- Inhaltsverzeichnis 

3 .................. 01 Schnellkurs C 

11 .................. 02 Syntaxregeln und Operatoren 

14 .................. 03 Datentypen und Wertebereiche 

20 .................. 05 Funktionen 

29 .................. 06 Zeiger und Felder 

34 .................. 07 #define-Makros 

35 .................. 08 Vereinbarungen, Zugriffe, Strukturen 

38 .................. 09 C++ / nicht-objektorientierte Erweiterungen 

41 .................. 10 Klassen 

46 .................. 11 Überladen von Operatoren 

48 .................. 12 Statische Objekte 

49 .................. 13 Vererbung 

54 .................. 14 Templates (Schablonen) 

61 .................. 15 Programmerzeugung mit "make" 

63 .................. 16 GUI – grafische Benutzeroberflächen 

66 .................. 17 Error Handler und Exceptions 

2

Kapitel 1 – Die Programmiersprache C (Schnellkurs) 

1.1) Programmentwicklungsschritte 

(Folie F1 und F2 aus dem Internet holen) 

1.2) Textausgabe 

#include 

void main () 

{ 

printf („\hHallo, Welt \n“); 

} 

Erläuterungen 

Zeile 1: 

Zeile 2: 

Zeile 3+5: 

Präprozessor kopiert die Datei stdio.h ein 

Kopf des Hauptprogramms 

Beginn, Ende Hauptprogramm 

Anmerkung: stdio.h ist eine bereits bestehende Bibliothek für Standard-Input-Output und wird 

vor der Übersetzung aus dem System (hier Linux) einkopiert. 

Anmerkung: Der Slash „\“ in einer Textausgabe hat verschiedene Funktionen, die jeweils vom 

folgenden Buchstaben abhängen: 

n new line, Neue Zeile 

t tabulator, Tabulator 

b backspace, Rücksetzen 

a alert, Signalton 

\\ Zeichen „\“ 

Der Slash ist ein Fluchtsymbol bzw. der Beginn eines Steuerzeichens 

#include 

void main () 

{ 

int x,i; 

} 

for (i=0; i

} 

celsius = (5.0 / 9.0) * (fahrenheit – 32.0); 

printf („\n %lf °F = %lf °C \n“, fahrenheit, celsius); 

Anmerkung: 

In Zeile 6 des Programms muss bei der Division „.0“ hinter den Zahlen stehen (reelle Konstanten), da 

die Zahlen sonst als ganze Zahlen angesehen werden, so dass ein ganzzahliges Ergebnis erzwungen 

wird. Im Fall 5/9 hieße das, dass das Ergebnis 0 heisst, weil 9 = 0 Mal in 5 passt. Das gewünschte 

Ergebnis müsste 0.555 (Periode 5) heissen. 

In diesem Fall schneidet C einfach eine Stelle ab, weil der Speicherplatz beschränkt ist. Nach 15 

Stellen hinter dem Komma wird grundsätzlich standardmäßig abgeschnitten. Bei anderen 

Programmen kann gerundet oder ebenfalls geschnitten wird. 

double Datentyp; reele Zahl, doppelt genau 

printf („\n %lf °F = %lf °C \n“, fahrenheit, celsius); 

Auch das Prozentzeichen dient als Fluchtsymbol und korrespondiert mit den nachstehenden Werten 

der Variablen. In diesem Fall bezieht sich das erste %lf auf die Variable „fahrenheit“, die letzte auf 

„celsius“ 

Laut Professor Mehner ist... 

%lf eine Formatbeschreibung für double-Größen 

%f (flout), reelle Zahl, einfach genau 

%d int (Integer), ganze Zahl 

%15.5lf Formatierungsanweisung, die sich wie folgt aufbaut: 

% Gesamtstellen.Nachkommastellen lf 

1.4) Die Präprozessor-Anweisungen include und define 

Der Präprozessor ist der erste Teil eines Compilers, der über den Quellcode geht und 

Ersetzungen durchführt. 

include-Anweisung 

#include 

Die Standard-Header-Datei stdio.h wird an Stelle dieser Zeile vollständig 

einkopiert 

#include „projekt41.h“ 

Eigene Header-Datei im augenblicklich gültigen Arbeitsverzeichnis 

define-Anweisung 

#define Originaltext Ersetzungstext 

Beispiel: #define N 50 

#define PI 3.1415 

# define PI2 (2.0*PI) 

# define NL printf(„\n“) 

Anmerkung: 

Problem, dass auch Buchstaben in Anweisungen ersetzt würden, denn es 

erfolgt keine Überprüfung – deshalb sparsam gebrauchen!!! 

1.5) Einfache Ein- und Ausgabe 

4

Ausgabe: printf formatierte Ausgabe 

Beispiel: 

printf („x =%6.1lf,wi=w%lf%“,x,i); 

Aufbau der Teilformate: siehe Folie (F-3) 

Eingabe: 

Beispiel: 

scanf (Format, Variablenliste); 

ganze Zahl einlesen 

int i; 

printf („\n i = „); 

scanf („%d“, &i); 

Anmerkung: Das & ist ein sogenannter Adressoperator. Er ermöglicht den Schreibzugriff 

auf eine Variable. 

1.6) Ablaufsteuerung: while, for, if - else 

Bsp.: 

Temperaturrechnung 

°F -> °C 

2spaltige Tabelle 

Fahrenheit 0° bis 300° 

Schrittweite 20° 

#include 

void main() 

{ 

double fahrenheit, celsius; 

int unten, oben, schritt; 

unten = 0; 

oben = 300; 

schritt = 20; 

fahrenheit = unten; 

} 

while (fahrenheit < oben) 

{ 

celsius = (5./9.)*fahrenheit-32.0); 

printf("\n%5.0lf\t%5.1lf",fahrenheit,celsius 

); 

fahrenheit = fahrenheit + schritt; 

} 

while-Schleife 

for-Schleife 

if-Schleife 

1.7) Einfache Funktionen 

Mathematisch: y(x) = f(x) = x 2 – 27 + 3x 

x ist die unabhängige Variable 

5

Der nachstehende Term hinter f(x)= ist Berechnungsvorschrift 

Die gesamte Zeile wird Definition genannt 

y(3.3) = f(3.3)=... 

ist die Verwendung. 

Beispiel: °C = 5/9 (°F – 32) 

# include 

double celsius (double fahrenheit) 

{ 

double erg; 

erg (5.0/9.0)*(fahrenheit – 32); 

return erg; 

} 

//Def. der Fkt celsius, Kopf 

//Rumpf 

//Rumpf 

//Rumpf 

void main () 

{ 

double fahr, cels; 

int unten, oben, schritt; 

unten = 0; 

oben = 300; 

schritt = 20; 

} 

for (fahr=unten; fahr

Bsp.: 

Feld mit Quadratzahlen belegen 

#include 

#define N 100 

void main () 

{ 

int q[N], i, n; 

n=N; 

for(i=0; i

for (i=0; text[i] != '\O'; i=i+1) 

putchar (text [i]); 

summgr = 0; 

summkl = 0; 

/* Text untersuchen */ 

for (i=0; text [i] != '\O'; i=i+1) 

if (islower (text[i])) summkl = summkl + 1; 

if (isupper (text[i])) summgr = summgr + 1; 

/* Ergebnisse ausgeben */ 

} 

printf("\n %d Kleinbuchstaben, %d Grossbuchstaben", summkl, summgr); 

Anmerkungen: 

for (i=0; (c=getchar()) != ‘\n‘; i=i+1) 

Die gesamte Klammer hat den Wert des Zeichens (c) und kann deshalb mit anderen Objekten 

verglichen werden. Ausserdem stellt sie die Zuweisung des eingelesenen Zeichens an die 

Variable dar. 

for (i=0; ((c = getchar()) != ‘\n‘); i = i+1) 

Wert: eingelesenes Zeichen; Prüfung auf Ungleichheit 

û\nû Konstante vom Typ char (8bit) 

Einzelzeichen 

0 1 2 3 4 ... 255 

text D i e s \0 ... 

ASCII 68 105 

text[i]=‘\0‘; 

if (text[i]==‘ä‘ sumkl++; 

1.9) Dateihandhabung 

Umlenkung der Ein-/Ausgabe von der Kommandozeile 

...>prog1.e>prog1.out 

>prog1.e >prog1.out 

Eingaben; Ausgaben 

Lesen und Schreiben mit fscanf und fprintf 

fopen () 

fclose () 

fscanf () 

fprint () 

Datei öffnen 

Datei schließen 

Lesen 

Schreiben ACHTUNG: Variable muss Referenz haben!!! 

Öffnen einer Datei 

#include 

void main () 

{ 

FILE * input; 

//Dateizeiger: Eingabe 

8

FILE * output; 

input = fopen (“eingabe.dat“, “r“); 

output = fopen (“ausgabe.dat“, “r“); ... 

Dateizeiger (Adressvariable), Dateinamen, Modus (r-read, w-write) 

Schließen einer Datei 

... 

fclose (input); 

fclose (output); 

Dateizeiger 

Schreiben einer Datei 

fprintf (output, “%ld \n“, x); 

Dateien, Format, Variable 

Beispiel: Datei Ein-/Ausgabe: 

#include 

#include 

#define N 100 

int main () 

{ 

FILE * eingabe; 

FILE * ausgabe; 

double vector[N]; 

int i, n; 

/* --- Eingabedatei öffnen ---*/ 

eingabe = fopen ("vector.dat","r"); 

if (eingabe == NULL) 

{ 

printf ("\n vector.dat kann nicht geöffnet werden!"); 

exit(1); 

} 

/* --- Datei lesen ---*/ 

fscanf (eingabe, "%d", &n); //Anzahl Vek.-Elemente 

for (i=0; i

fprintf (ausgabe, "%d", n); 

for (i=0; i

Kapitel 2 – Syntaxregeln und Operatoren 

2.1 Syntaxregeln 

Syntax: 

Satzbau, richtige Art und Weise, Sprachelemente zu Sätzen zuzuordnen. 

Übersetzer muss entscheiden, ob ein vorgelegtes Programm fehlerfrei ist. 

Dafür ist erforderlich: 

Syntaxregeln müssen eindeutig festgelegt sein 

die Bedeutung der Zeichen und der Sprachkonstruktion muss eindeutig 

festgelegt sein (Semantik) 

Eine Möglichkeit zur Formalisierung der Syntax: Backus-Naur-Form 

Zweck: Beschreibung von Grammatiken von Programmiersprachen 

#include 

#include 

#define N 100 

int main () 

{ 

FILE * eingabe; 

FILE * ausgabe; 

double vector[N]; 

int i, n; 

/* --- Eingabedatei öffnen ---*/ 

eingabe = fopen ("vector.dat","r"); 

if (eingabe == NULL) 

{ 

printf ("\n vector.dat kann nicht geöffnet werden!"); 

exit(1); 

} 

/* --- Datei lesen ---*/ 

fscanf (eingabe, "%d", &n); //Anzahl Vek.-Elemente 

for (i=0; i

BNF (Backus-Nauer-Form) - Formalisierung einer Grammatik mit den Bestandteilen: 

(1) Terminalsymbole (die gültigen bzw. verwendbaren Zeichen) 

(2) Nichtterminalsymbole (Bsp.: letter, statement, identifier, ...) 

(3) Produktionen (auch Ableitungsregeln) 

(4) Startsymbol (ausgezeichnetes Nichtterminalsymbol) 

digit ::= 0|1|2|3|4|...|9 

syntaktische Kategorie 10 Alternativen Terminalsymbole (nicht weiter zerlegbar) 

Nichtterminalsymbol 

::= Bedeutung "kann ersetzt werden durch" 

Schreibweisen in Produktion 

| Auswahlzeichen, Alternativen 

{} 1 genau 1 Term ist auszuwählen 

{} 0+ 0 oder mehr Term sind auszuwählen 

{} 1+ 1 oder mehr Term sind auszuwählen 

{} wahlfreier Term 

2.2 C-Schlüsselwörter 

C hat 32 Schlüsselwörter (siehe Folie F-9). Dies sind reservierte Namen, die nicht mehr als 

eigene Variablen angegeben werden dürfen. 

2.3 Namen 

Bestandteile: 

Klein- und Großbuchstaben, Ziffern, Unterstrich 

BNF 

identifier ::= {letter | underscore} 0 

{letter | underscore | digit} 0+ 

!!! keine Ziffer am Anfang 

letter ::= lowercaseletter | uppercaseletter 

lowercaseletter ::= a | b | c ... /2 

uppercaseletter ::= A | B | C ... /2 

Regeln zur Namensvergabe: 

- am Anfang keine Ziffer 

- Variablen- und Funktionsnamen meist in Kleinbuchstaben 

- define-Konstanten meist in Großbuchstaben 

- mindestens die ersten 31 Zeichen werden unterschieden 

2.4 Ganzzahlige dezimale Konstanten 

BNF 

decimal_integer ::= 0 | positive_decimal_integer 

positive_decimal_integer ::= positive_digit {digit} 0+ 

positive_digit ::= 1 | 2 | ... | 9 

Folge: führende Nullen nicht erlaubt!!! 

2.5 Zeichenkonstanten 

Zeichenketten : Klammerung mit "..." 

12

Beispiel: "abc" 

97, 98, 99, 0 (Byte-ASCII-Code, binäre 0 als Abschlußzeichen 

Einzelzeichenkonstante 

Klammerung durch '...' (einfache Anführungszeichen) 

Beispiel: char yes= 'y'; 

2.6 Inkrement- und Dekrement-Operator 

++ Erhöhung einer ganzzahligen Variable um 1 

-- Verminderung um 1 

als Präfix-Operator: 

als Postfix-Operatoren: i+4; 

++i; 

Beispiel: 

for-Schleife 

for (Ci = 0; i < n; c + 4) .... 

2.7 Zuweisungsoperatoren 

Kurzschreibweise 

a += b 

a -= b 

b *= c 

b /= c 

b *= x + y +23 

a=b=c=0 

Bedeutung 

a=a+b 

a=a-b 

b=b*c 

b=b/c 

b=b*(x+y+23) 

rechte Seite wird zuerst 

ausgerechnet 

Mehrfachzuweisung 

2.8 Vorrang und Bindung 

Auswertungsreihenfolge in Ausdrücken 

Festlegung: 

(1) Klammerung 

(2) Beachtung der Vorrangsregeln 

Beispiel: 

if (2*a

Kapitel 3 – Datentypen und Wertebereiche 

Überreicht Basisdatentypen 

ganzzahlig: char signed char unsigned char 

short ... 

int ... 

long ... 

reell: float einfache Genauigkeit 

double 

doppelte Genauigkeit 

long double Kombination 

3.1 Datentyp char 

interne Darstellung (Bits 8 bit sind 1 byte) 

7 6 5 4 3 2 1 0 

0 0 1 0 0 1 0 1 

Verwendung: 

Darstellung von Zeichen (ASCII-Code) und kleinen ganzen Zahlen 

signed char : -128 ... +127 

unsigned char: 0 ... +255 

7 6 bis 0 

Vorzeichen Betrag 

char-Konstanten: 

char i, c; 

i = 120; 

c = 'c'; 

//Achtung: dem Zeichen 'c' ist ein Wert zugewiesen 

3.2 Datentyp int 

Darstellung abhängig vom Betriebssystem und Compiler 

Beispiel: 

GNU-C, Linux, Pentium: 

short int 

int 

long int 

2 Byte 

4 Byte 

4 Byte 

Typ "short int": 

15 14 bis 0 


signed short int: 

-2 15 ... +(2 15 –1) 

-32768 ... +32767 

unsigned short int 

0 ... (2 16 –1) 

0 ... 65535 

14

Typ "int": 

31 30 bis 0 


signed int: 

-2 31 ... +(2 31 –1) 

unsigned int: 

0 ... +(2 32 –1) 

Darstellung ganzzahliger Konstanten 

Suffixe für unsigned-Konstanten uU 

Suffixe für long-Konstanten 

lL 

x = 1000000L; 

y = 3000000UL; 

Oktale Konstanten: führende 0 (Null) 

x = 077 Wert für 63 

Hexadezimale Konstanten: führende 0x oder 0X 

y = 0x77 Wert für 119 

y = 0XFF Wert für 255 

Überschreitung des Zahlenbereichs (an einem Beispiel): 

int i; 

i = 100000; 

printf ("\n %d", (i*i)/i); 

Das Zwischenergebnis der Klammer (i*i) ergibt 10 10 zu hoch! 

3.3 Reelle Zahlentypen 

normalisierte Darstellung 

5,375 10 = 4 + 1 + 1/4 + 1/8 (dezimal) 

101,011 2 (dual) 

+ 1,01011 2 * 2 +2 

Vorz. Mantisse 

interne Darstellung von Float-Zahlen 

31 30 ... 23 22 ... 0 

Vorz. Exponent +127 (8 bit) Mantisse (23 bit) 

Exponent wird um +127 erhöht 

Am Beispiel 5,375: 

Mantisse: 010110...0 

Exponent: 2 10 10000001 

Vorzeichen: + 0 

31 30 ... 23 22 ... 0 

0 1 0 0 0 0 0 0 1 0 1 0 1 1 0 ... ... ... ... 0 

größte Mantisse: 1-2 23 

15

größter Exponent: 127 

größte Zahl: 2 * 2 127 3,4 * 10 38 

Anzahl der binären Nachkommastellen 

23 Nachkommastellen binär 7 Nachkommastellen dezimal 

Typ: "double" 

80 79 ... 52 51 ... 0 

Vorz. Exponent 11bit Mantisse 52bit 

kleinste Zahl: 2.22507385850720140*10 -308 

größte Zahl: 1.79769313486231570*10 +308 (Vorlesung 99-12-15) 

Anzahl der gültigen Stellen: 

float 32bit ~7 Stellen 

double 64bit ~15 Stellen 

long double 80bit ~19 Stellen 

Darstellungsbedingte Rundungsfehler 

Rundungsfehler treten bei jedem Zahlensystem auf, wenn eine feste Stellenanzahl verwendet wird. 

10er-System 1/10 = 0,1 exakt darstellbar 

2er-System 1/10 = 0,00011 

nicht exakt darstellbar 

Folgen: 

Grundgesetze der Arithmetik zum Teil ausser Kraft!!! 

x0 y x+y x x+y y 

Beispiel: 

große Zahl + kleine Zahl bei 7 gültigen Stellen 

x = 1.0e-4; 

y = 1.0e+4; 

z = x + y; 

x 0 , 0 0 0 1 

y 1 0 0 0 0 , 0 

z 1 0 0 0 0 , 0 0 0 1 

7 Stellen 

Praktische Folgen: 

1) Summation konvergierender Folgen 

Bsp.: n 

x x 

e 

n0 n! 

2) Aufsteigende / absteigende Summation liefert untersch. Ergebnisse 

1000000 

Bsp.: 

s 

 

 

1 

n1 n! 

harmonische Reihe 

16

3) direkte Verwendung math. Identitäten nicht möglich / sinnvoll 

Bsp.: sin( x) 

1 

cos 

2 ( x) 

c = cos(x) berechnet, aber evtl. mit 

s = sqrt(1.0 – c*c); 

c*c darf höchstens 1.0+ sein, sonst ist die Wurzel negativ 

Lösung: 

s = 1.0 – c*c; 

if (s > 0.0) 

s = sqrt(s); 

else 

s = 0,0; //Unterdrûckung von Rundungsfehlern 

4) kein direkter Vergleich numerischer Größen! 

x = ... ; 

if (x == 1,75) 

{...} 

VÖLLIG UNBRAUCHBAR!!! 

#define EPS 1.0e-8 

... 

if (fabs(x-1,75)

Beispiel: gemischte Ausdrücke, automatische Typumwandlung 

int a = 7; 

a *= 0.5; //Wert 3 

float c = 8.0; 

c *= ½; //Wert 0(!!!), denn ganzzahlige Division von1/2 = 0! 

Automatische Typumwandlung bei Zuweisungen 

int a; 

float f; 

double d; 

... 

a = f; 

f = d; 

//evtl. Verlust der Nachkommastellen 

//evtl. Überlauf oder Verlust gültiger Stellen 

Automatische Typumwandlung bei Funktionsargumenten und Rückgabewerten 

Definition einer Funktion (im Funktionskopf): 

int f (int a) 

{ ... } 

Aufruf: 

double a, b; 

b = 0,75; 

a = f(b); 

3.4.2 Explizite Typumwandlung (type cast) 

Beispiel 1: int i; 

double y; 

... 

y = (double) (i+1); 

//type-cast-Operator (...) 

Beispiel 2: double d; 

int i; 

d = ...; 

d = (int) (d+0.5); 

//echte Rundung 

Beispiel 3: i = (int) (log 10(d)) + 1; 

//Anzahl der Vorkommastellen 

18

Beispiel 4: d = ...; 

d = ((int) (10*d))/10.0; 

19

Kapitel 4 – Ablaufkontrolle 

4.1 Vergleichsoperatoren 

< kleiner 

größer 

>= größer gleich 

== Gleichheit (oder vergleichen?!) 

!= Ungleichheit 

Das Ergebnis eines Vergleichs ist ein Wahrheitswert: 

0 entspricht falsch 

1 entspricht richtig 

Beispiel: Umsetzung der math. Schreibweise 

3 < x < 7 

1.) int x = 2; 

if (3 < x < 7) 

{...} 

wahr 

//0 < 7 falsch 

2.) Bedingung muss ausformuliert werden!!! 

if (3

Beispiel: 

if (x0) 

{...} 

Fall x=0 fehlt!!! 

Beispiel: 

if (x

i = 2 * i + x%37; 

} 

Ein Ausdruck "for ( ; ; )" entspricht "while (true)", wird also als wahr angesehen und ist 

sozusagen eine Endlos-Schleife. 

4.6 Der Komma-Operator 

allgemeine Form: Ausdruck, Ausdruck, ...; 

Beispiel: 

Ausführungsreihenfolge 

sum = 0.0; 

for ( i=0; i

Die Fallbezeichnungen müssen zur Übersetzungszeit eine ganzzahlige Konstante liefern, 

möglich: 

case 27: ... 

case 0xA: ... 

case 'c': ... 

case 7+23: ... 

der default-Fall kann fehlen 

break kann fehlen, hat aber Konsequenzen beliebter Fehler! Ggf. wird der Code des 

nächsten Falls ausgeführt! 

Beispiel zu einer Switch-Anwendung: 

int tag,monat,jahr; 

... 

tag=...; monat=...; 

switch (monat) 

{ 

case 1: 

case 3: 

case 5: 

case 7: 

case 8: 

case 10: 

case 12: if (tag < 1 || tag > 31) 

printf ("..."); 

break; 

case 4: 

case 6: 

case 9: 

case 11: if (tag 30) 

printf ("..."); 

break; 

} 

case 2: 

default: 

if (tag28) //Schaltjahr? Y2K-Probleme!!! 

printf ("..."); 

break; 

printf ("Falsche Monatsangabe"); 

oder mit "int monat[13] = {0, 31, 28, 31, ..., 31}" 

(leeres Feld für die einfachere Umrechnung, sonst wäre z.B. Januar = 0) 

Beispiel: switch ersetzt if-else-Anweisung (dazu Folie 12!) 

int fall; 

fall = 0; 

if (a != 0) fall += 4; 

if (b != 0) fall += 2; 

if (c != 0) fall += 1; 

switch (fall) 

{ 

case 0: ...; break; 

case 1: ...; break; 

... 

} 

23

4.9 break-Anweisung 

Form: break; //beendet eine Schleife oder switch-Anweisungen 

alternativ: 

int feld[10000], i, n, wert; 

... 

for (i=0; i

Kapitel 5 – Funktionen 

5.1 Definition einer Funktion 

allgemeine Form: 

Typ Funktionsname (Parameterliste) 

{ 

Vereinbarungen 

Anweisungen 

} 

Wenn an Stelle von "Typ" nichts steht, wird automatisch int gewählt, 

aber: schlechter Programmierstil; 

Funktionsname ist vom Programmierer "frei" wählbar, 

eine Parameterliste muss nicht vorhanden sein, 

Beispiel: double fahr_celsius (double fahr) //Kopf mit Parameter in ( ) 

{ //ab hier: Rumpf 

double celsius; 

celsius = (3.0/9.0) (fahr – 32); 

return celsius; 

} 

Anmerkung: Zwischen Kopf und Rumpf kommt nichts! In alten 

C-Dokumenten ist das nicht immer so, aber: nicht beachten! 

Beispiel: void meldung3 () 

{ printf ("\n ...!"); } 

Beispiel: 

c 

a 

2 

b 

2 

#include 

#include 

double hypo(double a, double b) 

{ 

double c; 

c = sqrt (a a + b b) 

return c; 

} 

void main () 

{ 

double x, y, z; 

x = 2.3; 

y = 7.9; 

z = hypo (x, y); //Aufruf der Funktion mit Übergabe von zwei 

} //"aktuellen Parametern" ("Argumente") 

Durch das z wird eine Rücksprungadresse definiert. 

5.2 Die return-Anweisung 

2 Formen: return; //verlässt ddie Funktion ohne alles 

return Ausdruck; //gibt v.d. Verlassen noch einen Wert zurück 

Beispiele: return 0; 

return erg; 

return 2 h – 33; 

return sqrt(a a + b b); 

25

Für den Rückgabewert findet ggf. eine implizite Typersetzung statt. 

5.3 Prototypen 

Prototyp: 

Zweck: 

Funktionstyp, abgeschlossen mit Semikolon; die Implementierung 

kann in einer anderen Datei oder weiter unten stehen. 

Vereinbarung der Funktion (Name, Rückgabetyp, Anzahl und Typ der 

Parameter) zur automatischen Überprüfung der formalen Richtigkeit 

der Aufrufe. 

Beispiel: double hypo(double a, double b); /* Prototyp */ 

void main() 

{ 

... 

z = hypo(x,y); /* Aufruf */ 

5.4 Funktionsparameter mit Wertübergabe 

2 Arten der Parameterübergabe: - Wertpbergabe 

- Adressübergabe 

Adresse Inhalt Name 

101029 100 x 

... ... ... 

Bei C ist die Wertübergabe als Standardfall definiert. 

Eine Kopie des Parameterwertes wird an eine Funktion übergeben. 

Beispiel: 

Summe der Zahlen von 1 bis n 

summe_1_bis_n (int n) 

{ 

int summe = 0; 

for ( ; n>0 ; n--) summe += n; 

return summe; 

} 

void main() 

{ 

int n, s; 

n = 3; 

s = summe_1_bis_n (n); 

printf ("Summe = %d, n = %d", s, n); 

} 

Der Parameter n hat mit der Variable im Hauptprogramm nichts zu tun! Das n 

(mit Datentyp int) im Hauptprogramm existiert wirklich und bleibt unverändert. 

Die externe Prozedur erhält nur eine Kopie des Wertes und weiss daher nicht, 

woher der Wert kommt. 

5.5 Speicherklassen 

Grundlegende Gültigkeitsregeln für Variablen 

26

- eine Variable ist genau in dem Block gültig, in dem sie vereinbart ist (sog. lokale 

Variablen) 

5.5.1 Speicherklasse "auto" 

- Schlüsselwort "auto" 

- Variablen, die innerhalb eines Blockes vereinbart werden, besitzen den Speichertyp 

"auto" (Ersatztyp) 

- der zugehörige Speicher wird beim Betreten des Blockes beschafft, beim Verlassen 

freigegeben. 

5.5.2 Speicherklasse "extern" 

- Variablen, die ausserhalb einer Funktion vereinbart sind, haben den Speichertyp "extern" 

- der Speicherplatz ist permanent vorhanden (statisch) 

Vorteile: 

einfachste und unaufwendigste Möglichkeit, Werte zwischen Funktionen auszutauschen 

Nachteile: 

Gefahr des unbeabsichtigten Überschreibens! 

Beispiel: 

Summation 

int n = 10; 

double x[1000]; 

... 

double summe( ); 

{ 

int i; 

double summe = 0.0; 

for (i=0; i

static int aufruf = 0; 

Initialisierung findet nur beim 1. Aufruf der Funktion statt 

 

Speicherplatz und Inhalt bleiben nach Verlassen der Funktion erhalten. 

5.6 Rekursive Funktionen 

Eine Funktion heisst rekursiv, wenn sie sich direkt oder indirekt selbst aufruft. 

direkt: 

indirekt: 

Bsp.: 

f ruft f auf 

f ruft g auf, g ruft dann f auf. 

Berechnung der Fakultät 

int fakultaet (int n) 

{ 

if (n

Kapitel 6 – Zeiger und Felder 

Zum näheren Verständnis ist auch Kapitel 5 (Algorithmen) aus der Informatikvorlesungen ratsam. 

6.1 Eindimensionale Felder ( Folie 14) 

Beispiel: 

int a[100]; 

Index 0...99 //große Fehlerquelle, Start NICHT bei 1! 

Initialisierungsmöglichkeiten 

Beispiel: int a[4] = {3,5,8,2}; //Vorzuweisung 

int b[5] = {7}; 

//Rest wird mit 0 aufgefüllt 

int c[ ] = {3,4,5,9,2,8}; //ohne Längenangabe, aber der 

Übersetzer richtet sich autom. nach der 

Vorgabe in Klammern bequem 

6.2 Mehrdimensionale Felder ( Folie 14) 

Beispiel: int a[100]; //eindimensional 

int m[100] [100]; //zweidimensional 

int p[100] [100] [100]; //dreidimensional 

Grenzen beim Compiler bei ca. 8 bis 10 Dimensionen, aber: 

hoher Speicherverbrauch!!! 

int [10] [10]; 

// Zeilenindex, Spaltenindex 

Darstellung im Speicher ( Folie 14) 

Im Speicher (eindimensional) liegen die Felder zeilenweise hintereinander. 

("Zeilenweise Linealisierung einer Matrix im Speicher") 

Wir haben beispielsweise 10 Zeilen und 10 Spalten 

i = Zeilenindex 

j = Spaltenindex 

R = 10 * i + j ( Folie 14, unten, Element [2,0] 20) 

= 10 * 2 + 0 = 20 ( Annahme richtig) 

Diese Berechnung nennt sich "Speicherabbildungsfunktion" 

Initialisierung zweidimensionaler Felder 

int a[3] [2] = { 

}; 

{1,2}, // Zeile 0 

{7,9}, // Zeile 1 

{5,(-1)}, // Zeile 2 

6.3 Zeiger 

Zeiger: ist eine Speicheradresse 

Zeigervariable: Variabe, die Adresse speichern 

29

Vereinbarung von Zeigervariablen 

int *pa; 

double *pb; // Zeiger auf double-Größe 

int a; 

a = 77; 

pa = &a; 

Name Typ Adresse 

a int bffff8ae 

pa Zeiger auf int bffff8d4 

Operatoren 

& Adressoperator, beschafft die Adresse eines Objektes 

* Inhaltsoperator, beschafft den Inhalt des Speicherplatzes, auf 

den die Adresse zeigt 

&*... oder *&... oder *(&...) oder &(*...) heben sich gegenseitig auf. Die Variable bleibt stehen! Also *&a == &*a == a 

Beispiel: Verwendung einer Zeigervariablen 

#include 

void main ( ) 

{ 

int a; 

int *pa; 

a =77; 

pa =&a; 

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

printf ("\n *pa = %d", *pa); /*Aussage hex %x)! */ 

printf ("\n pa = %x", pa); 

printf ("\n &a = %x", &a); 

printf ("\n &pa = %x", &pa); 

... 

Ausgaben: 

a = 77 

*pa = 77 

pa = bffff8ac /* (Adresse von a) gespeichert in pa! */ 

&a = bffff8ac /* direkte Adressausgabe von a*/ 

&pa = bffff8d4 /* Adresse der Variablen pa */ 

Adresse Inhalt Name 

bffff8ac 

a 

bffff8d4 

pa 

Anmerkungen: 

& Adresse von a 

pa Zeiger auf a 

*pa Inhalt der Variablen, auf die pa zeigt 

&pa Adresse der Zeigervariablen pa 

30

char s[] = "test"; 

char *s = "test"; 

//Feld mit variabler Länge anlegen und mit Inhalt und abschließender /0 füllen 

//das Gleiche wie oben in Zeigerschreibweise (alternativ zur Felddeklaration) 

Feld von Zeigern auf Arrays bedeutet also nichts anderes als ein zweidimensionales Array! Also: 

s [ ] [ ] = *s [ ] = **s 

char *p, *z; 

//Feld mit var. Länge ohne Inhalt 

p = s; //Zeiger von p zeigt (direkt) auf den gleichen Speicherbereich und Inhalt wie s. 

//verändert man p, verändert sich auch das originale s, also p = s = "test". 

p = &s[0]; 

p = &(*(s+0)); 

p = &*s; 

p = s; 

//entspricht der vorherigen Befehlszeile... 

//...denn &* oder *& oder *(&...) oder &(*...) heben sich gegenseitig auf. 

//p enthält auch hier den String von s, also "test". 

*p = 'A'; //erstes Zeichen von p wird ein 'A',... 

p[0] = 'A'; //...deshalb enthält p[ ] nun den String "Aest" 

*p++; 

p++; 

(*p)++; 

++*p; 

z = &(*p); 

z = p; 

z = p; 

int i = (int) *p; 

p = 0; 

//“C“ arbeitet von rechts nach links Befehle ab. Hat eine Position keinen Rückgabe- 

//typ, bricht die Verarbeitung ggf. mit einem Compilerfehler ab oder ignoriert dieses; 

// der Stern wird hier ignoriert. Der Zeiger p zeigt auf das nächste Element. p = "est" 

//gleicher Sachverhalt, auch ohne den Stern. 1. Zeichen wieder kürzen p = "st" 

//statt von rechts bearbeitet der Compiler zunächst die Klammer. Der Inhalt von p 

//wird also um 1 erhöht (binärer ASCII-Wert von s + 1) aus "st" wird "tt" 

//bedeutet das Gleiche wie (*p)++, ist aber kein guter Stil! 

//s.o.; &* hebt sich auf. z erhält den verbleibenden String "tt" 

// der gleiche Befehl wie z = &(*p). (s.o., z erhält nochmals "tt") 

//explizite Typkonvertierung des ASCII-Wertes von p[0] (von "t") in eine int-Variable 

//der Zeiger wird gesetzt auf einen ungültigen Speicherbereich. Bei einer Ausgabe 

//käme ein BlueScreen (Speicherzugriffsfehler) oder ein Programmabsturz. 

6.4 Adressübergabe bei Funktionsparametern 

Beispiel: Wertetausch: 

übliche Methode: 

int a, b, h; 

a = 5; 

b = 7; 

h = a; 

b = a; 

b = h; 

oder: 

int a, b; 

a=5; 

b=7; 

tausche (&a, &b); 

//&=Adresse übergeben 

void tausche (int *a, int *b) //call-by-reference 

31

{ 

} 

int h; 

h = *a; 

//*=Inhalt der Variable holen 

*a = *b; //Bezugnahme auf den Inhalt, 

*b = h; //sog. "Inhaltsoperator" 

Wirkung: a = 7 und b = 5 

Beispiel: 

Koordinatentransformation (math.h für Bogenmaß Voraussetzung) 

x = r * cos 

y = r * sin 

= arc tan (y/x) 

r = sqrt (x 2 + y 2 ) 

void polar-kart (double r, double phi, double *x, double *y) 

{ 

*x = r * cos(phi); 

*y = r * sin(phi); 

} 

void kart_polar (double x, double y, double *r, double *phi); 

{ 

*r = sqrt ( x*x + y*y); 

*phi = atan 2 (y,x); /* beide Argumente einzeln überg. */ 

} 

oder: 

aber: 

atan (y/x) 

fehlende Vorzeichen, deshalb Betrachtung! 

6.5 Zusammenhang zwischen Feldern und Zeigern 

Ein Feldname ist wie ein Adresswert zu verwenden. 

Beispiel: 

int a[100], *pa; 

pa = a; 

pa = &a [0]; 

ist gleichbedeutend! 

Zeiger können auch zur Feldadressierung verwendet werden. 

int a[100], i, Summe, *pa; 

pa = a; 

for (i=0; i < 100; i++) *pa++=i; 

//Feld wird mit Werten von 0 bis 99 gefüllt 

summe=0; 

for (pa = a; pa < &a[100]; pa++) summe += *pa; 

oder: 

for (i=0, i < 100, i++) summe += *(pa+i); //Adressrechnung 

6.6 Felder als Funktionsargumente 

Felder werden immer per Adresse übergeben. 

32

Beispiel: double summe (double a[ ], int n) 

{ 

double s = 0.0; 

int i; 

for (i =0; i

Kapitel 7 – define-Makros 

7.1 include 

#include 

#include "projekt3.h" 

//Datei stdio.h aus Systemverz. wird einkopiert 

//Datei projekt3.h im Arbeitsverzeichnis 

7.2 define 


#define Name Ersetzungstext 

Beispiel: #define N 200 

#define SEKUNDE 1 

#define MINUTE (60 * SEKUNDE) 

#define EQ == 

#define BEGIN { 

#define END } 

#define NL print ("\n") 


Beispiel: 

#define name(Parameter1, Parameter2, ...) Ers.text 

#define QUAD(x) ((x)*(x)) 

..... 

y = QUAD (a+3); 

// y=((a+3)*(a+3)); 

#define QUAD(x)(x*x) 

..... 

y=QUAD(a+3); 

// y=a+3*a+3; 

#define QUAD(x)x*x 

..... 

y=QUAD(a+3)*7; // y=a+3*a+3*7; !!! 

Um eine Mehrfacheinbindung zu vermeiden, benutzt man eine spezielle Anweisung: 

#ifndef INTERNE_HEADERBEZEICHNUNG 

#define INTERNE_HEADERBEZEICHNUNG 

#endif 

//fragt ab, ob Name existiert 

//falls nicht,erstelle 

//falls doch, wird überlesen bis... 

//diese end-Anweisung auftaucht. 

34

Kapitel 8 – Vereinbarungen, Zugriffe, Strukturen 

8.1 Vereinbarung und Komponentenzugriff 

Vereinbarung 

1. Möglichkeit 

struct 

Schlüsselwort 

student 

Name 

...{ 

} 

char 

char 

long 

*nachname 

*vorname 

matr_nr 

Einrichtung von Variablen: 

struct student s1,s2,s3,st[1000]; 

Datentyp Variablen 

2. Möglichkeit: anonyme Struktur 

struct 

{ int tag, monat, jahr; 

} gestern, heute, morgen; 

3 Variablen 

Gebrauch von type def: 

type def unsigned char byte; 

Schlüsselwort existierender Typ neuer Typname 

type def double laenge; 

type def double vektor[3]; /*Vektoren fester Länge */ 

..... 

vektor vx, vy, vz; 

type def struct student Student; 

alte Bezeichnung 

neue Bezeichnung 

Zugriff auf Komponenten: 

Zugriffsoperator: . ( da ist ein Punkt!) 

Beispiel: struct student {...}; /* siehe oben */ 


Student s1, s2, s3; 

s1.nachname = "Meier"; //Anonymes Char-Feld 

8.2 Strukturen und Funktionen 

Strukturen können über return aus Funktionen zurückgegeben werden (Kopieren der 

Struktur!) 

Beispiel: 

struct student 

{ 

} 

char nachname[20]; 

char vorname[20]; 

long matr_nr; 

35


void print_student (Student *s); 

void lies_student (Student *s); 

void main () 

{ 

student stud[1000]; 

lies_student (&stud[1]); 

print_student (&stud[1]); 

} 

void print_student (Student *s) 

{ 

printf ("\n %20s, %20s, Matr.Nr. %8ld", 

snachname, svorname, smatr_nr); 

void lies_student (Student *s) 

{ 

printf ("\n Nachname: "); 

scanf ("%s", &snachname); 

... 

} 

Schreibweise: 

(*s).nachname 

s->nachname 

(gleichwertige Schreibweise!!!) 

Beispiel: 

Vektorarithmetik 

Vektoren der Länge 3, dargestellt durch Strukturen 

struct vector 3 

{ 

double x; 

double y; 

double z; 

}; 

typedef struct vector3 Vek3; 

Vek3 createv (double x, double y, double z) 

{ 

Vek3 a; 

a.x = x; a.y = y; a.z = z; 

return a; 

} 

Vek3 null( ){return createv (0,0,0);} 

Vek3 e_x( ) {return createv (1,0,0);} 

Vek3 e_y( ) {return createv (0,1,0);} 

Vek3 e_z( ) {return createv (0,0,1);} 

/* Vektor x Skalar */ 

Vek3 VxS (Vek3 a, double s) 

{ 

return createv (s*a.x, s*a.y, s*a.z); 

} 

Vek3 vaddv (Vek3 a, Vek3 b) 

{ 

36

} 

return createv (a.x+b.x, a.y+b.y, a.z+b.z); 

Vek3 vsubv (Vek3 a, Vek3 b) 

{ 

return createv (a.x-b.x, a.y-b.y, a.z-b.z); 

} 

double skalarprod (Vek3a, Vek3 b) 

{ 

return a.x*b.x + a.y*b.y + a.z*b.z; 

} 

Vek3 Kreuzprod (Vek3 a, Vek3 b) 

{ 

return createv ( a.y * b.z - a.z * b.y, 

a.z * b.x – a.x * b.z, 

a.x * b.y – a.y * b.x); 

} 

double lenght (Vek a) 

{ 

return sqrt (skalarprod (a*a)); 

} 

//Vektor normieren 

Vek3 normieren (Vek3 a) 

{ 

double l; 

l = length(a); 

if (l>EPSILON) return vxs (a, 1.0/l); 

else return a; 

} 

void print_vek (Vek3 a) 

{ 

... 

} 

Vek 3 scan_Vek (void) 

{ 

... 

} 

int main ( ) 

{ 

Vek3 a,b,c; 

a = createv (1,2,3); 

b = createv (3,1,2); 

c = vaddv (a,b); 

... 

c = vaddv (vxs(a,3),vxs(b,7)); 

c = kreuzprod (a,b); 

... 

} 

37

Kapitel 9: C++/ nicht-objektorientierte Erweiterungen 

9.1 Datentyp bool 

Datentyp: 

Konstanten: 

bool 

true, false 

Beispiel: bool b1, b2; 

b1 = false; 

b2 = true; 

b1 = 5; //entspricht true, denn 0 

9.2 Vereinbarungen 

Vereinbarungen müssen nicht mehr zwingend vor der ersten ausführbaren Anweisung eines 

Blockes stehen. 

Beispiel: void main ( ) 

{ 

cout

} 

double 

a* = *b; 

b* = h; 

h = *a; 

Beispiel 2) ... 

int a=5, b=7; 

double x=9, y=3; 

swap (&a, &b); // 1. swap ( ) 

swap (&x, &y); // 2. swap ( ) 

swap (&a, &x); 

// Fehler 

... 

swap 

9.6 new und delete – dynamische Speicherbelegung 

Beispiel: 

Wichtige Erläuterung: 

double *f = new double; 

int *feld = new int [1024]; 

... 

delete f; 

delete [ ] feld; //Feld freigeben 

new ist ein Operator, der sich ans Betriebssystem wendet. 

feld ist der Name des Zeigers. 

delete löscht Rückstände aus dem Speicher 

9.7 iostream – Bibliothek 

Beispiel: 

#include 

void main ( ) 

{ 

int i, n=10; 

double a[200] 

for (i=0; i

Anmerkung: 

Bsp.: 

Eine Referenz ist konstant und muss bei Einrichtung einen Adresswert 

erhalten. 

void swap (int &a, int &b) 

{ 

int h = a; 

a=b; 

b=h; 

} 

void main ( ) 

{ 

int x = 7, y = 28; 

... 

swap (x,y); 

... 

} 

Bsp.: 

double & square (double &x) 

{ 

x = x * x; 

return x; 

} 

möglicher Aufruf: double a = 3.0, b; 

b = square (a); 

Werte (anschließend): a=9.0 und b=9.0 

40

Kapitel 10 - Klassen 

10.1 Referenzen in Funktionen 

Bsp.: 

Datenstruktur Stapel (stack) 

Datenkomponenten: 

- Feld zur Aufnahme der Daten 

- Stapelzeiger (top) 

- Feldlänge 

Operationen: 

- Initialisierung (top=0) 

- Element hinzufügen 

- Element wegnehmen 

- oberstes Element lesen 

- Anzahl der Elemente feststellen 

10.2 Klassendefinitionen 

allg. Form: 

Bsp.: 

class Name 

{public: öffentliche Komponenten 

private: private Komponenten} 

stack (Datei: stack.cc) 

#include 

class Stack 

{ 

private: int daten; 

int zgr; 

int max; 

//nächstes freies Element 

//Feldlänge 

} ... 

public: Stack (int groesse = 100); //Konstruktor 

~Stack ( ) {delete daten;}; //Destruktor (inline) 

void init ( ) {zgr = 0;}; 

//(inline) 

void push (int datum); 

int pop ( ); 

int top ( ); 

bool empty ( ) {return zgr == 0;}; 

bool not_empty ( ) {return zgr != 0;}; 

int height ( ) 

{return zgr;}; 

int max_height ( ) {return max;}; 

//Implementierung der member-Funktionen 

Stack :: Stack (int groesse=100) 

{ 

if (groesse

} 

int Stack :: pop ( ) 

{ 

if (zgr>0) return daten[--zgr]; 

else { 

cerr 0) return daten [zgr-1]; 

else { 

cerr

Erläuterungen: 

Objektvereinbarung 

- der Konstruktor wird bei der Vereinbarung eines Objektes autom. aufgerufen. 

- folgende Vereinbarungen sind möglich: 

Stack stapel1; //ohne Param.:Länge 100 

Stack stapel2(88); //Länge 88 

Stack stapel3 = Stack (900); 

- Es können mehrere Konstruktoren vorhanden sein; 

Bsp.: Stack ( ); //leerer Stapel, evtl. 1 Platz 

Stack (int groesse); 

... 

Verwendung 

Stack Stack21; 

//1. Konstruktor 

Stack Stack22 (200); //2. Konstruktor 

Destruktoren 

Funktionskomponente, die automatisch am Lebensende eines Objektes aufgerufen wird. 

Hauptzweck: 

Freigabe von dynamisch belegten Speicher 

Definition: ~Stack( ); 

kein Rückgabewert, keine Parameter 

Implementierung: Stack:: ~Stack( ) 

{ 

delete daten; 

daten = 0; 

} 

//dyn. Speicher wieder freigeben 

10.4 Zuweisungsoperator 

... 

stack1 = stack2 

Anmerkung: 

Lösung: 

Stack-Feld von Stack1 nicht mehr zugreifbar 

Zuweisungsoperator = wird neu definiert 

Bsp.: class Stack { 

private: ... 

43

public: ... 

Stack & Operator = (const Stack & rechteseite); 

} 

Rückgabetyp, danach "&" für Schreibberechtigung auf die Variable 

Funktionsname 

Referenz auf einem Stack-Objekt 

Implementierung des Operators: 

-eigenen Speicher freigeben 

-neuen Speicher in der Größe des zu kopierenden Objektes anlegen 

-Feld kopieren 

-andere Datenkomp. kopieren 

Stack & Stack:: Operator = (const Stack & rechteseite) 

{ 

delete daten; 

//eig. dyn. Speicher freigeben 

max = rechteseite.max; 

daten = new int [max]; //neuen dyn. Speicher belegen 

zgr = rechteseite.zgr; 

for (int i=0; i

Stack :: Stack operator = (const Stack & stp); 

alle Datenkomp. werden kopiert 

Referenz auf ein unveränderliches Objekt 

kopiert alle Datenkomponenten 1:1 

Anmerkung: alle 4 Funktionen können überladen werden! 

10.6 Friends 

friend-Funktionen sind keine Komp.funktionen; haben jedoch Zugriff auf die priv. Daten. 

Bsp.: class matrix { 

private: double mat [3] [3]; 

public: ... 

friend vektor mult (matrix &m, vektor &v); 

}; 

class vektor { 

private: double vek [3]; 

public: ... 

friend vektor mult (matrix &m, vektor &v); 

}; 

vektor mult (matrix &m; vektor &v) 

{ 

vektor h; 

for (int i=0; i< 3, i++) { 

h.v [i] = 0; 

for (int j=0; j

Kapitel 11 – Überladen von Operatoren 

11.1 Unäre Operatoren (arithmetisch) 

Bsp.: 

Klasse Vektor mit 3 Komponenten 

class Vek3 

{ 

private: double x,y,z; 

public: Vek3 operator + ( ); 

Vek3 operator – ( ); 

... 

} 

Vek3 Vek3::operator + ( ) // u = +v 

{ 

return *this; //Zeiger auf sich selbst; muss klein geschrieben werden! 

} 

Vek3 Vek3::operator – ( ) // u = -v (verlangt mehrere Schritte) 

{ 

return Vek3 (-x, -y, -z); //Konstruktoraufruf 

} //oder Vek3 h (-x, -y, -z); return h; 

*this ist ein Zeiger auf das eigene Objekt 

2. Möglichkeit: Verwendung von friend-Funktionen 

friends sind Funktionen, die auch auf private-Bereiche zugreifen können (oder "auf die" ?) 

class Vek3 

{ 

... 

friend Vek3 operator + (const Vek3 &v); 

friend Vek3 operator – (const Vek3 &v); 

... 

} 

Vek3 operator + (const Vek3 &v) 

{ 

return v; 

} 

Vek3 operator – (const Vek3 &v) 

{ 

return Vek3 (-v.x, -v.y, -v.z); 

} 

11.2 Binäre Operatoren 

Ziel: 

u = v + 27.3 * (u1 + u2); 

1. Möglichkeit: Komponentenfunktionen 

Vek3 Vek3 :: operator + (const Vek3 &b) 

{ 

return Vek3 (x+b.x, y+b.y, z+b.z); 

} 

46

Vek3 Vek3 :: operator – (const Vek3 &b) 

{ 

return Vek3 (x-b.x, y-b.y, z-b.z); 

} 

2. Möglichkeit: friends 

Vek3 operator + (const Vek3 &a, const Vek3 &b) 

{ 

return Vek3 (a.x + b.x, a.y + b.y, a.z + b.z); 

} 

(Für "-" analog) 

11.3 Arithmetische Zuweisungsoperatoren 

Ziel: 

v += b; //v,b Vektoren 

1. Möglichkeit: Komponentenfunktion 

void Vek3 :: operator += (const Vek3 &b) 

{ 

x += b.x; 

y += b.y; 

z += b.z; 

} 

2. Möglichkeit: 

Vek3 Vek3 :: operator + (const Vek3 &b) 

{ 

x += b.x; 

y += b.y; 

z += b.z; 

} 

return *this; 

11.4 Ein- / Ausgabeoperator 

Operatoren: > 

Überladung des Ausgabeoperators 

ostream& operator (ostream &out, const Vek3 &v) 

{ 

out

Überladung des Eingabeoperators: 

istream& operator >> (istream &in, Vek3 &v) 

{ 

in >> v.x >> v.y >> v.z; 

} 

oder 

istream& operator >> (istream &ein, Vek3 &v) 

{ 

char kl, komma; 

in >> kl >> v.x >> komma >> v.y >> komma >> v.z >> kl; 

} 

Kapitel 12 - Statische Objekte 

Klassen können statische Datenkomponenten enthalten, die für die Klasse nur einmal existieren. 

Bsp.: 

Klasse für pgn-Bilder 

class pgn 

{ 

private: 

int breite, hoehe, maxgrau 

char **pixel 

static int zaehler; 

public: 

pgm() {pixel = 0; zaehler**;} 

~pgm {...; zaehler --;} 

} 

//Konstruktor 

//Destruktor 

int pgm::zaehler = 0; 

Definition und Anfangswertzuweisung erfolgen außerhalb der Klasse genau einmal. 

48

Kapitel 13 - Vererbung 

13.1 Abgeleitete Klasse 

Ziel: 

Code einer vorhandenen Klasse wieder verwenden, d.h. 

- zusätzliche Datenkomponenten 

- zusätzliche Funktionskomponenten 

- evtl. vorhandene Funktionen überladen 

Deklaration einer Klasse B, abgeleitet aus der Klasse A: 

class B: public A { ... } 

Über B Objekte wird auf die public-Komponenten von A zugegriffen werden 

class bahn 

{ 

protected: Vek3 pa; //Anfangspunkt 

Vek3 pe; //Endpunkt 

public: 

bahn(){}; 

bahn (const.Vek3 &p1, const Vek3 &p2){pa = p1; pe = p2;} 

} 

void start (const Vek3 &p) 

void ziel (const Vek3 &p) 

double laenge (void) 

{pa = p;} 

{pe.p;} 

{return(pe-pa).laenge()} 

class kbogen: public bahn { 

protected: Vek3 pm; //mittlerer Punkt 

public: kbogen() {}; 

kbogen ( const Vek3 &p1; 

const Vek3 &p2; 

const Vek3 &p3;) 

{pa=p1; pm=p2; pe=p3;} 

Ergänzung: 

void zwpunkt (const Vek3 &p) {pm=p;} 

Überladung der Funktion bahn::laenge() 

double laenge() {return (pe-pm).laenge() + (pm-pa).laenge();} 

int main() 

{ 

double bahnlaenge; 

bahn bahn1; 

kbogen bogen1, bogen2; 

Vek3 p1 (0,2,0); 

Vek3 p2 (2,2,0); 

Vek3 p3(2,0,0); 

bahn1.start (p1); 

bahn1.ziel(p1); 

bogen1.start(p1); 

bogen1.zwpunkt(p2); 

bogen1.ziel(p3); 

} 

cout

Klasse kbogen Vek3 pm zusätzliche Datenkomponenten 

void zwpunkt() zusätzliche Methode 

double laenge() überlädt Fkt. der Basisklasse 

Hauptprog.: bahn1.laenge(); Fkt. d. Basisklasse wird aufgerufen 

bahn1.laenge(); Fkt. d. abgeleiteten Klasse wird aufger. 

13.2 Initialisierung von Klassenkomponenten 

bahn --> kbogen 

class kbogen: public bahn 

{ 

... 

public: 

// -- Konstruktor 1 – 

kbogen() {}; 

... 

} 

// -- Konstruktor 2 – 

kbogen (const Vek3 &p1, const Vek3 &p2, const Vek &p3) : bahn 

(p1,p3) {pm = p2;} 

Aufruf des Basis-Klassenkonstruktors 

Initialisierung der neuen Komponente 

kbogen bg1 (v1,v2,v3); 

kbogen bg2; 

13.3 Virtuelle Funktionen 

--> kbogen 

bahn --> gerade 

--> parabel 

--> ... 

Zum Beispiel: Ein Roboterarm soll eine bestimmte unförmige Form abarbeiten. 

Ziel: 

- erweiterbare Klassenhierarchie 

- alle abgeleiteten Funktionen laenge() 

- die Längen gehen bereits in Berechnungen ein, die nach einer Erweiterung nicht mehr 

geändert werden sollen. 

1. Versuch (funktioniert nicht!) 

class bahn {...} 

class kbogen: public bahn {...} 

int main () 

{ 

double sum; 

bahn *b [100]; 

int n=6; 

b[0] = new bahn (p1,p2); 


//100 Zeiger auf Bahnobjekte 

50

[2] = new k.bogen (p3,p4,p4); 

... 


} 

sum = 0.0; 

for (int i=0; i laenge(); 

... 

Fehlschlag! Die Längenfunktion der Basisklasse wird aufgerufen! 

2. Versuch: Verwendung einer virtuellen Funktion 

class bahn 

{ 

protected: 

Vek3 pa, pe; 

public: bahn () 

{}; 

bahn (const Vek3 &p1, const Vek3 &p2) 

{pa = p1; pe = p2;} 

virtual double laenge () 

{} 

... 

} 

class gerade: public bahn { ... } 

class kbogen: public bahn { ... } 

jeweils eigene Längenfkt. 

(s.o.) 

double bahnlaenge (bahn *b[ ], int n) 

{ 

double sum = 0.0; 

for (int i=0; i laenge (); 

return sum; 

} 

int main () 

{ 

//s.o. 

} 

Anmerkungen: 

 

 

 

 

in bahnlaenge() werden die Funktionen laenge() der abgeleiteten Klassen 

aufgerufen 

die Funktion bahnlaenge(...) muss nicht geändert werden, wenn weitere von 

bahn abgeleitete Bahntypen hinzukommen 

Fallunterscheidungen entfallen 

die entsprechenden Funktionen der abgeleiteten Klassen müssen die selbe Signatur 

wie die Funktion der Basisklasse besitzen. 

Bsp.: 

class bahn 

{ ... 

virtual double xxx (int n); 

} 

class gerade: public bahn 

{ ... 

51

double xxx (long n); 

//überlädt nicht xxx in bahn! 

// Statischer Aufruf virtueller Funktionen 

double l1, l2; 

bahn b1; 

kbogen k1; 

... 

l1 = b1.laenge(); 

l2 = k1.laenge(); 

//bahn::laenge 

//kbogen::laenge 

//aufzurufende Funktion zur Übersetzungszeit bekannt: stat. Aufruf 

//sonst: dynamischer Aufruf 

double bahn_zeit (double v, bahn &b) 

{ 

if (v > 0.0) return b.laenge() / v; 

//dyn. Aufruf passende Fkt. muss zur 

else return 0,0; 

//Laufzeit ermittelt werden 

} 

13.4 Abstrakte Klassen 

abstrakte Klassen: 

Basisklassen zur Ableitung weiterer Klassen 

Bsp.: 

class bahn { 

protected: Vek3 pa, pe; 

public: bahn() { } 

... 

virtual double laenge () = 0; 

} 

class gerade: public bahn { 

... 

double laenge () {...}; 

} 

int main () 

{ 

bahn *b[100]; 

bahn b23; 

... 

} 

//100 Zeiger 

//Fehler! 

Anmerkungen: 

"virtual double laenge () = 0;" ist eine rein virtuelle Funktion. Eine Implementierung 

ist nicht vorhanden und auch nicht vorgesehen. 

52

Es bedarf einer Schnittstellendefinition für abgeleitete Klassen, d.h. im Falle eines Verkaufs ist 

der Code und die Bibliothek sozusagen kopier- / editiergeschützt. Die Vereinbarung eines 

bahn-Objektes ist NICHT mehr möglich. 

Die virtuelle Funktion muss in abgeleiteten Klassen überladen werden. 

53

Kapitel 14 – Templates 

Templates (Schablonen) für Funktionen und Klassen, die voneinander nur in verwendeten Datentypen 

abweichen. 

14.1 Funktions-Templates 

Bsp: allgem. Minimumfunktion 

Template T Min(T u, T b) 

{ 

if (a=0) return a; else return –a; 

} 

template < class T> bool IsInRange (T x, T unten, T oben) 

{ 

return ( unten

}; 

} 

int main ( ) 

{ 

bruch b1(4,9), b2(3,7), b3; 

b3 = b1*b2; 

cout

class Qelement 

{ 

public: 

T1 element; 

Qelement *p_next; 

Qelement (const T1 &value):element(value), p_next(0) { } 

}; 

Qelement *p_front, *p_end; 

public: 

friend class Qtraverse ; 

Queue ( ) {p_front = p_end = 0;} 

virtual ~Queue() { while(!empty())remove(); } //Fkt. inline definiert 

virtual T1 remove ( void ); 

virtual void add ( const T1 &element ); 

bool empty ( void ) { return p_front == 0; } 

}; //Ende class Queue 

template void Queue :: add ( const T1 &element) 

{ 

Qelement *p_element = new Qelement (element); 

if ( empty( ) ) p_front = p_element; 

else p_end -> p_next = p_element; 

p_end = p_element; 

} 

template < class T1 > T1 Queue :: remove( void ) 

{ 

if ( empty( ) ) 

{ 

cerr element; 

Qelement *p_element = p_front; 

p_front = p_front -> p_next; 

delete p_element; 

return element; 

} 

template class Qtraverse 

{ 

private: 

Queue *p_queue; 

Queue :: Qelement *p_peek; 

// Zeiger auf Warteschlange 

// Zeiger auf element 

public: 

void peek_reset() { p_peek = 0;} 

Qtraverse ( Queue &queue) 

{ 

p_queue = &queue; 

peek_reset(); 

} 

int peek (T1 &cur_element) 

{ 

if(p_peek==0) p_peek = p_queue -> p_front; // Zeiger auf Anfang 

else p_peek = p_peek -> p_next; 

if ( p_peek == 0) return 0; 

cur_element = p_peek -> element; 

return 1; 

} 

}; 

56

#endif 

//Ende der Vermeidung von Doppeleinbindungen 

DATEI: prk16-1.h aus dem Praktikum (getestet und lauffähig) 

#include "prk16-1.h" 

int main( void ) 

{ 

int n = 10000000; 

Queue x; //Warteschlange x 

Qtraverse itx ( x ); //Iterator für WS x 

int current, i = 0; 

for (i = 0; i < n; i++) x.add(i); 

i= 0; 

//Queue durchlaufen 

while ( itx.peek(current) ) 

if( i++ % 100 == 0 ) cout

{ 

Queue X; 

//Warteschlange 

qtraverse itx (x); //Iterator für Queue X 

int current; 

//laufendes Element 

for (int i=0;i

Verwendungsbeispiel 

als InputIterator: 

als T: 

*int 

int 

erzeugter Code: 

int* find (int* first, int* last, const int &value) 

{ 

while (first != last && *first != value) 

first++; 

return first; 

} 

Anforderungen: 

1. Vergleich zweier Objekte (first != last) 

2. Inkrementierung (first ++) 

3. Dereferenzierung (*first != value) 

template < class T1 > 

T1 Queue < T1 > :: remove( ) //T1 wird zurückgegeben 

{ 

if (empty ( )) 

{ 

cerr element; 

element xp-element = p-front; 

p-front = p-front -> next; 

delete p-element; 

return element; 

} 

Container und Algorithmen: 

Beispiel: 

... 

vektor v(3); //Vektor v der Länge 3 

v[0] = 7; 

v[1] = v[0] + 3; 

v[2] = v[1] + 8; 

//Anwendung eines Algorithmus 

reverse (v.begin(), v.end()); 

//global generische Funktion (arbeitet auf einem Bereich) 

Beispiel: valarray-Template 

Felder für numerische Operationen. 

Methoden erzeugen, kopieren, löschen, Wertzuweisung, Elementarzugriff, Elemente 

verschieben, ... 

Operatoren: Arithmetische Operationen, Vergleichsoperator, math. Funktionen 

#include 

59

#include 

int size = s; 

typedef valarray < double > darray; 

int main( ) 

{ 

darray v1(size), v2(size), v3(size); 

darray va(size); 

int i; 

for (i=0; i

Kapitel 15 – Programmerzeugung mit „make“ 

15.1 Funktions-Templates 

Zweck: 

- automatische Prüfung von Abhängigkeiten von Programmquellen 

- Steuerung der Übersetzungs- und Bindungsvorgänge, der Bibliotheken-Erzeugung, der 

Installation von Paketen, der Verzeichnisbereinigung 

Beispiel: makefile 

#einfacher makefile zu 15.1 

qtest 1.0 :„qtest.cc queue_contained.tv g++ -g –Wall –c qtest1.cc –o qtest1.o" 

#ausführbare Datei 

qtest1: qtest1.o g++ -g –o qtest1.e qtest1.o 

wobei der große Abstand durch einen Tabulator erreicht wird und –g für den Debugger steht. 

–o wird für objectfiles verwendet. Alle Warnungen sind angeschaltet 

#Hilfsdateien löschen 

clean: rm –f *.o *.e *.bak 

Aufbau einer make-Regel: 

Ziel: Abhängigkeiten Abhängigkeiten 

Kommando 

wobei der Abstand wieder ein Tabulator ist 

Aufruf der Kommandozeile: 

...> make //nur make tippen 

...> make –f makefile 

15.1.1 Makros 

Zweck: 

- Verbesserung / Verkürzung der Schreibweise 

- sicherer (jede Inform. nur einmal) 

Makrodefinition: 

Name = Zeichenkette 

Verwendung: 

$(Name) oder ${Name} 

Beispiel: makefile mit Makros 

CC = g++ #Compiler-Name 

CFLAGS = –c –g –Wall 

LDFLAGS = –g 

LIBS = –lm –lg++ 

qtest1.o: 

qtest1.e: 

clean: 

qtest1.cc queue container.h 

$(CC) $(CFLAGS) qtest1.cc qtest1.o 

qtest1.o queue container.h 

$(CC) $(LDFLAGS) –o $@ qtest1.o $(LIBS) 

rm –f *.o *.e *.bak *.bak~ 

mögliche Aufrufe: 

nur Übersetzung von qtest1.cc 

make qtest1.o 

61

Interne Makros 

Binden von qtest1.e (evtl. übersetzen) 

make qtest1.e 

Hilfsdateien löschen 

make clean 

Es existiert eine Reihe vordefinierter Ziele und Makros 

$@ Name des augenblicklichen Zieles 

$< Name der abhängigen Dateien, die jünger sind als das augenblickliche Ziel (nur im 

Suffix-Regeln) 

... 

15.1.2 Suffix-Regeln 

Zweck: 

ähnliche Regeln zu einer Regel zusammenfassen (es ist blödsinnig, 500 ähnliche Regeln 

einzeln aufzustellen) 

Beispiel: makefile, Verwendung von Suffix-Regeln 

OBJS = main.o sub1.o sub2.o sub3.o 

LIB = /home/mueller/lib/p1.a 

Programm: 

Ausführung: 

$(OBJS) $(LIB) 

$(CC) –o $@ $(OBJS) $(LIB) 

make 

geltende Regeln 

.SUFFIXES: .o .c .s ... 

.c.o: 

//2 Leerzeichen 

$(CC) $(CFLAGS) –c $< 

.SUFFIXES 

interne Liste gültiger Dateiendungen 

.c.o: Ziel; Erzeugung eines Objekts aus einer gleichnamigen C- 

Datei 

$(CC) 

voreingestellter Compiler-Name 

$(CFLAGS) 

voreingestellter Compiler-Schalter 

Aufruf von make 

make sub2.o 

62

Kapitel 16 – Grafische Benutzer-Oberflächen (GUI) 

GUI = graphische Benutzer-Oberflächen 

16.1 MVC-Konzept 

Model 

View 

Controller 

Anwendung: 

Graphische Bibliothek (Matrix, Qt, ...) 

Basissystem (X-Window, ...) 

Treiber 

Hardware 

Programmiermodell für graphische Bibliotheken: 

Initialisierung – Verbindung zum X-Server 

Interne Datenstrukturen initialisieren (graph. Objekte, Zeichensätze, Farben,...) 

evtl. callback-Funktion registrieren 

Graphische Objekte zeigen 

Ereignissteuerung – Hauptschleife starten 

callback „Berechnung starten, graphische Objekte verschieben“ 

Programm beenden 

Programmteile: 

1) Erzeugung graphischer Objekte 

GUI Toolkit 

direkte programmierung 

2) Hauptschleife (Controller) 

Bestandteil der Graphikbibliothek 

3) Anwendungsteile (Model) 

Berechnungen 

16.2 X-Windows 

siehe auch Folie 25! 

- mehrere Clients können denselben Server verwenden 

- X ist ereignisgesteuert 

Die 4 Typen von Botschaften 

REPLY Antwort des Servers 

EVENT Nachricht des Servers, z.B. Mausbewegung 

ERROR Fehlernachricht des Servers 

DISPLAY Requests und Events werden gepuffert (Verteilung der Netzlast) 

Request = Zeichenauftrag; Abfrage von Informationen durch den Client 

63

16.4 Die Qt-Bibliothek 

Qt C++-Klassenbibliothek UNIX(X11), Windows 

Folien: API Structure Overview + Kernel Classes 

Beispiel: 

Ausgabe eines Knopfes mt Beschriftung 

#include < qapplication.h > 

#include < qpushbutton.h > 

int main (int arg c, char **arg v) { 

Qapplication a (arg c, arg v); 

QPushButton hello („Hallo Welt!“); 

hello.resize (100,30); 

a.set MainWidget (&hello); //hello wird Hauptfenster 

hello.show(); 

return a.exec(); 

} 

Beispiel: 

Ausgabe eines Knopfes mit Funktionalität „quit“ 

#include < qapplication.h > 

#include < qpushbutton.h > 

int main (int arg c, arg v) 

{ 

Qapplication a (arg c, arg v); 

QPushButton hello („Hallo Welt!“); 

quit.resize (75,30); 

QObject::connect ( 

&quit, 

SIGNAL(clicked()), 

&a, 

SLOT(quit()); 

} 

a.set MainWidget (&quit); 

quit.show(); 

return a.exec(); 

Erläuterung zur wichtigsten (roten) Zeile: 

64

16.5 Signal-Slot-Mechanismus 

Signal: 

Ereignis-Mitteilungen werden anonym – d.h. ohne ausdrücklichen Empfänger 

– abgegeben. 

Das Objekt kann nicht feststellen, ob und wie das Signal verwendet wird. ( 

Obkekt kann als Komponente einfach wieder verwendet werden!) 

Slot: 

Slots sind Komponentenfunktionen. 

Ein Slot kann nicht feststellen, ob und welche Signale zugeordnet sind. 

Mehrfachzuordnungen sind möglich. ( Wiederverwendbarkeit!) 

Bsp.: 

Signal- und Slot-Mechanismus 

1) Qt-Klasse, abgeleitet von QObject (Basisobjekt) 

class Foo : public QObject 

{ Q_OBJECT Makro 

public: 

Foo( ); 

int value( ) {return val;} 

public slots: 

void setValue (int); 

signals: 

void value (hanged (int)); 

}; 

private: 

int val; 

2) Implementierung des Slots 

void Foo :: setValue (int v) 

{ 

if (v != val) 

{ 

val = v; 

emit valueChanged (v); 

} 

} 

3) Verbindung zweier Objekte 

Foo a, b; 

connect ( 

b.setValue (11); 

a.setValue (79); 

b.value ( ); 

&a, SIGNAL (valueChanged (int)), 

&b, SLOT (setValue (int))); 

Das valueChanged-Signal von a erreicht den Slot von b 

65

Neue Schlüsselwörter (der Qt-Bibliothek) 

public slots, signal, emit, ... 

Signals: 

- zufällige Reihenfolge der Slot-Aufrufe bei Mehrfachverknüpfungen 

- Rückkehr aus emit, wenn alle Slots abgearbeitet sind 

Slots: 

- normale Komponentenfunktionen 

- Regelung der Zugriffsrechte über public, protected, private 

MOC (Meta Object Compiler) 

- erzeugt aus den zusätzlichen Qt-Schlüsselwörtern C++-Code 

- Aufruf über make-Datei 

Event-Filter: 

- ein Objekt, das alle Signale bekommt, die für ein anderes Objekt bestimmt sind 

- Filter reagiert selbst oder sendet das Signal weiter 

Kapitel 17 – Error- Handler und Exceptions 

17.1 Funktionszeiger 

Beispiel: 

#include 

void f0 ( ) {printf („Fkt 0 \n“)} 



typedef void (*FPT) ( ); 

int main( ) 

{ 

FTP ftp[ ] = { f0, f1, f2}; 

fpt[2] ( ); 

return 0; 

} 

//Fkt.zeiger FPT 

 

66

Skript Programmierung C/C++

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?