Sisteme bidimensionale, programare pe c și c

C vă permite să creați tablouri multidimensionale. Cel mai simplu tip de matrice multidimensională este o matrice bidimensională. O matrice bidimensională este o matrice de matrice unidimensionale. O matrice bidimensională este declarată după cum urmează:







tip array_name [dimensiunea celei de-a doua dimensiuni] [dimensiunea primei dimensiuni];

Pentru a accesa un element cu indexurile 3, 5 ale matricei d, ar trebui să utilizați

În exemplul următor, în matricea bidimensională se introduc numere de la 1 la 12, după care se afișează matricea.

#include
int principal (void)
int t, i, num [3] [4];
/ * numere de încărcare * /
pentru (t = 0; t<3; ++t)
pentru (i = 0; i<4; ++i)
num [t] [i] = (t * 4) + i + 1;

În acest exemplu, num [0] [0] are valoarea 1, num [0] [1] are valoarea 2, num [0] [2] - 3 și așa mai departe. num [2] [3] are valoarea 12.

Matricele bidimensionale sunt stocate ca o matrice, unde primul indice este responsabil pentru șir, iar al doilea este coloana. Aceasta înseamnă că indicele corect se schimbă mai repede decât cel din stânga dacă vă mutați în jurul matricei în ordinea elementelor din memorie. În Fig. Se afișează o reprezentare grafică a unei matrice bidimensionale în memorie. Indicele stâng poate fi considerat ca un indicator pentru un șir.

Numărul de octeți din memorie necesari pentru a găzdui o matrice bidimensională se calculează după cum urmează:

numărul de bytes = dimensiunea celei de-a doua dimensiuni * dimensiunea primei dimensiuni * sizeof (tipul de bază)

Presupunând că sistemul are numere întregi de 2 octeți, o matrice integeră cu dimensiunile de 10 pe 5 va ocupa 10 * 5 * 2, adică 100 de octeți.







Atunci când o matrice bidimensională este folosită ca argument de funcție, este trecut un indicator la primul element. O funcție care primește o matrice bidimensională trebuie să determine, cel puțin, dimensiunea primei dimensiuni, deoarece compilatorul trebuie să cunoască lungimea fiecărui rând pentru a indexa corect matricea. De exemplu, o funcție care primește o matrice întregă bidimensională cu dimensiunile de 5, 10 va fi declarată după cum urmează:

Puteți stabili dimensiunea celei de-a doua dimensiuni, dar acest lucru nu este necesar. Compilatorul trebuie să cunoască dimensiunea primei dimensiuni pentru executarea corectă a operatorilor de tip

în funcție. Dacă lungimea șirului nu este cunoscută, nu este posibil să se știe unde începe următoarea linie.

Programul scurt de mai jos utilizează o matrice bidimensională pentru a stoca evaluările fiecărui student în clasele profesorilor. Programul presupune că profesorul are trei clase și în fiecare clasă pot exista maximum 30 de elevi. Să acordăm atenție modului în care gradul este accesat din fiecare funcție:

#include
#include
#include
#include
#define CLASE 3
#define GRADES 30
clasa int [CLASE] [clase];
void disp_grades (int g [] [GRADES]), enter_grade (void);
int get_grade (int num);
int principal (void) / * program pentru stocarea estimărilor * /
char ch;
pentru (;;) face printf ("(E) nter grades \ n");
printf ("(R) notează gradele \ n");
printf ("(Q) uit \ n");
ch = toupper (getche ());
>
în timp ce (ch! = 'E' ch! = 'R' ch! = 'Q');
comutator (ch)
cazul "E":
enter_grades ();
pauză;
cazul R:
disp_grades (grad);
pauză;
cazul Q:
retur 0;
>
>
>

/ * introduceți fiecare scor student * /
void enter_grades (void)
int t, i;
pentru (t = 0; t pentru (i = 0; i gradul [t] [i] = get_grade (i);
>
>

/ * evaluarea intrărilor reale * /
int get_grade (int num) caracter [80];
printf ("introduceți nota pentru student #: \ n", num + 1);
devine (e);
întoarcere (atoi (s));
>

/ * evaluări ale clasei de ieșire * /
void disp_grades (int g [] [GRADES])
int t, i;
pentru (t = 0; t printf ("Clasa #: \ n", t + 1);
pentru (i = 0; i printf ("nota pentru elevul # este. \ n", i + 1, g [t] [i]);
>
>

Figura. Plasarea unei matrice bidimensionale în memorie







Articole similare

Trimiteți-le prietenilor: