Umplerea unui tablou unidimensional cu pascal. Umplerea și procesarea unei matrice

Matrice unidimensionale. Formarea unui tablou și afișarea elementelor acesteia

Definiția conceptului

O matrice este o colecție de date de același tip cu un nume comun tuturor elementelor.

Elementele matricei sunt numerotate și vă puteți referi la fiecare dintre ele prin număr. Numerele elementelor de matrice sunt altfel numite indici, iar elementele de matrice în sine sunt numite variabile indexate.

Vector (liniar sau matrice unidimensională) este un exemplu de matrice în care elementele sunt numerotate cu același index.

• La fel de numere (index) element de matrice, în general, se utilizează expresia tip ordinal(cel mai adesea este o constantă întreagă sau o variabilă întreagă: întreg, cuvânt, octet sau scurtătură)
• Când se face referire la un element al unui tablou, indexul este indicat între paranteze drepte. De exemplu, a, masa.
• Elementele de matrice sunt procesate atunci când indicii elementului se modifică. De exemplu, în cazul utilizării unei expresii, este convenabil să folosiți următoarele variabile pentru a vizualiza elementele matricei într-o buclă:
  • a [i] - toate elementele;
  • a - elemente în locuri pare;
  • a - elemente care stau în locuri ciudate

Descrierea matricei

• Definirea unei variabile ca matrice fără a descrie mai întâi tipul matricei

Notă

• • Descrierea matricei este cerută de compilator pentru a aloca memorie pentru elementele sale.
  • O variabilă este definită ca o matrice prin intermediul unui cuvânt de serviciu matrice(matrice). Parantezele indică intervalul, adică limitele inferioare și superioare ale valorii indexului matricei. Valoarea limită superioară nu poate fi mai mică decât cea inferioară.
  • Aici variabilele s și k sunt considerate a fi de diferite tipuri. Pentru asigurarea compatibilităţii este necesară aplicarea declaraţiei de variabile printr-o declaraţie preliminară de tip.
  • Dacă tipurile de matrice sunt identice, atunci în program o matrice poate fi alocată altuia. În acest caz, valorile tuturor variabilelor unei matrice vor fi alocate elementelor corespunzătoare ale celei de-a doua matrice.
  • Operațiile relaționale nu sunt definite pe tablouri. Compararea a două matrice poate fi doar în funcție de elemente.
• Descrierea preliminară a tipului de matrice

Notă

• • Elementele matricei vor fi accesate astfel: a, a, a, a, a (adică tabloul conține cinci elemente).
  • Folosind constante(n în acest exemplu) este de preferat atunci când descrieți o matrice, deoarece în cazul modificării dimensiunii matricei, nu va fi necesar să faceți corecții în tot textul programului.
• Specificarea unui tablou cu o constantă tipizată

Notă

• • În acest exemplu, nu numai memoria este alocată matricei, ci și celulele sunt umplute cu date.
  • Elementele matricei pot Schimbareîn timpul programului (ca toate constantele tastate).

Umplerea unui tablou cu date

§ Pentru a umple matricea datele (și ieșirea lor) cel mai adesea se utilizează o buclă cu un parametru pentru

§ Pentru a umple matricea cu numere aleatorii, utilizați funcția Aleatoriu si procedura randomizare(inițializarea generatorului de numere aleatoare). Formatul de înregistrare este următorul: aleatoriu (B - A) + A, unde A și B sunt luate din intervalul: 4);

Un exemplu de program pentru intrarea și ieșirea unui tablou

Formularea problemei. Obțineți suma elementelor unui tablou de 10 elemente întregi. Elementele matricei sunt introduse de la tastatură.

Un exemplu de program pentru lucrul cu elemente de matrice

Formularea problemei. Obțineți media aritmetică a elementelor unui tablou. Elementele matricei sunt umplute cu numere aleatorii.

Secțiuni: Informatică

Obiective:

1. Pentru a familiariza studenții cu posibilitatea de a completa și procesa o matrice.
2. Creați o interfață grafică pentru un proiect pentru a umple o matrice și a calcula suma elementelor dintr-o matrice dată.
3. Dezvoltați un interes cognitiv pentru subiect
4. Promovează o atitudine de învățare responsabilă

ÎN CURILE CLASURILOR

1. Actualizarea lecției

Organizarea timpului

Sondaj frontal pe tema precedentă „Conceptul de matrice. Matrice unidimensională "

2. Formarea deprinderilor și abilităților

Explicația noului material

