Cum arată o matrice în c. Matrice statică: declarație, completare, utilizare. Inițializarea matricei inițiale

Ultima actualizare: 17.09.2017

Un tablou reprezintă un set de date de același tip. Definiția formală a unui tablou este următoarea:

Variable_type array_name [array_length]

După tipul variabilei vine numele matricei și apoi în paranteza patrata marimea lui. De exemplu, să definim o matrice de 4 numere:

numere int;

Această matrice are patru numere, dar toate aceste numere au o valoare nedefinită. Cu toate acestea, putem efectua inițializare și atribui câteva valori inițiale acestor numere prin acolade:

numere int = (1,2,3,4);

Valori în acolade numiți și inițializatori. Dacă există mai puține inițializatoare decât există elemente în matrice, atunci inițializatorii sunt utilizați pentru primele elemente. Dacă există mai mulți inițializatori decât elemente în matrice, atunci va apărea o eroare în timpul compilării:

numere int = (1, 2, 3, 4, 5, 6);

Aici matricea are o dimensiune de 4, dar îi sunt transmise 6 valori.

Dacă dimensiunea matricei nu este specificată în mod explicit, se deduce din numărul de inițializatoare:

numere int = (1, 2, 3, 4, 5, 6);

În acest caz, matricea are 6 elemente.

Inițializarea matricelor de caractere are propriile sale particularități. Putem transmite atât un set de inițializare, cât și un șir unei matrice de caractere:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "lume";

Mai mult, în al doilea caz, matricea s2 va avea nu 5 elemente, ci 6, deoarece atunci când este inițializată cu un șir, caracterul nul „\0” este adăugat automat la matricea de caractere.

În acest caz, nu este permisă alocarea unei matrice altei matrice:

Int nums1 = (1,2,3,4,5); int nums2 = nums1; // eroare nums2 = nums1; // eroare

Odată ce matricea este definită, îl putem accesa elemente individuale prin index. Indecii încep de la zero, așa că pentru a accesa primul element trebuie să folosim indicele 0. Accesând un element cu index, putem obține valoarea lui sau o putem modifica:

#include int main() ( int numere = (1,2,3,4); int primul_numar = numere; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Numărul de elemente ale matricei poate fi determinat și printr-o constantă:

Const int n = 4; numere int[n] = (1,2,3,4);

Iterarea peste matrice

Folosind bucle, puteți itera prin întreaga matrice și puteți accesa elementele acesteia prin indici:

#include int main() ( int numere = (1,2,3,4); int dimensiune = sizeof(numbers)/sizeof(numbers); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Pentru a trece printr-o matrice, mai întâi trebuie să găsiți lungimea matricei. Operatorul sizeof este folosit pentru a găsi lungimea. În esență, lungimea unui tablou este egală cu lungimea totală a elementelor sale. Toate elementele reprezintă același tip și ocupă aceeași dimensiune în memorie. Prin urmare, folosind expresia sizeof(numbers) găsim lungimea întregii matrice în octeți, iar folosind expresia sizeof(numbers) găsim lungimea unui element în octeți. Prin împărțirea celor două valori, puteți obține numărul de elemente din matrice. Și apoi, folosind o buclă for, repetăm ​​toate elementele până când contorul i devine egal cu lungimea matricei. Ca rezultat, toate elementele matricei vor fi afișate pe consolă:

Dar există și o altă formă a buclei for, care este concepută special pentru lucrul cu colecții, inclusiv matrice. Acest formular are următoarea definiție formală:

Pentru(tip de variabilă: colecție) ( instrucțiuni; )

Folosim acest formular pentru a itera printr-o matrice:

#include int main() ( int numere = (1,2,3,4); for(int number: numere) std::cout<< number << std::endl; return 0; }

Când iterați printr-o matrice, fiecare element iterat va fi plasat în variabila numerică, a cărei valoare este imprimată pe consolă într-o buclă.

Dacă nu cunoaștem tipul obiectelor din matrice, putem folosi specificatorul automat pentru a determina tipul:

Pentru (număr automat: numere) std::cout<< number << std::endl;

Matrice multidimensionale

