# Hvordan lage og bruke 2D-matriser i C

Arrays gjør det mulig å lagre et sett med relaterte data i C uten å måtte opprette flere variabler. Som regel er arrays endimensjonale, men de kan utvides til å omfatte et hvilket som helst antall dimensjoner. Vi viser deg hvordan du oppretter 2D-arrays i C og hvordan du bruker dem effektivt.

## Hva er grunnleggende om å lage matriser i C?

For å kunne opprette og beherske 2D-matriser i C, må du kjenne til grunnleggende om denne strukturen i programmeringsspråket C.

I likhet med mange andre språk er tabeller i C en **minneblokk** der flere verdier av samme datatype kan lagres. Dette gjør det mulig å lagre og kombinere flere verdier under ett variabelnavn. Størrelsen på tabellen må være kjent ved kompilering og kan ikke endres etterpå. Følgende kodeblokk illustrerer hvordan man oppretter tabeller i C:

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

Datatypen angis foran variabelnavnet. I dette eksemplet indikerer firkantparentesene at denne variabelen ikke er en enkeltverdi, men en matrise. Heltallet mellom parentesene angir hvor mange elementer av denne datatypen som kan lagres i matrisen. I eksemplet ovenfor opprettes matrisen `number1` **uten å være initialisert**. Dette betyr at det ikke er skrevet noen verdier i feltene. Disse kan deretter fylles med verdier i koden senere.

Array `number2`, derimot, initialiseres manuelt når den opprettes. Denne tilnærmingen er tidkrevende for større arrayer, og den resulterende koden er ofte uforståelig. I de fleste tilfeller er det derfor ikke den beste tilnærmingen. Det er vanligvis bedre å prøve å fylle arrayene **programmatisk**. Du kan for eksempel gjøre dette med en for-løkke:

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

Tip Avhengig av hvilket operativsystem du har, hvilken C-standard du bruker og hvor du har deklarert en uinitialisert variabel i programmet ditt, kan denne variabelen inneholde en tilfeldig verdi. Dette gjelder også for array-felt. Derfor er det best å ikke åpne felt som du ikke har initialisert ennå, spesielt hvis verdien som er lagret i dem tolkes som en **pekeren**.

Når en matrise er opprettet, kan du bruke indeksen til å få tilgang til individuelle verdier. Det er viktig å merke seg at matriser starter med indeksen 0. Eksemplet nedenfor viser deg dette:

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

En 2D-matrise kan utføres i C ved å opprette en matrise der **hvert felt inneholder en annen matrise**. Du kan lese mer om 2D-matriser i neste avsnitt.

## Hvordan lage 2D-matriser i C

2D-matriser i C er egentlig bare endimensjonale matriser. Hvert felt inneholder bare en annen matrise. En 2D-matrise kan forstås som en **tabell eller matrise** med verdier. 2D-matriser kan opprettes og fylles med følgende syntaks:

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

Her representerer tallet i venstre firkantparentes indeksen som skal åpnes i den første matrisen. Tallet til høyre representerer indeksen i den andre. Tenk på disse to tallene som **2D-koordinater, eller rad- eller kolonnenumre**. Akkurat som endimensjonale matriser kan også todimensjonale matriser initialiseres med verdier når de opprettes.

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

Prinsippet om en matrise innenfor en annen matrise er ikke begrenset til to dimensjoner. Du kan bruke denne metoden til å lage matriser med **et hvilket som helst antall dimensjoner**.

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

## Hvordan du kan bruke 2D-matriser i C

### Iterere over en 2D-matrise

2D-matriser i C (eller flerdimensjonale matriser) brukes oftest til å lage flerdimensjonale datastrukturer. I følgende eksempel fylles en todimensjonal matrise vekselvis med nuller og ettall for å representere et sjakkbrett:

```c
#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
*/
```

### Strengmatriser

Hvis du vil bruke matriser på en dyktig måte, er det viktig å huske at en matrise bare er en **pekeren til en plassering i minnet**, og det er slik C-kompilatoren forstår det. Indeksen som angis når du skriver til eller leser fra individuelle felt, representerer **forskyvningen langs matrisen i forhold til basisadressen**. La oss se på følgende eksempel for å få en bedre forståelse:

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

Strenger behandles på samme måte i C. Det er mulig å iterere **over en streng som om den var en matrise**. Du kan se dette i følgende eksempel, hvor tre poster lagret i en matrise skrives tegn for tegn med store bokstaver. For å få tilgang til tegnene brukes matriseindeksfeltet (kvadratparenteser):

```c
#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.
*/
```


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/2d-matriser-i-c-1/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/2d-matriser-i-c-1/) for AI/LLM consumption.