Matrice statică: declarație, completare, utilizare. Matrice unidimensională Matrice unidimensională c exemplu

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*/; //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 al tabloului 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țializează tabloul fără a-i determina dimensiunea.

În acest caz, compilatorul însuși va determina dimensiunea matricei unidimensionale. Mărimea unui tablou poate fi omisă doar la inițializarea acesteia când se declară 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 matricei unidimensionale 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ă 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 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 folosită 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 acoladele, 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 unui tablou bidimensional, 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,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++

La rezolvarea problemelor cu o cantitate mare de date de același tip, utilizarea variabilelor cu nume diferite care nu sunt ordonate după adresele de memorie îngreunează programarea. În astfel de cazuri, limbajul C folosește obiecte numite tablouri.

este o bucată adiacentă de memorie care conține o secvență de obiecte de același tip, notate printr-un singur nume.

Matricea este caracterizată de următoarele concepte de bază:

Element matrice (valoarea elementului matrice)– o valoare stocată într-o anumită celulă de memorie situată în cadrul matricei, precum și adresa acestei celule de memorie.
Fiecare element de matrice este caracterizat de trei valori:

• adresa elementului - adresa celulei de memorie de pornire în care se află acest element;
• indicele elementului (numărul ordinal al elementului din tablou);
• valoarea elementului.

Adresă matrice – adresa elementului de pornire al matricei.

Numele matricei este un identificator folosit pentru a face referire la elementele matricei.

Mărimea matricei – numărul de elemente ale matricei

Dimensiunea elementului este numărul de octeți ocupați de un element de matrice.

Grafic, locația matricei în memoria computerului poate fi reprezentată ca o bandă continuă de adrese.

Matricea prezentată în figură conține q elemente cu indici de la 0 la q-1. Fiecare element ocupă k octeți în memoria computerului, iar aranjarea elementelor în memorie este secvențială.

Adresele elementului i al tabloului sunt

Adresa matricei este adresa elementului de pornire (zero) al matricei. Pentru a accesa elementele matricei, se folosește numărul de serie (index) al elementului, a cărui valoare inițială este 0. Deci, dacă o matrice conține q elemente, atunci indicii elementelor matricei variază de la 0 la q-1.

Lungimea matricei este numărul de octeți alocați în memorie pentru a stoca toate elementele matricei.

Lungimea matricei = Dimensiunea elementului * Numărul de elemente

Funcția poate fi utilizată pentru a determina dimensiunea unui element de matrice

int dimensiunea(tip);

De exemplu,

sizeof(char) = 1;
sizeof(int) = 4;
sizeof(float) = 4;
sizeof(double) = 8;

Declararea și inițializarea tablourilor

Pentru a declara o matrice în C, se utilizează următoarea sintaxă:

nume de tip[dimensiune]=(init);

Inițializarea este un set de valori inițiale ale elementelor matricei, specificate între acolade, separate prin virgule.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // matrice a de 10 numere întregi

Dacă numărul de valori de inițializare specificat în acolade este mai mic decât numărul de elemente ale matricei specificat în paranteze pătrate, atunci toate elementele rămase din matrice (pentru care nu au existat suficiente valori de inițializare) vor fi zero. Această proprietate este convenabilă de utilizat pentru a seta toate elementele unui tablou la valori zero.

int b = (0); // matrice b de 10 elemente, inițializată la 0

Dacă matricea este inițializată atunci când este declarată, atunci valorile inițiale constante ale elementelor sale sunt indicate separate prin virgule în acolade. În acest caz, numărul de elemente din paranteze drepte poate fi omis.

int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);

La accesarea elementelor de matrice, indexul elementului necesar este indicat între paranteze drepte.

Exemplu în C

1
2
3
4
5
6
7
8

#include
int main()
{
int a = (5, 4, 3, 2, 1); // tabloul a conține 5 elemente
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
întoarce 0;
}

Rezultatul executiei programului:

Cu toate acestea, este adesea necesar să setați valorile elementelor matricei în timpul execuției programului. Aceasta utilizează o declarație de matrice fără inițializare. În acest caz, indicarea numărului de elemente între paranteze drepte este obligatorie.

int a;

Pentru a seta valorile inițiale ale elementelor matricei, se utilizează foarte des o buclă parametrică:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include
int main()
{
int a;
int i;
// Introducerea elementelor matricei
pentru (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d" , &a[i]);
}
// Elemente de matrice de ieșire
pentru (i = 0; i<5; i++)
printf("%d ", a[i]); // este necesar spațiu în formatul de imprimare
getchar(); getchar();
întoarce 0;
}

Rezultatul executării programului

Matrice multidimensionale

Matricele multidimensionale pot fi, de asemenea, declarate în C. Diferența dintre o matrice multidimensională și una unidimensională este că într-o matrice unidimensională poziția unui element este determinată de un index, iar într-o matrice multidimensională - de mai multe. Un exemplu de matrice multidimensională este o matrice.

Forma generală de declarare a unui tablou multidimensional

nume de tip[dimensiune1][dimensiune2]...[dimensiune];