Pe lângă tablourile unidimensionale din C++, există și cele multidimensionale. Elementele unor astfel de matrice sunt ele însele, la rândul lor, matrice, în care elementele pot fi și matrice. De exemplu, să definim o matrice bidimensională de numere:

numere int;

O astfel de matrice constă din trei elemente, fiecare element reprezentând o matrice de două elemente. Să inițializam o matrice ca aceasta:

Numerele int = ( (1, 2), (4, 5), (7, 8) );

Acoladele imbricate delimitează elementele pentru fiecare subgrup. O astfel de matrice poate fi reprezentată și ca un tabel:

De asemenea, puteți omite acoladele în timpul inițializării:

numere int = ( 1, 2, 4, 5, 7, 8 );

De asemenea, este posibil să inițializați nu toate elementele, ci doar câteva:

Numerele int = ( (1, 2), (), (7) );

Și pentru a accesa elementele unui tablou imbricat, aveți nevoie de doi indecși:

Numerele int = ( (1, 2), (3, 4), (5, 6) ); std::cout<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Să repetăm ​​o matrice bidimensională:

#include int main() (const int rânduri = 3, coloane = 2; int numere = ( (1, 2), (3, 4), (5, 6) ); for(int i=0; i< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

De asemenea, puteți utiliza o altă formă a buclei for pentru a itera elementele unui tablou multidimensional:

#include int main() (const int rânduri = 3, coloane = 2; int numere = ( (1, 2), (3, 4), (5, 6)); for(auto &subnumbers: numere) ( for(int number) : subnumere) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Pentru a itera peste matrice care sunt incluse într-o matrice, sunt folosite referințe. Adică, în bucla exterioară for(auto &subnumbers: numbers) &subnumbers reprezintă o referință subbarray în matrice. În bucla interioară for(int number: subnumbers), din fiecare subbary în subnumere, obținem elementele sale individuale în variabila număr și scoatem valoarea acesteia în consolă.

Să presupunem că trebuie să lucrăm cu o cantitate mare de date de același tip. De exemplu, avem o mie de măsurători ale coordonatelor unui pendul cu un anumit pas de timp. Crearea a 1000 de variabile pentru a stoca toate valorile este foarte... greoaie. În schimb, multe din același tip de date pot fi combinate sub un singur nume și fiecare element specific poate fi accesat prin numărul său de serie.
O matrice în C este definită după cum urmează
<тип> <имя массива>[<размер>];
De exemplu,
int a;
Vom primi o matrice numită A, care conține o sută de elemente de tip int. Ca și în cazul variabilelor, matricea conține gunoi.
Pentru a avea acces la primul element, scrieți numărul (indexul) acestuia între paranteze drepte. De exemplu

#include #include void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Primul element are numărul indice 0. Este important să înțelegem de ce. În cele ce urmează, vom reprezenta memoria computerului ca o bandă. Numele matricei este un pointer către adresa de memorie unde sunt situate elementele matricei.

Orez. 1 Matricea stochează adresa primului element. Indicele elementului i este o schimbare a i*sizeof(type) octeți de la început

Indicele matricei indică câți octeți trebuie deplasați de la începutul matricei pentru a accesa elementul dorit. De exemplu, dacă matricea A are tip int, apoi A înseamnă că am mutat 10*sizeof(int) bytes față de început. Primul element este la început și are un offset de 0*sizeof(int) .
În C, o matrice nu își stochează dimensiunea și nu verifică corectitudinea indexului matricei. Aceasta înseamnă că puteți ieși în afara matricei și puteți accesa memorie care este mai departe decât ultimul element al matricei (sau mai aproape).

Inițializarea inițială a matricei.

Să scriem un program simplu. Să creăm o matrice și apoi să găsim elementul maxim.

#include #include void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); unsigned i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Să ne uităm la un exemplu. Mai întâi creăm matricea și o inițializam la creare. După aceasta, atribuim elementului maxim găsit valoarea primului element al matricei.

Max = a;

Apoi trecem prin matrice. Deoarece ne-am uitat deja la primul element (are indice 1), nu are rost să-l mai uităm.
Același exemplu, doar acum utilizatorul introduce valori

