Zeigerdeklarationen

Eine Zeigerdeklaration benennt eine Zeigervariable und gibt den Typ des Objekts an, auf das die Variable zeigt. Eine Variable, die als Zeiger deklariert ist, enthält eine Speicheradresse.

Syntax

declarator:
 pointer_optdirect-declarator

direct-declarator:
 identifier
 ( declarator )
 direct-declarator[constant-expression_opt]
 direct-declarator ( parameter-type-list )
 direct-declarator(identifier-list_opt)

pointer:
 *type-qualifier-list_opt
 *type-qualifier-list_optpointer

type-qualifier-list:
 type-qualifier
 type-qualifier-list type-qualifier

type-specifier gibt den Typ des Objekts an, wobei es sich um jeden Basis-, Struktur- oder Union-Typ handeln kann. Zeigervariablen können auf Funktionen, Arrays und andere Zeiger zeigen. (Weitere Informationen zum Deklarieren und Interpretieren komplexerer Zeigertypen finden Sie unter Interpretieren von komplexeren Deklaratoren.)

Wenn Sie type-specifier auf void festlegen, können Sie die Spezifikation des Typs verzögern, auf den sich der Zeiger bezieht. Ein solches Element wird als „Zeiger auf void “ bezeichnet und in der Form void * geschrieben. Mit einer Variablen, die als Zeiger auf void deklariert wird, können Sie auf ein Objekt eines beliebigen Typs verweisen. Zum Ausführen der meisten Vorgänge für den Zeiger oder das Objekt, auf das dieser zeigt, müssen Sie jedoch den Typ, auf den der Zeiger zeigt, explizit pro Vorgang angeben. (Variablen der Typen char * und void * sind ohne Typumwandlung zuweisungskompatibel.) Diese Konvertierung kann durch eine Typumwandlung erfolgen. Weitere Informationen finden Sie unter Typumwandlungskonvertierungen.

Der type-qualifier kann const und/oder volatile sein. Diese Schlüsselwörter geben an, dass der Zeiger nicht vom Programm selbst geändert werden kann (const) bzw. dass der Zeiger von einem Prozess, der nicht vom Programm gesteuert wird, zulässigerweise geändert werden kann (volatile). Weitere Informationen zu const und volatile finden Sie unter Typqualifizierer.

Der declarator benennt die Variable und kann einen Typmodifizierer enthalten. Wenn der declarator z. B. ein Array darstellt, wird der Typ des Zeigers in einen Zeiger auf ein Array geändert.

Sie können einen Zeiger auf einen Struktur-, Union- oder Enumerationstyp deklarieren, bevor Sie den Struktur-, Union- oder Enumerationstyp definieren. Sie deklarieren den Zeiger, indem Sie das Struktur- oder Uniontag wie in den Beispielen gezeigt verwenden. Derartige Deklarationen sind zulässig, da dem Compiler die Größe der Struktur oder Union nicht bekannt sein muss, um Speicherplatz für die Zeigervariable zuzuweisen.

Beispiele

Die folgenden Beispiele veranschaulichen Zeigerdeklarationen.

char *message; /* Declares a pointer variable named message */

Der message-Zeiger zeigt auf eine Variable des char-Typs.

int *pointers[10];  /* Declares an array of pointers */

Das pointers-Array umfasst 10 Elemente. Jedes Element ist ein Zeiger auf eine Variable des int-Typs.

int (*pointer)[10]; /* Declares a pointer to an array of 10 elements */

Die pointer-Variable zeigt auf ein Array mit zehn Elementen. Jedes Element in diesem Array ist vom Typ int .

int const *x;      /* Declares a pointer variable, x,
                      to a constant value */

Der Zeiger x kann so geändert werden, dass er auf einen anderen int-Wert zeigt. Der Wert, auf den er zeigt, kann jedoch nicht geändert werden.

const int some_object = 5 ;
int other_object = 37;
int *const y = &fixed_object;
int volatile *const z = &some_object;
int *const volatile w = &some_object;

Die Variable y in diesen Deklarationen wird als konstanter Zeiger auf einen int-Wert deklariert. Der Wert, auf den er zeigt, kann geändert werden, aber der Zeiger selbst muss stets auf denselben Speicherort zeigen: die Adresse von fixed_object. Ebenso ist z ein konstanter Zeiger, der aber auch so deklariert wird, dass er auf int zeigt. Der zugehörige Wert kann nicht vom Programm geändert werden. Der Wert von const int, auf den z zeigt, kann zwar nicht vom Programm geändert werden, aber durch den Spezifizierer volatile wird festgelegt, dass der Wert durch einen gleichzeitig mit dem Programm ausgeführten Prozess geändert werden darf. Die Deklaration von w gibt an, dass das Programm den Wert, auf den gezeigt wird, und den Zeiger nicht ändern kann.

struct list *next, *previous; /* Uses the tag for list */

Dieses Beispiel deklariert zwei Zeigervariablen (next und previous), die auf den Strukturtyp list zeigen. Diese Deklaration kann vor der Definition des list-Strukturtyps stehen (siehe das nächste Beispiel), sofern die list-Typdefinition die gleiche Sichtbarkeit wie die Deklaration aufweist.

struct list
{
    char *token;
    int count;
    struct list *next;
} line;

Die line-Variable weist den Strukturtyp namens list auf. Der list-Strukturtyp hat drei Member. Der erste Member ist ein Zeiger auf einen char-Wert, der zweite ist ein int-Wert, und der dritte ist ein Zeiger auf eine andere list-Struktur.

struct id
{
    unsigned int id_no;
    struct name *pname;
} record;

Die record-Variable weist den id-Strukturtyp auf. pname wird als Zeiger auf einen anderen Strukturtyp namens name deklariert. Diese Deklaration kann vor der Definition des name-Typs stehen.

Siehe auch

Deklaratoren und Variablendeklarationen