Programmierkurs C

Sommersemester 2011, 8. Vorlesung

Stuttgart, den 20. April 2011

Heiko SchulzUniversity of Stuttgart, Math. department

Rückschau 238

L Matrizen und Vektoren als dynamische Strukturen, Operationen,

L Programmierbeispiel zu Schlangen,

L Datentyp bool,L mehrdimensionale Datenstrukturen - Graphen und Bäume:

L gerichtete und ungerichtete Graphen,L Wege in Graphen,L zusammenhängende und nicht zusammenhängende Graphen,L Zyklen in Graphen,L Bäume als spezielle Graphen,L Nachbarschaftsbeziehungen,L Graphen im Computer: Adjazenzmatrizen und Adjazenzlisten.

Graphen: definitions.h 239

Realisierung z.B. über Adjazenzmatrix: A � �ai ,j�ni,j�1 > R

n�n mit

ai ,j �

¢̈¨¦¨̈¤

1, falls �i , j� > E,

0, sonst.

#in c l u d e < s t d i o . h>#de f i n e MAXV 100 //Max . Kno tenzah l

t ypede f s t r u c t {i n t knoten [MAXV] [MAXV] ; // Ad j a z e n zma t r i x

i n t n_knoten ; // Anzah l d e r Knoten

i n t n_kanten ; // Anzah l d e r Kanten

} graph ;

vo i d i n i t g r a p h ( g raph *g ) ;vo i d r e a d a d jm a t r i x ( g raph *g ) ;vo i d p r i n t a d j m a t r i x ( g raph *g ) ;

Graphen: functions.c 240

#in c l u d e " d e f i n i t i o n s . h"

//Graph i n i t i a l i s i e r e n ( Ad j a z e n zma t r i x )

vo i d i n i t g r a p h ( g raph *g ) {i n t i , j ;

f o r ( i =0; i <g�>n_knoten ; i ++) {f o r ( j =0; j <g�>n_knoten ; j ++) {// Da t e n s t r u k t u r e n i n i t i a l i s i e r e n

g�>knoten [ i ] [ j ] = 0 ;g�>knoten [ j ] [ i ] = 0 ;}

}}

Graphen: functions.c 241

// Ad j a z e n zma t r i x e i n l e s e n

vo i d r e a d a d jm a t r i x ( g raph *g ) {i n t i , x , y ;

// Hauptpa ramete r e i n l e s e n

p r i n t f ( " Anzah l Ecken und Anzah l Kanten e i ngeben ,du rch L e e r z e i c h e n g e t r e n n t : " ) ;

s c a n f ( "%d %d" ,&(g�>n_knoten ) ,&(g�>n_kanten ) ) ;

i n i t g r a p h ( g ) ; //Graph i n i t i a l i s i e r e n

//Kanten e i n l e s e n

f o r ( i =0; i <g�>n_kanten ; i ++) {p r i n t f ( "%i � t e Kante i n de r Form ' Knoten1 Knoten2 '

e i n g e b en : " , i +1) ;s c a n f ( "%d %d" ,&x ,&y ) ;g�>knoten [ x � 1 ] [ y �1] = 1 ;g�>knoten [ y � 1 ] [ x �1] = 1 ;

}}

Graphen: functions.c 242

// Ad j a z e n zma t r i x ausgeben

vo i d p r i n t a d j m a t r i x ( g raph *g ) {

p r i n t f ( "Kanten des Graphen : \ n" ) ;

f o r ( i n t x =0; x<g�>n_knoten ; x++) {f o r ( i n t y =0; y<g�>n_knoten ; y++) {

i f ( g�>knoten [ x ] [ y ] == 1) {p r i n t f ( " ( v%i , v%i ) \n" , x +1 , y +1) ;

}}

}}

Graphen: graph.c 243

/* graph . c */

#in c l u d e " d e f i n i t i o n s . h"

// Haup t f u n k t i o n

i n t main ( ) {g raph g ; // V a r i a b l e des Daten typs g raph

r e a d a d jm a t r i x (&g ) ; //Graph e i n l e s e n

p r i n t a d j m a t r i x (&g ) ; //Graph ausgeben

// . . .

//

r e t u r n 0 ;}

Binäre Bäume � Implementierung 244

L Struktur (binärer Baum):

1 s t r u c t n o d e b i n t r e e {2 TYP VAR_1;3 TYP VAR_N;4 s t r u c t n o d e b i n t r e e * l e f t ;5 s t r u c t n o d e b i n t r e e * r i g h t ;6 s t r u c t n o d e b i n t r e e * a n c e s t o r ; // Vo r f a h r

7 } ;

L Rest wie bei verketteten Listen.

L Beispiele: Suchbäume, . . .

Datentyp bool: Beispiel 245

Es ist nachzuweisen, dass

a �2 b � �a - b� , � �a , b��

mit der binären Summe

a �2 b �� �a � b� mod 2

gilt. Anwendung: Spieltheorie, NIM-Spiel. Beim Nim-Spiel sind mehrereReihen mit Streichhölzern vorhanden. Zwei Spieler nehmen abwechselndStreichhölzer aus einer der Reihen weg. Wie viele sie nehmen, spieltkeine Rolle; es muss mindestens ein Streichholz sein und es dürfen beieinem Zug nur Streichhölzer einer einzigen Reihe genommen werden.Derjenige Spieler, der den letzten Zug macht, also die letztenStreichhölzer wegnimmt, gewinnt (Wikipedia).

Datentyp bool: Beispiel 246

#in c l u d e " d e f i n i t i o n s . h"

boo l binSumme ( boo l a , b oo l b ) {boo l r e s u l t ;i n t i a , i b ;i a =( i n t ) a ;i b =( i n t ) b ;r e s u l t =( boo l ) ( ( i a + i b )%2) ;r e t u r n ( r e s u l t ) ;

}

boo l au s s age ( boo l a , b oo l b ) {// r e t u r n ( ( a | | b ) && ( ! ( a && b ) ) ) ;

// r e t u r n ( binSumme ( a , b ) ) ;

r e t u r n ( ( ( a | | b ) && ( ! ( a && b ) ) ) == binSumme ( a , b ) ) ;}

Datentyp bool: Beispiel 247

i n t main ( ) {boo l a , b ;

p r i n t f ( " a b au s s age \n" ) ;f o r ( a= f a l s e ; a<= t r u e ; a++) {

f o r ( b= f a l s e ; b<= t r u e ; b++) {ausgabe ( a ) ;ausgabe ( b ) ;ausgabe ( au s s age ( a , b ) ) ;

p r i n t f ( "\n" ) ;i f ( b== t r u e ) break ;

}i f ( a== t r u e ) break ;

}

r e t u r n 0 ;}

Anwendung: Entwicklungssatz für Determinanten 248

Es sei A eine quadratische Matrix aus Rn�n. Dann lässt sich dieDeterminante von A über den Entwicklungssatz berechnen:

det�A� �n

Qj�1

ai ,jAi ,j (Entwicklung nach der i . Zeile)

berechnen. Dabei sind die Ai ,j die sogenannten Minoren:

Ai ,j � ��1�i�jdet�Mi ,j�,

wobei M > R�n�1���n�1� die Matrix ist, die durch Streichen der i . Zeileund j. Spalte aus A hervorgeht.

Idee: det�A� ist trivial für n � 2 det�A� � a11a22 � a12a21, rekursiverAufruf über den Entwicklungssatz, bis die Dimension auf n � 2 reduziertist.

Anwendung: Entwicklungssatz für Determinanten 249

mat r i x *minor ( ma t r i x *mat , i n t i , i n t j ) {ma t r i x * r e s u l t ;

i n t n , m;n=mat�>dim_n �1;m=mat�>dim_m�1;r e s u l t = i n i t_ma t r i x ( n ,m) ;f o r ( i n t i i =0; i i <n ; i i ++)

f o r ( i n t j j =0; j j <n ; j j ++)i f ( i i < i && j j < j ) r e s u l t �>e l emen te [ i i ] [ j j ]=mat�>

e l emen t e [ i i ] [ j j ] ;e l s e i f ( i i < i && j j >= j ) r e s u l t �>e l emen te [ i i ] [ j j ]=mat

�>e l emen te [ i i ] [ j j + 1 ] ;e l s e i f ( i i >= i && j j < j ) r e s u l t �>e l emen te [ i i ] [ j j ]=mat

�>e l emen te [ i i + 1 ] [ j j ] ;e l s e r e s u l t �>e l emen te [ i i ] [ j j ]=mat�>e l emen te [ i i + 1 ] [ j j

+ 1 ] ;ausgabe_matr i x ( r e s u l t ) ;

r e t u r n ( r e s u l t ) ;}

Anwendung: Entwicklungssatz für Determinanten 250

doub le d e t e rm i n a n t e ( ma t r i x *mat ) {i f (mat�>dim_m!=mat�>dim_n ) {

p r i n t f ( " d e t e rm i n a t e : Ma t r i x i s t n i c h t q u a d r a t i s c h . " ) ;e x i t ( �1) ;

}i f (mat�>dim_n==2) {

r e t u r n (mat�>e l emen te [ 0 ] [ 0 ] * mat�>e l emen te [ 1 ] [ 1 ]�mat�>e l emen te [ 0 ] [ 1 ] * mat�>e l emen te [ 1 ] [ 0 ] ) ;

}e l s e {

doub le summe=0;i n t vz =1;f o r ( i n t i =0; i <mat�>dim_n ; i ++) {

vz=�vz ;ma t r i x * s u bma t r i x ;s u bma t r i x=minor (mat , 1 , i ) ;summe+=vz *mat�>e l emen te [ 1 ] [ i ]* d e t e rm i n a n t e (

s u bma t r i x ) ;f r e e_ma t r i x ( s u bma t r i x ) ;

}r e t u r n ( summe) ;

}}

(etwas) mehr zum Thema gcc: Historie, etc. 251

L O�zieller Name: �GNU Compiler Collection�.

L Aktuelle Version: 4.6.0.

L GNU is Not Unix: Gedacht als OpenSource-Alternative für dieverschiedenen kommerziellen Unix-Varianten.

L Rahmen: �Free Software Foundation� (FSF), gegründet vonRichard Stallman, Lizenzmodell: GNU Public License (GPL), �FreeSoftware is not free beer�. Grundidee: �Freie Software� darf vonjedem benutzt und weiter entwickelt werden, aber die Ergebnissemüssen unter die selbe Lizenz gestellt werden � Schneeballe�ekt.

L Es entstanden zahlreiche weitere ähnliche, aber nicht so strengeLizenzmodelle, die eine Weiterverwendung in kommerziellenProdukten ermöglichen (LGPL, BSD, Apache, ... MAC OS X!).

L Bei uns installiert: gcc-4.1, gcc-4.3, gcc-4.4. Es gibt auchSoftware, die zwingen gcc 3 erfordert.

(etwas) mehr zum Thema gcc: eigene Bibliotheken 252

L Bibliothek: Sammlung von Funktionen zu einem bestimmtenBereich.

L Bei einem gröÿerem Projekt ist dies auch für die eigenenAnwendungen sinnvoll. So kann man sich alle eigenen�Standardfunktionen� in einer Bibliothek speichern und dieseeinfach stets bei neuen Programmen hinzuverlinken.

L Beim Linken gibt es zwei Varianten:statisch: Die Bibliothek wird vom Linker bei derabschlieÿenden Erstellen des Programms (�Linken�) fest demProgramm hinzugefügt. Vorteil: Das Programm �ruht in sich�,ist auf jedem Computer mit �ähnlicher Hardware� und�ähnlichem Betriebsystem� sofort lau�ähig. Nachteil: DasProgramm wird u.U. sehr groÿ.dynamisch, �shared�: Es werden lediglich Verweise in dieBibliothek eingefügt. Vorteil: Das Programm bleibt klein.Nachteil: Die Bibliothek muss extra kopiert oder als vorhandenvorausgesetzt werden.

(etwas) mehr zum Thema gcc: eigene Bibliotheken 253

Beispiel:

L Erstellen einer statischen Bibliothek mylinalg.a, welche alleFunktionen aus dem �matrix-Beispiel� enthalten soll.

L Verwendung von ar zum Zusammenfassen von Dateien.L Make�le:

CC=gccOPTS=� s t d=c99 �Wal l � lmOBJECTS= i n i t . o ausgabe . o o p e r a t i o n e n . o

a l l : main m y l i n a l g . a

main : m y l i n a l g . a m y l i n a l g . h main . c$ (CC) $ (OPTS) main . c m y l i n a l g . a �o main

m y l i n a l g . a : $ (OBJECTS)a r r u s m y l i n a l g . a $ (OBJECTS)

%.o : %.c m y l i n a l g . h$ (CC) $ (OPTS) �c $ (OPTS) $<

(etwas) mehr ...: Optimierungsoptionen 254

Mit den Optimierungsoptionen -O, -O1, -O2 etc. pp. versucht derCompiler, den Code zu optimieren, d.h. er �inspiziert� das Programmund prüft, was evtl. über�üssig ist oder besser gemacht werden kann.Beispiele:

L Multiplikation mit 0,

L Ausdrücke vereinfachen,

L Schleifendurchläufen reduzieren...

Der Compiler wird dafür mehr Zeit zum Compilieren benötigen.Auÿerdem waren zu starke Optimierung (zumindestens früher) aucheine zusätzliche Fehlerquelle.

Die Zahl nach -O gibt die Optimierungsstufe an, je höher, um so mehrversucht der Compiler, das Programm zu beschleunigen.

Makros I 255

L Idee: textuelles Ersetzen bei der Übersetzung des Quelltextes spartTipparbeit, schnellere Ausführung als Funktionsaufruf

L Makros über #de�ne MAKRO:

#in c l u d e < s t d i o . h>#de f i n e MAX(a , b ) ( ( a <= b ) ? b : a )#de f i n e ABS( a ) ( ( a <=0) ? �a : a )

i n t MaxInt ( i n t a , i n t b ) {r e t u r n a >= b ? a : b ;

}i n t main ( ) {

i n t a=�5 , b=10 , maxi , a b s i ;f l o a t x =1 .0 , y =2 .0 , maxf , a b s f ;

p r i n t f ( "%d\n" , MAX( a , b ) ) ; // l i e f e r n das g l e i c h e

p r i n t f ( "%d\n" , MaxInt ( a , b ) ) ; // E r g e b n i s

p r i n t f ( "%f \n" , MAX( x , y ) ) ; // abe r MAX geht auch

h i e r

r e t u r n 0 ;}

Makros II 256

L Weiteres Beispiel:

1 #de f i n e boo l i n t //Datentyp i n t d e f i n i e r e n

2 #de f i n e t r u e 13 #de f i n e f a l s e 04 #de f i n e TRUE 15 #de f i n e FALSE 0

L Für Zeiger ist in stdlib.h de�niert:

#de f i n e NULL 0

Typische C-Fehler 257

Fehlerhafte Kommentare

a=b ; /* t h i s i s a bug

c=d ; /* c=d w i l l n e v e r happen */

Semikolon schlieÿt Befehl ab

i n t i // e r s t e V a r i a b l e

i n t j ; // zwe i t e V a r i a b l e

Typische C-Fehler 258

Kein Semikolon nach if, while, for

i f ( i ==1) ; {p r i n t f ( " i hat den Wert 1 !\ n" ) ;

}

f o r ( i =0; i <10; i ++) ; {// i r g e ndwa s machen

}

i n t x = 5 ;wh i l e ( x > 0 ) ;

x ��;

Typische C-Fehler 259

Syntax for-Schleife

f o r ( i =0 , i <10 , i ++) ; {// i r g e ndwa s machen

}

Richtig:

f o r ( i =0; i <10; i ++) {// i r g e ndwa s machen

}

Typische C-Fehler 260

break in case-Block vergessen

i n t x = 2 ;sw i t ch ( x ) {

case 2 :p r i n t f ( "Two\n" ) ;

case 3 :p r i n t f ( "Three \n" ) ;

}

Zuweisung in if-Kopf

i n t x = 5 ;i f ( x = 6 )

p r i n t f ( " x e q u a l s 6\n" ) ;

Typische C-Fehler 261

Zeiger nicht initialisiert

#i n c l u d e < s t r i n g . h>i n t main ( ) {

char * s t ;s t r c p y ( s t , " abc " ) ;r e t u r n 0 ;

}