#include #include void main() ( int a; unsigned i; int max; printf("Introduceți 10 numere\n"); for (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] >max) ( max = a[i]; ) ) printf("elementul maxim este %d", max); getch(); )

Dacă în timpul inițializării sunt specificate mai puține valori decât dimensiunea matricei, elementele rămase sunt umplute cu zerouri.

#include #include void main() ( int a = (1,2,3); unsigned i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Dacă trebuie să umpleți întreaga matrice cu zerouri, atunci scrieți

Int a = (0);

Nu trebuie să specificați dimensiunea matricei în mod explicit, de exemplu

Int a = (1, 2, 3);

matricea va avea dimensiunea 3

Dimensiunea matricei

O matrice în C trebuie să aibă o dimensiune constantă. Aceasta înseamnă că este imposibil, de exemplu, să cereți utilizatorului o dimensiune și apoi să setați această dimensiune la o matrice.

Printf("Introduceți lungimea matricei"); scanf("%d", &lungime); (float x;)

Crearea de tablouri dinamice va fi discutată în continuare atunci când lucrați cu pointeri și memorie.
În unele cazuri, puteți afla dimensiunea matricei folosind funcția dimensiunea.

#include #include void main() ( int A; //sizeof returnează dimensiunea întregii matrice în octeți //Pentru a determina numărul de elemente, //împarte dimensiunea matricei la dimensiunea elementului său int size = sizeof(A) / sizeof(int); printf("Dimensiunea matricei este egală cu %d", dimensiune); getch(); )

Dar acest lucru este puțin probabil să fie util. Când treceți o matrice ca argument unei funcții, va fi trecut un pointer, astfel încât dimensiunea matricei nu va fi cunoscută.
Matricele statice sunt utile atunci când numărul de elemente este cunoscut dinainte. Ele oferă acces rapid, dar nesigur la elemente.

Debordarea matricei

Să sperăm că aveți acest cod

Int A; int i; pentru (i=0; i<=10; i++) { A[i] = 1; }

Iată o buclă pentru specificat cu o eroare. În unele versiuni mai vechi de compilatoare, acest cod ar fi în buclă. Ideea este că variabila i a fost localizat în timpul compilării imediat după matrice A. Când matricea a depășit limitele, contorul a fost setat la 1.
Matricele sunt nesigure, deoarece munca incorectă cu indexul poate duce la accesul la o porțiune arbitrară de memorie (Teoretic. Compilatorii moderni înșiși au grijă să nu pătrunzi în memoria altcuiva).
Dacă lucrați cu matrice, trebuie să vă asigurați că contorul nu depășește dimensiunea matricei și nu este negativ. Pentru aceasta, cel putin,

• 1. Utilizați tipul size_t pentru indexare. Vă va proteja de valorile negative și va fi întotdeauna suficient pentru o matrice de orice dimensiune.
• 2. Amintiți-vă că tabloul începe de la zero.
• 3. Ultimul element al matricei are un index (dimensiunea matricei este 1)

Exemple

Acum, iată câteva exemple tipice de lucru cu matrice
1. Inversați matricea.

#include #include //Aceasta este o macrocomandă. SIZE din cod va fi înlocuit cu 10u #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i, j; // numără jumătate fără semn; //mijlocul matricei tmp fără semn; //variabilă temporară pentru schimbul de valori jumătate = SIZE / 2; //Un numărător merge de la stânga la dreapta, celălalt de la dreapta la stânga pentru (i = 0, j = DIMENSIUNE - 1; i< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Iată un design necunoscut pentru tine

#define SIZE 10u

macro. Pe tot parcursul codului, preprocesorul va înlocui automat toate aparițiile SIZE cu 10u.
2. Ștergerea unui element selectat de utilizator.

#include #include #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //counter int index; //index introdus de utilizator //Matrice de ieșire pentru (i = 0; i< SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index >0 && index< SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

În acest caz, desigur, elementul nu este șters. Matricea rămâne aceeași dimensiune ca înainte. Pur și simplu suprascriem elementul care este șters cu următorul și scoatem elemente SIZE-1.
3. Utilizatorul introduce valori în matrice. După aceea, tipăriți toate valorile diferite pe care le-a introdus.
Lăsați utilizatorul să introducă un număr finit de elemente, să zicem 10. Apoi se știe dinainte că nu vor fi mai mult de 10 valori diferite în total. De fiecare dată când utilizatorul introduce un număr, vom trece prin matrice și vom verifica dacă a fost introdus un astfel de număr.

