Ha van egy tetszőleges típusú változónk a memóriában, akkor annak memóriacíme lekérdezhető a címképző operátor (&) használatával. A címképző operátort mindig a változó neve elé írjuk, ahogy ez a következő kód 7. sorában látható.

1
2
3
4
5
6
7
8

#include <iostream>

int main()
{
    int a = 42;
    std::cout << "value of 'a': " << a 
              << "; memory address of 'a': " << &a << std::endl;
}

A címképző operátor által megadott memóriacímet elmenthetjük egy változóban is. Ennek a változónak a típus deklarációjánál jeleznünk kell, hogy az adott változó memória címet tartalmaz. Ennek érdekében definiáljuk a pointer (mutató) típust. Egy pointer típusú változó esetén jeleznünk kell, hogy milyen típusú változó található a pointer által hivatkozott memóriacímen. Példánk 8. sorában egy int típusra hivatkozó mutató típusú változót definiálunk.

3
4
5
6
7
8
9

int main()
{
    int a = 42;
    std::cout << "value of 'a': " << a 
              << "; memory address of 'a': " << &a << std::endl;
    int* p = &a;
}

A pointer típusú változó által hivatkozott memória területen tárolt értéket elérhetjük és akár módosíthatjuk is a dereferencia operátoron (*) keresztül. A dereferencia operátort csak pointer típusú változó elé írhatjuk. A dereferencia operátor használatára a kódunk 10. sorában találunk példát.

 3
 4
 5
 6
 7
 8
 9
10
11

int main()
{
    int a = 42;
    std::cout << "value of 'a': " << a 
              << "; memory address of 'a': " << &a << std::endl;
    int* p = &a;
    std::cout << "value of 'p': " << p
              << "; dereferenced value via 'p': " << *p << std::endl;
}

Ne keverjük össze a kétféle szerepben használt * jelölést! Ha egy változó deklarációjánál használjuk (int* p), akkor azt jelenti, hogy pointer típusú változót definiálunk. Ha viszont egy már korábban létrehozott pointer típusú változó elé írunk *-ot (*p), akkor a pointer által mutatott memória területen tárolt értéket hivatkozzuk a derefencia operátoron keresztül.

Mutatók használata esetén jelezhetjük azt is, hogy egy mutató sehova sem mutat. Ennek érdekében vezették be a nullptr literált. Ha egy pointer típusú változó értékét nullptr-re állítjuk, akkor az adott változó aktuálisan nem mutat semmilyen memóriaterületre.

Ha egy pointer típusú változó aktuális értéke a nullptr, akkor a változón keresztüli derefereálás ún. segmentation fault-ot eredményez, azaz megszakad a programunk futása.

Ha egy poniter típusú változót nem inicializálunk, akkor nem egyértelműen definiált (azaz undefined), hogy mi lesz a változó kezdeti értéke. Ne építsünk arra, hogy ilyenkor a változó automatikusan nullptr értéket kap.