Meer pointers

Je weet dat pointers variabelen zijn die naar een geheugenadres wijzen van bijvoorbeeld een int, maar je kunt ze dan natuurlijk ook naar klassen laten wijzen (klassen bevatten ook variabelen). Hiervan heb ik natuurlijk ook weer een voorbeeldje met uitleg.

#include <iostream.h>

class auto			    //auto class
{
public: 		  	    //public deel
  auto(){snelheid= new int(180);}   //constructor met een new int 
  ~auto(){delete snelheid;}	    //destructor verwijdert data
  
  void setsnelheid(int waarde){*snelheid = waarde;} //instellen snelheid
  void getsnelheid(){return *snelheid;}	   	    //snelheid ophalen
	 				   
private:		   //private deel
  int *snelheid; 	   //een pointer naar een int
}

int main()
{
  auto *mercedes = new auto;                //maak een nieuwe auto
  cout << mercedes->getsnelheid(); //laat de snelheid zien 
  mercedes->setsnelheid(200);	    //stel de snelheid in
  cout << mercedes->getsnelheid(); //laat de snelheid zien
  delete mercedes;
  
  return 0;
}
Het is en blijft een moeilijk onderwerp dus ik zal mijn best doen om dit een beetje goed uit te leggen. In de main functie wordt eerst een klasse gemaakt in de vrije geheugen ruimte en het adres van deze nieuwe klasse wordt opgeslagen in de pointer mercedes. Doordat er een nieuwe klasse is gemaakt wordt de constructor opgeroepen die de waarde 180 in de vrije geheugen ruimte zet. Het geheugen adres waar de waarde (180) zich bevind wordt weer opgeslagen in de pointer snelheid die gemaakt is in het private deel.

Als we nu de waarde 180 weer op willen halen moeten we dat dus via de pointer snelheid doen, deze heeft namelijk het adres van de waarde. Omdat snelheid private is kunnen we er dus niet direct bij komen maar doen we dit met de functie getsnelheid, maar nu is er weer een probleem. De klasse moet worden aangesproken door een pointer en dat werkt niet zoals je normaal zou doen met "mercedes.getsnelheid();" maar nu moet dat met "mercedes->getsnelheid();". Op dezelfde manier kunnen we dus ook de waarde van snelheid veranderen wat in de derde regel van main gebeurt. Dan wordt de nieuwe waarde nog een keer weergegeven en wordt vervolgens de class mercedes verwijdert uit het vrije geheugen. Doordat de class wordt gedelete wordt de destructor opgeroepen die de waarde 180 verwijdert uit het geheugen en wordt het programma afgesloten.

De this pointer


De this pointer is een speciale pointer die elke methode binnen een klasse als extra parameter mee krijgt en wijst naar het individuele object van de methode. Om dit een beetje duidelijk te maken gebruiken we het onderstaande voorbeeldje.

class auto				   //auto class
{
public: 				   //public deel
  auto();
  ~auto(){}
  
  void setsnelheid(int waarde){this->snelheid = waarde;} //instellen snelheid
  void getsnelheid(){return this->snelheid;}	    	    //snelheid ophalen
} 

auto::auto()
{
  int snelheid;
}
Bij deze klasse gaat het eigenlijk alleen maar om de set- en getsnelheid methodes gaat die de this pointer gebruiken om toegang te krijgen tot de waarde in snelheid. De functie gebruikt this die naar de variabele snelheid wijst (dus een pointer naar snelheid), en kan zo een waarde instellen voor de snelheid. Hetzelfde geldt voor getsnelheid die de this pointer gebruikt om de waarde uit snelheid weer op te halen. This wijst dus kortweg naar het geheugen adres van snelheid.

constante pointers


Je weet dat er constante variabelen zijn, maar er bestaan ook constante pointers die op dezelfde manier werken. Hieronder vind je een voorbeeld van hoe je deze declareert.

const int * pointer;

deze pointer wijst naar een constante integer waarvan je de waarde dus niet kunt veranderen.

int * const pointer;

Hier is de pointer constant en kun je niet het geheugenadres in de pointer veranderen. Je kunt dus wel de waarde van de integer veranderen met deze pointer.

const int * const pointer;

Je snapt natuurlijk al dat hier de pointer en de integer constant zijn. Hier kun je dus het geheugen adres in de pointer niet veranderen, en ook kun je de waarde van de integer niet veranderen.

Waar je aan moet denken als je met const werkt is dat als je een constant object maakt van een klasse de this pointers ook naar een constant object wijzen. Je kunt dan dus de objecten ook niet meer veranderen.

Succes

Vampire,