# Sådan oprettes og bruges en 2D-matrix i C++

I C++ kan du bruge todimensionelle arrays til at organisere data på en tabelagtig måde. I matematik, især i lineær algebra, giver 2D-arrays en optimal struktur til at repræsentere **matricer**.

## Hvad er en 2D-matrix i C++?

I C++ er en 2D-matrix en datastruktur, der arrangerer elementer i et **todimensionelt, tabelagtigt format**. I modsætning til endimensionelle matricer, der blot gemmer elementer i en sekvens, organiserer en 2D-matrix data i rækker og kolonner. Hvert element i en 2D-matrix identificeres ved hjælp af dets række- og kolonneindeks, hvilket letter adgang til og manipulation af individuelle datapunkter. Fra matematiske operationer med matricer til håndtering af rasterdata er der mange forskellige anvendelsesmuligheder for denne type matrix.

## Hvordan er en 2D-matrix struktureret i C++?

I C++ består syntaksen til deklarering af 2D-arrays af følgende elementer:

```c++
data_type arrayName[num_rows][num_cols];
```

- **`data_type`**: Datatypen angiver den type data, der skal gemmes i 2D-arrayet. Dette kan f.eks. være `int` for heltal, `double` for flydende tal eller brugerdefinerede datatyper.
- **`arrayName`**: Navnet fungerer som en identifikator, som du kan bruge til at få adgang til hele arrayet.
- **`num_rows`**: Denne del af syntaksen angiver, hvor mange rækker 2D-arrayet skal have.
- **`num_cols`**: Her angiver du antallet af kolonner for hver række i 2D-arrayet.

I eksemplet nedenfor definerer vi en 2D-matrix kaldet `matrix`. Den består af 3 rækker og 4 kolonner og har i alt 12 elementer.

```c++
int matrix[3][4] = {{1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}};
```

### Sådan udskrives en 2D-matrix i C++

Du kan udskrive en 2D-matrix ved hjælp af en **for-loop**. Den ydre loop gentager rækkerne, mens den indre loop gentager kolonnerne i hver række. Sætningen `std::cout << matrix[i][j] << " ";` viser hvert element. Efter hver række opretter vi en ny række ved hjælp af `std::cout << std::endl;`. Dette sikrer et bedre format for udskriften.

```c++
#include <iostream>
int main() {
    int matrix[3][4] = {{1, 2, 3, 4},
                        {5, 6, 7, 8},
                        {9, 10, 11, 12}};
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            std::cout << matrix[i][j] << " ";
        }
 
        std::cout << std::endl;
    }
    return 0;
}
```

Elementerne i 2D-arrayet vises linje for linje i outputtet:

```c++
1 2 3 4
5 6 7 8
9 10 11 12
```

## Eksempler på brug af todimensionelle arrays i C++

Programmering med C++ betyder, at du før eller senere kommer til at arbejde med arrays. I det følgende afsnit viser vi dig typiske anvendelser for 2D-arrays i C++.

### 2D-matricer med brugerinput

Her er et enkelt C++-eksempel, hvor vi lader brugeren definere en 2D-matrix dynamisk. Først beder vi brugeren om at indtaste antallet af rækker og kolonner, efterfulgt af elementerne til matrixen.

```c++
#include <iostream>
int main() {
    int numRows, numCols;
    std::cout << "Number of rows: ";
    std::cin >> numRows;
    std::cout << "Number of columns: ";
    std::cin >> numCols;
    int userArray[numRows][numCols];
    std::cout << "Please enter in elements:\n";
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            std::cout << "Element [" << i << "][" << j << "]: ";
            std::cin >> userArray[i][j];
        }
    }
    std::cout << "2D array:\n";
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            std::cout << userArray[i][j] << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}
```

Hvis `2` rækker og `3` kolonner og værdierne `1, 2, 3, 4, 5, 6` indtastes som brugerinput, vil 2D-arrayet være:

```c++
2D array:
1 2 3
4 5 6
```

### Tilføjelse af matricer med 2D-matricer

Med C-operatorer som `+` kan vi nemt tilføje matricer i C++ ved hjælp af 2D-arrays.

```c++
#include <iostream>
const int numRows = 2; 
const int numCols = 2; 
void matrixAddition(int A[][numCols], int B[][numCols], int result[][numCols]) {
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
}
void displayMatrix(int matrix[][numCols]) {
    for (int i = 0; i < numRows; ++i) {
        for (int j = 0; j < numCols; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}
int main() {
    int matrixA[numRows][numCols] = {{1, 2}, {3, 4}};
    int matrixB[numRows][numCols] = {{5, 6}, {7, 8}};
    int resultMatrix[numRows][numCols];
    matrixAddition(matrixA, matrixB, resultMatrix);
    // Output of matrix A and B and their sum
    std::cout << "Matrix A:\n";
    displayMatrix(matrixA);
    std::cout << "\nMatrix B:\n";
    displayMatrix(matrixB);
    std::cout << "\nSum (A + B):\n";
    displayMatrix(resultMatrix);
    return 0;
}
```

Først opretter vi to `2x2` matricer, `A` og `B`. Derefter beregner vi deres sum, som vises i den resulterende matrix. Funktionen `matrixAddition` accepterer de to indledende matricer og den resulterende matrix som parametre og udfører additionen. Funktionen `displayMatrix` viser derefter summen af matricerne A og B på konsollen.

Her er resultatet:

```c++
Matrix A:
1 2
3 4
Matrix B:
5 6
7 8
Sum (A + B):
6 8
10 12
```


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