Soms is het nodig om een groep van gegevens als één geheel aan te spreken. Een array is een ‘container’ waarin verschillende gegevens van hetzelfde data type opgeslagen kunnen worden. Alle elementen van de array kunnen via de arraynaam benaderd worden.

We leggen dit uit aan de hand van een voorbeeld. Gevraagd: Maak een programma dat controleert of het getal 25 in de getallenreeks 4, 9, 3, 10, 25, 7, 36 voorkomt.

Mogelijke oplossingen om dit te programmeren:

Hoe het niet moet!

 // Voor elk getal declareren we een aparte variabele
int number1 = 4;
int number2 = 9;
int number3 = 3;
int number4 = 10;
int number5 = 25;
int number6 = 7;
int number7 = 36;

// Een if-else structuur voor het testen van elke variabele
if (number1 == 25)
{
    Console.WriteLine("Found number 25!");
}
else if (number2 == 25)
{
    Console.WriteLine("Found number 25!");
}
else if (number3 == 25)
{
    Console.WriteLine("Found number 25!");
}
...
else if (number7 == 25)
{
    Console.WriteLine("Found number 25!");
}

Deze oplossing werkt, maar is moeilijk te onderhouden of uit te bereiden. Indien dit voor bijvoorbeeld 100 getallen moeten getest worden, krijgen we een onoverzichtelijk geheel, om van het codeerwerk nog maar te zwijgen. Natuurlijk is er een meer efficiënte oplossing, namelijk de array.

De correcte oplossing: een array.

De getallen die getest moeten worden kunnen in een array geplaatst worden. Door middel van een lus kan het instructieblok voor elk element van de array herhaald worden. In combinatie met een array kan je hiervoor het foreach statement gebruiken.

// De getallen worden in een array met de naam numbers geplaatst.
int[] numbers = new int[] { 4, 9, 3, 10, 25, 7, 36 }; 

foreach (int number in numbers)
{
    if (number == 25)
    {
        Console.WriteLine("Found number 25!");
        break;
    }
}

Bespreking code:

• De test wordt voor elk element van de array uitgevoerd.
• Bij elke iteratie van het foreach statement bevat de variabele number het volgende nummer uit de array.
• Indien 25 in de array zit: Van zodra het getal 25 gevonden wordt, is verder zoeken niet meer nodig. Met het break statement wordt de lus onmiddellijk verlaten.
• Indien 25 niet in de array voorkomt, worden alle getallen doorlopen zonder dat de boodschap of break uitgevoerd worden. Na het afhandelen van het laatste getal stopt de lus automatisch.

In onderstaande figuur wordt het doorlopen van de array d.m.v. foreach grafisch voorgesteld. Bij elke foreachlus wordt er een ander element actief, de opschuivende pijl duidt dit principe aan.

In het voorbeeld zag je reeds een toepassing op het gebruik van arrays. In wat volgt wordt er wat dieper ingegaan op arrays.

In onderstaande voorbeelden wordt er telkens een array gedeclareerd. Een belangrijke opmerking hierbij is, dat eens de array gedeclareerd is, kan het aantal elementen van de array niet meer gewijzigd worden. Dit is een belangrijk verschil met een List, de andere gegevensstructuur die later in de cursus besproken wordt (Advanced deel).

Declaratie met gelijktijdige initialisatie van de array

int[] intArray = new int[] {3, 5, 1, 4, 10};

Bespreking code:

• Declaratie van een array met initialisatie van de elementen op de meegegeven waarden bij de declaratie. We declareren hier een array van het type integer met de naam intArray.
• Zoals je ziet bestaat de array intArray uit 5 elementen. Deze elementen kunnen elk afzonderlijk aangesproken worden door de naam van de array in combinatie met een index. Deze index bevindt zich tussen vierkante haken en duidt de positie van het element in de array aan. Merk op dat het eerste element start op index 0 en niet op 1.
• De array bevat nu volgende waarden:

  intArray[0] = 3
  intArray[1] = 5
  intArray[2] = 1
  intArray[3] = 4
  intArray[4] = 10
  

Afzonderlijke declaratie en initialisatie van de array

Een array kan ook gedeclareerd worden zonder dat ze onmiddellijk geïnitialiseerd wordt. Deze initialisatie kan dan ergens achteraf in het programma gebeuren.

Indien een array bij de declaratie niet onmiddellijk geïnitialiseerd wordt, moeten we bij de declaratie het aantal elementen opgeven dat de array moet bevatten.

Bijvoorbeeld: een array met de naam numbers die 5 integers moet kunnen bevatten, declareren we als:

int[] intArray = new int[5];

In onderstaand voorbeeld maken we echter gebruik van een constante (numElements) waarin we het aantal elementen van de array opgeven i.p.v. het getal (5) zelf te gebruiken. Deze constante wordt aangegeven met het keyword const en kan in de loop van het programma niet gewijzigd worden. Ze moet daarom ook onmiddellijk een waarde krijgen. De reden van deze werkwijze: het is mogelijk dat het aantal elementen dat de array bevat, op verschillende plaatsen in de code gebruikt zal worden. Door dit aantal eenmalig vast te leggen in een constante en deze constante in de code te gebruiken (i.p.v. het getal 5 zelf), worden fouten vermeden (bv. door ergens een foutief aantal elementen op te geven). De code wordt tevens beter aanpasbaar, want door de constante te wijzigen kan de array automatisch over het gehele programma groter of kleiner gemaakt worden.

Opmerkingen:

• Indien er geen waarden voor de elementen van de array meegegeven worden, zoals in onderstaand voorbeeld, dan worden deze elementen automatisch op hun standaardwaarde geïnitialiseerd. Voor int is deze standaardwaarde 0.
• In onderstaand voorbeeld wordt een for-lus gebruikt i.p.v. de foreach die we tot nu toe zagen. De reden hiervoor is dat een foreach niet toelaat om array-elementen van een primitief datatype (int, float, double, …) te wijzigen. Dit kan enkel door middel van een for-lus/

const int numElements = 5;

int[] numbers = new int[numElements];   

for (int i = 0; i < numElements; i++)
{
    numbers[i] = i;
}

We zagen reeds dat een array doorlopen kan worden met een foreach statement. Soms kan het nodig zijn om de elementen van een array te doorlopen met een for-lus. Bijvoorbeeld: als je zoekt op welke positie in de array een bepaald getal zich bevindt. Of zoals bij de initialisatie, zoals je daarnet zag. Hieronder vind je een voorbeeld waarin de elementen van een array uitgelezen worden d.m.v. een for-lus.

int[] numbers = new int[] { 3, 5, 1, 4, 10 };
for (int i = 0; i < 5; i++)
{
    Console.Write("{0} ", numbers[i]);
}

De teller van de for-lus wordt als index gebruikt, op die manier wordt elke element aangesproken.

Een array heeft de eigenschap Length die aangeeft hoeveel elementen er in de array zitten. Deze eigenschap kan gebruikt worden om de bovengrens van de teller aan te geven in de for-lus. Ook deze manier van werken vermijdt eventuele fouten veroorzaakt door een verkeerd aantal elementen op te geven.

int[] numbers = new int[] { 3, 5, 1, 4, 10 };

for (int i = 0; i < numbers.Length; i++) // Gebruik van Length.
{
    Console.Write("{0} ", numbers[i]);
}
Console.ReadKey();