C++ valodā masīvs ir datu struktūra, ko izmanto, lai saglabātu vairākas līdzīgu datu tipu vērtības blakus esošā atmiņas vietā.

Piemēram , ja mums ir jāsaglabā 4 vai 5 skolēnu atzīmes, mēs varam tās viegli saglabāt, izveidojot 5 dažādus mainīgos, bet ja mēs vēlamies saglabāt 100 skolēnu vai teiksim 500 skolēnu atzīmes, tad ir ļoti grūti izveidot šādu mainīgo skaitu. un pārvaldīt tos. Tagad attēlā parādās masīvi, kas to var viegli izdarīt, vienkārši izveidojot vajadzīgā izmēra masīvu.

Masīvu īpašības programmā C++

• Masīvs ir tāda paša veida datu kopums, kas glabājas blakus esošā atmiņas vietā.
• Masīva indeksēšana sākas no 0. Tas nozīmē, ka pirmais elements tiek saglabāts 0. indeksā, otrais 1. un tā tālāk.
• Masīva elementiem var piekļūt, izmantojot to indeksus.
• Kad masīvs ir deklarēts, tā lielums paliek nemainīgs visā programmā.
• Masīvam var būt vairākas dimensijas.
• Masīva lielumu baitos var noteikt pēc operatora lieluma, ar kuru mēs varam atrast arī elementu skaitu masīvā.
• Masīvā saglabāto elementu veidu lielumu varam atrast, atņemot blakus esošās adreses.

Masīva deklarācija C++ valodā

Programmā C++ mēs varam deklarēt masīvu, vispirms vienkārši norādot datu tipu un pēc tam masīva nosaukumu ar tā lielumu.

data_type array_name[Size_of_array];>

Piemērs

int arr[5];>

Šeit,

• int: Tas ir datu veids, kas jāsaglabā masīvā. Mēs varam izmantot arī citus datu tipus, piemēram, char, float un double.
• arr: Tas ir masīva nosaukums.
• 5: Tas ir masīva lielums, kas nozīmē, ka masīvā var saglabāt tikai 5 elementus.

Masīva inicializācija programmā C++

Programmā C++ mēs varam inicializēt masīvu daudzos veidos, taču mēs apspriedīsim dažus visizplatītākos masīva inicializācijas veidus. Mēs varam inicializēt masīvu deklarēšanas laikā vai pēc deklarēšanas.

1. Inicializējiet masīvu ar vērtībām C++ valodā

Mēs esam inicializējuši masīvu ar vērtībām. Vērtības, kas ietvertas krokainajās iekavās “{}”, tiek piešķirtas masīvam. Šeit 1 tiek saglabāts arr[0], 2 arr[1] un tā tālāk. Šeit masīva lielums ir 5.

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

2. Inicializējiet masīvu ar vērtībām un bez izmēra C++

Mēs esam inicializējuši masīvu ar vērtībām, bet neesam deklarējuši masīva garumu, tāpēc masīva garums ir vienāds ar elementu skaitu krokainajās iekavās.

math pow java

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

3. Inicializējiet masīvu pēc deklarēšanas (izmantojot cilpas)

Mēs esam inicializējuši masīvu, izmantojot cilpu pēc masīva deklarēšanas. Šo metodi parasti izmanto, ja mēs vēlamies saņemt ievadi no lietotāja vai mēs nevaram katram masīva indeksam piešķirt elementus pa vienam. Mēs varam modificēt cilpas nosacījumus vai mainīt inicializācijas vērtības atbilstoši prasībām.

for (int i = 0; i   arr[i] = value; }>

4. Daļēji inicializējiet masīvu C++

Šeit mēs esam deklarējuši masīvu “partialArray” ar izmēru “5” un tikai ar vērtībām “1” un “2”. Tātad šīs vērtības tiek saglabātas pie pirmajiem diviem indeksiem, bet pārējos indeksos tiek saglabāts “0”.

int partialArray[5] = {1, 2};>

5. Inicializējiet masīvu ar nulli C++ valodā

Mēs varam inicializēt masīvu ar visiem elementiem kā “0”, cirtainajās iekavās norādot “0”. Tas notiks nulles gadījumā tikai tad, ja mēģināsim inicializēt masīvu ar citu vērtību, piemēram, “2”, izmantojot šo metodi, tad “2” tiek saglabāts tikai 0. indeksā.

int zero_array[5] = {0};>

Piekļuve masīva elementam programmā C++

Masīva elementiem var piekļūt, norādot masīva nosaukumu, pēc tam elementa indeksu, kas ietverts masīva apakšindeksa operatorā []. Piemēram, arr[i].

1. piemērs: C++ programma, lai ilustrētu, kā piekļūt masīva elementiem

