Grundlagen der Programmiersprache C für Studierende der Naturwissenschaften

Transkript

1 Grundlagen der Programmiersprache C für Studierende der Naturwissenschaften Teil 10: Eigene Bibliotheken Patrick Schreier Abteilung für Angewandte Mathematik Vorlesung vom 14. Juli 2014

2 Gliederung eigene Bibliotheken Zeiger und Felder (Wdh.) Zeichenketten (Wdh.) Strukturierte Datentypen (Wdh.) Funktionen und Funktionsaufrufe (Wdh.) Dynamische Speicherverwaltung (Wdh.)

3 Eigene Bibliotheken Wenn einzelne Module ausreichend getestet und für gut befunden wurden, kann man sie in eigenen Bibliotheken zusammenfassen. Eigene Bibliotheken kann man erzeugen, indem man Objektdateien unter der Verwendung des Kommandos $ ar zusammenfügt.

4 Eigene Bibliotheken Wir möchten als Beispiel einen Bibliothek erstellen, die algebraische Operationen mit vollbesetzten Matrizen vom Datentyp double realisiert. Für eine Matrix führen wir eine Struktur ein: struct double_matrix{ double **index; double *values; int n, m; }; n und m speichert die Dimension der Matrix index soll den Zugriff auf die Matrix realisieren values speichert die Einträge a i,j der Matrix es soll gelten a i,j = Matrix.index[i][j]

5 Wdh: Matrix und Konsekutiver Speicher Zunächst wir ein Speicherbereich für die ganze Matrix angelegt: /* allocate memory first */ buffer = (double *) malloc(m*n*sizeof(double)); if(!buffer) return 1; Dann initialisieren wir A als Doppelzeiger: /* initialize A */ A = (double **) malloc(m*sizeof(double *)); if(!a) return 1; for(i = 0; i < m; ++i) A[i] = &buffer[i*n] ; Indexzugriff über a i,j =A[i][j]. Das Freigeben des Speichers erfolgt durch: /* free storage */ free(a); free(buffer);

6 Header matrix.h Die Definition der Struktur schreiben wir in eine neue Header-Datei matrix.h. Um Schreibarbeit zu ersparen definieren wir den neuen Datentyp Matrix, durch struct double_matrix{ double **index; double *values; int n, m; }; typedef struct double_matrix Matrix;

7 Header matrix.h Wir möchten für unseren Datentyp noch einige grundlegende Operationen festlegen: int initdoublematrix( Matrix *A, int m, int n); void freedoublematrix( Matrix *A ); void printdoublematrix( Matrix *A); Diese Funktionen soll das Initialisieren einer Matrix unseres Datentyps, die Rückgabe des angelegten Speichers und eine einfache Ausgabe auf der Konsole realisieren. Die tatsächliche Implementierung der Funktionen (Definition) steht dann später in der Datei matrix.c.

