Kuidas luua ja kasutada 2D-massiive C-keeles

Massiivid või­mal­da­vad sal­ves­tada C-keeles seotud andmete kogumi, ilma et oleks vaja luua mitut muutujat. Reeglina on massiivid ühe­mõõt­me­li­sed, kuid neid saab laiendada mis tahes arvule mõõt­me­tele. Näitame teile, kuidas luua C-keeles 2D-massiive ja kuidas neid tõhusalt kasutada.

Millised on mas­sii­vide loomise põhitõed C-keeles?

Et C-keeles 2D-massiive luua ja hallata, peate tundma selle struk­tuuri põ­hi­tõ­de­sid C-prog­ram­mee­ri­mis­kee­les.

Sarnaselt paljude teiste keeltega on massiivid C-keeles mälublokk, kuhu saab sal­ves­tada mitu sama and­me­tüübi väärtust. See võimaldab sal­ves­tada ja ühendada mitu väärtust ühe muutuja nime all. Massiivi suurus peab olema teada kom­pi­lee­ri­mise ajal ja seda ei saa hiljem muuta. Järgmine koo­dib­lokk il­lust­ree­rib, kuidas luua massiive C-keeles:

int numbers1[15];
// Optionally, the saved values can be specified when they are created:
int numbers2[5] = {1, 2, 3, 4, 5};

Andmetüüp on määratud muutuja nime ees. Selles näites näitavad nurk­sul­gu­des olevad numbrid, et see muutuja ei ole ük­sik­väär­tus, vaid massiiv. Sulgudes olev täisarv näitab, kui palju selle and­me­tüübi elemente saab massiivi sal­ves­tada. Eespool toodud näites luuakse massiiv number1 alg­sea­dis­ta­mata. See tähendab, et väl­ja­desse ei kirjutata mingeid väärtusi. Need saab hiljem koodis väär­tus­tega täita.

Seevastu massiiv number2 al­ga­ta­takse loomisel käsitsi. Suuremate mas­sii­vide puhul on see lä­he­ne­mine ae­ga­nõu­dev ja tu­le­mu­seks on sageli aru­saa­matu kood. Seega ei ole see enamasti parim lä­he­ne­mine. Ta­va­li­selt on parem proovida massiive täita prog­ram­mi­li­selt. Seda saab teha näiteks for-tsükliga:

int numbers3[100];
for(int i = 0; i < 100; i++) {
numbers3[i] = i + 1;
}
// Creates an array containing the integers 1 to 100.

Kui massiiv on loodud, saate selle indeksit kasutada üksikute väärtuste juur­de­pääs­uks. Oluline on märkida, et massiivid algavad indeksiga 0. Allpool olev näide näitab seda:

int numbers2[5] = {1, 2, 3, 4, 5};
numbers2[3] = numbers2[2];
printf("%d\n", numbers2[3]);
// Output: 3

2D-massiivi saab C-keeles luua, luues massiivi, mille iga väli sisaldab teist massiivi. 2D-mas­sii­vide kohta saate li­sa­tea­vet järg­mi­sest jaotisest.

Kuidas luua 2D-massiive C-keeles

C-keeles on 2D-massiivid te­ge­li­kult ühe­mõõt­me­li­sed massiivid. Iga väli sisaldab lihtsalt teist massiivi. 2D-massiivi võib mõista kui väärtuste tabelit või maat­rik­sit. 2D-massiive saab luua ja täita järgmise sün­tak­siga:

ints_two_dimensions[10][10];
ints_two_dimensions [0][1] = 0;
ints_two_dimensions [2][1] = 2;
ints_two_dimensions [9][4] = 36;
// etc.

Siin tähistab va­sak­pool­ses nurk­sul­gu­des olev number esimese massiivi indeksit, millele juur­de­pääs on. Pa­rem­poolne number tähistab teise massiivi indeksit. Mõelge neile kahele numbrile kui 2D-koor­di­naa­ti­dele või rea- või vee­ru­numb­ri­tele. Nagu ühe­mõõt­me­li­sed massiivid, saab ka ka­he­mõõt­me­lisi massiive nende loomisel alg­väär­tus­tega alg­sea­dis­tada.

floats_two_dimensions[2][6] = {
{0.1, 3.56, 6.346, 8.9, 45.345, 2.284},
{7.0, 1.12, 9.74, 0.0, 3.56, 4.4}
}

Massiivi massiivis põhimõte ei piirdu kahe mõõtmega. Seda meetodit saab kasutada mis tahes mõõtmete arvuga mas­sii­vide loomiseks.

int ints_four_dimensions[10][10][10][10];

Kuidas kasutada 2D-massiive C-keeles

Korrata 2D massiivi üle

C-keeles ka­su­ta­takse mit­me­mõõt­me­liste and­me­st­ruk­tuu­ride loomiseks kõige sa­ge­da­mini 2D-massiive (või mit­me­mõõt­me­lisi massiive). Järgmises näites on ka­he­mõõt­me­line massiiv täidetud va­hel­du­misi nullide ja ühtedega, et kujutada malelauad:

#include <stdio.h>
#define ARRAY_LENGTH 8
int main() {
    int chessboard[8][8];
    for(int i = 0; i < ARRAY_LENGTH; i++) {
        for(int j = 0; j < ARRAY_LENGTH; j++) {
            chessboard[i][j] = (i + j) % 2;
            printf("%d", chessboard[i][j]);
        }
        printf("\n");
    }
    return 0;
}
/*
Output:
01010101
10101010
01010101
10101010
01010101
10101010
01010101
10101010
*/

String-massiivid

Kui soovite massiive osavalt kasutada, on oluline meeles pidada, et massiiv on lihtsalt viide mälus asukohale ja nii mõistab seda ka C-kom­pi­laa­tor. Indeks, mis mää­ra­takse üksikute väljade kir­ju­ta­misel või lugemisel, esindab nihutust massiivis suhtes baasaad­res­siga. Vaadake järgmist näidet, et saada parem ülevaade:

#include <stdio.h>
int main() {
int number2[5] = {1, 2, 3, 4, 5};
printf("%d\n", *number2);
// Output: 1
printf("%d\n", *(number2 + 2));
// Output: 3
}

Stringid kä­sit­le­takse C-keeles samamoodi. Stringi on võimalik läbi käia nagu see oleks massiiv. Seda on näha järgmises näites, kus massiivis sal­ves­ta­tud kolm kirjet kir­ju­ta­takse täht-tähelt suur­täh­te­dega. Tähtedele juur­de­pääs­uks ka­su­ta­takse massiivi in­deksi­välja (nurk­sul­gu­des):

#include <stdio.h>
int main() {
    char* sentences[3];
    sentences[0] = "Hello, this is the first sentence.\n";
    sentences[1] = "This is the second sentence.\n";
    sentences[2] = "And now there are three.\n";
    printf("Original sentences:\n\n");
    for(int i = 0; i < 3; i++) {
        printf("%s", sentences[i]);
    }
    printf("\nChanged sentences:\n\n");
    for(int i = 0; i < 3; i++) {
        int j = 0;
        while(sentences[i][j] != '\n') {
            if(sentences[i][j] >= 'a' && sentences[i][j] <= 'z') {
                printf("%c", sentences[i][j] - 0x20);
            } else {
                printf("%c", sentences[i][j]);
            }
            j++;
        }
        printf("\n");
    }
}
/*
Output:
Original sentences:
Hello, this is the first sentence.
This is the second sentence.
And now there are three.
Changed sentences:
HELLO, THIS IS THE FIRST SENTENCE.
THIS IS THE SECOND SENTENCE.
AND NOW THERE ARE THREE.
*/