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

C++-is saab ka­he­mõõt­me­lisi massiive kasutada andmete ta­be­li­tao­lise kor­ral­da­miseks. Ma­te­maa­ti­kas, eriti li­neaaral­gebra vald­kon­nas, pakuvad 2D-massiivid op­ti­maal­set struk­tuuri maat­rik­site esi­ta­miseks.

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

C++ keeles on 2D-massiiv and­me­st­ruk­tuur, mis järjestab elemendid ka­he­mõõt­me­li­ses ta­be­li­laad­ses formaadis. Erinevalt ühe­mõõt­me­lis­test mas­sii­vi­dest, mis lihtsalt sal­ves­ta­vad elemendid jär­jes­tuses, korraldab 2D-massiiv andmed ridadesse ja veer­gu­desse. Iga 2D-massiivi element iden­ti­fit­see­ri­takse selle rea ja veeru indeksite abil, mis hõlbustab üksikute and­me­punk­tide juur­de­pääsu ja ma­ni­pu­lee­ri­mist. Sellist tüüpi mas­sii­vi­del on mit­me­su­gu­seid ka­su­tus­või­ma­lusi, alates maat­rik­seid hõl­ma­va­test ma­te­maa­ti­lis­test ope­rat­sioo­ni­dest kuni ras­te­rand­mete tööt­le­miseni.

Kuidas on 2D-massiiv C++-is struk­tu­ree­ri­tud?

C++ keeles koosneb 2D mas­sii­vide dek­la­ree­ri­mise süntaks järg­mis­test ele­men­ti­dest:

data_type arrayName[num_rows][num_cols];

• data_type: Andmetüüp määrab 2D-massiivis sal­ves­ta­tava andmete tüübi. See võib olla näiteks int täis­ar­vude, double uju­ko­ma­ar­vude või kasutaja määratud and­me­tüü­pide puhul.
• arrayName: Nimi toimib iden­ti­fi­kaa­to­rina, mida saab kasutada kogu massiivi juur­de­pääs­uks.
• num_rows: Süntaxi see osa määrab, mitu rida 2D-massiivil peaks olema.
• num_cols: Siin mää­ra­takse 2D-massiivi iga rea veergude arv.

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

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

Kuidas väl­jas­tada 2D-massiiv C++-is

2D-massiivi saab väl­jas­tada 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.

#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:

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

Näited ka­he­mõõt­me­liste mas­sii­vide ka­su­ta­mise kohta C++ keeles

C++-keeles prog­ram­mee­ri­mine tähendab, et varem või hiljem hakkate töötama mas­sii­vi­dega. Järgmises osas tut­vus­tame teile C++-keeles 2D-mas­sii­vide tüüpilisi rakendusi.

2D massiivid kasutaja sisendiga

Siin on lihtne C++ näide, kus laseme kasutajal dü­naa­mi­li­selt mää­rat­leda 2D-massiivi. Esmalt palume kasutajal sisestada ridade ja veergude arv, seejärel massiivi elemendid.

#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:

2D array:
1 2 3
4 5 6

2D-mas­sii­vi­dega maat­rik­site liitmine

C-ope­raa­to­ri­tega, nagu +, saame C++-is hõlpsasti lisada maat­rik­seid, kasutades 2D-massiive.

#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 maat­rik­sit, A ja B. Seejärel arvutame nende summa, mis kuvatakse tu­le­mus­maat­rik­sis. matrixAddition funkt­sioon võtab pa­ra­meet­ri­tena vastu kaks alg­maat­rik­sit ja tu­le­mus­maat­riksi ning teostab liitmise. displayMatrix funkt­sioon kuvab seejärel maat­rik­site A ja B summa konsoolil.

Siin on väljund:

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