Declarație de matrice

O matrice este declarată în același mod în care este declarată o variabilă, este necesar doar să specificați intervalul modificării indexului. De exemplu, o matrice de numere întregi unidimensionale care conține 10 elemente este declarată după cum urmează:

A: matrice de numere întregi;

Sarcini de bază atunci când lucrați cu matrice

1. Formarea (umplerea) matricei

1.1. după formulele Pentru i: = 1 la 10 face a [i]: = i * i;

1.2. generați aleatoriu Pentru i: = 1 până la 10 faceți a [i]: = aleatoriu (20):

Funcția încorporată RANDOM (MAX), returnează un număr întreg aleatoriu distanțat uniform de la 0 la MAX - 1 (MAX este parametrul de apel)

1.3. introduceți de la tastatură Pentru i: = 1 la 10 do read (a [i]);

2. Sortarea matricei (crescător, descendent);

3. Căutați elemente dintr-o matrice;

4. Selectarea elementelor dintr-un tablou după condiție;

Umplerea matricei la întâmplare.

Pentru a începe să lucrați cu o matrice, aceasta trebuie să fie completată, de exemplu. atribuiți valori specifice elementelor matricei. Pentru a genera o secvență de numere aleatoare, utilizați funcția Aleatorie (100). Când programul pornește, această funcție va imprima o secvență pseudo-aleatorie de numere întregi în intervalul de la 0 la 100.

Pentru a genera secvențe de numere aleatoare care diferă unele de altele, se recomandă utilizarea operatorului Randomize

Acțiuni cu tablouri unidimensionale

1. Calculul sumei elementelor

Pentru I: = 1 La 10 Do s: = s + a [i]; (acumularea obișnuită a sumei în s)

2. Calculul produsului

Pentru I: = 1 To 10 Do p: = p * a [i]; (acumularea obișnuită a produsului în p)

3. Căutați un element cu o valoare dată

3. Notă deprinderi de învățare în practică

Proiectul „Suma elementelor dintr-o matrice”. Vom dezvolta un proiect „Suma elementelor dintr-o matrice”, care va umple matricea cu numere aleatoare și va calcula suma acestor numere.

Mai întâi, să creăm o procedură pentru umplerea matricei

1. Porniți sistemul de programare Delphi.

2. Lucrul la proiect începe cu crearea unei interfețe grafice, pentru aceasta în fereastră Constructor de formulare controalele sunt plasate pe formular. Pentru a crea o interfață grafică pentru proiect, vom plasa pe formular două câmpuri de text pentru afișarea datelor numerice (unul pentru completarea matricei, celălalt pentru afișarea sumei) și două butoane pentru implementarea procedurilor eveniment: completarea tabloului și a sumei.

3.Utilizarea Bare de instrumente puneți câmpul de text Editl și butonul de comandă Buttonl pe Forml

Următorul pas este codificarea procedurilor evenimentului. Făcând dublu clic pe butonul pentru care doriți să creați un cod de program, apare fereastra Cod program cu un stub gol al unei proceduri de eveniment.

4. Faceți dublu clic pe butonul Buttonl, va apărea un șablon pentru procedura de eveniment TForml.ButtonlClick: Declarați matricea Ași descrierea variabilelor ESTEîn secțiunea declarații variabile var

A: matrice de numere întregi;

procedura TForm1.Button1Click (Expeditor: TObject);

Pentru I: = 1 To 10 Do

A [I]: = Aleatoriu (10);

Edit1.Text: = Edit1.Text + "" + IntToStr (a [i]);

5. Salvați proiectul ca

6. Compilarea proiectului (Proiect - Compilare)

Acum să creăm o procedură pentru calcularea sumei elementelor din tabloul umplut

Prin intermediul Bare de instrumente n Plasați butonul Button2 și câmpul de text Edit2 în formularul Forml. Făcând dublu clic pe Button2, pentru care trebuie să creați un cod de program, se afișează fereastra Cod program cu un stub gol al unei proceduri de eveniment.

procedura TForm1.Button2Click (Expeditor: TObject);

Pentru I: = 1 To 10 Do

Edit2.Text: = Edit2.Text + "" + IntToStr (e)

Salvarea proiectului întregului proiect (Salvare proiect).

Să compilam proiectul (apăsând tasta F9).

Faceți clic pe butoanele Fill Array și Sum.

Rezultatele sumelor vor fi afișate în caseta de text pentru diferite opțiuni de umplere

4. Rezumând

