C-keele navigaator – Kõige võimsam ressurss süsteemiarenduseks

C-keel: Kahemõõtmelised massiivid algajatele – selgitused ja näited

C-keele põhialused
目次

1. Sissejuhatus

C-keel on üks olulisemaid ja ajalooliselt tähtsamaid programmeerimiskeeli. Selle sees on “massiivid” hädavajalik funktsioon andmete tõhusaks haldamiseks ja töötlemiseks. Eriti “kahemõõtmelised massiivid” on väga kasulikud maatriksite või tabelikujuliste andmete käsitlemisel.

Selles artiklis selgitame kahemõõtmelisi massiive C-keeles algajatele arusaadaval viisil. Kirjeldame samm-sammult nende põhilist kasutamist ja edasijõudnud rakendusi, pakkudes lugejale praktilist teavet, mida saab kasutada tegelike programmide kirjutamisel.

Massiivide tähtsus C-keeles

C-keele massiivid on andmestruktuurid, mis võimaldavad hallata korraga mitut sama tüüpi väärtust. See säästab vajadust deklareerida eraldi muutujaid ja hoiab koodi lihtsana. Näiteks, kui on vaja salvestada mitu numbrit või stringi, võimaldab massiiv neid tõhusalt käsitleda.

Eriti “kahemõõtmelised massiivid” on kasulikud järgmistes olukordades:

  • Matemaatiliste maatriksite arvutamine
  • Mängulaudade (nt male, Othello) haldamine
  • Tabelite või arvutustabelite struktuuri töötlemine

Mida sellest artiklist õpid

Sellest artiklist saad samm-sammult teada järgmised asjad:

  1. Kahemõõtmeliste massiivide põhiline struktuur ja deklaratsioon
  2. Initsialiseerimine ja elementide juurde pääsemine
  3. Kahemõõtmeliste massiivide haldamine mälus
  4. Praktilised näited programmides
  5. Kuidas dünaamiliselt eraldada ja vabastada kahemõõtmelisi massiive
  6. Levinud vead ja olulised tähelepanekud massiividega töötamisel

Isegi algajad saavad selle artikli abil õppida kahemõõtmeliste massiivide põhitõdesid ja omandada oskusi, mida saab kasutada tegelikes programmides.

Kellele see artikkel on mõeldud

See selgitus on mõeldud nii algajatele, kes on just C-keele õppimist alustanud, kui ka kesktasemel programmeerijatele, kes soovivad oma teadmisi laiendada. Eriti kasulik neile:

  • Kellel on põhiline arusaam massiividest, kuid pole kunagi kasutanud kahemõõtmelisi massiive
  • Kes soovivad käsitleda tabelikujulisi andmeid programmis
  • Kes tahavad C-keele põhikäske üle korrata

2. Mis on kahemõõtmeline massiiv

C-keeles on “kahemõõtmeline massiiv” andmestruktuur, mis salvestab andmeid ridade ja veergude kaupa. See toimib kui “massiivide massiiv”. See on väga mugav näiteks maatriksite arvutamisel või tabelite töötlemisel ning seda kasutatakse sageli programmides.

Siin selgitame üksikasjalikult kahemõõtmelise massiivi põhimõisteid ja struktuuri.

Kahemõõtmelise massiivi põhistruktuur

Kahemõõtmeline massiiv koosneb mitmest reast ja veerust. Konkreetsemalt on iga rida ühemõõtmeline massiiv ning need moodustavad koos kahemõõtmelise massiivi.

Näide: kahemõõtmelise massiivi kujutis

Andmed salvestatakse järgmiselt:

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

Antud juhul on array 3 rida ja 4 veergu. Indekseid kasutades pääseb ligi konkreetsetele elementidele.

  • array[0][0] = “1”
  • array[2][3] = “12”

Kahemõõtmelise massiivi kasutusalad

Kahemõõtmelisi massiive kasutatakse järgmistes olukordades:

  1. Matemaatilised maatriksoperatsioonid
    Näide: maatriksite liitmine ja korrutamine
  2. Tabelikujuliste andmete haldamine
    Näide: arvutustabelid või andmebaasi struktuurid
  3. Mänguarendus
    Näide: malelaua või Othello laua oleku haldamine
  4. Pilditöötlus
    Näide: piksli värviandmete salvestamine

Nagu nendest kasutusjuhtudest näha, on kahemõõtmeline massiiv oluline baasstruktuur keeruliste andmete tõhusaks haldamiseks.

Erinevus ühe- ja kahemõõtmelise massiivi vahel

Ühemõõtmelise massiivi omadused

Ühemõõtmeline massiiv salvestab andmeid “lineaarselt”.

int array[5] = {1, 2, 3, 4, 5};

Indekseid kasutades viidatakse elementidele järjest:

  • array[0] = “1”
  • array[4] = “5”

Kahemõõtmelise massiivi omadused

Kahemõõtmeline massiiv salvestab andmeid “ridade” ja “veergude” kaupa.

int array[2][3] = {
  {1, 2, 3},
  {4, 5, 6}
};

Indekseid kombineerides viidatakse elementidele:

  • array[0][2] = “3”
  • array[1][0] = “4”

Seega on kahemõõtmelised massiivid eriti kasulikud keeruliste andmestruktuuride käsitlemisel.

年収訴求

3. Kahemõõtmelise massiivi deklareerimine ja initsialiseerimine

C-keeles tuleb kahemõõtmelise massiivi kasutamiseks see esmalt deklareerida ning vajaduse korral initsialiseerida. Järgnevalt selgitame täpsemalt deklaratsiooni ja initsialiseerimise viise.

Deklaratsioon

Kahemõõtmelise massiivi deklaratsioon tehakse järgmiselt:

tüüp massiivi_nimi[read][veerud];
  • tüüp: massiivis salvestatavate andmete tüüp (nt int, float, char).
  • read ja veerud: täisarvud, mis näitavad massiivi suurust.

Näide deklaratsioonist

Näiteks, 3 rida ja 4 veergu sisaldava int-massiivi deklaratsioon:

int array[3][4];

See reserveerib mälu, kuhu saab salvestada 3×4 = 12 täisarvu.

Initsialiseerimine

Massiivi võib initsialiseerida deklareerimise ajal, määrates sellele algväärtused. Selleks on mitu võimalust.

Meetod 1: kõik elemendid selgesõnaliselt

int array[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

Mälu paigutus:

1  2  3
4  5  6
  • array[0][0] → 1
  • array[1][2] → 6

Meetod 2: ainult osa elemente

int array[2][3] = {
    {1, 2},
    {4}
};

Mälu paigutus:

1  2  0
4  0  0

Meetod 3: {0} kõigi elementide nullimiseks

int array[3][4] = {0};

Kõik väärtused seatakse nulliks.

Olulised märkused initsialiseerimisel

  • Ridade arv peab alati olema määratud
int array[][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8}
};
  • Veergude arv peab olema määratud

Koodinäide: deklaratsioon ja initsialiseerimine

Järgmine kood näitab, kuidas deklareerida kahemõõtmeline massiiv, sellele väärtused määrata ning tulemused välja printida:

#include <stdio.h>

int main() {
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("array[%d][%d] = %d\n", i, j, array[i][j]);
        }
    }

    return 0;
}

Väljund

array[0][0] = 1
array[0][1] = 2
array[0][2] = 3
array[1][0] = 4
array[1][1] = 5
array[1][2] = 6

4. Kahemõõtmeliste massiivide kasutamine: elementide viitamine ja muutmine

C-keeles saab kahemõõtmelise massiivi elementidele ligi ning neid muuta. Järgnevalt selgitame üksikasjalikult, kuidas elemente viidata ja töödelda.

Elementidele ligipääs

Kahemõõtmelises massiivis määratakse element rea- ja veeruindeksi kaudu.

Põhiline ligipääsuviis

array[rida][veerg]

Näiteks järgmine massiiv:

int array[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
  • array[0][0] → 1 (1. rida, 1. veerg)
  • array[1][2] → 6 (2. rida, 3. veerg)

Näide: elementide väljastamine

#include <stdio.h>

int main() {
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    printf("array[0][0] = %d\n", array[0][0]);
    printf("array[1][2] = %d\n", array[1][2]);

    return 0;
}

Väljund

array[0][0] = 1
array[1][2] = 6

Elementide muutmine

Massiivi elementidele saab määrata uusi väärtusi.

Väärtuse muutmise viis

array[rida][veerg] = uus_väärtus;

Näide: väärtuste muutmine programmis

#include <stdio.h>

int main() {
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    // väärtuste muutmine
    array[0][0] = 10;
    array[1][2] = 20;

    // tulemuste väljastamine
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("array[%d][%d] = %d\n", i, j, array[i][j]);
        }
    }

    return 0;
}

