CKTIS / C++
Pointerdeclarator (*) in C++
Leer hoe `*` in ISO C++23 een pointer declareert, waarop `const` van toepassing is en hoe een pointer naar een array verschilt van een array van pointers.
Versie: ISO C++23; implementation support may vary
Syntax
T* p = nullptr;
T const* read = &obj;
T* const fixed = &obj;
T const* const fixed_read = &obj;
T** pp = &p;
T* slots[N];
T (*whole)[N] = &array;
R (*fn)(Args...);In int* p, q; hoort het sterretje alleen bij de declarator van p; q heeft type int. Spaties veranderen dit niet. Elk sterretje voegt een niveau van indirectie toe: int** pp is een pointer naar een pointer. In expressies neemt de ingebouwde operator & in &x het adres van x, en derefereert de ingebouwde unaire operator * in *p de pointer; hij declareert of vermenigvuldigt niet. In int& r = x; declareert & een lvalue-referentie en neemt het geen adres.
Bij const int* p (gelijkwaardig aan int const* p) kun je p een andere waarde geven, maar de aangewezen int niet via p wijzigen. Bij int* const p staat de pointerwaarde na initialisatie vast, maar kun je de aangewezen int wijzigen. const int* const p combineert beide beperkingen. Bij parameters die op waarde worden doorgegeven, kunnen int* en const int* overloads onderscheiden; int* en int* const kunnen dat niet.
int* a[3] is een array van drie pointers; int (*a)[3] is een pointer naar een volledige array van drie int-elementen. Op dezelfde manier is int (*f)(double) een functiepointer, terwijl int* f(double) een functie declareert die een pointer teruggeeft. int C::* m declareert een apart type: een pointer naar een niet-statisch datalid van C.
Een ruwe pointer zegt op zichzelf niets over eigenaarschap en verlengt de levensduur van een object niet. Een array kan worden geconverteerd naar een pointer naar het eerste element; die pointer bevat de lengte niet. Als een pointer nog niet naar een object moet wijzen, initialiseer hem dan met nullptr in plaats van een lokale pointer ongeïnitialiseerd te laten. Een controle op ongelijkheid met nullptr bewijst niet dat het object nog leeft of dat een index binnen de grenzen valt. Het derefereren van een nullpointer of een pointer vlak voorbij het einde van de array, of het benaderen van een object via een bungelende pointer, veroorzaakt ongedefinieerd gedrag.
Voorbeelden
#include <iostream>
int main() {
int values[3]{2, 4, 6};
const int* read = values;
int* const first = &values[0];
int (*whole)[3] = &values;
*first = 3;
std::cout << *read << ' ' << (*whole)[2] << '\n';
}Resultaat
3 6
`read` wijst naar het eerste element zonder wijzigingen via die pointer toe te staan. `first` wijst naar hetzelfde element, kan geen andere waarde krijgen en maakt het mogelijk om via `*first` de waarde `3` te schrijven. `whole` wijst naar de hele array, dus `(*whole)[2]` leest het derde element. Verwachte uitvoer: `3 6`.
Gerelateerde lessen
- C++ · Les 47 · Gevorderd · Versie: 3
- C++ · Les 49 · Gevorderd · Versie: 3
- C++ · Les 51 · Gevorderd · Versie: 3
- C++ · Les 56 · Gevorderd · Versie: 3
- C++ · Les 58 · Gevorderd · Versie: 3