5. Temă: Creați un proiect „Produs de elemente ale matricei”, care prevede umplerea matricei cu numere aleatorii și posibilitatea de a afișa produsul tuturor elementelor din matrice în câmpul de text.

O matrice unidimensională este o secvență numită de elemente numerotate de același tip. Elementele pot fi orice disponibile în Pascal(excluzând fișierul) tip de date. Un număr, numit și index, este atribuit fiecărui element din matrice. Indicele trebuie să fie de tip ordinal. O matrice unidimensională poate fi declarată ca variabilă:

var<имя переменной>: matrice de<тип элементов>;

asa si ca:

tip<имя типа>= matrice de<тип элементов>;

Aici m Este numărul primului element și n- acesta din urmă. De exemplu, dacă intervalul este specificat astfel:, atunci aceasta înseamnă că este definită o matrice unidimensională de 10 elemente cu indici de la 1 la 10.

Pentru a accesa un element de matrice, trebuie să specificați numele și numărul acestuia: mas [i], aici mas este numele, i este numărul. În programul de mai jos, vom declara o matrice și vom efectua operații simple asupra elementelor sale.

Într-un fel, puteți lucra cu matrice la fel ca și cu variabile obișnuite, dar imaginați-vă, de exemplu, o situație în care trebuie să umpleți o matrice formată din zeci sau mii de elemente. Va fi mai convenabil să faceți acest lucru printr-o buclă. Următoarea construcție umple o matrice cu numere și le afișează pe ecran.

pentru i: = 1 la n do
începe
mas [i]: = i;
scrie (mas [i]: 3);
Sfârșit;

Dacă doriți ca matricea să fie compusă din valori introduse de la tastatură, pur și simplu înlocuiți alocarea cu o instrucțiune de citire. Există, de asemenea, situații în care trebuie să completați o matrice cu numere aleatorii. Programul de mai jos atribuie alternativ o valoare aleatorie fiecărui element.

Există probleme larg răspândite asociate cu diferite tipuri de algoritmi aplicabili matricelor. Printre acestea, metodele de căutare și sortare a elementelor sunt deosebit de populare. Dar fiecare dintre acești algoritmi necesită un studiu individual, astfel încât să vă puteți familiariza cu ei în alte articole:

Algoritmi de sortare:

Algoritmi de căutare:

Metodele de determinare a numărului de elemente pozitive și negative, minime și maxime sunt mai puțin complexe și, în același timp, solicitate. Să le luăm în considerare.

Găsirea elementului maxim dintr-o matrice:

Pentru a realiza un program pentru găsirea elementului minim, trebuie doar să schimbați semnul< в 15 строке на >.

Determinarea numărului de elemente pozitive:

Lecție din serie: „ Limbajul de programare Pascal»

După declararea matricei, puteți lucra cu el. De exemplu, atribuiți valori elementelor matricei și, în general, tratați-le ca variabile obișnuite. Pentru a face referire la un anumit element, trebuie să specificați identificatorul (numele) matricei și indexul elementului între paranteze drepte.

De exemplu, înregistrarea Mas, A permite accesarea celui de-al doilea element al matricei MAS și al zecelea element al matricei A. Când lucrați cu o matrice bidimensională, specificați doi indici, cu o matrice n-dimensională - n indici.

De exemplu, intrarea Matr pune la dispoziție pentru procesare valoarea elementului situat în al patrulea rând al coloanei a patra a matricei M.

Elementele indexate ale unui tablou se numesc variabile indexate. Nu puteți trece dincolo de limitele matricei. Adică, dacă există cinci elemente în tabloul Mas, atunci accesul la al șaselea sau al optulea element va duce la o eroare.

Să luăm în considerare operațiile tipice care apar atunci când lucrăm cu tablouri unidimensionale.

Umplerea unui tablou unidimensional cu valori

Umplerea și afișarea unei matrice se poate face numai element cu element, adică mai întâi puteți atribui o valoare primului element, apoi celui de-al doilea și așa mai departe, la fel cu afișarea - afișăm primul, al doilea, al treilea și așa mai departe până când ultimul.

Pascal nu are mijloace de intrare-ieșire a elementelor matricei simultan, prin urmare, intrarea și valorile sunt efectuate element cu element. Un element de matrice pot fi alocate valori folosind operatorul de atribuire sau introduse de la tastatură folosind operatorii Read sau Readln. Este foarte convenabil să iterați peste toate elementele unui tablou într-o buclă for.