Typische C-Fehler 262

Lokale Variable zurückgeben

#i n c l u d e < s t r i n g . h>char * f u n k t i o n ( ) {

char s t [ 2 0 ] ;s t r c p y ( s t , " abc " ) ;r e t u r n ( s t ) ;

}

Richtig:

#i n c l u d e < s t r i n g . h>char * f u n k t i o n ( ) {

char * s t =( char *) ma l l o c (20) ;i f ( ! s t ) r e t u r n NULL ; // k e i n S p e i c h e r

s t r c p y ( s t , " abc " ) ;r e t u r n ( s t ) ;

}

Typische C-Fehler 263

Zeichenkonstanten vs. Stringkonstanten

char ch = 'A ' ;char ch = "A" ;

Vorzeichenbehaftete vs. vorzeichenunbehaftete Werte

char s = 127 ;uns igned char u = 127 ;

s ++; // E r g e b n i s i s t n e g a t i v , �128

i f ( s<u ) { /* wahr */ }i f ( s >127) { /* n i e wahr */ }i f ( u<0) { /* n i e wahr */ }

Typische C-Fehler 264

Strings vergleichen mit strcmp

char s t 1 [ ] = " abc " ;char s t 2 [ ] = " abc " ;i f ( s t 1 == s t 2 )

