14.12 Äquivalenz zwischen Zeigern und Arrays
Es wurde ja bereits erwähnt, dass Zeiger und Arrays zwar eine gewisse Ähnlichkeit in ihrer Anwendung aufweisen, aber deswegen noch lange nicht gleich sind – geschweige denn untereinander austauschbar sind. Dennoch wird häufig beides in einen Topf geworfen.
/* ptr_versus_array1.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int var[] = { 123, 456, 789};
printf("*var : %d; var[0] : %d\n", *var, var[0]);
return EXIT_SUCCESS;
}
Wenn Sie dieses Beispiel übersetzen, verstehen Sie, worauf ich hinaus will. Die Angaben von var[0] und *var repräsentieren ja dieselbe Adresse. Somit stehen Ihnen also zwei Möglichkeiten zur Verfügung. Damit Sie bei diesem Wirrwarr noch die Übersicht behalten können, folgt jetzt eine Tabelle, welche die Verwandtschaft zwischen den Zeigern und den Arrays verdeutlicht. Falls Sie wieder einmal einen Quellcode finden, bei dem Sie nicht wissen, was das nun wieder sein soll, blättern Sie einfach zu diesen Tabellen. Es sollen folgende Werte für die erste Tabelle verwendet werden:
int n=3;
int array[5]={ 0 }; /* eindim. Array mit Platz für 5 Werte*/
int *ptr = array; /* int-Zeiger verweist jetzt auf array[0] */
Folgendes ist jetzt gleichwertig in Bezug auf den Zugriff von Werten. Zuerst die Möglichkeiten des Zugriffs auf das erste Element:
Tabelle 14.1
Äquivalenz beim Zugriff auf das erste Element
| Zeiger-Variante
|
Array-Variante
|
| *ptr
|
ptr[0]
|
| *array
|
array[0]
|
Als Nächstes folgt die Möglichkeit des Zugriffs auf das n-te Element:
Tabelle 14.2
Äquivalenz beim Zugriff auf das n-te Element
| Zeiger-Variante
|
Array-Variante
|
| *(ptr+n)
|
ptr[n]
|
| *(array+n)
|
array[n]
|
Die nächste Tabelle zeigt alle möglichen Zugriffe auf die Anfangsadresse:
Tabelle 14.3
Äquivalenz beim Zugriff auf die Anfangsadresse
| Ohne Adressoperator
|
Mit Adressoperator
|
| ptr
|
&ptr[0]
|
| array
|
&array[0]
|
Jetzt folgt die Tabelle für den Zugriff auf die Speicheradresse des n-ten Elements:
Tabelle 14.4
Äquivalenz beim Zugriff auf die Adresse des n-ten Elements
| Ohne Adressoperator
|
Mit Adressoperator
|
| ptr+n
|
&ptr[n]
|
| array+n
|
&array[n]
|
Nun folgt noch ein Listing, welches alle Punkte nochmals demonstriert:
/* ptr_versus_array2.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n=3;
/* eindim. Array mit Platz für 5 Werte */
int array[5]={ 1,2,3,4,5 };
/* int-Zeiger verweist jetzt auf array[0] */
int *ptr = array;
/* 4 Möglichkeiten, um auf das erste Element zuzugreifen */
printf("%d ", *ptr);
printf("%d ", ptr[0]);
printf("%d ", *array);
printf("%d\n", array[0]);
/* 4 Möglichkeiten, um auf das n-te Element zuzugreifen */
printf("%d ", *(ptr+n));
printf("%d ", ptr[n]);
printf("%d ", *(array+n));
printf("%d\n", array[n]);
/* 4 Möglichkeiten, um auf die Anfangsadresse zuzugreifen */
printf("%p ", ptr);
printf("%p ", &ptr[0]);
printf("%p ", array);
printf("%p\n", &array[0]);
/* 4 Möglichkeiten, um auf die Adresse des n-ten Elements
zuzugreifen */
printf("%p " , ptr+n);
printf("%p ", &ptr[n]);
printf("%p ", array+n);
printf("%p\n", &array[n]);
return EXIT_SUCCESS;
}
|