Modalități de a completa matrice unidimensionale:

1. Introducerea unei valori de la tastatură.
2. Setarea valorilor într-o declarație de atribuire folosind un generator de numere aleatorii. Această metodă este mai convenabilă atunci când există multe elemente în matrice (este nevoie de mult timp pentru a le introduce valorile de la tastatură).
3. Setarea valorilor printr-o formulă.
4. Introducerea elementelor matrice dintr-un fișier

1. Introducerea valorilor elementelor matricei de la tastatură. Datorită faptului că a fost folosită instrucțiunea Readln, fiecare valoare va fi introdusă pe o nouă linie.

2. Umplerea matricei numere generate aleatoriu din interval. Conectăm generatorul de numere aleatoare - funcția aleatoare.

3. Umplere matrice conform formulei. Fiecărui element din matrice i se atribuie o valoare calculată prin formulă. Dacă fiecare element al matricei este egal cu de trei ori valoarea numărului său ordinal (index), atunci procedura va arăta astfel:

4. Citirea numerelor dintr-un fișier. Trebuie să creați în prealabil un fișier text, în care scrieți mai multe rânduri, fiecare conținând 30 de numere.

Afișarea valorilor elementelor matricei pe ecran

Concluzie valorile elementelor matrice ecranul este executat, ca și intrare, element cu element într-o buclă. Pentru ieșire, vom folosi instrucțiunile Write sau Writeln. Ca parametri de intrare, vom trece la procedură nu doar un tablou, ci și numărul de elemente care trebuie afișate, începând de la primul (vom avea nevoie de acesta când ștergem și adăugam elemente în matrice).

Exemplul 1. Populați matricea de la tastatură și afișați-o.

Soluţie.

Programul va folosi două proceduri: procedura Init1 (umplerea matricei de la tastatură) și procedura Print (afișarea matricei pe ecran).

Exemplul 2. Populați matricea dintr-un fișier text și afișați. Fișierul text conține mai multe rânduri, fiecare linie conține 30 de numere.

Ați învățat cum să umpleți o matrice unidimensională și să o afișați pe ecran.

În următoarea lecție, vom continua să ne familiarizăm cu algoritmii de procesare a tablourilor unidimensionale.

O matrice este o structură de date prezentată ca un grup de celule de același tip, unite sub un singur nume. Matricele sunt folosite pentru a procesa cantități mari de același tip de date. Numele matricei este ceea ce sunt pointerii, vă voi spune puțin mai târziu. O singură celulă de date matrice se numește element matrice. Elementele matricei 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 matrice n-dimensionale. Matricele unidimensionale și bidimensionale sunt cele mai des folosite în programare, așa că vom lua în considerare doar aceste matrice.

Matrice unidimensionale în C++

Matrice unidimensională - 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 al n-lea 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 egal cu 15, dar dimensiunea matricei este de 16 celule, deoarece numerotarea celulelor din matrice începe întotdeauna de la 0. Indexul celulei este un număr întreg nenegativ prin care vă puteți referi la fiecare celulă din matrice și puteți efectua orice acțiuni asupra acestuia (celulă).

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

unde, int este un număr întreg;

A este numele tabloului unidimensional;
16 - dimensiunea unei matrice unidimensionale, 16 celule.

Întotdeauna imediat după numele matricei, există paranteze pătrate, în care este setată dimensiunea unei matrice unidimensionale, acesta este ceea ce diferă matricea de toate celelalte variabile.

// un alt mod 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țializați tabloul unidimensional

Inițializarea unui tablou unidimensional se realizează în acolade după semn egală, fiecare element al matricei 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țializați matricea fără a-i determina dimensiunea.

În acest caz, compilatorul va determina dimensiunea matricei unidimensionale în sine. Mărimea matricei poate fi omisă numai în timpul inițializării sale; cu declarația obișnuită a unui tablou, este necesar să se indice dimensiunea matricei. Să dezvoltăm un program simplu pentru procesarea unui tablou 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; }

V liniile 10 - 11 declarat și inițializat este o matrice întreagă unidimensională numită array1, a cărei dimensiune este de 16 celule, adică o astfel de matrice poate stoca 16 numere. Orice procesare a unui tablou este fezabilă numai în combinație cu bucle. Ce buclă să alegeți pentru a procesa matricea depinde de dvs. Dar este cel mai potrivit pentru această sarcină. Contorul de variabile contor va fi folosit pentru a se referi la elementele matricei unidimensionale ale matricei1. 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, elementele din matrice sunt 16. În corpul buclei for, operatorul cout imprimă elementele unui tablou unidimensional (vezi Figura 2).