Väljund

array[0][0] = 10
array[0][1] = 2
array[0][2] = 3
array[1][0] = 4
array[1][1] = 5
array[1][2] = 20

Kahemõõtmelise massiivi läbimine tsüklitega

Kahemõõtmeliste massiivide käsitlemisel kasutatakse sageli pesastatud tsükleid.

Näide: ridade ja veergude läbimine

#include <stdio.h>

int main() {
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    // elementide väljastamine
    for (int i = 0; i < 2; i++) { // ridade tsükkel
        for (int j = 0; j < 3; j++) { // veergude tsükkel
            printf("array[%d][%d] = %d\n", i, j, array[i][j]);
        }
    }

    return 0;
}

Väljund

array[0][0] = 1
array[0][1] = 2
array[0][2] = 3
array[1][0] = 4
array[1][1] = 5
array[1][2] = 6

Näide: kõikide elementide seadmine kindlale väärtusele

Tsükleid kasutades saab massiivi kõik elemendid seada ühele kindlale väärtusele.

Näide: kõik väärtused = 5

#include <stdio.h>

int main() {
    int array[3][3];

    // kõigi elementide väärtuseks pannakse 5
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            array[i][j] = 5;
        }
    }

    // tulemuste väljastamine
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("array[%d][%d] = %d\n", i, j, array[i][j]);
        }
    }

    return 0;
}

Väljund

array[0][0] = 5
array[0][1] = 5
array[0][2] = 5
array[1][0] = 5
array[1][1] = 5
array[1][2] = 5
array[2][0] = 5
array[2][1] = 5
array[2][2] = 5

5. Kahemõõtmeliste massiivide mälustruktuur ja selle mõistmine

C-keeles on oluline mõista, kuidas kahemõõtmelised massiivid mällu paigutatakse. See aitab parandada programmi tõhusust ja muudab töö pointeritega sujuvamaks.

Mälupaigutus

C-keeles salvestatakse kahemõõtmelised massiivid tegelikult järjestikku ühemõõtmelisse mällu. Seda paigutust nimetatakse rea-järjekorraks (row-major).

Mis on row-major?

Row-major tähendab, et massiivi andmed salvestatakse ridade kaupa järjestikku.

Näide: massiivi mälustruktuur

