Programmeren in C++/Pointers

Pointers behoren tot de krachtigste hulpmiddelen in C++. Het werken met pointers is wel tamelijk lastig om te leren, wat gedeeltelijk veroorzaakt wordt door de enigszins verwarrende wijze waarop in C++ variabelen gedeclareerd worden. Zo is:

C++-code:

int *intPnt

niet de declaratie van een integer met de naam *intPnt, maar de declaratie van een pointer naar een integer met de naam intPnt. De werkelijke achtergrond van deze notatie is echter dat *intPnt wel degelijk een integer is, en juist de integer waar intPnt naar wijst. In dit artikel moet je wel weten wat een variabele is, wat voor types je hebt en hoe je ze aanmaakt.

Een pointer is een variabele waarin je een geheugenadres opslaat. Waarschijnlijk moet je de regel een paar keer lezen om hem te snappen, maar ik zal hem hier nog even uitgebreid verklaren. Een pointer is dus een variabele. Dat is een object waarin je gegevens kunt opslaan. In het geval van een pointer sla je dus in die variabele een geheugenadres op.

Wat is nou een geheugenadres? Het geheugen is verdeeld in hokken, laten we zeggen postvakjes. Ieder postvakje heeft een uniek adres oftewel een uniek geheugenadres. Ieder postvakje is 1 byte groot. Zo worden bijvoorbeeld bij een unsigned long int 4 postvakjes gereserveerd. Een unsigned long int is 4 bytes, dus krijgt hij 4 vakjes toegewezen.

Nou hoef je natuurlijk als programmeur niet de adressen van je variabelen te weten. Daar heeft C++ een operator voor. Om achter het adres van een variabele te komen gebruik je de "address of"-operator oftewel &. Om dit te demonstreren is hier een voorbeeld.

C++-code:

#include <iostream> 
using namespace std;

int main() 
{ 
    unsigned short shortVar=5; 

    cout << "shortVar: " << shortVar; 
    cout << " Adres van shortVar: " << &shortVar << endl; 

    return 0; 
}

De uitvoer zou kunnen zijn (verschilt per computer):

C++-code:

shortVar: 5 Adres van shortVar: 0x8fc9:fff4

In dit geval heeft de variabele 'shortVar' het adres '0x8fc9:fff4'. Dat betekent niets anders dan dat de geheugenplaats '0x8fc9:fff4' samen met de drie daarop volgende geheugenplaatsen de variabele 'shortVar' voorstelt. Het adres'0x8fc9:fff4' zelf kan met de naam 'shortVar' aangesproken kan worden. Dat is voor ons gemakkelijker dan steeds dat hex-getal te moeten gebruiken.

In een geheugenplaats kan ook informatie opgeslagen worden. In 'shortVar' zelf is het getal 5 opgeslagen. Maar soms willen we ook het adres van shortVar, dus het hex-getal '0x8fc9:fff4' ergens opslaan. Eigenlijk interesseert het ons niet welk hex-getal het is, dat hoeven we niet te weten, het gaat er alleen om dat het het adres van 'shortVar' is. We hebben dus een variabele nodig waarin je zo'n adres kunt opslaan. Zo'n variabele is een pointer.

Een voorbeeld.

C++-code:

int myAge = 15; // Maakt variabele myAge 
int *pAge = 0; // Maakt pointer pAge 

pAge = &myAge ; // zet het adres van myAge in de pointer pAge

We declareren weer eerst een variabele, nl. 'myAge'. In de tweede regel declareren we een pointer, 'pAge', waarin we het adres van 'myAge' kunnen opslaan. Door het sterretje(*) voor 'pAge' wordt 'pAge' een pointer naar een integer. In de derde regel wordt in de pointer het adres van 'myAge' opgeslagen.

Wat kun je hier nou mee? Heel simpel je kunt nu met de pointer pAge, de waarde van myAge ophalen. Dit wordt indirectie genoemd. Let wel op, om de waarde op te halen moet je het sterretje(*) voor de pointer zetten, dus het wordt *pAge. Het sterretje(*) wordt ook wel de indirectie-operator genoemd.

In deze tutorial ga ik het hebben over de vrije geheugenruimte, ook wel de heap genoemd. De heap is de ruimte waar variabelen en objecten blijven bestaan tot het moment dat jij ze verwijdert of het programma is beëindigd.