p r i n t f ( "Yes" ) ;e l s e

p r i n t f ( "No" ) ;

Richtig:

i f ( s t rcmp ( st1 , s t 2 ) ==0) {// g l e i c h

} e l s e {// n i c h t g l e i c h

}

Typische C-Fehler 265

Strings kopieren, auf Laenge achten!

char * copy_st r = ma l l o c ( s t r l e n ( o r i g_ s t r ) ) ;s t r c p y ( copy_str , o r i g_ s t r ) ;

Richtig:

char * copy_st r = ma l l o c ( s t r l e n ( o r i g_ s t r ) +1) ;s t r c p y ( copy_str , o r i g_ s t r ) ;

Falsche Syntax in Ausdruecken

i f ( 0 < a < 5) { /* mach ' was */ }i f ( a =! b ) { /* mach ' was */ }

Richtig:

i f ( 0 < a && a < 5) { /* mach ' was */ }i f ( a != b ) { /* mach ' was */ }

Typische C-Fehler 266

Vergessene return-Anweisungen

i n t f u n k t i o n ( i n t a ) {i f ( a )

r e t u r n 1 ;}

Richtig:

i n t f u n k t i o n ( i n t a ) {i f ( a )

r e t u r n 1 ;e l s e

r e t u r n 0 ;}

Typische C-Fehler 267

�Hängenden Zeiger� verwenden

i n t *a ;a [ 1 0 ] = 0 ;

i n t *b=( i n t *) ma l l o c (10* s i z e o f ( i n t ) ) ;f r e e ( b ) ;b [ 1 0 ] = 5 ;

Speicherlecks

i n t i ,* a ;f o r ( i =0; i <10; i ++) {

a=( i n t *) ma l l o c (1000* s i z e o f ( i n t ) ) ;}f r e e ( a ) ;

p r i n t f ( " . . . " , matmalvek ( . . . ) ) ;

Typische C-Fehler 268

Aufpassen beim Referenzieren/Pointern

i n t x ;char * s t = ( char *) ma l l o c (31) ;i f ( ! s t ) e x i t ( 1 ) ; // k e i n S p e i c h e r

s c a n f ( "%d" , &x ) ; //& b e n o e t i g t */

s c a n f ( "%30s " , s t ) ; // k e i n & h i e r !

Versehentliches ganzzahliges Teilen

doub le h a l f = 1/2 ; // g a n z a h l i g !

doub le h a l f = 1 . 0 / 2 ; // f l i e s s k omma

i n t x = 5 , y = 2 ;doub le d = ( ( doub le ) x ) /y ; // f l i e s s k omma

Weitere typische C-Fehler 269

L Vergessen, Rückgabewert von malloc() oder calloc() zu testen(nicht NULL!),

L free() mehrmals mit selbem Zeiger aufrufen,

L free() mit Zeiger aufrufen, welcher nicht mitmalloc()/calloc() geholt wurde,

L Bereits freigegebenen Zeiger weiter verwenden (hängender Zeiger,dangling pointer),

L Speicherlecks (memory leak): Speicher wird geholt, wird aber nichtzurückgegeben.

Tipps und Tricks 270

L Richtige Einrückungen verwenden, insbesondere bei Schleifen,

