Arrays maken het mogelijk om een reeks ge­re­la­teer­de gegevens in C op te slaan zonder dat er meerdere va­ri­a­be­len hoeven te worden aan­ge­maakt. In de regel zijn arrays een­di­men­si­o­naal, maar ze kunnen worden uit­ge­breid tot een wil­le­keu­rig aantal dimensies. We laten u zien hoe u 2D-arrays in C kunt maken en hoe u deze effectief kunt gebruiken.

Wat zijn de ba­sis­prin­ci­pes van het maken van arrays in C?

Om 2D-arrays in C te kunnen maken en beheersen, moet u de ba­sis­prin­ci­pes van deze structuur in de pro­gram­meer­taal C kennen.

Net als in veel andere talen zijn arrays in C een ge­heu­gen­blok waarin meerdere waarden van hetzelfde ge­ge­vens­ty­pe kunnen worden op­ge­sla­gen. Hierdoor kunnen meerdere waarden worden op­ge­sla­gen en ge­com­bi­neerd onder één va­ri­a­be­le­naam. De grootte van de array moet bekend zijn op het moment van com­pi­le­ren en kan daarna niet meer worden gewijzigd. Het volgende codeblok il­lu­streert hoe arrays in C kunnen worden gemaakt:

int numbers1[15];
// Optionally, the saved values can be specified when they are created:
int numbers2[5] = {1, 2, 3, 4, 5};
c

Het ge­ge­vens­ty­pe wordt voor de va­ri­a­be­le­naam ge­spe­ci­fi­ceerd. In dit voorbeeld geven de vierkante haken aan dat deze variabele geen enkele waarde is, maar een array. Het gehele getal tussen de haken geeft aan hoeveel elementen van dit ge­ge­vens­ty­pe in de array kunnen worden op­ge­sla­gen. In het bo­ven­staan­de voorbeeld wordt de array number1 niet-ge­ï­ni­ti­a­li­seerd aan­ge­maakt. Dit betekent dat er geen waarden in de velden zijn ge­schre­ven. Deze kunnen later in de code met waarden worden gevuld.

De array number2 wordt daar­en­te­gen handmatig ge­ï­ni­ti­a­li­seerd wanneer deze wordt aan­ge­maakt. Deze aanpak is tijd­ro­vend voor grotere arrays en de re­sul­te­ren­de code is vaak on­be­grij­pe­lijk. In de meeste gevallen is dit dus niet de beste aanpak. Het is meestal beter om uw arrays pro­gram­ma­tisch te vullen. U kunt dit bij­voor­beeld doen met een for-lus:

int numbers3[100];
for(int i = 0; i < 100; i++) {
numbers3[i] = i + 1;
}
// Creates an array containing the integers 1 to 100.
c
Tip

Af­han­ke­lijk van het be­stu­rings­sys­teem dat u gebruikt, de C-standaard die u gebruikt en waar u een niet-ge­ï­ni­ti­a­li­seer­de variabele in uw programma hebt ge­de­cla­reerd, kan deze variabele een wil­le­keu­ri­ge waarde bevatten. Dit geldt ook voor ar­ray­vel­den. Daarom kunt u het beste geen velden openen die u nog niet hebt ge­ï­ni­ti­a­li­seerd, vooral als de waarde die erin is op­ge­sla­gen, wordt ge­ïn­ter­pre­teerd als een pointer.

Zodra een array is aan­ge­maakt, kunt u de index ervan gebruiken om toegang te krijgen tot af­zon­der­lij­ke waarden. Het is be­lang­rijk om te weten dat arrays beginnen met index 0. Het on­der­staan­de voorbeeld laat dit zien:

int numbers2[5] = {1, 2, 3, 4, 5};
numbers2[3] = numbers2[2];
printf("%d\n", numbers2[3]);
// Output: 3
c

Een 2D-array kan in C worden uit­ge­voerd door een array te maken waarin elk veld een andere array bevat. In het volgende gedeelte vindt u meer in­for­ma­tie over 2D-arrays.

Hoe maak je 2D-arrays in C

2D-arrays in C zijn eigenlijk gewoon een­di­men­si­o­na­le arrays. Elk veld bevat gewoon een andere array. Een 2D-array kan worden gezien als een tabel of matrix met waarden. 2D-arrays kunnen worden aan­ge­maakt en gevuld met de volgende syntaxis:

