Programmeren in C/Arrays en pointers

Arrays

Arrays worden veel gebruikt in C. Ze zijn handig om veel data op te slaan van één type in één variabele. Ook kunnen arrays gebruikt worden om gegevens te sorteren. De meest voorkomende array is echter de string, zoals de tekst die geprint wordt in het "Hello world!" programma in hoofdstuk 3. Een array is simpel gezegd een rij van variabelen. Een goede grafische weergave van een array is daarom:

a b c d e f g
0 1 2 3 4 5 6 7 8 

Zo is de array ook in het geheugen gerepresenteerd, alle variabelen staan direct achter elkaar en met behulp van een typering weet de compiler hoe groot elk element in de array is. Het eerste element in een array heeft de index nul. Men initialiseert een array met behulp van het volgende statement:

int data[10];

Met deze statement geef je aan, dat je een array wenst van integers en 10 elementen groot. De compiler reserveert dan 10 * sizeof(int) bytes (het is natuurlijk afhankelijk van de compiler, welke groote een integer heeft, doorgaans is een integer 4 byte op een 32 bits machine) en geeft het geheugenadres van het element met index 0. Een element uit een array kan benaderd worden door de subscriptnotatie. Tussen vierkante haakjes plaats je de index van het element dat je wil benaderen (gaande van 0 tot en met de grootte - 1). Het volgende voorbeeld illustreert hoe een array gevuld kan worden met het kwadraat van de index:

int main()
{
   int tabel[15];
   int i=0;
   for(i=0;i<15;i++){
       tabel[i]= i*i;
   }
}

Van elk type kan op deze manier een array gemaakt worden. C controleert echter niet of u zich houdt aan de grootte van de array, zo zal het statement,

data[10] = '\0';

prima gecompileerd worden. Dit betekent echter niet dat het programma goed werkt, zo kun je je voorstellen, dat het geheugen er op dat moment zo uit ziet:

Voor de bewerking: [geheugen voor data(int data)][geheugen voor andere variabele(char *bla)]

data:										bla:
0	1	2	3	4	5	6	7	8	9	0	1	2	3	4	5	6	7	8	9	10	11	12
7	2	9	1	0	0	2	12	3	3	H	e	l	l	o		w	o	r	l	d	!	\0

printf(bla); levert dan op: Hello world!

Na de bewerking(data[10] = '\0']:

[geheugen voor data(int data)][geheugen voor andere variabele(char *bla)]

data:										bla:
0	1	2	3	4	5	6	7	8	9	0	1	2	3	4	5	6	7	8	9	10	11	12
7	2	9	1	0	0	2	12	3	3	\0	e	l	l	o		w	o	r	l	d	!	\0

printf(bla); levert dan op:

De string bla die eerst "Hello world!" bevatte, begint nu met '\0', waardoor dit het einde van de string is en bla dus een lege string is geworden. Dit soort fouten zijn moeilijk te vinden en geven aanleiding tot willekeurig gedrag van een programma. Soms kan een programma hierdoor zelfs vastlopen.

De hierboven genoemde array is eendimensionaal. Men kan er ook een van twee dimensies of meer dimensies definieren:

char data[9][10][7];

Deze worden ook wel maps genoemd. Je zou namelijk de analogie van een landkaart kunnen trekken. Arrays kunnen alleen statisch een grootte meekrijgen. Dit betekent, dat het alleen mogelijk is om tijdens het programmeren de grootte van de array te definieren en niet tijdens de uitvoering van het programma:

// Dit programma zal niet gecompileerd worden
// Arrays dienen statisch te worden geinitialiseerd.

int fout(int gr);

int main()
{
   int gr; // grootte van de array, die je wilt maken.
   printf("Kies de grootte van de array:");
   scanf("%d", &gr);
   return fout(gr);
}

int fout(int gr)
{
   char data[gr];
   return 0;
}

Dit probleem kan worden opgelost met ingewikkeldere datastructuren, zoals gelinkte lijsten, door gebruik te maken van dynamische geheugenallocatie.

Pointers

Pointers bevatten de adressen waar de 'gepointe' variabele zich bevindt. Als je een variabele declareert, reserveert het programma een adres in het geheugen van de computer. Dit adres wordt vervolgens gebruikt wanneer je een waarde toekent aan de variabele. Dus bij het volgende stukje programma

int i;
i=3;

wordt bij "int i;" een stukje geheugen van sizeof(int) (4) bytes gereserveerd op bv. adres 10000, omdat het hierbij gaat om een integer zullen de bytes 10000 tot en met 10003 worden gereserveerd. Dit adres is te achterhalen door middel van het & teken. Als je zegt "printf("i=%d en staat op adres %d", i, &i);" , krijg je als output: i=3 en staat op adres 10000. Als je hetzelfde zou doen voor een array, krijg je dat er opeenvolgend geheugenplaatsen worden gereserveerd ter grootte van het type variablele dat je declareert.

int i[10];

reserveert in het geheugen 10 * 4 bytes = 40 bytes ruimte voor 10 integers. Deze geheugenplaatsen kun je vervolgens benaderen op de volgende manier:

int i[10];
for(int n=0;n<10;n++){
   i[n]=100+n;
}