L Bei Schleifen und if immer Klammern setzen: { ... },

L Variablen initialisieren (!),

L Immer Parameter von Funktionen überprüfen: Wertetest, NULL,etc.,

L Debugger benutzen.

Rückschau: Fortran 271

L Anfänge: 1953, erste wirklich realisierte Programmiersprache.

L Verschiedene Standards und Weiterentwicklungen, �Fortran 66�,�Fortran 77�, �Fortran 90�, ...

L Keine dynamische Speicherverwaltung, keine eigenen Datentypen,keine Strukturen, ....

L Aber: Einfach erlernbar, immer noch verbreitet, da es nach wie vorviel Software in Fortran gibt.

L Kombination von (u.a.) Fortan und C ist durch die Modultechnikoder das Einbinden von Bibliotheken möglich.

L Beispiel:

PROGRAM BEM2D

i n c l u d e ' pa r amete r . i n c 'i n c l u d e ' ma t r i x . i n c 'i n c l u d e 'mesh . i n c '

Rückschau: Fortran 272

INTEGER NE,ME, IECK (10) ,GRIDF , IEE (20*MAX_EMT)REAL*8 XIC (10) ,XE(20*MAX_PKT) ,FNZ(MAX_EMT)

INTEGER I , I1 , I2 , J , IEH (120*MAX_EMT) ,NH(20) , J0 ,ZA(MAX_EMT) ,Q

REAL*8 L1 , L2 ,DDF(20*MAX_PKT) ,F(MAX_PKT)REAL*8 H(40*MAX_EMT) ,NDE(10*MAX_EMT) ,HH(40*MAX_EMT)REAL*8 NDR(10*MAX_PKT) ,NDRD(10*MAX_EMT) ,NORM1,NORM2REAL*8 Y(2) ,U(2 ) ,UH(2) ,ERR

c WRITE(* ,* ) 'Q = 'c READ(* ,* ) Q

Q=6

CALL READIN(GRID)CALL PARREADIN(D,NU,MU,SMEP,VKEP,SMSP,VKSP,RELERR ,

&ZAS ,THETA,ZBC,ZREF , ZIA ,ZVOL,ZRHS ,XC)

. . .

Von C zu C++ 273

L C++ ist eine standardisierte höhere Programmiersprache, wurde ab1979 von Bjarne Stroustrup bei AT&T als Erweiterung derProgrammiersprache C entwickelt.

L Erweiterungen gegenüber C: weitere Datentypen sowie neuartigeTypenumwandlungsmöglichkeiten, Klassen, Ausnahmebehandlung,Templates (Schablonen), Namensräume, Überladen von Operatorenund Funktionsnamen, erweiterte Standardbibliothek u.v.m.

L Hauptunterschied zu C: C++ ist eine objektorientierteProgrammiersprache.

L Aufruf: g++, sehr ähnlich zu gcc.

L Übliche Dateiendung: .cpp.

Objektorientierung und Klassen 274

L Eine Klasse ist abstraktes Modell bzw. einen �Bauplan� für eineReihe von ähnlichen Objekten. Objekt einer gegebenen Klasse istsog. Instanz der Klasse.

L Klasse dient als Bauplan für Abbildung von realen Objekten inProgrammen, fasst Daten (sog. Attribute) und Funktionen (sog.Methoden) der Objekte zusammen. Salopp: �Klasse ist Datentypeines Objekts, also erweiterter Datentyp�

L �struct mit Funktionen�, so ist auch die Syntax(Zugri�soperatoren . und ->)

L Für Klassen können die üblichen Operatoren de�niert werden:+,-,/,*, etc. (man spricht von überladen).

L Warum Klassen? Vereinfachung durch Aufteilung der Programmein Sinneinheiten. Weniger Fehler, Klassen können getrennt getestetwerden.

L Konstruktor und Destruktor zum Erzeugen (Speicher holen,Initialisierung) bzw. �Aufräumen� einer Variablen bzw. Instanz.

Beispielklasse � Bruch 275