// C++ Program to Illustrate How to Access Array Elements #include  using namespace std; int main() {  int arr[3];  // Inserting elements in an array  arr[0] = 10;  arr[1] = 20;  arr[2] = 30;  // Accessing and printing elements of the array  cout << 'arr[0]: ' << arr[0] << endl;  cout << 'arr[1]: ' << arr[1] << endl;  cout << 'arr[2]: ' << arr[2] << endl;  return 0; }>

arr[0]: 10 arr[1]: 20 arr[2]: 30>

Atjauniniet masīva elementu

Lai atjauninātu masīva elementu, mēs varam izmantot indeksu, kuru vēlamies atjaunināt, kas ietverts masīva apakšindeksa operatorā, un piešķirt jaunu vērtību.

arr[i] = new_value;>

Pārvietojiet masīvu programmā C++

Mēs varam šķērsot masīvu ar cilpas palīdzību izmantojot indeksēšanu programmā C++. Pirmkārt, mēs esam inicializējuši masīvu “table_of_two” ar reizinājumu ar 2. Pēc tam mēs palaižam for cilpu no 0 līdz 9, jo masīvā indeksēšana sākas no nulles. Tāpēc, izmantojot indeksus, mēs izdrukājam visas masīvā saglabātās vērtības.

2. piemērs: C++ programma, kas ilustrē, kā šķērsot masīvu

// C++ Program to Illustrate How to Traverse an Array #include  using namespace std; int main() {  // Initialize the array  int table_of_two[10]  = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };  // Traverse the array using for loop  for (int i = 0; i < 10; i++) {  // Print the array elements using indexing  cout << table_of_two[i] << ' ';  }  return 0; }>

2 4 6 8 10 12 14 16 18 20>

Masīva lielums programmā C++

Programmā C++ mums nav garuma funkcijas kā Java, lai atrastu masīva lielumu, bet mēs varam aprēķināt masīva lielumu, izmantojot operatoru sizeof(). triks. Pirmkārt, mēs atrodam atmiņā visa masīva aizņemto izmēru un pēc tam sadalām to ar masīvā saglabātā elementa veida lielumu. Tas mums iegūs masīvā saglabāto elementu skaitu.

data_type size = sizeof(Array_name) / sizeof(Array_name[index]);>

3. piemērs: C++ programma, kas ilustrē, kā atrast masīva lielumu

// C++ Program to Illustrate How to Find the Size of an // Array #include  using namespace std; int main() {  int arr[] = { 1, 2, 3, 4, 5 };  // Size of one element of an array  cout << 'Size of arr[0]: ' << sizeof(arr[0]) << endl;  // Size of array 'arr'  cout << 'Size of arr: ' << sizeof(arr) << endl;  // Length of an array  int n = sizeof(arr) / sizeof(arr[0]);  cout << 'Length of an array: ' << n << endl;  return 0; }>

Size of arr[0]: 4 Size of arr: 20 Length of an array: 5>

Attiecības starp masīviem un rādītājiem programmā C++

Programmā C++ masīvi un norādes ir cieši saistīti viens ar otru. Masīva nosaukums tiek uzskatīts par rādītāju, kas saglabāja masīva pirmā elementa atmiņas adresi. Kā jau minēts iepriekš, masīva elementi tiek glabāti blakus esošās atmiņas vietās, tāpēc mēs varam piekļūt visiem masīva elementiem, izmantojot masīva nosaukumu.

4. piemērs: masīva un rādītāju attiecību ilustrēšana

// C++ Program to Illustrate that Array Name is a Pointer // that Points to First Element of the Array #include  using namespace std; int main() {  // Defining an array  int arr[] = { 1, 2, 3, 4 };  // Define a pointer  int* ptr = arr;  // Printing address of the arrary using array name  cout << 'Memory address of arr: ' << &arr << endl;  // Printing address of the array using ptr  cout << 'Memory address of arr: ' << ptr << endl;  return 0; }>

Memory address of arr: 0x7fff2f2cabb0 Memory address of arr: 0x7fff2f2cabb0>

Paskaidrojums:

Iepriekš minētajā kodā mēs vispirms definējam masīvu arr un pēc tam paziņojiet rādītāju ptr un piešķiriet tam masīvu arr. Mēs varam piešķirt arr ptr, jo arr ir arī rādītājs. Pēc tam mēs izdrukājam atmiņas adresi arr izmantojot atsauces operatoru ( & ) un arī izdrukājiet rādītājā saglabāto adresi ptr un mēs varam redzēt arr un ptr, abi saglabā vienu un to pašu atmiņas adresi.

5. piemērs: masīva elementu drukāšana bez indeksēšanas programmā C++