#include #include #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //cate numere diferite sunt introduse. Cel puțin unul. int input; int wasntFound; //flag că numărul introdus nu a fost găsit //Introduceți primul număr. Nu a fost încă găsit. printf("0. "); scanf("%d", &A); for (i = 1; i< SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. Utilizatorul introduce un număr - numărul de măsurători (de la 2 la 10). După aceasta, introduce toate măsurătorile. Programul afișează valoarea medie, varianța și eroarea.

#include #include #include #define SIZE 20u void main() ( //Coeficienții elevului încep de la două dimensiuni const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do ( printf("Introduceți numărul de măsurători "); scanf("%u", &limit); if (limită > 1 && limită< 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Sortare cu bule matrice

#include #include #define SIZE 10 #define false 0 #define true !false void main() ( float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0) f); float tmp; unsigned i, j; char flag; //Afișează o matrice pentru (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >a) ( tmp = a[i]; a[i] = a; a = tmp; flag = adevărat; ) ) ) while(flag == adevărat); //Ieșiți tabloul sortat pentru (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Amestecați matricea. Să folosim algoritmul pentru asta

Matricele sunt un subiect extrem de important în C++. Sunt folosite foarte des în programe și este necesar să înțelegeți temeinic acest subiect. Te voi face fericit imediat - înțelegerea și învățarea cum să folosești matrice este destul de simplă chiar și pentru un începător.

Deci, de ce sunt necesare matrice și ce sunt acestea? Până acum știți bine că datele programului sunt stocate în fișierul . Dar se întâmplă că un program trebuie să stocheze sute (sau chiar mai multe) de variabile de același tip de date și, de asemenea, trebuie să lucreze cu ele - să atribuie valori, să le schimbe etc.

De exemplu, trebuie să stocați numerele de serie ale liniilor. De acord - oricine s-ar speria la ideea de a crea cinci sute de variabile de tip int, dându-le fiecăruia un nume unic și atribuind o valoare de la 1 la 500. (Sunt deja speriat :) În acest caz, matricele ne vor salva pur și simplu.

Să notăm punctele principale și să trecem la un exemplu practic:

• O matrice în C++ este o colecție de un anumit număr de variabile de același tip care au același nume. De exemplu, int matrice;. Această intrare înseamnă că am declarat o matrice numită matrice, care conţine 3 variabile de tip int ;
• variabilele matrice se numesc elemente;
• Fiecare element are propriul său index unic - propriul său număr de serie. Folosind un index putem accesa un anumit element. IMPORTANT - indexarea elementelor matricei începe de la 0 . Deci, în matrice int matrice primul element are un index 0 , iar ultimul este 2 . Pentru a accesa, de exemplu, elementul zero al unei matrice și a-i schimba valoarea, trebuie să specificați numele matricei și să indicați indexul elementului între paranteze drepte - matrice = 33 .

Să ne uităm la un exemplu:

tablouri C++

// în acest program creăm o matrice cu dimensiunea mărimii, // folosind o buclă for introducem date în toate celulele // ale matricei și le afișăm conținutul pe ecran #include folosind namespace std; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //declară o constantă int firstArray; //declară o matrice cu numărul de elemente SIZE pentru (int i = 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

Pe linia 12 definim o constantă întreagă MĂRIMEA, care va stoca dimensiunea matricei (definită de noi, numărul elementelor sale). În linia 13 declarăm o matrice: indicăm tipul de date care vor fi stocate în celulele matricei, dăm un nume și indicăm dimensiunea între paranteze drepte.

Este important să putem scrie numai valori întregi constante între paranteze pătrate. Trebuie fie să introduceți imediat un număr întreg între paranteze drepte atunci când declarați o matrice ( int firstArray;), sau definiți o constantă întreagă înainte de a declara matricea și introduceți numele acestei constante între paranteze drepte (ca în exemplul nostru).

