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

Du kan pålideligt bestemme længden af arrays i C ved hjælp af forskellige metoder. Dette gør det lettere at administrere 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 indeholder. Denne information er afgørende for at få adgang til individuelle elementer i matrixen, gennemgå den eller udføre manipulationer. Når du deklarerer en matrix i C, allokeres hukommelsen til elementerne i matrixen sammenhængende i RAM (dvs. sekventielt uden mellemrum). I C er der ingen indbygget funktion til at bestemme arrayets længde, så du skal bestemme den manuelt.

De mest almindelige metoder er:

- **`sizeof()`**
- **Peger-aritmetik**
- **Loops**

## `sizeof()`

`sizeof()`en operator i C. Den bestemmer **størrelsen af en datatype eller en variabel i byte** under kompilering. Returtypen for `sizeof` er `size_t`, en usigneret heltalstype, der repræsenterer størrelsen 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ørrelsen af et enkelt element.

```c
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 returnerer den samlede størrelse af arrayet i bytes.
- **sizeof(array\_name\[index\])**: Ved at dividere den samlede størrelse af arrayet med størrelsen af et enkelt element får du antallet af elementer i arrayet.
- **index**: Dette repræsenterer indekset for et element i arrayet.

### Eksempel

I dette eksempel bruger vi `sizeof()` til at bestemme størrelsen på arrayet `myArray` samt størrelsen på et enkelt element. Med disse oplysninger kan vi derefter beregne antallet af elementer i arrayet ved **at dividere den samlede størrelse med størrelsen på et enkelt element**. Vi måler størrelsen på elementet og arrayet i byte.

```c
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:

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

## Peger-aritmetik

Pegere indeholder ikke selv oplysninger om størrelsen eller længden af en matrix. Vi kan dog bruge pegearitmetik sammen med **adresserne på matrixelementerne** til at bestemme længden af C-matrixen.

### Syntaks

```c
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 forskellen mellem pegeren, der peger på den næste matrix `&arr + 1`, og pegeren, der peger på det første element i den oprindelige matrix. I dette tilfælde er det ‘næste’ hukommelsesområde slutningen af den første matrix. Den resulterende forskel er lig med antallet af elementer i matrixen.

```c
#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:

```c
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 gennemløbe arrayet og tælle antallet af elementer, det indeholder. For at bruge denne teknik skal det array, hvis længde du vil bestemme, være i samme koderegister 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. Betingelsen `i < sizeof(arr) / sizeof(arr[0])` sikrer, at løkken kun kører, hvis der er elementer i arrayet.

```c
#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:

```c
Number of elements in the array: 8
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/c-array-laengde/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/c-array-laengde/) for AI/LLM consumption.