Welcome to Serpia's blog!

Blog Entry

C++ deel-4

Naar deel 3

Arrays

Een array is een opeenvolgende reeks van elementen van hetzelfde type opgeslagen in het geheugen, waarvan ieder element kan worden benaderd. Bijvoorbeeld kunnen we 5 elementen van het type int opslaan, ieder met een eigen waarde en eigen adres.

	0	1	2	3	4
frankie	16	32	96	760	1036

int frankie[5] = {16, 32, 96, 760, 1036} int frankie[] = {16, 32, 96, 760, 1036} // mag ook frankie[1] // 2e element van de array (32) frankie[2] = 75; // sla de waarde '75' op in het 3e element

Maar er is meer! Er zijn ook multi dimensionale arrays:

		0	1	2	3	4
frankie	0	16	32	96	760	1036
	1	2	1	4	6	7
	2	100	11	124	1	12

int frankie[3][5] // declaratie frankie[1][3] // het 2e element verticaal en 4e element horizontaal

Pointers

Het onderwerp pointers wordt vaak lastig gevonden en niet zonder reden. Neem de tijd om dit goed te bestuderen omdat het een fundamenteel onderwerp is. Kijk ook eens naar de onderstaande video:

#include <iostream> using namespace std; int main() { int a=25; cout << "a: " << a << endl; // a: 25 cout << "adres van a: " << &a << endl; // adres van a: 0x7fff14c5ed434 }

Op regel 06 definieren we de parameter 'a' en kennen de waarde '25' toe. Regel 07 voert deze waarde uit naar het scherm. Op regel 08 gebruiken we de 'referentie operator &' om het geheugenadres van de variabele 'a' weer te geven. In mijn geval de waarde '0x7fff14c5ed434'.

#include <iostream> using namespace std; int main() { int a=25; cout << "a: " << a << endl; // a: 25 cout << "adres van a: " << &a << endl; // adres van a: 0x7fff14c5ed434 // nieuw: int * mp; // declaratie pointer mp = &a; // pointer wijst naar geheugenadres van 'a' cout << "mp: " << mp << endl; // mp: 0x7fff14c5ed434 }

In regel 10 declareren we een pointer, let op: het type moet hetzelfde zijn als de variabele als waar naar verwezen wordt. Regel 11 kent de adreswaarde van 'a' toe aan de net gemaakte pointer. En inderdaad, op regel 12 zie je dat dit inderdaad het geval is.

#include <iostream> using namespace std; int main() { int a=25; cout << "a: " << a << endl; // a: 25 cout << "adres van a: " << &a << endl; // adres van a: 0x7fff14c5ed434 int * mp; // declaratie pointer mp = &a; // pointer wijst naar geheugenadres van 'a' cout << "mp: " << mp << endl; // mp: 0x7fff14c5ed434 // nieuw: *mp = 255; // wel wat verwarrend die '*'! cout << "mp: " << mp << endl; // nog steeds hetzelfde... cout << "a: " << a << endl; // a: 255 }

Op regel 14 gebruiken we de 'dereference operator *' om via de pointer 'mp' de waarde van het geheugenadres van 'a' te wijzigen in '255'. Het kan verwarrend zijn dat voor het declareren van een pointer (regel 10), ook een '*' wordt gebruikt! Inderdaad, als we regel 15 uitvoeren is het geheugenadres nog steeds hetzelfde. Maar op regel 16 zien we dat inderdaad de waarde van 'a' is veranderd, via de pointer mp! Laat dit goed op je inwerken, er is veel informatie te vinden op het net over pointers.

Pointers en Arrays

... zijn als beste maatjes van elkaar. Sterker nog, de referentie naar een array is het adres van het eerste element en ook de pointer zal dit adres gebruiken. Dus dit is geldig;

int straatnummers[25]; int * p; cout << straatnummers << endl; // stel: ff6600 cout << p << endl; // stel: 006600 p = straatnummers; cout << straatnummers << endl; // ff6600 cout << p << endl;// ook: ff6600 // het bewijs: if (p==straatnummers) { cout << "KLOPT" << endl; }

Hieronder nog een mooi voorbeeld uit de tutorial van cplusplus.com om dit gedeelte af te ronden;

#include <iostream> using namespace std; int main () { int numbers[5]; int * p; p = numbers; *p = 10; p++; *p = 20; p = &numbers[2]; *p = 30; p = numbers + 3; *p = 40; p = numbers; *(p+4) = 50; for (int n=0; n<5; n++) cout << numbers[n] << ", "; return 0; }

Rekenen met pointers

Rekenen met pointers is anders dan het rekenen met 'normale' int's. Ten eerste kun je met pointers alleen optellen en aftrekken en ten tweede is de uitkomst afhankelijk van het gedefinieerde type.

char * mijnchar; // stel: 1000; short * mijnshort; // stel: 2000; long * mijnlong; // stel: 3000; mijnchar++; // geeft 1001; mijnshort++; // geeft 2002; mijnlong++; // geeft 3004;

Ook kunnen pointers naar elkaar wijzen, naar functies en klassen wijzen. Meer hierover later in de onderdeel over 'klassen'.

xkcd over pointers

Naar deel 5

Comments

Post a comment

Your name:

Comment: