Sådan bestemmes længden af en matrix i C

Du kan på­li­de­ligt bestemme længden af arrays i C ved hjælp af for­skel­li­ge metoder. Dette gør det lettere at ad­mi­ni­stre­re arrays dynamisk og tilpasse sig ændringer i størrelse.

Hvad er array-længde i C, og hvilke metoder findes der til at måle den?

Når du måler længden af en matrix i C, måler du antallet af elementer, som matrixen in­de­hol­der. Denne in­for­ma­tion er afgørende for at få adgang til in­di­vi­du­el­le elementer i matrixen, gennemgå den eller udføre ma­ni­pu­la­tio­ner. Når du de­kla­re­rer en matrix i C, allokeres hukom­mel­sen til ele­men­ter­ne i matrixen sam­men­hæn­gen­de i RAM (dvs. se­kven­ti­elt uden mellemrum). I C er der ingen indbygget funktion til at bestemme arrayets længde, så du skal bestemme den manuelt.

De mest al­min­de­li­ge metoder er:

• sizeof()
• Peger-aritmetik
• Loops

sizeof()

sizeof()en operator i C. Den bestemmer stør­rel­sen af en datatype eller en variabel i byte under kom­pi­le­ring. Re­tur­ty­pen for sizeof er size_t, en usigneret hel­tals­ty­pe, der re­præ­sen­te­rer stør­rel­sen i byte. I C kan du også bruge sizeof() til at beregne array-længder.

Syntaks

For at bestemme antallet af elementer i en matrix skal du dividere matrixens samlede størrelse med stør­rel­sen af et enkelt element.

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

• data_type: Dette er den datatype, hvor længden af arrayet vil blive gemt.
• array_name: Angiver navnet på arrayet.
• sizeof(array_name): Denne udtryk-sætning re­tur­ne­rer den samlede størrelse af arrayet i bytes.
• sizeof(array_name[index]): Ved at dividere den samlede størrelse af arrayet med stør­rel­sen af et enkelt element får du antallet af elementer i arrayet.
• index: Dette re­præ­sen­te­rer indekset for et element i arrayet.

Eksempel

I dette eksempel bruger vi sizeof() til at bestemme stør­rel­sen på arrayet myArray samt stør­rel­sen på et enkelt element. Med disse op­lys­nin­ger kan vi derefter beregne antallet af elementer i arrayet ved at dividere den samlede størrelse med stør­rel­sen på et enkelt element. Vi måler stør­rel­sen på elementet og arrayet i byte.

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

Outputtet er:

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

Peger-aritmetik

Pegere in­de­hol­der ikke selv op­lys­nin­ger om stør­rel­sen eller længden af en matrix. Vi kan dog bruge pe­gea­rit­me­tik sammen med adres­ser­ne på ma­trix­e­le­men­ter­ne til at bestemme længden af C-matrixen.

Syntaks

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

• &arr: Dette opretter en pointer, der peger på en hel matrix af elementer.
• (&arr + 1): Her øges pegeren, der peger på arrayet arr, med 1. Da arr er et array, betyder det, at pegeren vil pege på det næste på hinanden følgende array, der er af samme type som arr.

Eksempel

Udtrykket *(&arr + 1) - arr beregner for­skel­len mellem pegeren, der peger på den næste matrix &arr + 1, og pegeren, der peger på det første element i den op­rin­de­li­ge matrix. I dette tilfælde er det ‘næste’ hukom­mel­ses­om­rå­de slut­nin­gen af den første matrix. Den re­sul­te­ren­de forskel er lig med antallet af elementer i matrixen.

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

Output:

Number of elements in the array: 5

For-løkker

En anden metode til at bestemme array-længder i C er at bruge en for-loop. Denne metode indebærer at gen­nem­lø­be arrayet og tælle antallet af elementer, det in­de­hol­der. For at bruge denne teknik skal det array, hvis længde du vil bestemme, være i samme ko­de­re­gi­ster som den for-loop, du bruger til at bestemme dets længde.

Eksempel

Her øger løkken tæller arrayLength for hvert element, der passerer igennem. Be­tin­gel­sen i < sizeof(arr) / sizeof(arr[0]) sikrer, at løkken kun kører, hvis der er elementer i arrayet.

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

Output:

Number of elements in the array: 8