 |
F3 [4]; /* der Länge 4 */
Z[0] = F1; /* Wertzuweisung an die char-Zeiger */
Z[1] = F2;
Z[2] = F3;
Die Situation stellt sich bildlich folgendermaßen dar:
Man sieht folgende Analogie zwischen Zeiger-Arrays und mehrdimensionalen Arrays:
| Z+i |
ist ein Zeiger auf das (i+1)-te Element des Zeiger-Arrays Z |
| *(Z+i) = Z[i] |
ist das Array, auf das das (i+1)-te Element des Zeiger-Arrays zeigt,
also ein Zeiger auf das erste Element dieses Arrays. |
| *(Z+i) + j = Z[i] + j |
ist ein Zeiger auf das (j+1)-te Element des Arrays, auf das das
(i+1)-te Element des Zeiger-Arrays Z zeigt. |
*(*(Z+i) + j) = *(Z[i] + j) =
= Z [i][j] = (*(pa+i)) [j] |
ist das (j+1)-te Element des Arrays, auf das das (i+1)-te Element
des Zeiger-Arrays Z zeigt. |
Das obige Beispiel geht davon aus, dass die Elemente des Zeiger-Arrays alle auf
Arrays gleicher Größe verweisen. Dies bedingt die große
Ähnlichkeit zu mehrdimensionalen Arrays. Bei häufigen Anwendungen
von Zeiger-Arrays besitzen die referenzierten Arrays unterschiedliche
Längen, z.B. verschieden lange Strings.
/* Programm: ZEIGER-Array */
/* Aehnlichkeit und Unterschied zu mehrdim. Arrays */
#include <stdio.h>
char TagFeld[][11] =
{
"Montag", /* Dies ist ein 2-dimensionales Array */
"Dienstag", /* Die zweite Dimension ist fest 11, */
"Mittwoch", /* die erste wird durch die Initialisierung */
"Donnerstag", /* festgelegt mit 7 - für jeden String */
"Freitag", /* werden genau 11 Zeichen reserviert */
"Samstag",
"Sonntag"
};
char *TagZeiger[] =
{
"Montag", /* Dies ist ein Zeigerarray mit genau */
"Dienstag", /* 7 Zeigern als Elemente. Die Strings */
"Mittwoch", /* besitzen unterschiedliche Laenge */
"Donnerstag",
"Freitag",
"Samstag",
"Sonntag"
};
int IndexLesen(int *,int *);
int main (void)
{
int i, j;
char Ca, Cb;
while (IndexLesen(&i, &j) >= 0)
{
/* Zugriff auf das 2-dimensionale Array */
Ca = TagFeld[i][j];
/* Zugriff über das Zeiger-Array */
Cb = TagZeiger[i][j];
printf("TagFeld [%2d][%2d] = %c (= %2x hex)\n", i, j,Ca,Ca);
printf("TagZeiger [%2d][%2d] = %c (= %2x hex)\n",i,j,Cb,Cb);
}
return(0);
}
int IndexLesen(int *I, int *J)
{
printf("\nZeile: "); scanf("%d",I);
if(*I < 0) return -1;
printf("\nSpalte: "); scanf("%d",J);
if(*J < 0) return -1;
return(1);
}
Das Ergebnis eines Probelaufs sieht so aus:
Zeile: 0
Spalte: 4
TagFeld [ 0][ 4] = a (= 61 hex)
TagZeiger [ 0][ 4] = a (= 61 hex)
Zeile: 2
Spalte: 9
TagFeld [ 2][ 9] = (= 0 hex) /* Wie laesst sich dieser Unterschied */
TagZeiger [ 2][ 9] = D (= 44 hex) /* erklaeren ? */
Zeile: -1
Das folgende Beispiel zeigt, wie man einen Vektor von Zeigern
initialisieren kann:
char *month_name(int n) /* liefert Name des n. Monats */
{
static char *name[] = { /* Vektor von Zeigern */
"falscher Monat", /* String ist ein char- */
"Januar", /* Vektor und daher durch */
"Februar", /* seine Anfangsadresse */
"Maerz", /* charakterisiert */
"April",
"Mai",
"Juni",
"Juli",
"August",
"September",
"Oktober",
"November",
"Dezember"
};
return ((n < 1 || n > 12) ? name[0] : name[n]);
}
Übrigens: Zeiger auf Zeiger sind eine äquivalente Formulierung für
Vektoren von Zeigern:
int *iff[]; /* sind äquivalent, da iff die
int **iff; Adresse des Vektors enthält */
|
|
|
DIENSTE