A doua metodă este de preferat să fie folosită dacă în timpul programului va trebui să accesați matricea de mai multe ori printr-o buclă. Acest lucru se explică prin faptul că atunci când declarăm o buclă, putem specifica în ea condiția de schimbare a contorului la valoarea MĂRIMEA .

Imaginează-ți doar că trebuie să schimbăm dimensiunea matricei de la 10 elemente la 200. În acest caz, tot ce trebuie să facem este să schimbăm valoarea constantei întregi și, astfel, vom înlocui automat noile valori de dimensiune atât în matrice și în toate buclele programului.

În exemplul nostru, puteți încerca să adăugați orice alt număr la constantă MĂRIMEA. Și veți vedea că programul va funcționa grozav - va crea o matrice cu atâtea elemente câte specificați, va introduce datele și le va afișa pe ecran.

Și dacă matricea este foarte mică, de exemplu cu 5 elemente, o puteți inițializa imediat după declarare:

Deci elementul cu indicele 0 – firstArray– i se va atribui o valoare 11 , și ultimul element al matricei firstArray- sens 1 5 . Există un astfel de truc - nu puteți indica dimensiunea matricei între paranteze drepte și nu puteți scrie asta:

Intrarea anterioară este echivalentă cu aceasta. Numai în al doilea caz, compilatorul va calcula automat dimensiunea matricei pe baza cantității de date din acolade.

De asemenea, în timpul inițializării inițiale a elementelor matricei, atunci când matricea trebuie să fie curățată de „gunoaie” (date reziduale din alte programe din memorie), este mai bine să atribuiți imediat o valoare tuturor elementelor. 0 . Arata cam asa:

Trebuie amintit că o astfel de inițializare este posibilă numai pentru umplerea cu zerouri. Dacă trebuie să completați elementele matricei cu alte numere, este mai bine să utilizați o buclă. În C++11 (standard de codare), atunci când utilizați inițializarea listei (inițializarea cu acolade), aveți chiar voie să renunțați la semnul = .

Aș dori să arăt încă o tehnică de inițializare atunci când creez o matrice. De exemplu, pentru o matrice de 30 de elemente trebuie să introducem valorile 33 Și 44 numai la celulele cu un indice 0 Și 1 în consecință, și umpleți restul cu zerouri. Apoi facem asta:

aceste date vor fi introduse în celulele zero și primele, iar restul vor prelua automat valoarea 0 .

De asemenea, puteți organiza umplerea unei matrice folosind operatorul cin:

pentru (int i = 0; i< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> firstArray[i]; )

Ce sunt matricele în C?

Cum se declară matrice în C?

Cum să inițializez matrice în C?

Matrice în C pentru manechine.

Matrice în C

O matrice în C este o colecție de elemente de același tip care pot fi accesate prin index. Elementele matricelor din C sunt situate una după alta în memoria computerului.

Un exemplu simplu de creare și completare a unui tablou în C:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0 ;)

Primim:

În exemplu, declarăm o matrice care conține elemente de tip int:

aici numele matricei este nArr, numărul elementelor matricei este trei, tipul elementului matricei este int.

Un tablou este o colecție de elemente. Fiecare element al matricei poate fi referit prin numărul său. Numărul este de obicei numit index. Elementele matricei sunt numerotate începând de la zero. Să atribuim o valoare primului element al matricei, iar primul element are indice zero:

Să atribuim o valoare celui de-al doilea element al matricei, iar al doilea element are un index:

Să atribuim o valoare celui de-al treilea element al matricei, iar al treilea element are indexul doi:

Când afișăm elemente de matrice pe ecran, obținem valorile acestora. Ca aceasta:

printf("nArr\t=\t%d\n", nArr);

Pentru a obține un element de matrice, trebuie să specificați numele matricei și indexul elementului:

Acesta este primul element al matricei, deoarece primul element are indice zero.

Să atribuim valoarea celui de-al treilea element al matricei variabilei int a:

indicele celui de-al treilea element al tabloului este egal cu doi, deoarece indicii sunt numărați de la zero.

Acum, regula generală pentru declararea matricelor în C: atunci când declarați o matrice, trebuie să indicați numele acestuia, tipul de elemente și numărul de elemente. Numărul de elemente este un număr natural, adică. întregul este pozitiv. Zero nu poate fi numărul de elemente. Nu puteți specifica un număr variabil de elemente de matrice. Iată exemple de declarații de matrice în C:

int nArr; // O matrice a fost declarată să conțină o sută de numere întregi;
float fArr; // A fost declarată o matrice concepută pentru a stoca 5 numere flotante;
char carr; // A fost declarată o matrice pentru a stoca două caractere;

Ar fi o greșeală să declarați o matrice cu un număr variabil de elemente:

Int varElem;
int nArr; // Eroare! Numărul de elemente nu poate fi setat la o variabilă;

Dar puteți seta numărul de elemente cu o valoare constantă: fie un întreg pozitiv direct 1, 2, 3... fie o constantă:

Const int arrayLength = 3;
int nArr;

Când declarați o matrice în C, o puteți inițializa imediat:

int nMassiv = (1, 2, 3);

Puteți omite numărul de elemente ale matricei dintre paranteze drepte dacă toate elementele matricei sunt inițializate:

int nMassiv = (1, 2, 3);

numărul de elemente va fi determinat automat în acest caz.

Puteți defini doar o parte din elementele unui tablou atunci când o declarați:

int nMassiv = (1, 2);

în acest exemplu, primele două elemente ale matricei sunt inițializate, dar al treilea este nedefinit.

Exemplu de matrice de caractere:

char cArr = ("S", "B", "P");

Când declarați o matrice, nu puteți specifica numărul de elemente ale unei variabile. Dar puteți folosi variabile atunci când accesați elementele matricei:

Int ind = 0;
char cr = cArr;

Acesta este folosit atunci când lucrați cu bucle. Exemplu:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

În exemplu, în prima buclă umplem tabloul cu elemente de tip int, iar în a doua buclă afișăm aceste elemente pe ecran.

O matrice este o structură de date reprezentată ca un grup de celule de același tip, unite sub un singur nume. Matricele sunt folosite pentru a procesa cantități mari de date de același tip. Numele matricei este ceea ce sunt pointerii, vă voi spune puțin mai târziu. O celulă de date individuală a unei matrice se numește element de matrice. Elementele unui tablou pot fi date de orice tip. Matricele pot avea una sau mai multe dimensiuni. În funcție de numărul de dimensiuni, matricele sunt împărțite în matrice unidimensionale, matrice bidimensionale, matrice tridimensionale și așa mai departe până la o matrice n-dimensională. Matricele unidimensionale și bidimensionale sunt cele mai des folosite în programare, așa că vom lua în considerare numai aceste matrice.

Matrice unidimensionale în C++

Matrice unidimensională este o matrice cu un parametru care caracterizează numărul de elemente ale matricei unidimensionale. De fapt, o matrice unidimensională este o matrice care poate avea doar un rând și n număr de coloane. Coloanele dintr-o matrice unidimensională sunt elementele matricei. Figura 1 prezintă structura unui tablou unidimensional întreg A. Dimensiunea acestei matrice este de 16 celule.

Figura 1 - Matrice în C++

Rețineți că indicele maxim al unui tablou unidimensional A este 15, dar dimensiunea matricei este de 16 celule, deoarece numerotarea celulelor matricei începe întotdeauna de la 0. Indicele celulei este un număr întreg nenegativ prin care puteți accesa fiecare celulă a matricei și puteți efectua orice acțiuni asupra acesteia ( celulă).

//sintaxă pentru declararea unui tablou unidimensional în C++: /*tipul de date*/ /*numele unui tablou unidimensional*/; //un exemplu de declarare a unui tablou unidimensional prezentat în Figura 1: int a;

unde, int este un număr întreg;

A este numele unui tablou unidimensional;
16 este dimensiunea unei matrice unidimensionale, 16 celule.

Întotdeauna imediat după numele matricei există paranteze pătrate în care este specificată dimensiunea matricei unidimensionale; aceasta este ceea ce distinge matricea de toate celelalte variabile.

//o altă modalitate de a declara tablouri unidimensionale int mas, a;

Două rețele unidimensionale mas și a sunt declarate cu dimensiunile 10 și, respectiv, 16. Mai mult, în această metodă de declarare, toate tablourile vor avea același tip de date, în cazul nostru - int.