8 matrix.c int initdoublematrix( Matrix *A, int m, int n) { int i, j; // Speicher allozieren: A->values = (double*)malloc(m*n*sizeof(double)); if( A->values == NULL ) return 1; A->index = (double**)malloc(m*sizeof(double*)); if( A->index == NULL ) return 1; A->m = m; A->n = n; //Speicherbloecke zuweisen: for(i = 0; i < m; i++) A->index[i] = &A->values[i*n]; // Matrix mit 0 Eintraegen initialisieren for( i = 0; i < m; i++ ) for( j = 0; j < n; j++ ) A->index[i][j] = 0.; return 0; }

9 matrix.c void freedoublematrix( Matrix *A ) { free(a->index); free(a->values); } void printdoublematrix( Matrix * A) { int i,j; printf(" m = %d, n = %d \n", A->m, A->n); //Ausgabe der Matrix: for( i = 0; i < A->m; i++){ for( j = 0; j < A->n; j++ ) printf("%lf ", A->index[i][j] ); printf("\n"); } }

10 Header einbinden Die Quelltextdatei matrix.c muss dann neben den Header aus der Standardbibliothek: #include<stdio.h> #include<stdlib.h> auch den selbsterstellten Header matrix.h einbinden: #include"matrix.h" damit innerhalb von matrix.c der Datentyp Matrix bekannt ist.

11 Weitere Module erstellen Wir möchten nun die Bibliothek um eine Funktion erweitern, die Matrix-Vektor-Multiplikation mit unserem Datentyp realisiert. Als n-vektor verstehen wir ein double-array der Länge n: double *x = (double*)malloc( n * sizeof(double) ); Die Funktion können wir also folgendermaßen deklarieren: void matrix_vector( Matrix *A, double *x, double *y); Dabei soll eine Matrix A mit einem Vektor x multipliziert werden. Das Ergebnis wird in y gespeichert. Die Funktion soll dann in einer neuen Datei matrix_vektor.h deklariert werden.

12 Header Guards Um die Funktion void matrix_vector( Matrix *A, double *x, double *y); in matrix _ vektor.h zu deklarieren, müssen wir den Datentyp Matrix kennen. Wir möchten also matrix.h einbinden, um sicher zu sein, dass der Datentyp bekannt ist. Um bei mehrfachem Einbinden, mehrfache Definitionen von Funktion und Datentypen zu verhindern, baut man sogenannte Header Guards ein: #ifndef EXAMPLE_H #define EXAMPLE_H //some code #endif // EXAMPLE_H example.h

13 Header Guards Header Guards (oder auch Include Guard, Include Wachter ) sorgen dafür, dass eine Headerdatei nur einmal eingebunden wird. Für jede Headerdatei wird ein eindeutiges Makro verwendet, hier: EXAMPLE_H. #ifndef EXAMPLE_H fragt ob EXAMPLE_HH schon definiert wurde, falls ja ist die Datei schon kompiliert und der Präprozessor überspringt den #ifndef... #endif Block. #ifndef EXAMPLE_H #define EXAMPLE_H //some code #endif // EXAMPLE_H

14 matrix.h mit Header Guard Die fertige Headerdatei matrix.h mit Header Guard, könnte dann so aussehen: 1 #ifndef MATRIX_H 2 #define MATRIX_H 3 4 struct double_matrix{ 5 double **index; 6 double *values; 7 int n, m; 8 }; 9 typedef struct double_matrix Matrix; int initdoublematrix( Matrix *A, int m, int n); 12 void freedoublematrix( Matrix *A ); 13 void printdoublematrix( Matrix *A); #endif // MATRIX_H

15 matrix_vektor.h Für die Matrix-Vektor-Multiplikation vereinbaren wir den Header matrix_vektor.h: 1 #ifndef MATRIX_VECTOR_H 2 #define MATRIX_VECTOR_H 3 4 #include "matrix.h" 5 6 void matrix_vector( Matrix *A, double *x, double *res); 7 8 #endif // MATRIX_VECTOR_H

16 matrix_vektor.c Die tatsächliche Implementierung der Matrix-Vektor-Multiplikation erfolgt dann in matrix_vektor.c: 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include "matrix.h" 4 5 void matrix_vector( Matrix *A, double *x, double *res) { 6 int i, j; 7 for( i = 0; i < A->m; i++) 8 res[i] = 0.; 9 for( i = 0; i < A->m; i++) 10 for( j = 0; j < A->n; j++) 11 res[i] += A->index[i][j] * x[j]; 12 }

17 Bibliothek erstellen Insgesammt haben wir nun die Module matrix.c mit Header matrix.h matrix_vektor.c mit Header matrix_vektor.h Wir wollen nun diese Module zu einer Bibliothek verbinden. Zunächst werden die Objektdateien matrix.c und matrix_vektor.o erstellt über $ gcc -c matrix.c $ gcc -c matrix_vektor.c Mit ar -r können sie diese zu einer Bibliothek libdoublematrix.a zusammenfassen: $ ar -r libdoublematrix.a matrix.o matrix_vector.o

18 Bibliothek verwenden Möchten man nun die Funktionalität von libdoublematrix.a in einem Programm main.c verwenden, müssen zunächst beide Header eingebunden werden: #include "matrix.h" #include "matrix_vektor.h" und linkt das Programm durch $ gcc -o prog_name main.c libdoublematrix.a

19 Bibliothek verwenden Alternativ kann man einen Header doublematrix.h erstellen, der die Präprozessor-Direktiven : #include "matrix.h" #include "matrix_vektor.h" enthält. Dann muss im Hauptprogramm nur doublematrix.h eingebunden werden. ist die Bibliothek in einem anderen Verzeichnis untergebracht, muss das beim Linken mit der Option -L angegeben werden und die Bibliothek wird mit -l angegeben. $ gcc -o prog_name main.c -L<Verzeichnis> -ldoublematrix Der Präfix lib und der Suffix.a werden dabei weggelassen.

20 einfaches Makefile einfaches Makefile, um die Bibliothek libdoublematrix.a zu erstellen: 1 install: matrix.o matrix_vector.o 2 ar -r libdoublematrix.a matrix.o matrix_vector.o 3 4 matrix.o: matrix.c 5 gcc -c matrix.c 6 7 matrix_vector.o: matrix_vector.c 8 gcc -c matrix_vector.c 9 10 clear: 11 rm -f *.o *.a

22 Zeigertypen und -variablen Für jeden Typ typename erhalten wir einen Zeigertyp typename * Ein Zeiger ist eine Variable von einem Zeigertyp. Der Typ typename gibt an, auf welchen Typ ein Zeiger verweist: typename *identifier; Beispiele: int *p; /* pointer to int */ double *q; /* pointer to double */

23 Der Adressoperator & Jedes Objekt (Variablen, Konstanten, Funktionen, etc.) belegt Platz im Speicher. Der Speicher eines Systems ist adressiert, d. h. jede Position im Speicher hat eine Adresse. Jedem Objekt ist damit eine eindeutige Adresse zugeordnet. Die Adresse eines Objekts ermitteln wir mit dem Adressoperator &: double x; &x; Der Typ des Ausdrucks &x ist ein Zeigertyp: double *p = &x;

24 Initialisierung von Zeigern In einem Zeiger kann die Adresse eines Objekts gespeichert werden. double x; double *p = &x; int a; int *q = &a; Die Typen der Ausdrücke links und rechts einer Zuweisung müssen übereinstimmen! Ein besonderer Zeigerwert ist die Null: double *p = 0; int *q = 0; Jeder Zeiger (egal welchen Typs) kann mit diesem Wert belegt werden.

25 Dereferenzieren von Zeigern Soll auf das Objekt zugegriffen werden, auf das ein Zeiger verweist, spricht man vom Dereferenzieren des Zeigers. Mit dem Inhaltsoperator * spricht man den Speicherbereich an, auf den ein Zeiger verweist: double x = 1.; double *p = &x; *p = 2.; printf("x = %f\n", x); /* x = 2. */ Das Dereferenzieren eines ungültigen Zeigers ist verboten und führt in der Regel zum sofortigen Programmabbruch: double *p = 0; *p; /* error: p not properly initialized */

26 Übung zu Zeigern Sei a vom Typ int und p vom Typ int *. Welche der folgenden Anweisungen lässt p auf a zeigen? 1. * p = a; 2. p = *a; 3. &p = a; 4. p = &a;

27 Übung zu Zeigern Sei a vom Typ int und p vom Typ int *. Welche der folgenden Anweisungen lässt p auf a zeigen? 1. * p = a; 2. p = *a; 3. &p = a; 4. p = &a;

28 Übung zu Zeigern Sei b vom Typ int und q vom Typ int *. Welche der folgenden Anweisungen weist b den Wert des Objekts zu, auf das q zeigt? 1. * q = b; 2. &b = q; 3. b = *q; 4. b = &q;

29 Übung zu Zeigern Sei b vom Typ int und q vom Typ int *. Welche der folgenden Anweisungen weist b den Wert des Objekts zu, auf das q zeigt? 1. * q = b; 2. &b = q; 3. b = *q; 4. b = &q;

30 Felder Für jeden Datentyp (elementar oder benutzerdefiniert) kann ein Feld angelegt werden. Ein Feld ist eine zusammenhängende Folge von Objekten gleichen Typs: a[0] a[1] a[2] Zur Vereinbarung muss neben Typ und Name die Länge des Feldes angegeben werden: int a[3];

31 Zugriff auf Feldelemente Auf die einzelnen Elemente eines Felds wird über einen Index zugegriffen: int a[3]; a[0], a[1], a[2]; /* access all entries */ In C beginnen Indizierungen immer mit dem Wert 0. Der letzte gültige Index eines Felds der Länge N ist dann N 1. Achtung: Beim Elementzugriff findet keine Bereichsüberprüfung statt: int a[3]; a[99]; /* wrong, invalid index */

32 Zusammenhang von Zeigern und Felder Sei int a[3]; ein Feld. Sein Name a ist ein Ausdruck vom Typ int *. Sein Wert entspricht der Adresse des ersten Elements von a: a == &a[0] Die folgenden Zuweisungen sind daher identisch: int *p = &a[0]; int *p = a;

33 Unterschiede von Zeigern und Feldern Ein Zeiger ist eine Variable, deren Wert sich (durch Zuweisungen, Inkrementoperatoren, etc.) ändern kann: int a[3]; int *p = a; ++p; /* p points to a[0] */ Ein Feldname ist keine Variable. Ausdrücke wie a = p oder ++a sind daher nicht erlaubt.

35 Zeichenketten Eine Zeichenkette ist eine zusammenhängende Folge von char-einträgen. char str[32]; sprintf(str, "hello"); stdio.h */ /* sprintf is contained in Ein besonderes Zeichen, das Terminierungszeichen \0, markiert das Ende einer Zeichenkette: 'h''e''l''l''o''\0 ''X''Y''Z'

36 Stringkonstanten Stringkonstanten sind Zeichenketten, die in doppelte Anführungszeichen gesetzt sind: "hello" Ein Feld vom Typ char lässt sich mit einer Stringkonstanten initialisieren: char str[] = "hello"; Bei der Initialisierung eines char-feldes mit einer Stringkonstanten wird automatisch das Terminierungszeichen hinzugefügt. Das Feld str belegt also 6 Byte: sizeof(str) = 6.

37 Stringhandling Die C-Standardbibliothek stellt eine Reihe von Funktionen zum Arbeiten mit Strings bereit, z. B.: size_t strlen(const char *str); char *strcpy(char *dest, const char *src); char *strncpy(char *dest, const char *src, size_t n); Alle hier beschriebenen Funktionen sind in der Datei string.h enthalten.

38 Übung zu Vereinbarungen Welche der folgenden Vereinbarungen sind korrekt? Aus welchen Gründen sind die übrigen falsch? 1. double größe; 2. unsigned int u; 3. char c = z ; 4. char str[] = hallo ; 5. double b[ 2 ] = { 9., 3. };

39 Übung zu Vereinbarungen Welche der folgenden Vereinbarungen sind korrekt? Aus welchen Gründen sind die übrigen falsch? 1. double größe; 2. unsigned int u; 3. char c = z ; 4. char str[] = hallo ; 5. double b[ 2 ] = { 9., 3. };

41 Vereinbarung von Strukturen Strukturen gehören zu den benutzerdefinierten Datentypen. Eine Struktur wird definiert durch Angabe des Schlüsselworts struct, ihres Namens und ihrer Elemente in geschweiften Klammern mit abschließendem Strichpunkt. Beispiel: struct Student { char name[64]; char matrikelnr[16]; };

42 Variablen von strukturierten Datentypen Eine Variable vom Typ struct Student wird wie folgt definiert: struct Student student; Mit der Definition kann eine Variable von strukturiertem Datentyp initialisiert werden: struct Student student = {"Max Mustermann", " "}; Zeiger auf Objekte von strukturiertem Datentyp kann man so anlegen: struct Student *pstudent = &student; Merke: Das Schlüsselwort struct muss immer mit angegeben werden.

43 Auswahloperatoren Die Auswahloperatoren. und -> erlauben den Zugriff auf die Elemente einer Struktur. Beispiel: struct Student student; sprintf(student.name, "Max Mustermann"); sprintf(student.matrikelnr, " "); Der Auswahloperator -> darf nur auf Zeiger angewandt werden: student->name; /* equals: (*student).name */

45 Funktionen vereinbaren Bei Funktionen unterscheidet man zwischen Deklaration und Definition: Die Deklaration vereinbart lediglich Rückgabetyp, Namen und Parameterliste der Funktion. Erst die Definition legt die Aktionen fest, die bei Funktionsaufruf ausgeführt werden sollen.

46 Übung zu Funktionsdeklarationen Wie lauten die Deklarationen der folgenden Funktionen? square ist eine Funktion, die eine double-größe erwartet und ihr Quadrat zurückgibt:

47 Übung zu Funktionsdeklarationen Wie lauten die Deklarationen der folgenden Funktionen? square ist eine Funktion, die eine double-größe erwartet und ihr Quadrat zurückgibt: double square(double x);

48 Übung zu Funktionsdeklarationen Wie lauten die Deklarationen der folgenden Funktionen? sort ist eine Funktion, die ein Feld elements von Integer-Zahlen und dessen Länge N als Parameter erhält und einen Zeiger auf das erste Feldelement zurückgibt.

49 Übung zu Funktionsdeklarationen Wie lauten die Deklarationen der folgenden Funktionen? sort ist eine Funktion, die ein Feld elements von Integer-Zahlen und dessen Länge N als Parameter erhält und einen Zeiger auf das erste Feldelement zurückgibt. int *sort(int elements[], int N);

50 Übung zu Funktionsdeklarationen Wie lauten die Deklarationen der folgenden Funktionen? innerproduct ist eine Funktion, die zwei konstante Zeiger auf struct Vector übergeben bekommt und eine double-größe zurückgibt:

51 Übung zu Funktionsdeklarationen Wie lauten die Deklarationen der folgenden Funktionen? innerproduct ist eine Funktion, die zwei konstante Zeiger auf struct Vector übergeben bekommt und eine double-größe zurückgibt: double innerproduct(const struct Vector *x, const struct Vector *y);

52 Funktionszeiger Ist der Prototyp einer Funktion (bestehend aus Rückgabetyp, Namen und Parameterliste) bekannt, lässt sich ein Zeiger auf die Funktion definieren. Beispiel: double square(double x); double (*f)(double) = square; Um eine Funktion über einen Zeiger auszuwerten, gibt es mehrere Möglichkeiten: double x = f(2.); /* x = 4. */ double x = (*f)(2.); /* x = 4. */

53 Übergabe per Wert Betrachten wir die folgende einfache Funktion: void settozero(double x) { x = 0; } Beim Funktionsaufruf double x = 1.; settozero(x); printf("x = %f\n", x); /* x = 1. */ wird lediglich der Funktionswert des Arguments an die Funktion übergeben.

54 Übergabe per Referenz Als Übergabe per Referenz bezeichnet man die Übergabe von Zeigern an Funktionen: void settozero(double *x) { *x = 0; }... double x = 1.; settozero(&x); printf("x = %f\n", x); /* x = 0. */ Zwar wird wieder eine Kopie an die Funktion übergeben (die des Zeigers!). Die Funktion greift aber auf den Speicherplatz von x zu, und die lokalen Änderungen werden im gesamten Programm wirksam.

56 Funktionen zur dynamischen Speicherverwaltung Die folgenden Methoden zur dynamischen Speicherverwaltung sind in der Datei stdlib.h enthalten: /* allocate memory */ void *malloc(size_t size); /* allocate and initialize memory */ void *calloc(size_t number, size_t size); /* deallocate memory */ void free(void *ptr); /* try to resize memory at given address */ void *realloc(void *ptr, size_t size);

57 Anfordern von Speicher In der Regel müssen wir Speicher für eine Zahl n von Objekten von bekanntem Typ typename anlegen. Der Speicherbedarf hierfür beträgt gerade n*sizeof(typename); Beispiele (Speicher für 100 Integer-Werte reservieren): int *p = (*int) malloc(100*sizeof(int)); int *q = (*int) calloc(100,sizeof(int)); Was ist der Unterschied zwischen malloc und calloc?

58 Fehlerbehandlung Der Rückgabewert der Methoden zum Anfordern von Speicher void *malloc(size_t size); void *calloc(size_t number, size_t size); void *realloc (void *ptr, size_t size); ist jeweils ein Zeiger vom Typ void *. Im Fehlerfall, d. h. konnte der Speicher nicht angelegt werden, hat der Rückgabewert den Wert Null,sprich der Zeiger ist ungültig. Beispiel: size_t size = 4; void *p = malloc(size); if(!p) printf("error");

59 Zugriff auf dynamisch erzeugten Speicher Mit malloc oder calloc angelegter Speicher ist zusammenhängend. Auf die Elemente des erzeugten Speicherblocks wird über den Operator [] und einen Index zugegriffen. Beispiel: int i, size = 4; int *p = (int*) malloc(size*sizeof(int)); assert(p); /* remember to include assert.h */ for(i = 0; i < size; ++i) p[i] = 0;

60 Freigeben von Speicher Dynamisch angelegter Speicher muss freigegeben werden, wenn er nicht mehr verwendet wird und anderen Prozessen zur Verfügung stehen soll. Die Funktion void free(void *ptr); gibt den Speicherbereich, auf den ptr zeigt und der über malloc oder calloc angelegt wurde, wieder frei. Beispiel: int *p = (int*) malloc(4*sizeof(int));... free(p); Auf freigegebenen Speicher darf nicht mehr zugegriffen werden.

61 Autoren Autoren die an diesem Skript mitgewirkt haben: : Christoph Gersbacher 2014 : Patrick Schreier This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) License. licenses/by-sa/4.0/legalcode