Zusammengehörige Daten struct. Strukturierte Datentypen und Funktionszeiger. Zugriff auf struct-elemente. Variablendeklarationen mit struct

Transkript

1 Zusammengehörige Daten Anstatt logisch zusammengehörende Daten in mehreren unabhängigen Variablen zu speichern, kann man für sie einen eigenen Datentyp ( Verbund, Record ) definieren, der diesen Zusammenhang explizit macht. Zum Beispiel kann bei einem Prüfungsergebnis der Name des Prüflings und die erreichte Punktzahl zusammengefasst werden: ergebnis /* Schlüsselwort + "Etikett" */ char name[20]; /* Felder der Struktur wie */ int punkte; /* in Variablendeklaration */ ; /* Semikolon beachten! */ Variablendeklarationen mit Jetzt ist ergebnis ein Datentyp wie z.b. int und kann genauso zur Deklaration von einfachen Variablen, Zeigern, Arrays, etc. benutzt werden: ergebnis e; /* e ist ein Ergebnis */ ergebnis *ep; /* ep ist Zeiger auf ein Ergebnis */ ergebnis ea[10]; /* ea ist ein Array von 10 Ergebnissen */ Zugriff auf -Elemente Um auf eine Komponente einer Struktur zuzugreifen, wird die Struktur, gefolgt von einem Punkt und dem Namen der Komponente hingeschrieben. /* Beispiel 1 - einfache Variable */ strcpy( e.name, "Claire" ); /* aus string.h */ e.punkte = 16; /* Beispiel 2 - Array */ for (i=0; i<20; i++) printf( "%s hat %d Punkte\n", ea[i].name, ea[i].punkte );

2 Zugriff über Zeiger Im Falle eines Zeigers auf eine Struktur kann man mit ep->name auf eine Komponente zugreifen. Zu dieser Notation ist (*ep).name äquivalent die Klammern sind aufgrund der Vorrangregeln von C erforderlich. Der Punkt. und der Pfeil -> sind Operatoren. Zuweisungen Strukturen können insgesamt zugewiesen werden: ea[5] = e; Dabei wird der gesamte Inhalt der Struktur kopiert. (Falls die Struktur Zeiger enthält, werden diese kopiert, nicht das, worauf diese Zeiger zeigen!) Strukturen können als Parameter an Funktionen übergeben sowie von Funktionen zurückgegeben werden. Auch hierbei wird der gesamte Inhalt kopiert. (Es gilt also die übliche call-by-value-semantik.) Das vollständige Kopieren ist bei umfangreicheren Strukturen zu aufwendig und sollte vermieden werden. In solchen Fällen werden nur Zeiger auf Strukturen übergeben, auch wenn diese Strukturen nicht geändert werden sollen. Ein Vergleich mit == oder!= ist nicht möglich. Funktionen und Strukturen Sofortige Initialisierung /* Gib eine neue Ergebnisstruktur mit gegenüber e um n erhöhter Punktezahl zurück. */ ergebnis verbessert( ergebnis e, int n ) e.punkte += n; /* Original bleibt unverändert! */ return e; /* Erhöhe das Ergebnis, auf das der Zeiger ep zeigt, um n Punkte. */ void verbesserung( ergebnis *ep, int n ) ep->punkte += n; Ähnlich wie bei Arrays kann eine -Variable gleich bei der Deklaration initialisiert werden, indem die Startwerte innerhalb geschweifter Klammern angegeben werden: ergebnis e = "Claire", 16 ; ergebnis liste[] = "Anton", 13, "Berta", 17, "Carla", 15 ; Bei der Initialisierung des Arrays können die inneren Klammern auch weggelassen werden. Der gcc warnt dann allerdings, sofern die Option -Wall benutzt wird.

3 Sofortige Variablendeklaration bei Strukturdefinition Strukturtypen und Header-Files Strukturdefinition und zugehörige Variablendeklaration könnnen gemeinsam geschehen: ergebnis char name[20]; int punkte; e, *ep, ea[10]; Wenn man den Strukturtyp nicht noch an anderer Stelle braucht, kann man dabei das Etikett (hier: ergebnis) auch weglassen. In der Regel wird ein Strukturtyp in mehreren Dateien benutzt. Eine Datei stellt elementare Operationen zur Verfügung, und andere benutzen sie. Dann kann die Strukturdefinition in ein Header-File geschrieben werden. Alternativ kann man den Strukturtyp im Header nur deklarieren, dazu schreibt man etwa ergebnis; In anderen Dateien kann dann auf die Komponenten der Struktur nicht zugegriffen werden, und es können nur Zeiger auf die Struktur angelegt werden. Weitere Beispiele Namensräume /* Stackelemente und Stackpointer zusammen */ stack double values[stacksize]; int sp; ; /* Matrix, die ihre Größe mitspeichert */ matrix int rows, cols; double **M; ; Die Komponentennamen verschiedener Strukturtypen sind unabhängig. /* erlaubt: */ point2d double x, y; ; point3d double x, y, z; ; Etiketten, Komponentennamen und gewöhnliche Bezeichner sind unabhängig. /* nicht schön, aber erlaubt: */ i int i; i;

