Datei: svn/ckurs/trunk/c_texte/c_arrptr.txt, Datum: 30. Juni Felder und Zeiger

Transkript

1 Datei: svn/ckurs/trunk/c_texte/c_arrptr.txt, Datum: 30. Juni 2015 Felder und Zeiger 1. Felder 1. Felder werden deklariert und definiert durch die Angabe der Elementanzahl nach dem Feldnamen mit dem Feldoperator []: char s[10]; double x, v [10], m [10] [15], t [10] [3] [2], y; 2. Der Feldoperator wirkt nur auf die unmittelbar davorstehende Variable. x und y sind keine Felder, sondern einfache Variable vom Typ double. 3. Der Feldoperator klammert von links nach rechts. Also ist m ein Feld aus 10 Vektoren mit je 15 doubles, also insgesamt 150 reellen double-zahlen. Entsprechend ist t ein Feld mit insgesamt 60 reellen double-zahlen. Es besteht aus 10 Matrizen zu je 3 Vektoren mit je 2 Zahlen. 4. Die Feldelemente sind numeriert. Die Nummer des ersten Elementes ist immer 0, die des letzten ist immer gleich der angegebenen Feldgröße 1! Das Feld s mit 10 Zeichen enthält die Zeichenvariablen s [0], s [1], s [2],..., s [8] und s [9]. Das letzte Element von v ist v [9]; m [9] [14] und t [9] [2] [1] stehen ebenfalls im Speicher ganz am Ende von m und t. 5. Für die sequentielle Verarbeitung der Feldelemente bieten sich die Feldschleifen an: for (i = 0; i < 10; i++) {... s [i]... } So kann mit einer der folgenden Schleifen ein Feld von der Tastatur gelesen werden, bis eine 0 oder eine nichtnumerische Eingabe das Ende signalisiert oder das Feld voll ist: for (i = 0; i < 10 && scanf ("%lf", & v [i]) == 1 && v [i++]!= 0;); for (i = 0; i < 10 && scanf ("%lf", & v [i]) && v [i]; i++); 6. Interessanterweise ist der Feldoperator [] in C wie andere (+ - * /) ein normaler Operator, der Feldnamen und Feldindex zu einer Speicheradresse verknüpft. Insbesondere ist er kommutativ, d.h. ähnlich wie bei der Addition (a + b b + a) gilt: x [5] 5 [x] Die zweite (erlaubte) Schreibweise wird allerdings in der Programmierpraxis nie angewendet.

2 2. Zeiger 2 2. Zeiger 1. Zeigervariable werden deklariert und definiert durch ein Sternchen (*) vor dem Variablennamen: int y,*p,x,i; float *q,f; double ** r, *pd, d; 2. Der Zeigeroperator wirkt nur auf die unmittelbar nachfolgende Variable; deshalb sind d, f, i, x und y keine Zeiger, sondern normale double-, float- und int-variable. Unabhängig von der Anzahl der Sterne sind p, pd, q und r alle Zeigervariable. 3. Im Gegensatz zu dieser Regel denkt man manchmal den * als zum Typ gehörend und spricht von der int *-Variablen p, der float *-Variablen q und der double **- Variablen r. 4. Zeigervariable enthalten als Werte die Speicheradressen anderer Variabler. Man sagt, sie zeigen auf diese Variablen. Diese Variablen heißen die Bezugsvariablen des Zeigers. In Skizzen zieht man einen Pfeil von der Zeigervariablen zur Bezugsvariablen. 5. Zeiger sind qualifiziert, d.h. der Typ der Bezugsvariablen wird vom Programmierer festgelegt. 6. Unqualifizierte Zeiger sind für spezielle Zwecke (Systemprogrammierung) möglich mit der Deklaration void * u;. void heißt hier Zeiger auf alles mögliche. 7. Mit dem Adressoperator & kann vom nachfolgenden Operanden dessen Adresse und damit ein möglicher Wert für eine entsprechende Zeigervariable ermittelt werden. int i, k [10], m [10] [5]; Mit &i, &k [0], &m [0] [0], & k [1], & m [3] und &m [4] [5] werden die Speicheradressen der entsprechenden Variablen bezeichnet. 8. Jetzt kann ein sinnvoller Adresswert in einer Zeigervariablen gespeichert werden: p = &i; 9. Als bequeme Sonderregel steht ein Feldname in C für die Speicheradresse des ersten Feldelementes. Also darf man schreiben: k statt & k [0] m statt & m [0] [0] 10. Mit dem Referenzoperator * kann zum nachfolgenden Zeiger-Operanden (Variable oder Wert) dessen Bezugsvariable bezeichnet werden. p ist die Zeigervariable auf eine int- Größe; *p ist diese int-größe selbst. 11. Die Operatoren & und * sind umgekehrte Operationen, d.h. es gilt immer: &*p &(*p) p *&i *(&i) i Man beachte aber die unterschiedliche Betonung beider Relationen: Folgt man einer Zeigervariablen p bis zu ihrer Bezugsvariablen *p und bildet deren Adresse &*p, so ist der erhaltene Adresswert gleich dem in p stehenden Zeigerwert. Bildet man umgekehrt erst die Adresse einer Variablen &i und dann die Bezugsvariable dieser Adresse *&i so erhält man eine Alternativschreibweise für die Variable i. 12. Zeigerwerte können ein- und ausgegeben werden. Bei der Eingabe entstehen jedoch beliebige Zeigerwerte, die die Benutzung des gesamten Rechnerspeichers ermöglichen. Da das meistens keinen Sinn gibt, ist die Eingabe von Zeigerwerten extrem selten.

