Programmeren in C/Arrays en pointers

Uit Wikibooks

[bewerken] 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

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 is 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 geheugen adres van het nulde element. Een element uit een array kan benaderd worden door de subscript notatie. 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 alle kwadraten 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 groote van de array, zo zal het statement,

data[11] = 0;

prima compileren. Dit betekent echter niet dat het programma goed draait, zo kun je jezelf voorstellen, dat het geheugen erop dat moment zo uit ziet:

Voor de bewerking:
[geheugen voor data(int data)][geheugen voor andere variabele(char *bla)]
0 1 2 3 4 5 6 7 8 9             Hello world!\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)]
0 1 2 3 4 5 6 7 8 9              \0ello world!\0 
printf(bla); levert dan op:

Dit heeft bijvoorbeeld tot gevolg, dat de string "Hello world!" niet meer geprint wordt door printf. Dit soort fouten zijn moeilijk te vinden en geven aanleiding tot willekeurig gedrag van een programma. Soms kan een programma zelfs vastlopen hierdoor.

De hierboven genoemde array is een-dimensionaal. 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 het draaien van het programma:

// Dit programma zal niet compileren
// 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 door gebruik te maken van dynamische geheugenallocatie.

[bewerken] Pointers

Pointers bevatten de adressen waar de 'gepointe' variabele zich bevindt. Als je een variabele declareert, dan 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 10004 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);" Dan krijg je als output:i=3 en staat op adres 10000. Als je hetzelfde zou doen voor een array dan krijg je dat er opeenvolgens een aantal geheugenplaatsen worden gereserveerd ter groote van het type variablele dat je declareert.

int i[10];

declareert 10 keer het geheugen voor een integer, of 10 * 4 bytes = 40 bytes. deze geheugen plaatsen kun je vervolgens benaderen op de volgende manier. ==>OPM: ZIJN ONDERSTAANDE VOOBEELDEN WEL JUIST? ZIET ER ONLOGISCH UIT

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

maar met behulp van pointers gaat het ook op de volgende manier.

  int i[10];
  for (int a=%i) ;