Zeigerdeklarationen

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

Syntax

declarator:
  pointer _wählendirect-declarator

direct-declarator:
 identifier
  ( declarator )
  direct-declarator [ constant-expression _optieren]
  direct-declarator ( parameter-type-list )
  direct-declarator ( identifier-list _optieren)

pointer:
  * type-qualifier-list _optieren
  * type-qualifier-list _optierenpointer

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

Der type-specifier Typ des Objekts, das ein beliebiger grundlegender, struktur- oder vereinigungstyp sein kann. Zeigervariablen können auch auf Funktionen, Arrays und andere Zeiger verweisen. (Informationen zum Deklarieren und Interpretieren komplexerer Zeigertypen finden Sie unter Interpretation komplexerer Deklaratoren.)

Indem Sie die type-specifiervoidSpezifikation des Typs verzögern, auf den sich der Zeiger bezieht. Ein solches Element wird als "Zeiger auf void" bezeichnet und wird als void *geschrieben. Eine Variable, die als Zeiger deklariert wird, void kann verwendet werden, um auf ein Objekt eines beliebigen Typs zu verweisen. Um jedoch die meisten Vorgänge für den Zeiger oder für das Objekt auszuführen, auf das es verweist, muss der Typ, auf den er verweist, für jeden Vorgang explizit angegeben werden. (Variablen vom Typ char * und Typ void * sind zuordnungskompatibel ohne Typ cast.) Eine solche Konvertierung kann mit einer Typumwandlung erreicht werden. Weitere Informationen finden Sie unter Type-Cast Konvertierungen.

Dies type-qualifier kann entweder const oder volatilebeides sein. Diese Schlüsselwörter geben an, dass der Zeiger nicht vom Programm selbstconst () geändert werden kann oder dass der Zeiger legitim von einem Prozess geändert werden kann, der über die Kontrolle des Programms hinausgeht (volatile). Weitere Informationen zu const und volatile, finden Sie unter Typqualifizierer.

Die declarator Namen der Variablen und können einen Typmodifizierer enthalten. Wenn z declarator . B. ein Array darstellt, wird der Zeigertyp so geändert, dass er ein Zeiger auf ein Array ist.

Sie können einen Zeiger auf eine Struktur, union oder einen Enumerationstyp deklarieren, bevor Sie die Struktur, die Union oder den Enumerationstyp definieren. Sie deklarieren den Zeiger mithilfe des Struktur- oder Unionstags, wie in den Beispielen gezeigt. Solche Deklarationen sind zulässig, da der Compiler nicht die Größe der Struktur oder Vereinigung kennen muss, um Platz 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 mit char Typ.

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

Das pointers Array verfügt über 10 Elemente. Jedes Element ist ein Zeiger auf eine Variable mit int Typ.

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

Die pointer Variable verweist auf ein Array mit 10 Elementen. Jedes Element in diesem Array hat int Typ.

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, aber der Wert, auf den er verweist, kann 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 es verweist, kann geändert werden, der Zeiger selbst muss jedoch immer auf die gleiche Position verweisen: die Adresse von fixed_object. Ebenso handelt es sich um einen konstanten Zeiger, aber er wird auch so deklariert, z dass er auf einen int Wert verweist, dessen Wert nicht vom Programm geändert werden kann. Der volatile Bezeichner gibt an, dass der Wert des const int durch das Programm angegebenen Werts z zwar nicht geändert werden kann, aber von einem Prozess, der gleichzeitig mit dem Programm ausgeführt wird, legitim geändert werden kann. Die Deklaration von w specifies that the program can't change the value point to and that the program can't modify the pointer.

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

In diesem Beispiel werden zwei Zeigervariablen (next und previous) deklariert, die auf den Strukturtyp listverweisen. Diese Deklaration kann vor der Definition des list Strukturtyps angezeigt werden (siehe nächstes Beispiel), solange die list Typdefinition dieselbe Sichtbarkeit wie die Deklaration hat.

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

Die Variable line hat den Strukturtyp namens list. Der list Strukturtyp hat drei Elemente: Das erste Element 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 Variable record weist den Strukturtyp idauf. pname wird als Zeiger auf einen anderen Strukturtyp mit dem Namen namedeklariert. Diese Deklaration kann angezeigt werden, bevor der name Typ definiert wird.

Siehe auch

Deklaratoren und Variablendeklarationen