Elementele unui tablou multidimensional sunt situate în celule RAM succesive în ordinea crescătoare a adreselor. În memoria computerului, elementele unui tablou multidimensional sunt aranjate într-un rând, de exemplu o matrice cu 2 rânduri și 3 coloane,

int a;

va fi localizat în memorie după cum urmează

Numărul total de elemente din matricea bidimensională dată este determinat ca

Număr de rânduri * Număr de coloane = 2 * 3 = 6.

Numărul de octeți de memorie necesari pentru a găzdui matricea este dat de

Număr de articole * Dimensiunea articolului = 6 * 4 = 24 de octeți.

Inițializarea tablourilor multidimensionale

Valorile elementelor unui tablou multidimensional, ca și în cazul unidimensional, pot fi specificate prin valori constante atunci când sunt declarate, cuprinse între acolade (). Totuși, în acest caz, numărul de elemente din rânduri și coloane trebuie indicat între paranteze drepte.

Exemplu în C

1
2
3
4
5
6
7
8
9

#include
int main()
{
int a = (1, 2, 3, 4, 5, 6);
printf("%d %d %d\n" , a, a, a);
getchar();
întoarce 0;
}

Cu toate acestea, mai des este necesar să introduceți valorile elementelor unui tablou multidimensional în timpul execuției programului. În acest scop, este convenabil să folosiți o buclă parametrică imbricată.

Exemplu în C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
int a; // matrice de 2 rânduri și 3 coloane
int i, j;
// Introducerea elementelor matricei
pentru (i = 0; i<2; i++) // buclă prin linii
{
pentru (j = 0; j<3; j++) // buclă prin coloane
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Elemente de matrice de ieșire
pentru (i = 0; i<2; i++) // buclă prin linii
{
pentru (j = 0; j<3; j++) // buclă prin coloane
{
printf("%d ", a[i][j]);
}
printf("\n"); // linie nouă
}
getchar(); getchar();
întoarce 0;
}

Transmiterea unui tablou unei funcții

Procesarea matricei poate fi organizată convenabil folosind funcții speciale. Pentru a procesa o matrice, trebuie să treceți ca argumente funcției

• adresa matricei,
• dimensiunea matricei.

Excepție fac funcțiile de procesare a șirurilor, unde este suficient să treci doar adresa.

Când se transmit variabile ca argumente unei funcții, datele sunt transmise ca copii. Aceasta înseamnă că, dacă valoarea unui parametru se modifică în interiorul unei funcții, aceasta nu va afecta valoarea acestuia în cadrul funcției de apelare.

Dacă o adresă variabilă (sau o adresă de matrice) este transmisă unei funcții, atunci toate operațiunile efectuate în funcție asupra datelor din domeniul de aplicare al adresei specificate sunt efectuate pe datele originale, astfel încât matricea inițială (sau valoarea variabilei) poate fi modificată prin funcția numită.

Exemplu în matrice C Dan de 10 elemente. Schimbați elementele cele mai mari și inițiale ale matricei. Pentru operațiuni maxime de căutare și schimb de elemente, utilizați funcția.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#include
// Funcția de schimb
modificare nulă (int *x, int n)
{
// x - pointer către matrice (adresă matrice)
// n - dimensiunea matricei
int i;
int max, index;
max = x;
indice = 0;
// Găsirea elementului maxim
pentru (i = 1; i {
dacă (x[i]>max)
{
max = x[i];
indice = i;
}
}
// Schimb valutar
x = x;
x = max;
}
// Functie principala
int main()
{
int a;
int i;
pentru (i = 0; i<10; i++)
{
printf("a[%d] = ", i);
scanf("%d" , &a[i]);
}
schimbare (a, 10); // apelează funcția de schimb
// Elemente de matrice de ieșire
pentru (i = 0; i<10; i++)
printf("%d ", a[i]);
getchar();
getchar();
întoarcere
p = p * x[i];
}
întoarcere p;
}
// Functie principala
int main()
{
int a; // a declarat tabloul a de 5 elemente
int i;
int pr;
// Introducerea elementelor matricei
pentru (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d" , &a[i]); // &a[i] - adresa elementului i al matricei
}
pr = func(a, 5); // calculează produsul
printf("\n pr = %d" , pr); // scoate produsul elementelor pare
getchar(); getchar();
întoarce 0;
}

Vă rugăm să suspendați AdBlock pe acest site.

O matrice este cel mai simplu tip de date compus. Când am discutat despre variabile, am avut o analogie bună cu o casetă. Să revenim la asta. Dacă o variabilă este o singură casetă, atunci o matrice este mai multe casete identice numerotate care au același nume și diferă doar prin numărul lor de serie.

Fig.1 Variabile și tablouri. Analogie cu cutiile.

Imaginea de mai sus prezintă trei matrice:

• un tablou întreg de 8 elemente numit arr_int
• matrice float de 11 elemente numite arr_float
• o matrice de caractere cu 6 elemente numită arr_char

