# Kā izveidot un izmantot 2D masīvu C++ valodā

C++ valodā var izmantot divdimensionālus masīvus, lai organizētu datus tabulas veidā. Matemātikā, īpaši lineārā algebrā, 2D masīvi nodrošina optimālu struktūru **matricu** attēlošanai.

## Kas ir 2D masīvs C++ valodā?

C++ valodā 2D masīvs ir datu struktūra, kas sakārto elementus **divdimensionālā, tabulas veida formātā**. Atšķirībā no vienkāršajiem masīviem, kas vienkārši uzglabā elementus secībā, 2D masīvs organizē datus rindās un kolonnās. Katrs elements 2D masīvā tiek identificēts pēc tā rindas un kolonnas indeksiem, kas atvieglo piekļuvi atsevišķiem datu punktiem un to apstrādi. No matemātiskām operācijām ar matricām līdz rastra datu apstrādei — šāda veida masīviem ir dažādi lietojumi.

## Kā ir strukturēts 2D masīvs C++ valodā?

C++ valodā 2D masīvu deklarēšanas sintakse sastāv no šādiem elementiem:

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

- **`data_type`**: Datu tips nosaka datu tipu, kas jāuzglabā 2D masīvā. Tas var būt, piemēram, `int` veseliem skaitļiem, `double` peldošā punkta skaitļiem vai lietotāja definētiem datu tipiem.
- **`arrayName`**: Nosaukums darbojas kā identifikators, kuru var izmantot, lai piekļūtu visam masīvam.
- **`num_rows`**: Šī sintakses daļa norāda, cik rindām jābūt 2D masīvā.
- **`num_cols`**: Šeit norādāt kolonnu skaitu katrai rindai 2D masīvā.

Zemāk redzamajā piemērā mēs definēsim 2D masīvu ar nosaukumu `matrix`. Tas sastāv no 3 rindām un 4 kolonnām un kopumā satur 12 elementus.

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

### Kā izvadīt 2D masīvu C++ valodā

Jūs varat izvadīt 2D masīvu, izmantojot **for cilpu**. Ārējā cilpa atkārtojas pa rindām, bet iekšējā cilpa atkārtojas pa katras rindas kolonnām. Teikums `std::cout << matrix[i][j] << " ";` parāda katru elementu. Pēc katras rindas mēs izveidosim jaunu rindu, izmantojot `std::cout << std::endl;`. Tas nodrošina labāku izvades formātu.

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

2D masīva elementi izvades failā tiek attēloti rindā pa rindai:

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

## Piemēri, kā izmantot divdimensionālos masīvus C++ valodā

Programmēšana ar C++ nozīmē, ka agrāk vai vēlāk jums nāksies strādāt ar masīviem. Nākamajā sadaļā mēs parādīsim tipiskus 2D masīvu pielietojumus C++.

### 2D masīvi ar lietotāja ievadi

Šeit ir vienkāršs C++ piemērs, kurā ļaujam lietotājam dinamiski definēt 2D masīvu. Vispirms lūdzam lietotāju ievadīt rindu un kolonnu skaitu, pēc tam masīva elementus.

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

Ja lietotājs ievada `2` rindas un `3` kolonnas un vērtības `1, 2, 3, 4, 5, 6`, 2D masīvs būs šāds:

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

### Matricu summēšana ar 2D masīviem

Izmantojot C operatorus, piemēram, `+`, mēs varam viegli pievienot matricu C++, izmantojot 2D masīvus.

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

Vispirms izveidojam divas `2x2` matricas, `A` un `B`. Tad aprēķinām to summu, kas tiks parādīta rezultātā iegūtajā matricā. `matrixAddition` funkcija kā parametrus pieņem divas sākotnējās matricas un rezultātā iegūto matricu un veic summēšanu. `displayMatrix` funkcija pēc tam konsolē parāda matricu A un B summu.

Šeit ir rezultāts:

```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/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/2d-masivi-c-plus-plus/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/2d-masivi-c-plus-plus/) for AI/LLM consumption.