c l a s s b ruch {p r i v a t e : // nur f u e r Methoden de r K l a s s e s i c h t b a r

i n t nenne r ; // V a r i a b l e n h e i s s e n A t t r i b u t e

i n t z a e h l e r ;

p u b l i c : // von a l l e n s i c h t b a r

b ruch & op e r a t o r =( cons t b ruch &x ) ; // Zuwe isung

b ruch & op e r a t o r +( cons t b ruch &x ) ; // Ad d i t i o n

// Funk t i onen h e i s s e n "Methoden"

vo i d s e t z e ( i n t n , i n t z ) { nenne r=n ; z a e h l e r =z ; }i n t nenne r ( ) { r e t u r n nenne r ; }i n t z a e h l e r ( ) { r e t u r n z a e h l e r ; }

} ;

i n t main ( ) {b ruch a , b , c ; // I n s t a n z e n b i l d e n

a . s e t z e (1 , 2 ) ; //Methode " s e t z e " a u f r u f e n , w ie s t r u c t

b . s e t z e (2 , 3 ) ;c=a+b ; //Geht , da Ope ra to r en +,= " u e b e r l a d e n " wurden

r e t u r n 0 ; }

Beispiel mit Konstruktor und Destruktor 276

/* l a d e e d u . com */

#in c l u d e < io s t r e am >

c l a s s Rechteck{ // E ine e i n f a c h e K l a s s e

i n t Hoehe ;i n t B r e i t e ;

p u b l i c :Rechteck ( vo i d ) ; // mit e inem

Kons t r u to r ,

i n t F l a e c h e ( vo i d ) ; // zwe i Methoden ,

vo i d I n i t i a l i s i e r e ( i n t , i n t ) ;~Rechteck ( vo i d ) ; // und e inem

De s t r u k t o r

} ;

Beispiel mit Konstruktor und Destruktor 277

Rechteck : : Rechteck ( vo i d ) // Kon s t r u k t o r

{Hoehe = 6 ;B r e i t e = 6 ;

}

i n t Rechteck : : F l a e c h e ( vo i d ) // F l a e c h e des

Rech teck s

{r e t u r n Hoehe * B r e i t e ;

}

vo i d Rechteck : : I n i t i a l i s i e r e ( i n t I n iHoehe , i n t I n i B r e i t e ){

Hoehe = I n iHo eh e ;B r e i t e = I n i B r e i t e ;

}

Beispiel mit Konstruktor und Destruktor 278

Rechteck : : ~ Rechteck ( vo i d ) // De s t r u k t o r

{Hoehe = 0 ;B r e i t e = 0 ;

}

s t r u c t Mast{

i n t Laenge ;i n t T i e f e ;

} ;

i n t main ( ){

Rechteck Box , Quadrat ;Mast Fahnenmast ;

s t d : : cout << "Der F l a e c h e n i n h a l t d e r Box i s t " <<Box . F l a e c h e ( ) << "\n" ;

s t d : : cout << "Der F l a e c h e n i n h a l t des Quadra te s i s t "<<Quadrat . F l a e c h e ( ) << "\n" ;

Beispiel mit Konstruktor und Destruktor 279

// Box . Hoehe = 12 ;

// Box . B r e i t e = 10 ;

// Quadrat . Hoehe = Quadrat . B r e i t e = 8 ;

Box . I n i t i a l i s i e r e (12 , 10) ;Quadrat . I n i t i a l i s i e r e (8 , 8) ;

Fahnenmast . Laenge = 50 ;Fahnenmast . T i e f e = 6 ;

s t d : : cout << "Der F l a e c h e n i n h a l t d e r Box i s t " <<Box . F l a e c h e ( ) << "\n" ;

s t d : : cout << "Der F l a e c h e n i n h a l t des Quadra te s i s t "<<

Quadrat . F l a e c h e ( ) << "\n" ;// s t d : : cout << "Die boese F l a e c h e i s t " <<

// F l a e c h e ( Quadrat . Hoehe , Fahnenmast .

T i e f e ) << "\n " ;

r e t u r n 0 ;}

// E r g e b n i s beim Aus f u eh r en

//

// Der F l a e c h e n i n h a l t d e r Box i s t 36

// Der F l a e c h e n i n h a l t des Quadra te s i s t 36

// Der F l a e c h e n i n h a l t d e r Box i s t 120

// Der F l a e c h e n i n h a l t des Quadra te s i s t 64

Vielen Dank... 280

... für Ihre Aufmerksamkeit

und �bis morgen�...