int array[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

Mälu kujul salvestatakse see järgmiselt:

Mälu: 1  2  3  4  5  6
  • array[0][0] → esimene mälupositsioon
  • array[0][1] → teine positsioon
  • array[1][0] → neljas positsioon

Elementidele viitamine indeksitega

C-keeles arvutatakse indeksite põhjal elementide asukoht järgmiselt:

array[i][j] = *(array + (i * veergude_arv) + j)

Näide: mäluaadressi arvutus

Massiivis array[2][3]:

  • array[1][2] leitakse järgmisel viisil:
*(array + (1 * 3) + 2) = *(array + 5)

Pointerite kasutamine

Kahemõõtmelisi massiive saab käsitleda ka pointerite abil, mis annab rohkem paindlikkust.

Pointer ja kahemõõtmeline massiiv

int array[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
int *ptr = &array[0][0];

printf("%d\n", *(ptr + 4)); // väljund: 5

Visuaalne selgitus

Mälu: 1  2  3  4  5  6
Indeksid:
  [0][0] [0][1] [0][2] [1][0] [1][1] [1][2]

Soovitused efektiivseks kasutamiseks

  1. Kasuta row-major järjekorda – fikseeri rida ja liigu veergude kaupa.
for (int i = 0; i < read; i++) {
    for (int j = 0; j < veerud; j++) {
        // row-major ligipääs
    }
}
  1. Kasutage pointereid – see vähendab arvutuskulusid.

6. Praktilised näited: maatriksarvutused ja mängulaua loomine

Kahemõõtmelisi massiive kasutatakse sageli matemaatikas ja mänguarenduses. Siin toome kaks praktilist näidet: maatriksarvutused ja mängulaua haldamine.

Näide: maatriksite liitmine

#include <stdio.h>

int main() {
    int matrix1[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int matrix2[3][3] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };
    int result[3][3];

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            result[i][j] = matrix1[i][j] + matrix2[i][j];
        }
    }

    printf("Maatriksite liitmise tulemus:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Väljund

Maatriksite liitmise tulemus:
10 10 10
10 10 10
10 10 10

Näide: maatriksite korrutamine

#include <stdio.h>

int main() {
    int matrix1[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int matrix2[3][3] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };
    int result[3][3] = {0};

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 3; k++) {
                result[i][j] += matrix1[i][k] * matrix2[k][j];
            }
        }
    }

    printf("Maatriksite korrutamise tulemus:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Väljund

Maatriksite korrutamise tulemus:
30 24 18
84 69 54
138 114 90

Näide: Othello mängulaua loomine

#include <stdio.h>

int main() {
    int board[8][8] = {0};

    // algseisu määramine
    board[3][3] = 1; // valge
    board[3][4] = 2; // must
    board[4][3] = 2; // must
    board[4][4] = 1; // valge

    printf("Othello laua algseis:\n");
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            printf("%d ", board[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Väljund

Othello laua algseis:
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 1 2 0 0 0
0 0 0 2 1 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

7. Kahemõõtmeliste massiivide ja pointerite seos

C-keeles on kahemõõtmelistel massiividel ja pointeritel tihe seos. Pointerite kasutamine võimaldab massiive tõhusamalt töödelda. Järgnevalt selgitame põhikontseptsioone ja toome praktilisi näiteid.

Põhiline seos

Kahemõõtmeline massiiv on tegelikult „massiiv massiividest“. Seetõttu saab iga rida käsitleda pointerina.

Näide: kahemõõtmelise massiivi struktuur

int array[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

See massiiv paikneb mälus järgmiselt:

[1] [2] [3] [4] [5] [6]
  • array → osutab massiivi algusele
  • array[i] → osutab tervele reale
  • array[i][j] → konkreetsele elemendile

Elementidele ligipääs pointeritega

*(array[0] + 1)   // sama mis array[0][1]
*(*(array + 1) + 2) // sama mis array[1][2]

Kahemõõtmelise massiivi edasiandmine funktsioonile

Sageli on mugav kasutada pointereid massiivide funktsioonidesse edastamiseks.

Näide

#include <stdio.h>

void printArray(int (*array)[3], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    printArray(array, 2);
    return 0;
}

Väljund

1 2 3
4 5 6
  • int (*array)[3] tähendab pointerit massiivile, millel on 3 veergu.
  • Funktsioonis pääseb elementidele ligi ridade ja veergude kaudu.

Dünaamilised kahemõõtmelised massiivid pointeritega

Pointereid kasutades saab kahemõõtmelisi massiive luua dünaamiliselt programmi töö ajal.

Näide: dünaamiline eraldamine

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 2, cols = 3;

    int** array = malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        array[i] = malloc(cols * sizeof(int));
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            array[i][j] = i * cols + j + 1;
        }
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }

    for (int i = 0; i < rows; i++) {
        free(array[i]);
    }
    free(array);

    return 0;
}

Väljund

1 2 3
4 5 6

8. Kuidas dünaamiliselt eraldada ja vabastada kahemõõtmelisi massiive

C-keeles saab kasutada dünaamilist mälu, et luua kahemõõtmelisi massiive programmi töö ajal. See on kasulik siis, kui massiivi suurus pole teada kompileerimise ajal.

Põhitõed

Dünaamiliseks eraldamiseks kasutatakse funktsioone malloc ja calloc.
Mälu suuruse saab määrata jooksvalt vastavalt vajadusele.

Meetodid

  1. Pointerite massiiv (iga rea jaoks eraldi mälu)
  2. Ühemõõtmeline massiiv, mida kasutatakse kahemõõtmelisena

Meetod 1: pointerite massiiv

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3, cols = 4;
    int** array = malloc(rows * sizeof(int*));

    for (int i = 0; i < rows; i++) {
        array[i] = malloc(cols * sizeof(int));
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            array[i][j] = i * cols + j + 1;
        }
    }

    printf("Dünaamiliselt loodud 2D massiiv:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }

    for (int i = 0; i < rows; i++) {
        free(array[i]);
    }
    free(array);

    return 0;
}

Väljund

Dünaamiliselt loodud 2D massiiv:
1 2 3 4
5 6 7 8
9 10 11 12

Meetod 2: ühe massiivina

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3, cols = 4;
    int* array = malloc(rows * cols * sizeof(int));

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            array[i * cols + j] = i * cols + j + 1;
        }
    }

    printf("Ühemõõtmeline massiiv 2D-na:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", array[i * cols + j]);
        }
        printf("\n");
    }

    free(array);
    return 0;
}