3 2. Zeiger 3 printf ("In %p steht der Wert %d", &i, i) printf ("In %p steht der Wert %d", p, *p) scanf ("%p", &p) 3. Zeiger als Referenzparameter von Funktionen Zeigerargumente werden in C genutzt, um über Wertparameter auf Variable des Aufrufers zugreifen zu können. void swap (int * p, int * q) { int h; h = *p; *p = *q; *q = h; }... int main (void) { int a, b;... swap (&a, &b);... } Beim Aufruf werden die Adressen der Variablen a und b übergeben und in die lokalen Wertparameter p und q gespeichert. p und q in swap zeigen also auf Variable des Aufrufers, deren Namen in swap gar nicht bekannt oder sichtbar sind. Die Bezugsvariablen *p und *q von p und q sind identisch mit den Variablen des Aufrufers, deren Adressen übergeben wurden (hier a und b) und erlauben deren Manipulation.

4 4. Felder und Zeiger 4 4. Felder und Zeiger 1. Zeigt ein Zeiger in ein Feld, so darf mit dem Zeiger gerechnet werden. Solange der Zeiger das Feld nicht verläßt (Programmiererverantwortung) kann mit Additionen und Subtraktionen von Zahlen jedes Feldelement vom ersten bis einschließlich zum nicht mehr existierenden Feldelement nach dem letzten adressiert werden. int a [5], *p; p = a; /* oder p = & a [0]; */ Es gilt: p + i & p [i] für i = 0,..., 5 Mit float b [10], * q; q = & b [2]; gilt: q + i & q [i] für i = 2,..., 8 2. Abgesehen von der jeweils nicht existierenden letzten Variablen darf von jedem Adresswert auch seine Bezugsvariable gebildet werden. *(p + i) p [i] für i = 0,..., 4 *(q + i) q [i] für i = 2,..., 7 3. Diese Adressarithmetik ermöglicht schnellere Schleifen, weil mit Zeigern die Feldelemente direkt adressiert werden können: for (p = a; p < a + 5; p++) { /* Benutze *p */ } for (p = a; *p!= 3; p++); /* Suche die 3 in a */ Die 3 als Feldinhalt muß im letzten Beispiel existieren, wenn das Programm nicht abstürzen soll (Programmiererverantwortung) 4. Die Differenz zweier Zeigerwerte p2 - p1 liefert die Anzahl der Feldelemente zwischen den durch p1 und p2 adressierten Elementen desselben Feldes. 5. Jeder Zeiger mit einem sinnvollen Wert zeigt auf eine Bezugsvariable. 6. Diese Bezugsvariable kann Element eines Feldes sein. 7. Die Zeigerarithmetik dient zum Bezeichnen der übrigen Feldelemente dieses Feldes. 8. Unqualifizierte Zeiger ermöglichen das Ansprechen des gesamten Speichers (meist in der Systemprogrammierung). 9. Der eigenständige Indizierungsoperator wird vom Compiler prinzipiell in die Zeigerschreibweise übersetzt. x [i] *(x+i) (informell) x [i] (*(x+(i))) (bei abgesättigten Feldzugriffen) x [i] (&(*(x+(i)))) (bei unvollständigen Feldzugriffen)

5 4. Felder und Zeiger 5 5. Zeichenfelder 1. Zeichenfelder können zusammen mit und als Strings verwendet werden. Sie sollten dann immer das Zeichen Nummer 0 ( \0 ) als Abschlußzeichen enthalten. 2. Stringerzeugende C-Funktionen sorgen fast immer für diese 0; bei selbstgeschriebenem Code ist das Programmiererverantwortung. Ausnahme sind die strn*-funktionen! 3. String-Konstante in C enthalten diese 0 ebenfalls immer. Die Stringkonstante steht in C für die Speicheradresse des Strings. char x [100], *p p = "Hallo\n"; /* Die Adresse der Zeichenfolge kommt nach p*/ p [i], i = 0,..., 6 enthält die Zeichen H, a,... o, \n, \0

