const en vluchtige aanwijzers

De const - en vluchtige trefwoorden veranderen hoe pointers worden behandeld. Het const trefwoord geeft aan dat de aanwijzer niet kan worden gewijzigd na initialisatie; de aanwijzer wordt daarna beveiligd tegen wijziging.

Het volatile trefwoord geeft aan dat de waarde die is gekoppeld aan de volgende naam, kan worden gewijzigd door andere acties dan die in de gebruikerstoepassing. Daarom is het trefwoord handig voor het volatile declareren van objecten in gedeeld geheugen die toegankelijk zijn voor meerdere processen of globale gegevensgebieden die worden gebruikt voor communicatie met onderbrekingsserviceroutines.

Wanneer een naam wordt gedeclareerd als volatile, wordt de waarde opnieuw geladen vanuit het geheugen telkens wanneer deze wordt geopend door het programma. Dit vermindert de mogelijke optimalisaties aanzienlijk. Wanneer de status van een object echter onverwacht kan worden gewijzigd, is het de enige manier om voorspelbare programmaprestaties te garanderen.

Als u het object wilt declareren waarnaar wordt verwezen door de aanwijzer als const of volatile, gebruikt u een declaratie van het formulier:

const char *cpch;
volatile char *vpch;

Als u de waarde van de aanwijzer wilt declareren ( dat wil zeggen het werkelijke adres dat in de aanwijzer is opgeslagen ), gebruikt constvolatileu een declaratie van het formulier:

char * const pchc;
char * volatile pchv;

De C++-taal voorkomt toewijzingen die het wijzigen van een object of aanwijzer als consttoestaan. Dergelijke toewijzingen zouden de informatie verwijderen waarmee het object of de aanwijzer is gedeclareerd, waardoor de bedoeling van de oorspronkelijke verklaring wordt geschonden. Houd rekening met de volgende declaraties:

const char cch = 'A';
char ch = 'B';

Gezien de voorgaande declaraties van twee objecten (cchvan het type const char en ch, van het type char), zijn de volgende declaraties/initialisaties geldig:

const char *pch1 = &cch;
const char *const pch4 = &cch;
const char *pch5 = &ch;
char *pch6 = &ch;
char *const pch7 = &ch;
const char *const pch8 = &ch;

De volgende declaratie/initialisaties zijn onjuist.

char *pch2 = &cch;   // Error
char *const pch3 = &cch;   // Error

De verklaring van pch2 declareert een aanwijzer waardoor een constant object kan worden gewijzigd en daarom niet is toegestaan. De declaratie van pch3 geeft aan dat de aanwijzer constant is, niet het object; de declaratie is om dezelfde reden niet toegestaan dat de pch2 declaratie niet is toegestaan.

De volgende acht toewijzingen tonen het toewijzen via aanwijzer en het wijzigen van de aanwijzerwaarde voor de voorgaande declaraties; voor nu wordt ervan uitgegaan dat de initialisatie juist was voor pch1 de implementatie pch8.

*pch1 = 'A';  // Error: object declared const
pch1 = &ch;   // OK: pointer not declared const
*pch2 = 'A';  // OK: normal pointer
pch2 = &ch;   // OK: normal pointer
*pch3 = 'A';  // OK: object not declared const
pch3 = &ch;   // Error: pointer declared const
*pch4 = 'A';  // Error: object declared const
pch4 = &ch;   // Error: pointer declared const

Aanwijzers die zijn aangegeven als volatile, of als mengsel van const en volatile, voldoen aan dezelfde regels.

Aanwijzers naar const objecten worden vaak als volgt gebruikt in functiedeclaraties:

errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource );

De voorgaande instructie declareert een functie , strcpy_s, waarbij twee van de drie argumenten van het type aanwijzer charzijn. Omdat de argumenten worden doorgegeven door verwijzing en niet op waarde, is de functie vrij om beide strDestination te wijzigen en strSource indien strSource niet gedeclareerd als const. De verklaring van strSource as const verzekert de aanroeper die strSource niet kan worden gewijzigd door de aangeroepen functie.

Opmerking

Omdat er een standaardconversie is van typenaam* naar consttypenaam*, is het juridisch om een argument van het type char * door te geven aan strcpy_s. Het omgekeerde is echter niet waar; er bestaat geen impliciete conversie om het const kenmerk uit een object of aanwijzer te verwijderen.

Een const aanwijzer van een bepaald type kan worden toegewezen aan een aanwijzer van hetzelfde type. Een aanwijzer die niet aan een aanwijzer kan worden toegewezen, kan echter niet const worden toegewezen aan een const aanwijzer. De volgende code toont de juiste en onjuiste toewijzingen:

// const_pointer.cpp
int *const cpObject = 0;
int *pObject;

int main() {
pObject = cpObject;
cpObject = pObject;   // C3892
}

In het volgende voorbeeld ziet u hoe u een object als const declareert als u een aanwijzer naar een object hebt.

// const_pointer2.cpp
struct X {
   X(int i) : m_i(i) { }
   int m_i;
};

int main() {
   // correct
   const X cx(10);
   const X * pcx = &cx;
   const X ** ppcx = &pcx;

   // also correct
   X const cx2(20);
   X const * pcx2 = &cx2;
   X const ** ppcx2 = &pcx2;
}

Zie ook

aanwijzers
Onbewerkte aanwijzers