const och flyktiga pekare

Nyckelorden const och volatile ändrar hur pekare behandlas. Nyckelordet const anger att pekaren inte kan ändras efter initieringen. Pekaren skyddas därefter från ändringar.

Nyckelordet volatile anger att värdet som är associerat med namnet som följer kan ändras av andra åtgärder än de i användarprogrammet. Nyckelordet volatile är därför användbart för att deklarera objekt i delat minne som kan nås av flera processer eller globala dataområden som används för kommunikation med avbrottstjänstrutiner.

När ett namn deklareras som volatileläser kompilatorn in värdet från minnet varje gång det används av programmet. Detta minskar avsevärt de möjliga optimeringarna. Men när tillståndet för ett objekt kan ändras oväntat är det det enda sättet att säkerställa förutsägbara programprestanda.

Om du vill deklarera objektet som pekaren pekar på som const eller volatileanvänder du en deklaration av formuläret:

const char *cpch;
volatile char *vpch;

Om du vill deklarera värdet för pekaren – det vill säga den faktiska adressen som lagras i pekaren – som const eller volatile, använder du en deklaration av formuläret:

char * const pchc;
char * volatile pchv;

C++-språket förhindrar tilldelningar som tillåter ändring av ett objekt eller pekare som deklarerats som const. Sådana tilldelningar skulle ta bort den information som objektet eller pekaren deklarerades med, vilket bryter mot avsikten med den ursprungliga deklarationen. Tänk på följande deklarationer:

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

Med tanke på föregående deklarationer av två objekt (cchav typen const char och ch, av typen char), är följande deklaration/initieringar giltiga:

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;

Följande deklaration/initieringar är felaktiga.

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

Deklarationen deklarerar pch2 en pekare genom vilken ett konstant objekt kan ändras och därför inte tillåts. Deklarationen anger att pekaren är konstant, inte objektet. deklarationen tillåts inte av pch3 samma anledning som deklarationen pch2 inte tillåts.

Följande åtta tilldelningar visar tilldelning via pekare och ändring av pekarvärde för föregående deklarationer. anta för tillfället att initieringen var korrekt för pch1 via 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

Pekare som deklareras som volatile, eller som en blandning av const och volatile, följer samma regler.

Pekare till const objekt används ofta i funktionsdeklarationer på följande sätt:

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

Föregående -instruktion deklarerar en funktion , strcpy_s, där två av de tre argumenten är av typen pekare till char. Eftersom argumenten skickas med referens och inte efter värde kan funktionen ändra båda strDestination och strSource om strSource de inte deklarerades som const. Deklarationen av strSource som const försäkrar anroparen som strSource inte kan ändras av den anropade funktionen.

Anmärkning

Eftersom det finns en standardkonvertering från typename* till consttypename* är det lagligt att skicka ett argument av typen char * till strcpy_s. Det omvända är dock inte sant; det finns ingen implicit konvertering för att ta bort const attributet från ett objekt eller pekare.

En const pekare av en viss typ kan tilldelas en pekare av samma typ. En pekare som inte kan tilldelas en const pekare kan dock inte const tilldelas. Följande kod visar korrekta och felaktiga tilldelningar:

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

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

Följande exempel visar hur du deklarerar ett objekt som const om du har en pekare till en pekare till ett objekt.

// 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;
}

Se även

pekare
Råpekare