Aanwijzerdeclaraties

Een aanwijzerdeclaratie noemt een aanwijzervariabele en geeft het type object aan waarop de variabele wijst. Een variabele die is gedeclareerd als een aanwijzer, bevat een geheugenadres.

Syntaxis

declarator:
  pointer _{kiezen voor}direct-declarator

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

pointer:
  * type-qualifier-list _opteren
  * type-qualifier-list _opterenpointer

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

De type-specifier geeft het type van het object, dat elk type basis, structuur of samenvoeging kan zijn. Aanwijzervariabelen kunnen ook verwijzen naar functies, matrices en andere aanwijzers. (Voor informatie over het declareren en interpreteren van complexere aanwijzertypen raadpleegt u Meer complexe declaraties interpreteren.)

Door de type-specifiervoidaanwijzer te maken, kunt u de specificatie van het type vertragen waarnaar de aanwijzer verwijst. Een dergelijk item wordt aangeduid als een "aanwijzer naar void" en wordt geschreven als void *. Een variabele die is gedeclareerd als een aanwijzer void , kan worden gebruikt om naar een object van elk type te verwijzen. Als u echter de meeste bewerkingen wilt uitvoeren op de aanwijzer of op het object waarnaar deze verwijst, moet het type waarnaar deze verwijst expliciet worden opgegeven voor elke bewerking. (Variabelen van het type char * en het type void * zijn toewijzingsgewijze compatibel zonder een type cast.) Een dergelijke conversie kan worden uitgevoerd met een typecast. Zie Type-Cast Conversies voor meer informatie.

Dit type-qualifier kan een const of volatilebeide zijn. Deze trefwoorden geven respectievelijk aan dat de aanwijzer niet kan worden gewijzigd door het programma zelf (const) of dat de aanwijzer legitiem kan worden gewijzigd door een bepaald proces buiten de controle van het programma (volatile). Zie Type Kwalificatie voor meer informatie over const envolatile.

De declarator namen van de variabele en kunnen een typemodifier bevatten. Als declarator dit bijvoorbeeld een matrix vertegenwoordigt, wordt het type aanwijzer gewijzigd als een aanwijzer naar een matrix.

U kunt een aanwijzer declareren naar een structuur, samenvoeging of opsommingstype voordat u het type structuur, samenvoeging of opsomming definieert. U declareert de aanwijzer met behulp van de structuur- of samenvoegtag, zoals wordt weergegeven in de voorbeelden. Dergelijke declaraties zijn toegestaan omdat de compiler niet de grootte van de structuur of samenvoeging hoeft te kennen om ruimte toe te wijzen voor de aanwijzervariabele.

Voorbeelden

In de volgende voorbeelden ziet u declaraties van aanwijzers.

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

De message aanwijzer verwijst naar een variabele met char type.

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

De pointers matrix heeft 10 elementen. Elk element is een aanwijzer naar een variabele met int type.

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

De pointer variabele verwijst naar een matrix met 10 elementen. Elk element in deze matrix heeft een int type.

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

De aanwijzer x kan worden gewijzigd om naar een andere int waarde te verwijzen, maar de waarde waarnaar de aanwijzer verwijst, kan niet worden gewijzigd.

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;

De variabele y in deze declaraties wordt gedeclareerd als een constante aanwijzer naar een int waarde. De waarde waarnaar wordt verwezen, kan worden gewijzigd, maar de aanwijzer zelf moet altijd naar dezelfde locatie verwijzen: het adres van fixed_object. Op dezelfde manier z is het een constante aanwijzer, maar deze wordt ook gedeclareerd om te verwijzen naar een int wiens waarde niet kan worden gewijzigd door het programma. De volatile aanduiding geeft aan dat hoewel de waarde van de const int punt waarnaar wordt verwezen z niet kan worden gewijzigd door het programma, het legitiem kan worden gewijzigd door een proces dat gelijktijdig met het programma wordt uitgevoerd. De declaratie van w geeft aan dat het programma de waarde waarnaar wordt verwezen niet kan wijzigen en dat het programma de aanwijzer niet kan wijzigen.

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

In dit voorbeeld worden twee aanwijzervariabelen (next en previous) gede declareert die verwijzen naar het structuurtype list. Deze declaratie kan worden weergegeven vóór de definitie van het list structuurtype (zie het volgende voorbeeld), zolang de list typedefinitie dezelfde zichtbaarheid heeft als de declaratie.

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

De variabele line heeft het structuurtype met de naam list. Het list structuurtype heeft drie leden: het eerste lid is een aanwijzer naar een char waarde, het tweede is een int waarde en het derde is een aanwijzer naar een andere list structuur.

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

De variabele record heeft het structuurtype id. pname wordt gedeclareerd als een aanwijzer naar een ander structuurtype met de naam name. Deze declaratie kan worden weergegeven voordat het name type is gedefinieerd.

Zie ook

Declaraties en variabelendeclaraties