// tablourile pot fi inițializate atunci când sunt declarate: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inițializarea unui tablou unidimensional

Inițializarea unui tablou unidimensional se realizează în acolade după semn egală, fiecare element de matrice este separat de cel anterior printr-o virgulă.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inițializarea matricei fără a-i determina dimensiunea.

În acest caz, compilatorul însuși va determina dimensiunea matricei unidimensionale. Mărimea unei matrice poate fi omisă numai la inițializarea acesteia; atunci când declarați o matrice în mod normal, trebuie specificată dimensiunea matricei. Să dezvoltăm un program simplu pentru a procesa o matrice unidimensională.

// array.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

// array.cpp: Definește punctul de intrare pentru aplicația consolă. #include folosind namespace std; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

ÎN liniile 10 - 11 A fost declarată și inițializată o matrice unidimensională întregă numită array1, a cărei dimensiune este de 16 celule, adică o astfel de matrice poate stoca 16 numere. Orice procesare de matrice este posibilă numai în combinație cu bucle. Ce buclă să alegeți pentru procesarea matricei este decizia dvs. Dar este cel mai potrivit pentru această sarcină. Vom folosi variabila counter pentru a accesa elementele tabloului unidimensional array1. Condiția pentru continuarea buclei for conține un semn de inegalitate strict, deoarece nu există un al șaisprezecelea indice în tabloul unidimensional matrice1. Și deoarece numerotarea celulelor începe de la zero, există 16 elemente în matrice.În corpul buclei for, operatorul cout imprimă elementele unui tablou unidimensional (vezi Figura 2).

Obrabotka massiva indexează elementul massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 11 array1 43 array1 35 Pentru a continua, apăsați orice tasta array1 -1 39. . .

Figura 2 - Matrice în C++

Să dezvoltăm un alt program pentru procesarea unui tablou unidimensional în C++. Programul trebuie să citească secvenţial zece numere introduse de la tastatură. Toate numerele introduse sunt însumate și rezultatul este afișat pe ecran.

// array_sum.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

// array_sum.cpp: Definește punctul de intrare pentru aplicația consolă. #include folosind namespace std; int main(int argc, char* argv) ( int array1; // declară o matrice întregă cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>array1; // citesc numerele introduse de la tastatura cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Înainte de a procesa o matrice, aceasta trebuie declarată, iar dimensiunea unei matrice unidimensionale este 10, deoarece acest lucru este stipulat de condiția sarcinii. În variabila sumă vom acumula suma elementelor unui tablou unidimensional. Prima buclă for umple matricea unidimensională declarată cu numere introduse de la tastatură, liniile 12 - 13. Variabila contor este utilizată pentru a accesa secvențial elementele matricei unidimensionale ale matricei1, începând de la indicele 0 și până la al 9-lea inclusiv. A doua buclă for afișează elementele matricei, rândurile 15 - 16. Cea de-a treia buclă pentru citește secvențial elementele unui tablou unidimensional și le însumează, suma este acumulată în variabila sumă. rândurile 17 - 18. Rezultatul programului este prezentat în Figura 3.

Introduceți elementi massiva: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Pentru a continua, apăsați orice tastă. . .

Figura 3 - Matrice în C++

Mai întâi, toate cele 10 numere au fost introduse secvenţial, după care a fost afişată o matrice unidimensională şi a fost tipărită suma numerelor din matrice.

Matrice bidimensionale în C++

Până în acest punct, am luat în considerare tablourile unidimensionale, care nu pot fi întotdeauna limitate la. Să presupunem că trebuie să procesați unele date dintr-un tabel. Un tabel are două caracteristici: numărul de rânduri și numărul de coloane. De asemenea, într-o matrice bidimensională, pe lângă numărul de elemente ale matricei, există caracteristici precum numărul de rânduri și numărul de coloane ale unei matrice bidimensionale. Adică, vizual, o matrice bidimensională este un tabel obișnuit, cu rânduri și coloane. De fapt, o matrice bidimensională este o matrice unidimensională de matrice unidimensionale. Structura unui tablou bidimensional, numit a, de dimensiunea m cu n este prezentată mai jos (vezi Figura 4).

