Programmierkurs C. Sommersemester 2011, 5. Vorlesung. Stuttgart, den 15. April Heiko Schulz. University of Stuttgart, Math.

Transkript

1 Programmierkurs C Sommersemester 2011, 5. Vorlesung Stuttgart, den 15. April 2011 Heiko Schulz University of Stuttgart, Math. department

2 Rückschau 161 Zeiger und Felder Komplexe Datentypen (struct) Dateioperationen und die Struktur FIE Dateioperationen: zeichenweise, stringweise, formatiert Algorithmen: Suchen und Sortieren, untere Schranken andau-symbole

3 Caesar-Chire 162 Aufgabenstellung: Implementierung des Caesar-Chire. Einfachen Art der Verschlüsselung: Es wird zu jedem Zeichen c zwischen 'a' und 'z' bzw. 'A' und 'Z' eine positive ganze Zahl 1 B x B 25 addiert (x ist der geheime Schlüssel) Springt bei der Addition das Zeichen c über 'z' bzw. 'Z' hinaus, so wird 26 von c abgezogen, so dass c also wieder zwischen 'a' und 'z' bzw. 'A' und 'Z' liegt. Entschlÿselung mit gleichem Verfahren: jedem Zeichen den ihm bekannten Wert y 26 x addieren und erhält (nach eventuellem verschieben, falls das Zeichen aus dem Bereich 'a' bis 'z' bzw. 'A' bis 'Z' herausspringt) so den Klartext der Nachricht. Einfach zu entschlüsseln, da jedem Zeichen genau ein anderes Zeichen zugeordnet ist, d.h. man bekommt knackt den Schlüssel z.b. leicht durch einen Häugkeitsvergleich.

4 Caesar-Chire 163 /* c a e s a r. c */ #i n c l u d e < s t d i o. h> c h a r c a e s a r ( c h a r c, i n t key ) { // c um k e y w e i t e r s c h i e b e n i n t r e s u l t =c ; i f ( ( r e s u l t >= ' a ' ) && ( r e s u l t <= ' z ' ) ) { // k l e i n e r B u c h s t a b e r e s u l t = r e s u l t +key ; i f ( r e s u l t > ' z ' ) // a u s s e r h a l b d e s B e r e i c h s r e s u l t =26; // z u r u e c k s c h i e b e n i f ( ( r e s u l t >= 'A ' ) && ( r e s u l t <= 'Z ' ) ) { // g r o s s e r B u c h s t a b e r e s u l t = r e s u l t +key ; i f ( r e s u l t > 'Z ' ) // a u s s e r h a l b d e s B e r e i c h s r e s u l t =26; // z u r u e c k s c h i e b e n r e t u r n ( c h a r ) r e s u l t ;