6 6. Stringfunktionen 6 6. Stringfunktionen 1. Stringfunktionen stehen in der Bibliothek <string.h> 2. strcpy (a, b) kopiert die Zeichen in b nach a; Alle Zeichen bis zur abschließenden 0 in b werden kopiert. a muß ausreichenden Platz auch für die 0 haben (Programmiererverantwortung) char x [100], *p, *q; strcpy (x, "Hallo\n"); /* x wird mit den Zeichen Hallo\n gefuellt */ p = (char*) malloc (7 * sizeof (char)); strcpy (p, "Hallo\n"); q = (char*) malloc ((strlen (x) + 1) * sizeof (char)); strcpy (q, p); 3. strncpy (a, b, n) kopiert die Zeichen in b nach a, jedoch maximal n Zeichen; n ist üblicherweise der Platz in a; (Vergessen Sie bei Platzberechnungen nicht die zusätzlich zu speichernde 0). strncpy hat wie die anderen strn*-funktionen die (zugegeben schwachsinnige) Eigenschaft (bug oder feature), ein abschließende 0 nicht anzufügen, wenn sie nicht sowieso aus b mitkopiert wurde. Damit ist strncpy praktisch nicht verwendbar, außer mit der zusätzlichen Sicherheitsanweisung a [n-1] = 0; char x [100], *p p = "Hallo\n"; strncpy (x, p, 100); /* Ist strlen (p) > 100, enthaelt x keine 0 */ strncpy (x, p, 100); x [99] = 0; /* zus. Sicherheitsanweisung */ 4. strcat (a, b) verlängert den String in a um alle Zeichen in b; Alle Zeichen bis zur abschließenden 0 in b werden an a angehängt. a muß ausreichenden Platz auch für die 0 haben (Programmiererverantwortung) 5. strncat (a, b, n) verlängert den String in a um die Zeichen in b nach a, jedoch maximal um n Zeichen; n ist üblicherweise der Restplatz in a; (Vergessen Sie bei Platzberechnungen nicht die auch zu speichernde 0) 6. strcmp (s1, s2) vergleicht die beiden Strings s1 und s2 lexikalisch. Würde s1 in einem englischsprachigen Lexikon vor s2 stehen, ist strcmp (s1, s2) < 0; steht umgekehrt s1 nach s2, ist das Ergebnis > 0 und sind s1 und s2 identisch, ist das Ergebnis 0 strcmp ("Balken", "Balkon") < 0; strcmp ("Balkon", "Balken") > 0;

7 6. Stringfunktionen 7 strcmp ("Balkon", "Balkonpflanze") < 0; strcmp ("Balken", "Balken") == 0; strcmp ("Potter, Harry", "Granger, Hermione") > 0; 7. strncmp (s1, s2, n) arbeitet wie strcmp; allerdings gehen maximal n Zeichen in den Vergleich ein. 8. strchr (s, ch) sucht das Zeichen ch in s und liefert dessen Position als Adresse. 9. strstr (s, t) sucht den Teilstring t in s und liefert dessen Position als Adresse. 10. strlen (s) ermittelt die Anzahl der Zeichen in s ohne die abschließende Dynamische Felder 1. Funktionen zur dynamischen Feldverwaltung stehen in der Bibliothek <stdlib.h> 2. Ein neues Feld wird mit malloc erzeugt (alloziert), d.h. es bekommt Speicherplatz. Ein Zeiger auf seine Anfangsadresse wird zurückgegeben und kann in einer Zeigervariablen gespeichert werden. Wegen der Typprüfung muß gecastet werden. Anschließend sollte immer geprüft werden, ob der Speicherplatz verfügbar war. int * p, n; p = (int *) malloc (n * sizeof (int)) if (!p) { /* kein Speicherplatz verfuegbar */ } 3. Der Speicherplatz kann mit free wieder freigegeben werden. free (p); 4. Der Speicherplatz kann mit realloc an den aktuellen Bedarf angepaßt werden. p = (int *) realloc (p, n * sizeof (int)); if (!p) { /* kein Speicherplatz verfuegbar */ } 5. Beispiel: Lesen eines beliebig langen Strings von der Tastatur. Der benötigte Speicherplatz wird blockweise (je 10 Zeichen) an den Bedarf angepaßt. #include <stdio.h> #include <stdlib.h> int ch, a, u; /* gelesenes Zeichen, allocated, used */ char * w; w = (char *) malloc ((a=10) * sizeof (char)); if (!w) exit (1); w [0] = 0; u = 0; while ((ch = getchar ())!= EOF) { if (u + 1 >= a) { w = (char *) realloc (w, (a+=10) * sizeof (char)); if (!w) exit (1); } w [u++] = ch; w [u] = 0; }

8 7. Dynamische Felder 8 /* Verarbeitung von w */ free (w)