O matrice, ca o variabilă, are propriul nume și tip de date. În plus, matricea are o caracteristică suplimentară - dimensiunea matricei. Mărimea unei matrice este numărul de elemente care pot fi stocate în ea. În analogia noastră cu casete, acesta este numărul de casete.

Notă!

Numerotarea elementelor matricei începe de la zero, nu de la unu.

Declararea și inițializarea unui tablou

Declararea unui tablou este foarte asemănătoare cu declararea unei variabile. Singura diferență este că ar trebui să indicați suplimentar dimensiunea matricei între paranteze drepte. Aici sunt cateva exemple:

Listarea 1.

Int arr_int; dublu arr_float; număr flotant;

Numele matricei este supus unor restricții similare cu cele impuse numelui variabilei.

Regulă de denumire a matricei

Un nume de matrice este orice succesiune de caractere, numere și liniuța de subliniere „_” care începe cu o literă. Literele majuscule sunt importante.

Iată mai multe exemple de declarații de matrice:

Lista 2.

Note int, ordine; preturi duble;

O matrice, ca orice variabilă, i se pot atribui valori inițiale atunci când este declarată. Dacă elementelor matricei nu li se atribuie nicio valoare, atunci ele vor stoca gunoiul, la fel ca variabilele obișnuite.

Lista 3.

Int arr_int = (2, 5, 5, 3, 4); double arr_float = (1,2, -2,3, 4,5, 3,83, 0,01, -0,12, 44,2, 123,7, 23,44, -3,7, 7);

Dacă trebuie să atribuiți valori zero tuturor elementelor unui tablou, puteți face acest lucru:

Lista 4.

Arr dublu = (0);

Lucrul cu elemente de matrice individuale

Pentru a face referire la un element de matrice individual, trebuie să scrieți numele și numărul de serie ale acestuia între paranteze drepte. Nu uitați că numerotarea începe de la zero, nu de la unu.

Să afișăm, de exemplu, elementele unui tablou de cinci elemente pe ecran.

Lista 5.

#include int main(void)( int arr = (2, 4, 3, 5, 5); printf("%d %d %d %d %d\n",arr, arr, arr, arr, arr); return (0);

Desigur, dacă matricea este foarte mare, atunci scoaterea acestuia element cu element în acest fel este încă o plăcere. Și nimeni nu face asta cu matrice mici. Este mai bine și mai corect să folosiți bucle. De exemplu:

Lista 6.

#include int main(void)( int arr = (0); for(int i = 0; i< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

Programul din prima buclă salvează prima sută de numere pare într-o matrice, iar în a doua buclă le afișează pe ecran.

Înarmați cu noile noastre instrumente, să ne rescriem programul de la începutul lecției, astfel încât să folosească o matrice pentru a stoca statisticile cu numere aleatorii.

Lista 7.

#include #include #include int main(void) (srand(time(NULL)); int count = (0); int rand_number; for (int i = 0; i< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Acordați atenție tehnicii utilizate în acest program.
Elementul zero al matricei stochează numărul de apariții ale numărului 0, primul element - numărul de apariții ale numărului 1, al doilea element - numărul 2. Adică, numărul generat în sine vă permite să determinați la ce element al matricei trebuie să adăugați unul. Prin urmare, nu este nevoie de o declarație de selecție a comutatorului. Convenabil, nu-i așa?

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 matricele 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 array;. 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; }

// în acest program creăm o matrice cu dimensiunea dimensiunii, // folosiți o buclă for pentru a introduce date în toate celulele // matrice și afișează conținutul lor pe ecran #include folosind namespace std ; int main() setlocale(LC_ALL, "rus"); const int SIZE = 10 ; //declară o constantă int firstArray[SIZE]; //declară o matrice cu numărul de elemente SIZE pentru (int i = 0; i< SIZE ; i ++ ) //completați și afișați valorile pe ecran firstArray[i] = i+1; // la primul pas al buclei atribuie firstArray 1 (0 + 1) cout<< i << „-a celulă stochează numărul”<< firstArray [ i ] << endl ; cout<< endl ; returnează 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]; )

pentru (int i = 0; i< size ; i ++ ) //completați și afișați valorile pe ecran

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 o 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 din nou.
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ă este necesar să umplem întregul tablou cu zerouri, atunci scriem

Int a = (0);

Nu trebuie să setați în mod explicit dimensiunea matricei, 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);

Dar acest lucru este puțin probabil să fie util. Când treceți o matrice ca argument unei funcții, va fi transmis 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ă a memoriei (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 puțin,

• 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)

Nu există modalități complete de a verifica dacă am depășit sau nu limitele matricei. Prin urmare, fie îi cunoaștem exact dimensiunea, fie îl stocăm într-o variabilă și o citim atunci când este necesar.

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; // counters unsigned half //mijlocul matricei unsigned tmp //variabilă temporară pentru schimbul de valori jumătate = SIZE / 2 //Un numărător merge de la stânga la dreapta pentru (i = 0; j = DIMENSIUNE - 1;< 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. Printf("0.");< 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 sum = .0f; float relError do (printf("Introduceți numărul de măsurători"); scanf("%u", &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;< 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