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 dezelfde interface (de array) aangesproken 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 dit is geen efficiënte manier van programmeren. Niet enkel worden er 7 variabelen gedeclareerd, er wordt voor elke variabele ook nog eens een aparte selectie voorzien. Al deze selecties zijn bijna identiek, enkel de te testen variabele is verschillend. Onthou dat je programmatorisch vaak niet goed bezig bent als je eenzelfde groep van instructies meerdere malen in je code herhaalt.

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 code ziet er als volgt uit:

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

// 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.
// Foreach stopt als alle elementen van de array doorlopen zijn.
foreach (int number in numbers)
{
    if (number == 25)
    {
        Console.WriteLine("Found number 25!");
    }
}

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.

Declaratie met gelijktijdige initialisatie van de array

// Declaratie van een array met initialisatie van de elementen op de meegegeven waarden.
// We declareren hier een array van het type integer met de naam intArray.

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

Door deze declaraties worden volgende elementen gecreëerd:

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

Zoals je ziet bestaat de array intArray uit 5 elementen. Deze elementen kunnen elk apart 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.

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 kan in de loop van het programma niet gewijzigd worden. De reden van deze werkwijze: het is mogelijk dat het aantal elementen dat de array bevat 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.

const int numElements = 5;

// Declaratie van een array van integers.
// Indien er geen waarden voor de elementen van de array meegegeven worden dan worden 
// deze elementen automatisch op nul geïnitialiseerd.

int[] numbers = new int[numElements];

// Na de initialisatie kunnen de elementen van de array door middel van een `for`statement
// geïnitialiseerd worden.

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 };

// de variabele numElements initialiseren op het aantal elementen van de array.
int numElements = numbers.Length;

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