Hoe bepaal je de lengte van een array in C?

Je kunt de lengte van arrays in C op ver­schil­len­de manieren be­trouw­baar bepalen. Hierdoor wordt het een­vou­di­ger om arrays dynamisch te beheren en aan te passen aan ver­an­de­rin­gen in grootte.

Wat is de lengte van een array in C en welke methoden zijn er om deze te meten?

Wanneer u de lengte van een array in C meet, meet u het aantal elementen dat de array bevat. Deze in­for­ma­tie is cruciaal voor het benaderen van in­di­vi­du­e­le elementen in de array, het doorlopen ervan of het uitvoeren van be­wer­kin­gen. Wanneer u een array in C de­cla­reert, wordt het geheugen voor de elementen in de array aan­een­ge­slo­ten (d.w.z. op een se­quen­ti­ë­le manier zonder hiaten) in het RAM toe­ge­we­zen. In C is er geen in­ge­bouw­de functie om de lengte van een array te bepalen, dus moet je dit handmatig doen.

De meest voor­ko­men­de methoden zijn:

• sizeof()
• Pointer-re­ken­kun­de
• Lussen

sizeof()

sizeof()een operator in C. Deze bepaalt tijdens het com­pi­le­ren de grootte van een ge­ge­vens­ty­pe of een variabele in bytes. Het re­tour­ty­pe van de sizeof is size_t, een unsigned integer-type dat de grootte in bytes weergeeft. In C kunt u ook de sizeof() gebruiken om de lengte van arrays te berekenen.

Syntaxis

Om het aantal elementen in een array te bepalen, moet u de totale grootte van de array delen door de grootte van een enkel element.

data_type arrayLength = sizeof(array_name) / sizeof(array_name[index]);

• data_type: Dit is het ge­ge­vens­ty­pe waarin de lengte van de array wordt op­ge­sla­gen.
• array_name: Geeft de naam van de array op.
• sizeof(array_name): Deze expressie geeft de totale grootte van de array in bytes weer.
• sizeof(array_name[index]): Door de totale grootte van de array te delen door de grootte van een enkel element, krijgt u het aantal elementen in de array.
• index: Dit ver­te­gen­woor­digt de index van een element in de array.

Voorbeeld

In dit voorbeeld gebruiken we sizeof() om de grootte van de array myArray en de grootte van een enkel element te bepalen. Met deze in­for­ma­tie kunnen we ver­vol­gens het aantal elementen in de array berekenen door de totale grootte te delen door de grootte van een enkel element. We gaan de grootte van het element en de array in bytes meten.

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    size_t totalSize = sizeof(myArray);
    size_t elementSize = sizeof(myArray[0]);
    size_t arrayLength = totalSize / elementSize;
    printf("Total size of the array: %d bytes\n", (int)totalSize);
    printf("Size of a single element: %d bytes\n", (int)elementSize);
    printf("Number of elements in the array: %d\n", (int)arrayLength);
    return 0;
}

De uitvoer is:

Total size of the array: 20 bytes
Size of a single element: 4 bytes
Number of elements in the array: 5

Pointer-re­ken­kun­de

Pointers zelf bevatten geen in­for­ma­tie over de grootte of lengte van een array. We kunnen echter pointer-re­ken­kun­de gebruiken in com­bi­na­tie met de adressen van array-elementen om de lengte van de C-array te bepalen.

Syntaxis

data_type arr_length = *(&arr + 1) - arr;

• &arr: Hiermee wordt een pointer gemaakt die naar een volledige array van elementen verwijst.
• (&arr + 1): Hier wordt de pointer die naar de array arr verwijst met 1 verhoogd. Aangezien arr een array is, betekent dit dat de pointer naar de volgende op­een­vol­gen­de array van hetzelfde type als arr zal verwijzen.

Voorbeeld

De uit­druk­king *(&arr + 1) - arr berekent het verschil tussen de pointer die naar de volgende array &arr + 1 verwijst en de pointer die naar het eerste element van de oor­spron­ke­lij­ke array verwijst. In dit geval is het ‘volgende’ ge­heu­gen­ge­bied het einde van de eerste array. Het re­sul­te­ren­de verschil is gelijk aan het aantal elementen in de array.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int length = *(&arr + 1) - arr;
    printf("Number of elements in the array: %d\n", length);
    return 0;
}

Uitvoer:

Number of elements in the array: 5

For-lussen

Een andere methode om de lengte van een array in C te bepalen, is door gebruik te maken van een for-lus. Bij deze aanpak wordt de array doorlopen en wordt het aantal elementen geteld dat deze bevat. Om deze techniek te kunnen gebruiken, moet de array waarvan u de lengte wilt bepalen zich in hetzelfde co­de­ge­bied bevinden als de for-lus die u gebruikt om de lengte te bepalen.

Voorbeeld

Hier verhoogt de lus de teller arrayLength voor elk element dat wordt door­ge­ge­ven. De voor­waar­de i < sizeof(arr) / sizeof(arr[0]) zorgt ervoor dat de lus alleen wordt uit­ge­voerd als er elementen in de array staan.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t arrayLength = 0;
    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
        arrayLength++;
    }
    printf("Number of elements in the array: %d\n", arrayLength);
    return 0;
}

Uitvoer:

Number of elements in the array: 8