Väljund

Ühemõõtmeline massiiv 2D-na:
1 2 3 4
5 6 7 8
9 10 11 12

9. Tähtsad tähelepanekud kahemõõtmeliste massiivide kasutamisel

Kahemõõtmelised massiivid on võimsad ja kasulikud, kuid valesti kasutades võivad need põhjustada vigu või mäluleke. Siin on peamised punktid, millele tähelepanu pöörata.

Vältida tuleb väljaspool piire ligipääsu

Kui üritatakse massiivi piire ületada, võib programm käituda ettearvamatult või kokku kukkuda.

Näide: viga

#include <stdio.h>

int main() {
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    printf("%d\n", array[2][0]); // Vale: rea 2 pole olemas
    return 0;
}

Õige lahendus

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", array[i][j]);
    }
}

Mäluleke

Kui dünaamiliselt eraldatud mälu ei vabastata, tekib mäluleke.

Näide: vale vabastamine

#include <stdlib.h>

int main() {
    int rows = 2, cols = 3;
    int** array = malloc(rows * sizeof(int*));

    for (int i = 0; i < rows; i++) {
        array[i] = malloc(cols * sizeof(int));
    }

    free(array); // Vale: read jäeti vabastamata
    return 0;
}

Õige vabastamine

for (int i = 0; i < rows; i++) {
    free(array[i]);
}
free(array);

Suuruse muutmise piirangud

Staatilise massiivi suurust ei saa muuta. Kui on vaja paindlikkust, tuleb kasutada dünaamilist massiivi ja vajadusel realloc funktsiooni.

Algväärtustamine

Algväärtustamata massiivis võivad olla „prügiväärtused“.

int array[2][3];
printf("%d\n", array[0][0]); // ettearvamatu väärtus

Õige viis

int array[2][3] = {0};

või dünaamiliselt:

int* array = calloc(rows * cols, sizeof(int));

Mälu kasutamise tõhusus

Kõige parem on andmetele ligi pääseda row-major järjekorras:

for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        printf("%d ", array[i][j]);
    }
}

Kontrollnimekiri levinud vigade kohta

  1. Kas ei ületata rea/veeru piire?
  2. Kas dünaamiline mälu vabastatakse alati?
  3. Kas massiiv on enne kasutamist initsialiseeritud?
  4. Kas suuruse muutmisel kasutatakse õigesti realloc?
  5. Kas andmeid töödeldakse row-major järjekorras?

10. Kokkuvõte

Selles artiklis vaatasime läbi C-keele kahemõõtmelised massiivid, alustades põhitõdedest ja lõpetades edasijõudnud kasutusega. Need on kasulikud nii maatriksarvutustes, mänguarenduses kui ka andmetöötluses.

1. Põhistruktuur

  • Kahemõõtmeline massiiv koosneb ridadest ja veergudest.
int array[read][veerud];

2. Initsialiseerimine ja elementide muutmine

  • Massiive saab initsialiseerida mitmel viisil.
  • Näide: int array[2][3] = { {1,2,3}, {4,5,6} };
  • Kõik nulliks: int array[2][3] = {0};

3. Mälustruktuur ja pointerid

  • Massiivid salvestatakse row-major järjekorras.
  • Pointereid saab kasutada tõhusamaks tööks.
*(*(array + i) + j);

4. Dünaamiline mälu

  • Dünaamiline mälu võimaldab luua massiive jooksvalt.
  • Tuleb alati mälu vabastada, et vältida leket.

5. Tähtsad tähelepanekud

  • Vältida piiri ületamist
  • Alati initsialiseerida
  • Dünaamilisel kasutamisel vabastada mälu

Kahemõõtmeliste massiivide eelised

  1. Maatriksite arvutused
  2. Mänguarendus (nt male, Othello)
  3. Tabelite andmetöötlus
  4. Pilditöötlus

Edasised sammud

  • Mitmemõõtmelised massiivid (3D ja edasi)
  • Pointerite keerukam kasutamine
  • Mälu haldamine, sealhulgas realloc abil suuruse muutmine

Lõppsõna

Kahemõõtmeliste massiivide valdamine aitab oluliselt arendada C-keele programmeerimisoskusi. Korda praktikas õpitud teadmisi ja kasuta ametlikku dokumentatsiooni või täiendavaid õppeallikaid keerukamate teemade puhul.

年収訴求