# Kaip sukurti ir naudoti 2D masyvą C++ kalba

C++ kalboje galite naudoti dvimatės matricos, kad duomenis organizuotumėte lentelės forma. Matematikoje, ypač linijinėje algebrą, 2D matricos suteikia optimalų struktūrą **matricų** atvaizdavimui.

## Kas yra 2D masyvas C++ kalboje?

C++ kalboje 2D masyvas yra duomenų struktūra, kuri elementus išdėsto **dvimatėje, lentelės formos struktūroje**. Skirtingai nuo vienmatės masyvų, kurie elementus saugo paprasčiausiai eilės tvarka, 2D masyvas duomenis išdėsto eilutėmis ir stulpeliais. Kiekvienas 2D masyvo elementas identifikuojamas pagal jo eilutės ir stulpelio indeksus, todėl lengva pasiekti ir manipuliuoti atskirais duomenų taškais. Nuo matematinės operacijos su matricomis iki rastro duomenų tvarkymo, šios rūšies masyvai turi įvairių panaudojimo būdų.

## Kaip C++ kalboje struktūrizuojamas 2D masyvas?

C++ kalboje 2D masyvų deklaravimo sintaksė susideda iš šių elementų:

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

- **`data_type`**: Duomenų tipas nurodo duomenų tipą, kuris turi būti saugomas 2D masyve. Tai gali būti, pavyzdžiui, `int` sveikiesiems skaičiams, `double` slankiesiems skaičiams arba vartotojo apibrėžtiems duomenų tipams.
- **`arrayName`**: Pavadinimas veikia kaip identifikatorius, kurį galite naudoti norėdami pasiekti visą masyvą.
- **`num_rows`**: Ši sintaksės dalis nurodo, kiek eilučių turėtų būti 2D masyve.
- **`num_cols`**: Čia nurodote kiekvienos 2D masyvo eilutės stulpelių skaičių.

Toliau pateiktame pavyzdyje apibrėšime 2D masyvą, pavadintą `matrix`. Jis susideda iš 3 eilučių ir 4 stulpelių ir turi iš viso 12 elementų.

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

### Kaip išvesti 2D masyvą C++ kalba

2D masyvą galite išvesti naudodami **for ciklą**. Išorinis ciklas kartojasi per eilutes, o vidinis ciklas kartojasi per kiekvienos eilutės stulpelius. Teiginys `std::cout << matrix[i][j] << " ";` rodo kiekvieną elementą. Po kiekvienos eilutės, naudodami `std::cout << std::endl;`, sukursime naują eilutę. Tai užtikrina geresnį išvesties formatą.

```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 masyvo elementai išvedami eilutėmis išvestyje:

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

## Pavyzdžiai, kaip naudoti dvimatės matricos C++ kalboje

Programavimas C++ kalba reiškia, kad anksčiau ar vėliau dirbsite su masyvais. Toliau pateiksime tipiškus 2D masyvų taikymo pavyzdžius C++ kalba.

### 2D masyvai su vartotojo įvestimi

Štai paprastas C++ pavyzdys, kuriame leidžiame vartotojui dinamiškai apibrėžti 2D masyvą. Pirmiausia paprašome vartotojo įvesti eilučių ir stulpelių skaičių, po to – masyvo 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;
}
```

Jei vartotojas įveda `2` eilučių ir `3` stulpelių bei reikšmes `1, 2, 3, 4, 5, 6`, 2D masyvas bus toks:

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

### Matricų su 2D masyvais sudėties

Naudodami C operatorius, pvz., `+`, galime lengvai sudėti matricą C++ kalba, naudodami 2D masyvus.

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

Pirmiausia sukuriame dvi `2x2` matricas, `A` ir `B`. Tada apskaičiuojame jų sumą, kuri bus rodoma galutinėje matricoje. `matrixAddition` funkcija priima dvi pradines matricas ir galutinę matricą kaip parametrus ir atlieka sudėties veiksmą. `displayMatrix` funkcija tada konsolėje rodo matricų A ir B sumą.

Štai rezultatas:

```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/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/2d-masyvai-c-plus-plus-kalboje/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/2d-masyvai-c-plus-plus-kalboje/) for AI/LLM consumption.