# Kuidas luua ja kasutada 2D-massiivi C++-is

C++-is saab kahemõõtmelisi massiive kasutada andmete tabelitaolise korraldamiseks. Matemaatikas, eriti lineaaralgebra valdkonnas, pakuvad 2D-massiivid optimaalset struktuuri **maatriksite** esitamiseks.

## Mis on 2D-massiiv C++-is?

C++ keeles on 2D-massiiv andmestruktuur, mis järjestab elemendid **kahemõõtmelises tabelilaadses formaadis**. Erinevalt ühemõõtmelistest massiividest, mis lihtsalt salvestavad elemendid järjestuses, korraldab 2D-massiiv andmed ridadesse ja veergudesse. Iga 2D-massiivi element identifitseeritakse selle rea ja veeru indeksite abil, mis hõlbustab üksikute andmepunktide juurdepääsu ja manipuleerimist. Sellist tüüpi massiividel on mitmesuguseid kasutusvõimalusi, alates maatrikseid hõlmavatest matemaatilistest operatsioonidest kuni rasterandmete töötlemiseni.

## Kuidas on 2D-massiiv C++-is struktureeritud?

C++ keeles koosneb 2D massiivide deklareerimise süntaks järgmistest elementidest:

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

- **`data_type`**: Andmetüüp määrab 2D-massiivis salvestatava andmete tüübi. See võib olla näiteks `int` täisarvude, `double` ujukomaarvude või kasutaja määratud andmetüüpide puhul.
- **`arrayName`**: Nimi toimib identifikaatorina, mida saab kasutada kogu massiivi juurdepääsuks.
- **`num_rows`**: Süntaxi see osa määrab, mitu rida 2D-massiivil peaks olema.
- **`num_cols`**: Siin määratakse 2D-massiivi iga rea veergude arv.

Allpool toodud näites määratleme 2D-massiivi nimega `matrix`. See koosneb 3 reast ja 4 veerust ning sisaldab kokku 12 elementi.

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

### Kuidas väljastada 2D-massiiv C++-is

2D-massiivi saab väljastada **for-tsükli** abil. Välimine tsükkel kordab ridu, sisemine tsükkel kordab iga rea veerge. Käsk `std::cout << matrix[i][j] << " ";` kuvab iga elemendi. Pärast iga rida loome uue rea käsu `std::cout << std::endl;`. See tagab väljundi parema vormingu.

```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-massiivi elemendid kuvatakse väljundis rida-rea haaval:

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

## Näited kahemõõtmeliste massiivide kasutamise kohta C++ keeles

C++-keeles programmeerimine tähendab, et varem või hiljem hakkate töötama massiividega. Järgmises osas tutvustame teile C++-keeles 2D-massiivide tüüpilisi rakendusi.

### 2D massiivid kasutaja sisendiga

Siin on lihtne C++ näide, kus laseme kasutajal dünaamiliselt määratleda 2D-massiivi. Esmalt palume kasutajal sisestada ridade ja veergude arv, seejärel massiivi elemendid.

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

Kui kasutaja sisestab `2` rida ja `3` veergu ning väärtused `1, 2, 3, 4, 5, 6`, on 2D-massiiv järgmine:

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

### 2D-massiividega maatriksite liitmine

C-operaatoritega, nagu `+`, saame C++-is hõlpsasti lisada maatrikseid, kasutades 2D-massiive.

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

Esmalt loome kaks `2x2` maatriksit, `A` ja `B`. Seejärel arvutame nende summa, mis kuvatakse tulemusmaatriksis. `matrixAddition` funktsioon võtab parameetritena vastu kaks algmaatriksit ja tulemusmaatriksi ning teostab liitmise. `displayMatrix` funktsioon kuvab seejärel maatriksite A ja B summa konsoolil.

Siin on väljund:

```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/et-ee/digitalguide/veebisaidid/veebiarendus/2d-massiivid-c-keeles/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/2d-massiivid-c-keeles/) for AI/LLM consumption.