4 Geschachtelte Strukturen Strukturen können andere Strukturen beeinhalten: /* Ein Punkt in der Ebene ist festgelegt durch zwei Koordinaten */ point double x, y; ; /* Ein Dreieck ist festgelegt durch drei Punkte */ triangle point p1, p2, p3; ; Beispiel: Komplexe Zahlen Headerfile /* complex.h */ complex double real, imag; ; complex mkcomplex( double real, double imag ); void printcomplex( complex z ); complex addcomplex( complex a, complex b); Beispiel: Komplexe Zahlen - Erzeugen /* complex.c */ #include <stdio.h> #include "complex.h" complex mkcomplex( double real, double imag ) complex z; z.real = real; z.imag = imag; return z;... Beispiel: Komplexe Zahlen - Ausgabe und Addition... void printcomplex( complex z ) printf( "%g%+gi", z.real, z.imag ); complex addcomplex( complex a, complex b); complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z;

5 Hinweis: Komplexe Zahlen in C99 In C99 und als Erweiterung beim gcc gibt es eingebaute komplexe Zahlen. Sie können mit den normalen Operatorzeichen verknüpft werden. #include <stdio.h> #include <complex.h> int main( void ) complex double a = * I; /* oder nur complex */ complex double b = 1 - I; complex double z = a*b; printf( "%g%+gi\n", creal(z), cimag(z) ); return 0; Alternative Daten - Manchmal will man in einer Variablen abwechselnd verschiedene Arten von Werten speichern können, z.b. entweder eine Fließkommazahl oder ein Zeichen. Anstatt einer Struktur, die Platz für jeden Datentyp gleichzeitig hat, gibt es hierfür die Union, in der der Platz geteilt wird, so dass nur immer nur ein Datentyp gespeichert werden kann. val /* Schlüsselwort + "Etikett" */ double f; /* Alternativen der Union wie */ char c; /* in Variablendeklaration */ ; /* Semikolon beachten! */ Deklaration und Zugriff Verfolgen des aktuellen Typs Deklaration (in allen Varianten) und Zugriff (auch über Zeiger) ist wie bei Strukturen. val v; v.f = 2.7; printf( "%g\n", v.f ); v.c = x ; printf( "%c\n", v.c ); Sofern man nicht gerade raffinierte implementationsabhängige Tricks macht, darf man nur auf die Alternative zugreifen, der man zuletzt etwas zugewiesen hat. Man kann bei einer Union nicht herausfinden, welcher Alternative als letztes etwas zugewiesen wurde. Unter Umständen ist die Programmlogik so, dass man es immer weiß. Ansonsten muss man es sich extra im Programm merken. Hierfür bietet es sich an, die Union in eine Struktur einzubetten: valx int isnum; /* 1 für Zahl, * * 0 für Zeichen in u */ val u; ;

6 Sofortige Initialisierung Quicksort vergleiche CoMa Eine sofortige Initialisierung ist nur für die erste Alternative möglich und erfordert geschweifte Klammern: val v = 3.1 ; (C99 bietet weitere Möglichkeiten.) /* qsort: sortiere v[l]...v[r] aufsteigend */ void qsort( int v[], int l, int r ) int i, m; if ( l >= r ) /* nichts zu sortieren */ return; swap( v, l, (l+r)/2 ); /* zentrales El. */ m = l; for ( i = l+1; i<=r; i++ ) /* aufteilen */ if ( v[i] < v[l] ) swap( v, ++m, i ); swap( v, l, m ); /* zentrales El. */ qsort( v, l, m-1 ); qsort( v, m+1, r ); von Ergebnislisten Funktionszeiger Was, wenn Ergebnislisten ergebnis liste[] sortiert werden sollen? Ändern des Arraytyps kein Problem Anpassen von swap kein Problem Vergleichen von Strukturen mit einer eigenen Funktion statt mit < Brauchen wir mehrere Sortierfunktionen, um mal nach Punkten und mal alphabetisch nach Namen zu sortieren? (Wir könnten jede sinnvolle Vergleichsfunktion einbauen und anhand einer übergebenen Nummer angeben, welche genommen werden soll, aber es soll etwas allgemeineres gemacht werden: Übergabe der Vergleichsfunktion) Genauso, wie double g( double ); besagt, dass g eine Funktion ist, die einen double-wert nimmt und einen double-wert als Ergebnis hat, wird durch double (*f)( double ); besagt, dass f ein Zeiger auf eine derartige Funktion ist. f kann dann wie folgt benutzt werden: double x; f = sin; /* oder: f = &sin */ x = f( 1.5 ); /* oder: x = (*f)( 1.5 ); */

7 Vergleichsfunktionen In C wird das Ergebnis eines Vergleichs compare(e1,e2) durch einen int-wert dargestellt. Das Ergebnis ist positiv, falls e1 nach e2 kommt, negativ, falls e1 vor e2 kommt, Null, falls sie gleich sind. (Falls man die Werte Subtrahieren kann, stimmen die Vorzeichen von compare(e1,e2) und e1-e2 überein.) In unserem Fall wird ein Zeiger auf eine passende Vergleichsfunktion deklariert durch: int (*cmp)( ergebnis, ergebnis ); Da wir eine solche Funktion übergeben wollen, taucht diese Deklaration innerhalb der Deklaration des erweiterten qsort auf. Quicksort für Ergebnislisten void qsort( ergebnis v[], int l, int r, int (*cmp)( ergebnis, ergebnis ) ) int i, m; if ( l >= r ) /* nichts zu sortieren */ return; swap( v, l, (l+r)/2 ); /* zentrales El. */ m = l; for ( i = l+1; i<=r; i++ ) /* aufteilen */ if ( cmp( v[i], v[l] ) < 0 ) swap( v, ++m, i ); swap( v, l, m ); /* zentrales El. */ qsort( v, l, m-1, cmp ); qsort( v, m+1, r, cmp ); Vergleichsfunktionen in unserem Beispiel #include <string.h> /* für strcmp */ /* Alphabetischer Vergleich der Namen */ int name_cmp( ergebnis e1, ergebnis e2 ) return strcmp( e1.name, e2.name ); /* Vergleich der Punkte */ int punkte_cmp( ergebnis e1, ergebnis e2 ) return e1.punkte - e2.punkte; /* Vorsicht: wenn der Wertebereich ausgeschöpft wird, drohen bei dieser Technik Fehler durch Überläufe! */ Anwendung int main( void ) ergebnis liste[]= "Claire", 16, "Anna", 18, "Berta", 13, "Carla", 16, "Dieter", 17 ; int size = sizeof( liste ) / sizeof( liste[0] ); printlist( liste, size ); qsort( liste, 0, size-1, name_cmp ); printlist( liste, size ); qsort( liste, 0, size-1, punkte_cmp ); printlist( liste, size ); return 0;

8 qsort in der C-Bibliothek void * Anwendung Hilfsfunktionen /* vertausche v[i] und v[j] */ void swap( ergebnis v[], int i, int j ) ergebnis tmp = v[i]; v[i] = v[j]; v[j] = tmp; /* Ausgabe der Ergebnisliste v der Größe n */ void printlist( ergebnis v[], int n ) int i; for (i=0; i<n; i++) printf( "%10s: %d\n", v[i].name, v[i].punkte ); printf("\n"); qsort in der C-Bibliothek Eine noch allgemeinere Sortierfunktion, wie sie in der C-Bibliothek zu finden ist, darf nicht vom Datentyp der zu sortierenden Elemente abhängen. Hierfür wird der spezielle Zeigertyp void * benutzt. Zeiger auf Daten können (auch implizit) in diesen Zeigertyp umgewandelt werden und zurück. qsort (aus stdlib.h) ist deklariert als void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)); Hierbei ist nmemb die Anzahl der Elemente, die zu sortieren sind, und size die Größe eines Elements. size_t ist ein Integertyp, der für Speichergrößen verwendet wird. qsort in der C-Bibliothek void * Anwendung qsort in der C-Bibliothek void * Anwendung Vergleichsfunktionen für dieses qsort Anwendung des Bibliotheks-qsort Eine entsprechende Vergleichsfunktion muss Parameter vom Typ const void * akzeptieren. In unserer Anwendung werden diese in const ergebnis * umgewandelt. (Durch const wird angegeben, dass die Variablen nur gelesen, aber nicht geändert werden.) /* Alphabetischer Vergleich der Namen */ int name_cmp_x( const void *x1, const void *x2 ) const ergebnis *e1 = x1, *e2 = x2; return strcmp( e1->name, e2->name ); #include <stdlib.h> int main( void ); ergebnis liste[] =...; int size = sizeof( liste ) / sizeof( liste[0] ); qsort( liste, size, sizeof(liste[0]), name_cmp_x );...