Hoe werkt dit nu? Kijk even naar het volgende voorbeeld:

C++-code:

int mijnLeeftijd = 18; 
int *pLeeftijd = new int; 
pLeeftijd = &mijnLeeftijd; 

cout << *pLeeftijd;

Output: 18

Wat heb je nu gedaan? Denk er eerst zelf even over na, dan leg ik het uit....

We beginnen met het maken van een lokale variabele in de stack, genaamd 'mijnLeeftijd' en geven die de waarde 18.

In de vrije geheugenruimte maken we een pointer 'pLeeftijd' groot genoeg om het adres van een integer op te slaan.

Het adres van 'mijnLeeftijd' stoppen we in de pointer 'pLeeftijd' door middel van de operator & (address of).

Vervolgens geven we de waarde weer die op het opgeslagen adres staat, 18 dus. Dit proces noemen we indirectie.

Behalve met variabelen werkt dit proces ook met objecten, zoals een class. Hier volgt een voorbeeld.

C++-code:

#include <iostream> 
using namespace std;

class CSimpleCat 
{ 
    public: 
        CSimpleCat(); 
        ~CSimpleCat(); 
        int getAge() const { return *itsAge; } 
        void setAge(int age) { *itsAge = age; } 

        int getWeight() const { return *itsWeight; } 
        int setWeight ( int weight) { *itsWeight = weight; } 

    private: 
        int *itsAge; 
        int *itsWeight; 
}; 

CSimpleCat::CSimpleCat() 
{ 
    itsAge = new int(2); 
    itsWeight = new int(5); 
} 

CSimpleCat::~CSimpleCat() 
{ 
    delete itsAge; 
    delete itsWeight; 
} 

int main() 
{ 
    CSimpleCat * pFrisky = new CSimpleCat; 
    cout << "Frisky is "<< pFrisky->getAge() << " jaar oud" << endl; 
    pFrisky->setAge(5); 
    cout << "Frisky is "<< pFrisky->getAge() << " jaar oud" << endl; 
    delete pFrisky; 
    return 0; 
}

Zo dat ziet er waarschijnlijk een beetje moeilijk uit, no worry. Hier is de uitleg.

We maken gewoon een class 'CSimpleCat' met een constructor en een aantal accessorfuncties. Dit moet je allemaal bekend voorkomen.

De variabelen zijn ook pointers naar variabelen in de vrije geheugenruimte. Dat hebben we net behandeld en dat snap je nu denk wel.

In de main-functie krijgen we wel wat nieuwe dingen; die ga ik nu behandelen.

C++-code:

CSimpleCat * pFrisky = new CSimpleCat;

Wat zeggen we hier eigenlijk? In gewoon Nederlands zeggen we: "Maak een pointer van het type CSimpleCat in de vrije geheugenruimte met de naam 'pFrisky' wat een CSimpleCat is". Logisch? Niet echt hè.

'pFrisky' is dus van het zelfgemaakte type 'CSimpleCat'. Nu zorgen we er dus voor dat 'pFrisky' het juiste aantal bytes heeft dat 'CSimpleCat' nodig heeft. De opdracht new CSimpleCat zorgt er echter voor dat het ook echt een CSimpleCat wordt.

De eerste CSimpleCat is er dus om geheugen te reserveren, de tweede voor de definitie!

Hoe bereik je nu de methoden van CSimpleCat door middel van je pointer? Ook hiervoor moet je indirectie toepassen wat betekent dat je het volgende krijgt:

C++-code:

(*pFrisky).getAge();

Omdat dit nogal omslachtig is, heeft men in C++ een verkorte versie gemaakt. De "->"-operator. Dus nu schrijf je:

C++-code:

pFrisky->getAge();

Om weer over niet-gebruikt geheugen te kunnen beschikken, moet je geheugenruimte vrijmaken. Dit doe je met delete.Daarmee voorkom je ook memory-leaks.

C++-code:

delete pFrisky; 
pFrisky = 0;

Waarom zetten we 'pFrisky' op 0? Als je dit niet doet krijg je een zogeheten wilde pointer. Het gevaar hiervan is, dat als je hem nog een keer verwijdert, in het mooiste geval je programma crasht, maar in het ergste geval je een vastloper krijgt.

Nu kan je namelijk veilig het volgende doen:

C++-code:

int *pInt = new int; 
delete pInt; 
pInt = 0; 
delete pInt;