Obrabotka massiva indeks element 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 43 array1 39 Apăsați orice tastă pentru a continua. ... ...

Figura 2 - Matrice în C++

Să dezvoltăm un alt program pentru procesarea unui tablou unidimensional în C++. Programul ar trebui să citească secvenţial zece numere introduse de la tastatură. Însumați toate numerele introduse, afișați rezultatul.

// 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 >> matrice1; // 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 matricea, aceasta trebuie declarată, iar dimensiunea matricei unidimensionale este 10, deoarece aceasta este stipulată de condiția problemei. În suma variabilă, vom acumula suma elementelor unui tablou unidimensional. Prima buclă for umple matricea unidimensională declarată cu numerele introduse de la tastatură, liniile 12 - 13... Contorul de variabile contor este utilizat pentru accesul secvenţial la elementele matricei unidimensionale ale matricei1, începând de la indicele 0 şi până la al 9-lea inclusiv. A doua buclă for imprimă elementele matricei pe ecran, liniile 15 - 16... A treia buclă pentru citește secvențial elementele matricei unidimensionale și le însumează, suma este acumulată în suma variabilă, rândurile 17 - 18... Vedeți rezultatul programului î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 Apăsați orice tastă pentru a continua. ... ...

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 matricei.

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. Există două caracteristici într-un tabel: 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 unui tablou bidimensional. 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, dimensiunea m cu n, este prezentată mai jos (vezi Figura 4).

Figura 4 - Matrice în C++

unde, m este numărul de linii ale unui tablou bidimensional;
n este numărul de coloane dintr-o matrice bidimensională;
m * n este numărul de elemente din tablou.

// sintaxă pentru declararea unei matrice bidimensionale / * tip de date * / / * nume matrice * /;

În declararea unei matrice bidimensionale, precum și în declarația unei matrice unidimensionale, primul lucru de făcut este să specificați:

• tipul de date;
• numele matricei.

După aceea, în primele paranteze pătrate este indicat numărul de rânduri ale unei matrice bidimensionale, în a doua paranteză pătrată - numărul de coloane ale unei matrice bidimensionale. O matrice bidimensională diferă vizual de o matrice unidimensională prin a doua pereche de paranteze pătrate. Luați în considerare un exemplu de declarare a unui tablou bidimensional. Să presupunem că trebuie să declarăm o matrice bidimensională, cu numărul 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 - numele unui tablou întreg
• numărul din primele paranteze pătrate indică numărul de linii ale tabloului bidimensional, în acest caz sunt 5;
• numărul din a doua paranteză pătrată indică numărul de coloane din matricea bidimensională, în acest caz sunt 3.

// inițializați o matrice bidimensională: int a = ((4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), (1) , 1, unu) );

Această matrice are 5 rânduri, 3 coloane. după semnul de atribuire, sunt plasate acolade comune, în interiorul cărora există atâtea perechi de acolade 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 unui tablou bidimensional, separate prin virgule. Toate bretele trebuie să aibă același număr de elemente. Deoarece există cinci linii în matrice, există și cinci paranteze interioare. Parantezele interioare conțin câte trei elemente, 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 este afișată valoarea, 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, care se numește „Labirint”. Labirintul ar trebui să fie 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-conditionat "peretii labirintului" // 2- "cale corecta, iesire din labirint" // 0- "cale falsa" int mas = ((1, 2,1 , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inițializarea unui bidimensional matrice (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,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.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,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,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,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,1,2,1,), (1,2,1,1,2, 1, 1,0,1,2,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,), (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,2,1,), (1,2,1,1,2,1,0,1,1,2,1,1,2,1,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,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 - una internă și una externă, care accesează 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 unei matrice bidimensionale. Prima buclă for comută între liniile unui tablou bidimensional. Deoarece există 33 de șiruri într-o matrice bidimensională, variabila contor i este incrementată de la 0 la 33, linia 46... În interiorul primei bucle, există o buclă for care comută între elementele șirului unui tablou bidimensional. În corpul celei de-a doua bucle for, o operație de conversie unică a tipului de date este efectuată intern - static_cast<>(), care tipărește caracterul, la numărul 176. Operația de conversie a tipurilor de date este duplicată pentru a crește lățimea labirintului. Rezultatul programului (vezi Figura 6).

Figura 6 - Matrice în C++