Mēs parasti piekļūstam masīva elementiem un tos izdrukājam, izmantojot indeksēšanu. Piemēram, lai piekļūtu pirmajam izmantotajam elementam masīva_nosaukums[0]. Iepriekš mēs apspriedām, ka masīva nosaukums ir rādītājs, kas saglabā pirmā elementa adresi, un masīva elementi tiek glabāti blakus esošās vietās. Tagad mēs piekļūsim masīva elementiem, izmantojot tikai masīva nosaukumu.

// C++ Program to Print Array Elements without Indexing #include  using namespace std; int main() {  // Define an array  int arr[] = { 11, 22, 33, 44 };  // Print elements of an array  cout << 'first element: ' << *arr << endl;  cout << 'Second element: ' << *(arr + 1) << endl;  cout << 'Third element: ' << *(arr + 2) << endl;  cout << 'fourth element: ' << *(arr + 3) << endl;  return 0; }>

first element: 11 Second element: 22 Third element: 33 fourth element: 44>

Paskaidrojums

Iepriekš minētajā kodā mēs vispirms deklarējām masīvu arr ar četriem elementiem. Pēc tam mēs drukājam masīva elementus. Apspriedīsim, kā mēs to darām. Mēs apspriedām, ka masīva nosaukums ir rādītājs, kas saglabā masīva pirmā elementa adresi, tāpēc, lai izdrukātu pirmo elementu, uz kuru mēs atsaucām. (*arr) izmantojot atsauces atcelšanas operatoru (*) kas izdrukā šajā adresē saglabātos datus.

Lai izdrukātu otro masīva elementu, mēs vispirms pievienojam 1 uz arr kas ir līdzvērtīgs (adrese arr + size_of_one_element *1), kas novirza rādītāju uz adresi tieši pēc pirmās, un pēc tam mēs atceļam šo rādītāju, lai drukātu otro elementu. Līdzīgi mēs izdrukājam pārējos masīva elementus, neizmantojot indeksēšanu.

Masīva nodošana funkcijai programmā C++

Lai efektīvi izmantotu masīvus, mums jāzina, kā nodot masīvus funkcionēšanai. Mēs varam nodot masīvus funkcijām kā argumentu tāpat kā mainīgos nododam funkcijām, taču mēs zinām, ka masīva nosaukums tiek uzskatīts par rādītāju, izmantojot šo koncepciju, mēs varam nodot masīvu funkcijām kā argumentu un pēc tam piekļūt visiem šī masīva elementiem, izmantojot rādītājs.

Tātad galu galā, masīvi vienmēr tiek nodoti kā norādes uz funkciju. Apskatīsim 3 veidus, kā nodot masīvu funkcijai, kas tiek izmantota galvenokārt.

1. Masīva nodošana kā rādītājs

Izmantojot šo metodi, mēs vienkārši nododam masīva nosaukumu funkcijas izsaukumā, kas nozīmē, ka mēs nododam adresi pirmajam masīva elementam. Izmantojot šo metodi, mēs varam modificēt funkcijas masīva elementus.

Sintakse