ints_two_dimensions[10][10];
ints_two_dimensions [0][1] = 0;
ints_two_dimensions [2][1] = 2;
ints_two_dimensions [9][4] = 36;
// etc.
c

Hier staat het getal tussen de lin­ker­haak­jes voor de index die in de eerste array moet worden opgehaald. Het getal rechts staat voor de index in de tweede array. Je kunt deze twee getallen zien als 2D-co­ör­di­na­ten, of rij- of ko­lom­num­mers. Net als een­di­men­si­o­na­le arrays kunnen ook twee­di­men­si­o­na­le arrays bij het aanmaken worden ge­ï­ni­ti­a­li­seerd met waarden.

floats_two_dimensions[2][6] = {
{0.1, 3.56, 6.346, 8.9, 45.345, 2.284},
{7.0, 1.12, 9.74, 0.0, 3.56, 4.4}
}
c

Het principe van een array binnen een andere array is niet beperkt tot twee dimensies. U kunt deze methode gebruiken om arrays met een wil­le­keu­rig aantal dimensies te maken.

int ints_four_dimensions[10][10][10][10];
c

Hoe je 2D-arrays kunt gebruiken in C

Herhaal over een 2D-array

2D-arrays in C (of mul­ti­di­men­si­o­na­le arrays) worden meestal gebruikt om mul­ti­di­men­si­o­na­le ge­ge­vens­struc­tu­ren te maken. In het volgende voorbeeld wordt een twee­di­men­si­o­na­le array af­wis­se­lend gevuld met nullen en enen om een schaak­bord weer te geven:

#include <stdio.h>
#define ARRAY_LENGTH 8
int main() {
    int chessboard[8][8];
    for(int i = 0; i < ARRAY_LENGTH; i++) {
        for(int j = 0; j < ARRAY_LENGTH; j++) {
            chessboard[i][j] = (i + j) % 2;
            printf("%d", chessboard[i][j]);
        }
        printf("\n");
    }
    return 0;
}
/*
Output:
01010101
10101010
01010101
10101010
01010101
10101010
01010101
10101010
*/
c

String-arrays

Als u arrays vakkundig wilt gebruiken, is het be­lang­rijk om in gedachten te houden dat een array slechts een ver­wij­zing is naar een locatie in het geheugen en dat dit ook de manier is waarop de C-compiler het begrijpt. De index die wordt opgegeven bij het schrijven naar of lezen van af­zon­der­lij­ke velden ver­te­gen­woor­digt de ver­schui­ving langs de array ten opzichte van het ba­sis­adres. Laten we eens kijken naar het volgende voorbeeld om een beter beeld te krijgen:

#include <stdio.h>
int main() {
int number2[5] = {1, 2, 3, 4, 5};
printf("%d\n", *number2);
// Output: 1
printf("%d\n", *(number2 + 2));
// Output: 3
}
c

Strings worden op dezelfde manier behandeld in C. Het is mogelijk om een string te doorlopen alsof het een array is. Dit is te zien in het volgende voorbeeld, waarin drie records die zijn op­ge­sla­gen in een array, teken voor teken in hoofd­let­ters worden ge­schre­ven. Om toegang te krijgen tot tekens, wordt het array-indexveld (vierkante haken) gebruikt:

#include <stdio.h>
int main() {
    char* sentences[3];
    sentences[0] = "Hello, this is the first sentence.\n";
    sentences[1] = "This is the second sentence.\n";
    sentences[2] = "And now there are three.\n";
    printf("Original sentences:\n\n");
    for(int i = 0; i < 3; i++) {
        printf("%s", sentences[i]);
    }
    printf("\nChanged sentences:\n\n");
    for(int i = 0; i < 3; i++) {
        int j = 0;
        while(sentences[i][j] != '\n') {
            if(sentences[i][j] >= 'a' && sentences[i][j] <= 'z') {
                printf("%c", sentences[i][j] - 0x20);
            } else {
                printf("%c", sentences[i][j]);
            }
            j++;
        }
        printf("\n");
    }
}
/*
Output:
Original sentences:
Hello, this is the first sentence.
This is the second sentence.
And now there are three.
Changed sentences:
HELLO, THIS IS THE FIRST SENTENCE.
THIS IS THE SECOND SENTENCE.
AND NOW THERE ARE THREE.
*/
c
Ga naar hoofdmenu