Figura 4 - Matrice în C++

unde, m este numărul de rânduri ale unui tablou bidimensional;
n este numărul de coloane ale unui tablou bidimensional;
m * n — numărul de elemente ale matricei.

// sintaxă pentru declararea unui tablou bidimensional /*tip de date*/ /*nume tablou*/;

În declararea unei matrice bidimensionale, precum și în declararea unei matrice unidimensionale, în primul rând, trebuie să specificați:

• tipul de date;
• numele matricei.

După aceea, primele paranteze pătrate indică numărul de rânduri ale matricei bidimensionale, iar cele doua paranteze pătrate indică numărul de coloane ale matricei bidimensionale. O matrice bidimensională se distinge vizual de o matrice unidimensională printr-o a doua pereche de paranteze pătrate. Să ne uităm la un exemplu de declarare a unui tablou bidimensional. Să presupunem că trebuie să declarăm o matrice bidimensională cu un număr de elemente egal cu 15. În acest caz, o matrice bidimensională poate avea trei rânduri și cinci coloane sau cinci rânduri și trei coloane.

// exemplu de declarare a unui tablou bidimensional: int a;

• a este numele matricei întregi
• numărul din primele paranteze pătrate indică numărul de rânduri ale matricei bidimensionale, în acest caz sunt 5;
• numărul din a doua paranteză pătrată indică numărul de coloane ale matricei bidimensionale, în acest caz sunt 3.

// inițializarea unui tablou bidimensional: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1));

Această matrice are 5 rânduri, 3 coloane. după semnul de atribuire, sunt plasate paranteze generale, în interiorul cărora sunt plasate atâtea perechi de paranteze câte linii ar trebui să fie într-o matrice bidimensională, iar aceste paranteze sunt separate prin virgule. În fiecare pereche de acolade, scrieți elementele unei matrice bidimensionale separate prin virgule. În toate bretele, numărul de elemente trebuie să fie același. Deoarece există cinci linii în matrice, există și cinci perechi interioare de paranteze. Trei elemente sunt scrise în parantezele interioare, deoarece numărul de coloane este de trei. Grafic, matricea noastră va arăta ca un tabel bidimensional (vezi Figura 5).

Figura 5 - Matrice în C++

În fiecare celulă a unui tablou bidimensional A valoarea este afișată, adresa acestei celule este afișată în colțul din dreapta jos. Adresa celulei unei matrice bidimensionale este numele matricei, numărul rândului și numărul coloanei.

Să dezvoltăm un program simplu pentru procesarea unei matrice bidimensionale, numit „Labirint”. Labirintul trebuie construit pe baza unui tablou bidimensional. Vom alege dimensiunea labirintului la discreția noastră.

// array2.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) altfel cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

// array2.cpp: Definește punctul de intrare pentru aplicația consolă. #include folosind namespace std; int main(int argc, char* argv) ( // 1-condiționat „pereții labirintului” // 2-“cale corectă, ieșire din labirint” // 0-“cale falsă” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inițializarea unei matrice bidimensionale ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,)); // două bucle - interne și externe, accesând fiecare element al matricei pentru (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) altfel cout<< " "; // вывести два пробела cout << endl; } return 0; }

Căile corecte și false ar putea fi notate cu același număr, de exemplu, zero, dar pentru claritate, calea corectă este notă cu numărul 2. Matricea a fost inițializată manual, doar pentru a simplifica programul. Deoarece programul procesează o matrice bidimensională, sunt necesare două bucle pentru a comuta între elementele matricei bidimensionale. Prima buclă for comută între rândurile unui tablou bidimensional. Deoarece există 33 de rânduri într-o matrice bidimensională, variabila contor i este incrementată de la 0 la 33, linia 46. În interiorul primei bucle se află o buclă for care parcurge elementele rând ale unui tablou bidimensional. În corpul celei de-a doua bucle for, o operație de conversie a tipului de date unare este efectuată în interior - static_cast<>() , care tipărește numărul de caracter 176. Operația de conversie a tipului de date este duplicată pentru a mări lățimea labirintului. Rezultatul programului (vezi Figura 6).

Figura 6 - Matrice în C++