5 Caesar-Chire 164 i n t main ( ) { u n s i g n e d c h a r c ; FIE * f = f o p e n ( " c h i f f r e. t x t ", " r t " ) ; // D a t e i o e f f n e n i f (! f ) { p r i n t f ( " F e h l e r beim O e f f n e n d e r D a t e i! \ n" ) ; r e t u r n 1; w h i l e (! f e o f ( f ) ) { // s o l a n g e e s e t w a s zu e s e n g i b t c =( u n s i g n e d c h a r ) f g e t c ( f ) ; // Z e i c h e n l e s e n c= c a e s a r ( c, 1 3 ) ; // Z e i c h e n r o t i e r e n p r i n t f ( "%c ", c ) ; // Z e i c h e n a u s g e b e n f c l o s e ( f ) ; // D a t e i s c h l i e s s e n r e t u r n 0 ;

6 chiffre.txt Faust. Der Tragödie erster Teil 165 Ihr naht euch wieder, schwankende Gestalten! Die früh sich einst dem trüben Blick gezeigt. Versuch' ich wohl euch diesmal fest zu halten? Fühl' ich mein Herz noch jenem Wahn geneigt? Ihr drängt euch zu! nun gut, so mögt ihr walten, Wie ihr aus Dunst und Nebel um mich steigt; Mein Busen fühlt sich jugendlich erschüttert Vom Zauberhauch der euren Zug umwittert.

7 Komplexe Zahlen complex.c 166 /* c o m p l e x. c */ #i n c l u d e < s t d i o. h> #i n c l u d e <math. h> s t r u c t complex { d o u b l e r e ; d o u b l e im ; ; v o i d ausgabe_complex ( s t r u c t complex z ) { // p r i n t f (" Re = % l f, Im = % l f ", z. r e, z. im ) ; p r i n t f ( "%l f +% l f * I ", z. re, z. im ) ; r e t u r n ;

8 Komplexe Zahlen complex.c 167 s t r u c t complex d i f f e r e n z _ c o m p l e x ( s t r u c t complex z1, s t r u c t complex z2 ) { s t r u c t complex r e s u l t ; r e s u l t. r e =z1. re z2. r e ; r e s u l t. im=z1. imz2. im ; r e t u r n r e s u l t ; s t r u c t complex produkt_complex ( s t r u c t complex z1, s t r u c t complex z2 ) { s t r u c t complex r e s u l t ; r e s u l t. r e =( z1. r e * z2. r e z1. im * z2. im ) ; r e s u l t. im =( z1. r e * z2. im + z1. im * z2. r e ) ; r e t u r n r e s u l t ;

9 Komplexe Zahlen complex.c 168 s t r u c t complex q u o t i e n t _ c o m p l e x ( s t r u c t complex z1, s t r u c t complex z2 ) { d o u b l e a=z1. re, b=z1. im, c=z2. re, d=z2. im ; s t r u c t complex r e s u l t ; i f ( ( c!= 0. 0 && d!= 0. 0 ) ) { r e s u l t. r e =( a * c+b*d ) /( c * c+d*d ) ; r e s u l t. im =( b*ca *d ) /( c * c+d*d ) ; r e t u r n r e s u l t ; r e s u l t. r e =0; r e s u l t. im =0; r e t u r n r e s u l t ;

10 Komplexe Zahlen complex.c 169 i n t main ( ) { s t r u c t complex z1, z2 ; z1. r e = 1. 0 ; z1. im = 2. 0 ; z2. r e = 3. 0 ; z2. im = 2. 0 ; p r i n t f ( " z1 z2 = " ) ; ausgabe_complex ( d i f f e r e n z _ c o m p l e x ( z1, z2 ) ) ; p r i n t f ( "\n" ) ; p r i n t f ( " z1 * z2 = " ) ; ausgabe_complex ( produkt_complex ( z1, z2 ) ) ; p r i n t f ( "\n" ) ; p r i n t f ( " z1 / z2 = " ) ; ausgabe_complex ( q u o t i e n t _ c o m p l e x ( z1, z2 ) ) ; p r i n t f ( "\n" ) ; r e t u r n 0 ;

11 Die Mathematikbibliothek math.h I 170 d o u b l e a c o s ( d o u b l e x ) a r c u s c o s i n u s d o u b l e a s i n ( d o u b l e x ) a r c u s s i n u s d o u b l e a t a n ( d o u b l e x ) a r c u s t a n g e n s d o u b l e c e i l ( d o u b l e x ) k l e i n s t e r I n t e g e r, d e r g r o e s s e r a l s x i s t d o u b l e c o s ( d o u b l e x ) c o s i n u s d o u b l e c o s h ( d o u b l e x ) c o s i n u s h y p e r b o l i c u s d o u b l e exp ( d o u b l e x ) E x p o n e n t i a l F u n k t i o n d o u b l e f a b s ( d o u b l e x ) A b s o l u t b e t r a g d o u b l e f l o o r ( d o u b l e x ) g r o e s s t e r I n t e g e r, d e r k l e i n e r a l s x i s t d o u b l e l o g ( d o u b l e x ) l n ( x ), o g a r i t h m u s z u r B a s i s e d o u b l e l o g 1 0 ( d o u b l e x ) o g a r i t h m u s z u r B a s i s 10 d o u b l e pow ( d o u b l e x, d o u b l e y ) P o t e n z f u n k t i o n x^y d o u b l e s i n ( d o u b l e x ) s i n u s d o u b l e s i n h ( d o u b l e x ) s i n u s h y p e r b o l i c u s d o u b l e s q r t ( d o u b l e x ) Q u a d r a t w u r z e l d o u b l e t a n ( d o u b l e x ) t a n g e n s d o u b l e t a n h ( d o u b l e x ) t a n g e n s h y p e r b o l i c u s

12 Die Mathematikbibliothek math.h II, Konstanten 171 M_E E, d i e B a s i s d e s n a t u e r l i c h e n o g a r i t h m u s M_OG2E log_2 (E) M_OG10E log_10 (E) M_N2 l n ( 2 ) M_N10 l n ( 1 0 ) M_PI P i M_PI_2 P i /2 M_PI_4 P i /4 M_1_PI 1/ P i M_2_PI 2/ P i M_2_SQRTPI 2/ S q r t ( P i ) M_SQRT2 Wurzel von 2 M_SQRT1_2 Wurzel von 1/2

13 Anwendung: Newtonverfahren 172 Aufgabenstellung: Gegeben sei eine Funktion f R R, gesucht ist eine Nullstelle x 0 : f ˆx 0 0. ösungsidee: Taylorentwicklung um x 0 : 0 f ˆx 0 f ˆx ˆx 0 x f œˆx Oˆx 0 x 2, falls f œœˆξ B c ξ > ˆx 0, x. Umformen nach x 0 ergibt x 0 x f ˆx f œˆx Oˆx 0 x 2, Ô Iterationsidee: x n1 x n f ˆx n f œˆx n.

14 Newtonverfahren newton.c 173 /* newton. c */ #i n c l u d e < s t d i o. h> // Ein und Ausgabe #i n c l u d e <math. h> // M a t h e m a t i k f u n k t i o n e n c o n s t d o u b l e e p s =1.0 e 6; d o u b l e f u n c ( d o u b l e x ) { r e t u r n s i n ( x ) x * x / 2. 0 ; d o u b l e d f u n c ( d o u b l e x ) { r e t u r n c o s ( x )x ;

15 Newtonverfahren newton.c 174 i n t main ( ) { d o u b l e xn, d e l t a ; i n t n =0; // xn = 1. 0 ; xn = ; do { n ++; d e l t a = f u n c ( xn ) / d f u n c ( xn ) ; xn=xn d e l t a ; p r i n t f ( "x_%i = %f, d e l t a = %f \n", n, xn, d e l t a ) ; w h i l e ( f a b s ( d e l t a )> e p s ) ; p r i n t f ( " f e r t i g! \ n" ) ; r e t u r n 0 ;

16 Kommandozeilenargumente 175 Bisher wurde die Funktion main durch void main (void) { Anweisungen oder int main (void) { Anweisungen deniert. Will man bereits beim Programmstart Argumente übergeben, so muss man die Funktion main folgendermaÿen denieren: int main ( int argc, char *argv []) { Anweisungen Dabei ist argc die Anzahl der übergebenen Argumente und argv ist ein Array von Zeigern, welche auf den Anfang eines als String übergegebenen Kommandozeilenarguments zeigen. argv[0] enthält den Programmnamen.

17 Kommandozeilenargumente Beispielprogramm 176 #i n c l u d e < s t d i o. h> /* a r g u m e n t s. c Programm, w e l c h e s s e i n e K o m m a n d o z e i l e n a r g u m e n t e a u s g i b t */ i n t main ( i n t argc, c h a r * a r g v [ ] ) { p r i n t f ( " D i e s e s Programm h e i s s t %s \n", a r g v [ 0 ] ) ; p r i n t f ( " Es e r h i e l t %d Parameter : \n", argc 1) ; f o r ( i n t i =1; i < a r g c ; i ++) p r i n t f ( "\ t %d. P arameter : %s \n", i, a r g v [ i ] ) ; r e t u r n 0 ;

18 Kommandozeilenargumente Beispielprogramm 177 #i n c l u d e < s t d i o. h> #i n c l u d e < s t d l i b. h> i n t main ( i n t argc, c h a r * a r g v [ ] ) { i f ( a r g c! = 2 ) { p r i n t f ( " A u f r u f : %s dim \n", a r g v [ 0 ] ) ; // i n t dim= a r g v [ 1 ] ; // i n t dim =( i n t ) a r g v [ 1 ] ; i n t dim= a t o i ( a r g v [ 1 ] ) ; p r i n t f ( " D i m e n s i o n : %s \n", a r g v [ 1 ] ) ; p r i n t f ( " D i m e n s i o n : %d\n", dim ) ; d o u b l e m a t r i x [ dim ] [ dim ] ; p r i n t f ( " s i z e o f ( m a t r i x ) = % l i \n", s i z e o f ( m a t r i x ) ) ; r e t u r n 0 ;

19 Dynamische Speicherallokation 178 Statische Felder sind oft zu unexibel. Ausweg: Dynamische Speicherallokation. Die Funktion malloc(n) liefert einen Zeiger auf die Startadresse eines n Byte groÿen Speicherbereichs, der dem Programm zur Verfügung gestellt wird. calloc(num, size) alloziert Speicherplatz für num Objekte der Gröÿe size Bytes und initialisiert alle Objekte mit Nullen. realloc(ptr,n) ändert die Gröÿe des Speicherbereichs, auf den der Zeiger ptr zeigt. free(ptr) gibt den Speicherbereich, auf den ptr zeigt, wieder frei.

20 Dynamische Speicherallokation 179 Rückgabetyp von malloc und calloc ist ein Zeiger auf leeren Datentyp, void *, der je nach Verwendungszweck umgewandelt (cast) werden muss. Beispiel: i n t * f e l d =( i n t *) m a l l o c ( n* s i z e o f ( i n t ) ) ; Vorsicht: C hat im Gegensatz zu anderen Sprachen (wie z.b. Java) keine automatische Speicherverwaltung, d.h. der Speicher muss explizit wieder freigegeben werden.

21 Dynamische Speicherallokation Beispiel 180 /* a l l o c. c */ #i n c l u d e < s t d i o. h> #i n c l u d e < s t d l i b. h> i n t main ( ) { d o u b l e * v p t r ; // Z e i g e r a u f d o u b l e F e l d i n t n ; // aenge d e s F e l d s p r i n t f ( "Wie g r o s s s o l l e n d i e V e k t o r e n s e i n?" ) ; s c a n f ( "%u", &n ) ; v p t r = ( d o u b l e *) m a l l o c ( n* s i z e o f ( d o u b l e ) ) ; i f ( v p t r == NU ) { p r i n t f ( "Zu w e n i g S p e i c h e r! \ n" ) ; e x i t ( 1 ) ; // Programm a b b r e c h e n v p t r [ 0 ] = 0. 0 ; // i r g e n d w a s m i t v p t r machen v p t r [ n 1]= v p t r [ 0 ] ; f r e e ( v p t r ) ; // n i c h t v e r g e s s e n : F r e i g e b e n! r e t u r n 0 ;

22 Dynamische Speicherallokation Beispiel II 181 /* dynmat. c */ #i n c l u d e < s t d i o. h> #i n c l u d e < s t d l i b. h> i n t main ( ) { u n s i g n e d i n t n, i, j ; d o u b l e *M; // f u e r M a t r i x p r i n t f ( "n x n M a t r i x b i t t e n e i n g e b e n : " ) ; s c a n f ( "%u", &n ) ; // S p e i c h e r h o l e n M = ( d o u b l e *) m a l l o c ( n*n* s i z e o f ( d o u b l e ) ) ; i f ( M == NU ) { p r i n t f ( "Zu w e n i g S p e i c h e r! \ n" ) ; e x i t ( 1) ; // Programm a b b r e c h e n

23 Dynamische Speicherallokation Beispiel II 182 f o r ( i = 0 ; i < n ; i ++) { // E i n h e i t s m a t r i x e r z e u g e n f o r ( j =0; j < n ; j ++) { i f ( i == j ) M[ i *n+ j ] = 1. 0 ; e l s e M[ i *n+ j ] = 0. 0 ; f r e e (M) ; r e t u r n 0 ;

24 Dynamische Speicherallokation Beispiel III 183 /* dynmat2. c */ #i n c l u d e < s t d i o. h> #i n c l u d e < s t d l i b. h> i n t main ( ) { u n s i g n e d i n t n, i, j ; d o u b l e **M; // f u e r M a t r i x p r i n t f ( "n x n M a t r i x b i t t e n e i n g e b e n : " ) ; s c a n f ( "%u", &n ) ; //M i s t F e l d a u s Z e i g e r n d e s Typs d o u b l e M = ( d o u b l e **) m a l l o c ( n* s i z e o f ( d o u b l e *) ) ; i f (M == NU) { p r i n t f ( "Zu w e n i g S p e i c h e r! \ n" ) ; e x i t ( 1) ; // Programm a b b r e c h e n

25 Dynamische Speicherallokation Beispiel III 184 f o r ( i = 0 ; i < n ; i ++) { // S p e i c h e r f u e r Z e i l e n / S p a l t e n h o l e n M[ i ] = ( d o u b l e *) m a l l o c ( n * s i z e o f ( d o u b l e ) ) ; i f ( M[ i ] == NU ) { p r i n t f ( "Zu w e n i g S p e i c h e r! \ n" ) ; f o r ( j = 0 ; j < i ; j ++) // Aufraeumen f r e e (M[ j ] ) ; f r e e (M) ; e x i t ( 1) ; // E i n h e i t s m a t r i x e r z e u g e n f o r ( i = 0 ; i < n ; i ++) { f o r ( j = 0 ; j < n ; j ++) { i f ( i == j ) M[ i ] [ j ] = 1. 0 ; e l s e M[ i ] [ j ] = 0. 0 ;

26 Dynamische Speicherallokation Beispiel III 185 // S p e i c h e r f r e i g e b e n f o r ( i = 0 ; i < n ; i ++) f r e e ( M[ i ] ) ; f r e e ( M ) ; r e t u r n 0 ;

27 Verkettete isten I 186 Eine Struktur darf sich selbst nicht als Element enthalten, wohl aber einen Zeiger auf sich selbst. Strukturen, welche Zeiger auf sich selbst enthalten, nennt man rekursive Strukturen. Sollen exibel und dynamisch Elemente eines Datentyps angelegt werden können, die alle in einer iste zusammengefasst sind, bieten sich verkettete isten an. Eine einfach verkettete iste ist das einfachste Beispiel einer rekursiven Struktur.

28 Verkettete isten II 187 Jeder Knoten enthält nicht nur die Daten, sondern auch einen Zeiger auf seinen Nachfolgeknoten. Der einzige Knoten, der bekannt sein muss, ist der erste, der sogenannte Ankerknoten oder Kopf der iste. Im Gegensatz zu Feldern liegen die einzelnen Elemente (Knoten) einer iste nicht notwendig hintereinander im Speicher. Der Nachfolgezeiger des letzten Knotens in der iste zeigt auf NU. Andere Varianten: (1) Der letzte Knoten zeigt auf den ersten (Ringschluss). (2) Es gibt einen ausgezeichneten letzten Knoten, der auf sich selbst zeigt (sicheres Abschlusselement). Wird für ein eektives Arbeiten eine freiere Navigation benötigt, dann ist die Verwendung einer doppelt verketteten iste sinnvoll, in der jeder Knoten auch einen Zeiger auf seinen Vorgänger enthält.

29 Verkettete isten III 188 Einfach verkettete iste: s t r u c t node { TYP VAR_1 ;... TYP VAR_N; s t r u c t node * n e x t ; ; Doppelt verkettete iste: s t r u c t dnode { TYP VAR_1 ;... TYP VAR_N; s t r u c t dnode * p r e v ; s t r u c t dnode * n e x t ; ;

30 Verkettete isten III 189 Erstellung des Ankers: s t r u c t node * head =( s t r u c t node *) m a l l o c ( s i z e o f ( s t r u c t node ) ) ; head > n e x t =NU ; Neuen Knoten einfügen: s t r u c t node * newnode =( s t r u c t node *) m a l l o c ( s i z e o f ( s t r u c t node ) ) ; newnode > n e x t =head > n e x t ; head > n e x t =newnode ; Element entfernen, z.b. Kopf: s t r u c t node * t o d e l =head ; // Z e i g e r z w i s c h e n s p e i c h e r n head=head > n e x t ; // V o r s i c h t, d a r f n i c h t NU s e i n f r e e ( t o d e l ) ;

31 Verkettete isten Beispielprogramm 190 /* l i s t. c */ #i n c l u d e < s t d i o. h> #i n c l u d e < s t r i n g. h> #i n c l u d e < s t d l i b. h> s t r u c t node { c h a r name [ 3 0 ] ; s t r u c t node * n e x t ; // Z e i g e r a u f n a e c h s t e s E l e m e n t ; s t r u c t node * head ; // Anker, g l o b a l e V a r i a b l e /* F u n k t i o n s d e k l a r a t i o n e n */ v o i d i n i t i a l i z e ( v o i d ) ; v o i d i n s e r t ( c h a r *name ) ; v o i d o u t p u t ( v o i d ) ; v o i d d e l e t e ( v o i d ) ;

32 Verkettete isten Beispielprogramm 191 /* Hauptprogramm */ i n t main ( ) { c h a r name [ 3 0 ] ; i n i t i a l i z e ( ) ; // i s t e i n i t i a l i s i e r e n p r i n t f ( " Geben s i e Namen e i n ( Ende mit e e r z e i l e ) : \ n" ) ; w h i l e ( 1 ) { f g e t s ( name, 3 0, s t d i n ) ; // E i n l e s e n d e s S t r i n g s name i f ( s t r l e n ( name ) == 1) b r e a k ; i n s e r t ( name ) ; // E l e m e n t e i n f u e g e n o u t p u t ( ) ; // i s t e a u s g e b e n d e l e t e ( ) ; // i s t e l o e s c h e n r e t u r n 0 ;

33 Verkettete isten Beispielprogramm 192 /* i s t e i n i t i a l i s i e r e n */ v o i d i n i t i a l i z e ( v o i d ) { // S p e i c h e r a l l o k a t i o n head = ( s t r u c t node *) m a l l o c ( s i z e o f ( s t r u c t node ) ) ; i f ( head == NU ) { p r i n t f ( " N i c h t genug S p e i c h e r! \ n" ) ; e x i t ( 1 ) ; head > n e x t = NU ;

34 Verkettete isten Beispielprogramm 193 /* E l e m e n t e i n f u e g e n am Ende */ v o i d i n s e r t ( c h a r *name ) { s t r u c t node *p, * newnode ; // S p e i c h e r a l l o k a t i o n newnode = ( s t r u c t node *) m a l l o c ( s i z e o f ( s t r u c t node ) ) ; i f ( newnode == NU ) { p r i n t f ( " Not enough memory! \ n" ) ; e x i t ( 1 ) ; // Suche d a s l e t z t e E l e m e n t p = head ; w h i l e ( p> n e x t!= NU ) { p = p> n e x t ; s t r c p y ( newnode >name, name ) ; //Namen i n E l e m e n t k o p i e r e n newnode > n e x t = NU ; // newnode n e u e s l e t z t e s E l e m e n t p> n e x t = newnode ; //.. a n h a e n g e n

35 Verkettete isten Beispielprogramm 194 /* i s t e a u s g e b e n */ v o i d o u t p u t ( v o i d ) { s t r u c t node *p ; p = head > n e x t ; w h i l e ( p!= NU ) { p r i n t f ( "%s ", p>name ) ; p = p> n e x t ;

36 Verkettete isten Beispielprogramm 195 /* i s t e l o e s c h e n */ v o i d d e l e t e ( v o i d ) { s t r u c t node * d e l, *p ; p = head > n e x t ; //vom Anker s t a r t e n w h i l e ( p!= NU ) { d e l =p ; // E l e m e n t z w i s c h e n s p e i c h e r n p=p> n e x t ; //.. a u s i s t e e n t f e r n e n f r e e ( d e l ) ; // S p e i c h e r f r e i g e b e n f r e e ( head ) ; // Anker f r e i g e b e n

37 Bis morgen! 196