return_type   function_name   (   data_type *array_name   ) {     // set of statements  }>

2. Masīva kā bezizmēra masīva nodošana

Izmantojot šo metodi, funkcija pieņem masīvu, kā argumentu izmantojot vienkāršu masīva deklarāciju bez lieluma.

Sintakse

return_type   function_name    ( data_type array_name[]   ) {    // set of statements  }>

3. Masīva kā lieluma masīva nodošana

Šajā metodē funkcija pieņem masīvu, izmantojot vienkāršu masīva deklarāciju ar lielumu kā argumentu. Mēs izmantojam šo metodi, nosakot masīva izmērus, lai norādītu masīva lielumu.

Sintakse

return_type function_name(data_type array_name[size_of_array]){  // set of statements }>

Piezīme: Masīvs tiks apstrādāts kā rādītājs nodotajā funkcijā neatkarīgi no tā, kādu metodi mēs izmantojam. Kad masīvs tiek nodots kā norādes, tie zaudēs informāciju par tā lielumu, kā rezultātā parādīsies kā Masīva sabrukšana.

Piemērs: dažādu veidu ilustrācija, kā masīvus nodot funkcijai

#include  using namespace std; // passing array as a sized array argument void printArraySized(int arr[3], int n) {  cout << 'Array as Sized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << arr[i] << ' ';  }  cout << endl; } // passing array as an unsized array argument void printArrayUnsized(int arr[], int n) {  cout << 'Array as Unsized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << *(arr + i) << ' ';  }  cout << endl; } // Passing array as a pointer argument void printArrayPointer(int* ptr, int n) {  // Print array elements using pointer ptr  // that store the address of array passed  cout << 'Array as Pointer Argument: ';  for (int i = 0; i < n; i++) {  cout << ptr[i] << ' ';  } } // driver code int main() {  int arr[] = { 10, 20, 30 };  // Call function printArray and pass  // array and its size to it.  printArraySized(arr, 3);  printArrayUnsized(arr, 3);  printArrayPointer(arr, 3);  return 0; }>

Array as Sized Array Argument: 10 20 30 Array as Unsized Array Argument: 10 20 30 Array as Pointer Argument: 10 20 30>

Daudzdimensiju masīvi C++ valodā

Masīvus, kas deklarēti ar vairāk nekā vienu dimensiju, sauc par daudzdimensiju masīviem. Visplašāk izmantotie daudzdimensiju masīvi ir 2D masīvi un 3D masīvi. Šie masīvi parasti tiek attēloti rindu un kolonnu veidā.

Daudzdimensiju masīva deklarācija

Data_Type Array_Name[Size1][Size2]...[SizeN];>

kur,

• Datu tips: Masīvā glabājamo datu veids.
• Array_Name: Masīva nosaukums.
• Izmērs1, Izmērs2,…, IzmērsN: Katras dimensijas izmērs.

Divdimensiju masīvs C++ valodā

C++ valodā divdimensiju masīvs ir elementu grupējums, kas sakārtots rindās un kolonnās. Katram elementam var piekļūt, izmantojot divus indeksus: vienu rindai un vienu kolonnai, kas ļauj to viegli vizualizēt kā tabulu vai režģi.

2D masīva sintakse

data_Type array_name[n][m];>

kur,

• n: Rindu skaits.
• m: Kolonnu skaits.
  

Piemērs: C++ programma divdimensiju masīva ilustrēšanai

// c++ program to illustrate the two dimensional array #include  using namespace std; int main() {  // Declaring 2D array  int arr[4][4];  // Initialize 2D array using loop  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  arr[i][j] = i + j;  }  }  // Printing the element of 2D array  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  cout << arr[i][j] << ' ';  }  cout << endl;  }  return 0; }>

0 1 2 3 1 2 3 4 2 3 4 5 3 4 5 6>

Paskaidrojums

Iepriekš minētajā kodā mēs esam deklarējuši 2D masīvu ar 4 rindām un 4 kolonnām, pēc tam mēs inicializējām masīvu ar vērtību (i+j) katrā cilpas iterācijā. Pēc tam mēs izdrukājam 2D ​​masīvu, izmantojot ligzdotu cilpu, un tālāk redzamajā izvadā redzam, ka tajā ir 4 rindas un 4 kolonnas.

Trīsdimensiju masīvs C++ valodā

3D masīvs izmanto trīs dimensijas. To attēlošanai var izmantot dažādu divdimensiju masīvu kolekciju, kas sakrautas viena virs otras. Trīs indeksi — rindas indekss, kolonnas indekss un dziļuma indekss tiek izmantoti, lai unikāli identificētu katru 3D masīva elementu.

Trīsdimensiju masīva deklarācija C++ valodā

Lai deklarētu 3D masīvu programmā C++, mums ir jānorāda tā trešā dimensija kopā ar 2D izmēriem.

Data_Type Array_Name[D][R][C];>

kur,

• Datu tips: Katrā elementā glabājamo datu veids.
• Array_Name: Masīva nosaukums
• D: 2D masīvu skaits vai masīva dziļums.
• R: Rindu skaits katrā 2D masīvā.
• C: Kolonnu skaits katrā 2D masīvā.

Piemērs

int array[3][3][3];>

Piemērs: C++ programma 3D masīva ilustrēšanai

// C++ program to illustrate the 3d array #include  using namespace std; int main() {  // declaring 3d array  int arr[3][3][3];  // initializing the array  for (int i = 0; i < 3; i++) {  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  arr[i][j][k] = i + j + k;  }  }  }  // printing the array  for (int i = 0; i < 3; i++) {  cout << i << 'st layer:' << endl;  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  cout << arr[i][j][k] << ' ';  }  cout << endl;  }  cout << endl;  }  return 0; }>

0st layer: 0 1 2 1 2 3 2 3 4 1st layer: 1 2 3 2 3 4 3 4 5 2st layer: 2 3 4 3 4 5 4 5 6>

Paskaidrojums

Iepriekš minētajā kodā esam deklarējuši 3D masīvu un pēc tam to inicializējuši, izmantojot trīs ligzdotas cilpas. Pēc tam mēs vēlreiz izdrukājām visus 3D masīva slāņus, izmantojot trīs ligzdotas cilpas, kā redzams izvadē.

Saistītie raksti

• Daudzdimensiju masīvi C++ valodā
• Masīva īpašības
• Masīva sabrukšana