V C++ je pole dátová štruktúra, ktorá sa používa na ukladanie viacerých hodnôt podobných dátových typov v súvislom pamäťovom mieste.

Napríklad , ak musíme uložiť známky 4 alebo 5 študentov, potom ich môžeme ľahko uložiť vytvorením 5 rôznych premenných, ale čo ak chceme uložiť známky 100 študentov alebo povedzme 500 študentov, potom je veľmi náročné vytvoriť taký počet premenných a spravovať ich. Teraz prichádzajú na scénu polia, ktoré to dokážu jednoducho vytvorením poľa požadovanej veľkosti.

Vlastnosti polí v C++

• Pole je súbor údajov rovnakého typu údajov uložených v súvislom pamäťovom mieste.
• Indexovanie poľa začína od 0. Znamená to, že prvý prvok je uložený na 0. indexe, druhý na 1. atď.
• K prvkom poľa je možné pristupovať pomocou ich indexov.
• Akonáhle je pole deklarované, jeho veľkosť zostáva konštantná počas celého programu.
• Pole môže mať viacero rozmerov.
• Veľkosť poľa v bajtoch môže byť určená operátorom sizeof, pomocou ktorého môžeme zistiť aj počet prvkov v poli.
• Veľkosť typu prvkov uložených v poli môžeme zistiť odčítaním susedných adries.

Deklarácia poľa v C++

V C++ môžeme pole deklarovať tak, že najprv zadáme typ údajov a potom názov poľa s jeho veľkosťou.

data_type array_name[Size_of_array];>

Príklad

int arr[5];>

Tu,

• int: Je to typ údajov, ktoré sa majú uložiť do poľa. Môžeme použiť aj iné dátové typy ako char, float a double.
• arr: Je to názov poľa.
• 5: Je to veľkosť poľa, čo znamená, že do poľa je možné uložiť iba 5 prvkov.

Inicializácia Array v C++

V C++ môžeme pole inicializovať mnohými spôsobmi, ale budeme diskutovať o niektorých najbežnejších spôsoboch inicializácie poľa. Pole môžeme inicializovať v čase deklarácie alebo po deklarácii.

1. Inicializujte pole s hodnotami v C++

Inicializovali sme pole s hodnotami. Hodnoty uzavreté v zložených zátvorkách „{}“ sú priradené k poľu. Tu je 1 uložená v arr[0], 2 v arr[1] atď. Tu je veľkosť poľa 5.

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

2. Inicializujte pole s hodnotami a bez veľkosti v C++

Inicializovali sme pole s hodnotami, ale nedeklarovali sme dĺžku poľa, preto sa dĺžka poľa rovná počtu prvkov vo zložených zátvorkách.

rad objektov java

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

3. Inicializujte pole po deklarácii (pomocou slučiek)

Po deklarovaní poľa sme inicializovali pole pomocou cyklu. Táto metóda sa vo všeobecnosti používa, keď chceme získať vstup od používateľa alebo keď nemôžeme priradiť prvky jeden po druhom ku každému indexu poľa. Môžeme upraviť podmienky cyklu alebo zmeniť inicializačné hodnoty podľa požiadaviek.

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

4. Inicializujte pole čiastočne v C++

Tu sme deklarovali pole „partialArray“ s veľkosťou „5“ a iba s hodnotami „1“ a „2“. Takže tieto hodnoty sú uložené pri prvých dvoch indexoch a pri zvyšku indexov je uložená „0“.

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

5. Inicializujte pole s nulou v C++

Pole môžeme inicializovať so všetkými prvkami ako „0“ zadaním „0“ v zložených zátvorkách. Toto sa stane v prípade nuly iba vtedy, ak sa pokúsime inicializovať pole s inou hodnotou, povedzme „2“ pomocou tejto metódy, potom sa „2“ uloží iba na 0. index.

int zero_array[5] = {0};>

Prístup k prvku poľa v C++

K prvkom poľa možno pristupovať zadaním názvu poľa a potom indexu prvku uzavretého v dolnom indexe poľa []. Napríklad arr[i].

Príklad 1: Program C++ na ilustráciu prístupu k prvkom poľa

// 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>

Aktualizovať prvok poľa

Na aktualizáciu prvku v poli môžeme použiť index, ktorý chceme aktualizovať, uzavretý v rámci operátora dolného indexu poľa a priradiť mu novú hodnotu.

arr[i] = new_value;>

Prechádzať poľom v C++

Cez pole môžeme prechádzať pomocou slučky pomocou indexovania v C++. Najprv sme inicializovali pole „table_of_two“ s násobkom 2. Potom spustíme cyklus for od 0 do 9, pretože indexovanie v poli začína od nuly. Preto pomocou indexov vytlačíme všetky hodnoty uložené v poli.

Príklad 2: Program C++ na ilustráciu prechodu poľa

// 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>

Veľkosť poľa v C++

V C++ nemáme funkciu dĺžky ako v Jave na zistenie veľkosti poľa, ale môžeme vypočítať veľkosť poľa pomocou operátora sizeof(). trik. Najprv zistíme veľkosť, ktorú zaberá celé pole v pamäti a potom ju vydelíme veľkosťou typu prvku uloženého v poli. To nám dá počet prvkov uložených v poli.

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

Príklad 3: Program C++ na ilustráciu toho, ako nájsť veľkosť poľa

// 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>

Vzťah medzi poliami a ukazovateľmi v C++

V C++ sú polia a ukazovatele navzájom úzko prepojené. S názvom poľa sa zaobchádza ako s ukazovateľom, ktorý uložil pamäťovú adresu prvého prvku poľa. Ako sme už diskutovali, prvky poľa sú uložené v súvislých pamäťových miestach, a preto môžeme pristupovať ku všetkým prvkom poľa pomocou názvu poľa.

Príklad 4: Znázornenie vzťahu medzi poľom a ukazovateľmi

// 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>

Vysvetlenie:

Vo vyššie uvedenom kóde najprv definujeme pole arr a potom vyhlásiť ukazovateľ ptr a priraďte mu pole arr. Sme schopní priradiť arr k ptr, pretože arr je tiež ukazovateľ. Potom vytlačíme adresu pamäte arr pomocou referenčného operátora ( & ) a tiež vytlačte adresu uloženú v ukazovateli ptr a vidíme arr a ptr, oba ukladajú rovnakú adresu pamäte.

Príklad 5: Tlač prvkov poľa bez indexovania v C++

Vo všeobecnosti pristupujeme k prvkom poľa a tlačíme ich pomocou indexovania. Napríklad na prístup k prvému prvku, ktorý používame názov_poľa[0]. Vyššie sme diskutovali o tom, že názov poľa je ukazovateľ, ktorý ukladá adresu prvého prvku a prvky poľa sú uložené na susediacich miestach. Teraz budeme pristupovať k prvkom poľa iba pomocou názvu poľa.

// 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>

Vysvetlenie

Vo vyššie uvedenom kóde sme najprv deklarovali pole arr so štyrmi prvkami. Potom vytlačíme prvky poľa. Poďme diskutovať o tom, ako to robíme. Diskutovali sme o tom, že názov poľa je ukazovateľ, ktorý ukladá adresu prvého prvku poľa, takže na vytlačenie prvého prvku sme tento ukazovateľ dereferencovali (*arr) pomocou operátora dereferencovania (*) ktorý vytlačí údaje uložené na danej adrese.

Aby sme vytlačili druhý prvok poľa, najprv pridáme 1 do arr čo je ekvivalentné (adresa arr + veľkosť_jedného_prvku *1), ktorá prenesie ukazovateľ na adresu hneď za prvým a potom tento ukazovateľ dereferencujeme, aby sa vytlačil druhý prvok. Podobne vytlačíme zvyšok prvkov poľa bez použitia indexovania.

Odovzdanie poľa do funkcie v C++

Aby sme polia používali efektívne, mali by sme vedieť, ako odovzdať polia, aby fungovali. Polia môžeme odovzdať funkciám ako argument rovnako ako premenné funkciám, ale vieme, že s názvom poľa sa zaobchádza ako s ukazovateľom pomocou tohto konceptu, pole môžeme odovzdať funkciám ako argument a potom pristupovať ku všetkým prvkom tohto poľa pomocou ukazovateľ.

Takže nakoniec, polia sa vždy odovzdávajú ako ukazovatele na funkciu. Pozrime sa na 3 spôsoby, ako odovzdať pole funkcii, ktoré sa väčšinou používajú.

1. Odovzdanie poľa ako ukazovateľa

V tejto metóde jednoducho odovzdáme názov poľa vo volaní funkcie, čo znamená, že adresu odošleme prvému prvku poľa. V tejto metóde môžeme modifikovať prvky poľa v rámci funkcie.

Syntax

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

2. Odovzdávanie poľa ako poľa bez veľkosti

V tejto metóde funkcia akceptuje pole pomocou jednoduchej deklarácie poľa bez veľkosti ako argumentu.

Syntax

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

3. Odovzdávanie poľa ako veľkostného poľa

V tejto metóde funkcia akceptuje pole pomocou jednoduchej deklarácie poľa s veľkosťou ako argumentom. Túto metódu používame pri určovaní veľkosti poľa len na označenie veľkosti poľa.

Syntax

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

Poznámka: Pole sa bude považovať za ukazovateľ v odovzdanej funkcii bez ohľadu na to, akú metódu použijeme. Keď pole prejdú ako ukazovatele, stratia informácie o jeho veľkosti, čo vedie k javu pomenovanému ako Array Decay.

Príklad: Ilustrovanie rôznych spôsobov odovzdávania polí do funkcie

#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>

Viacrozmerné polia v C++

Polia deklarované s viac ako jednou dimenziou sa nazývajú viacrozmerné polia. Najpoužívanejšie viacrozmerné polia sú 2D polia a 3D polia. Tieto polia sú vo všeobecnosti reprezentované vo forme riadkov a stĺpcov.

Deklarácia multidimenzionálneho poľa

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

kde,

• Dátový typ: Typ údajov, ktoré sa majú uložiť do poľa.
• Názov poľa: Názov poľa.
• Veľkosť 1, veľkosť 2,…, veľkosť N: Veľkosť každého rozmeru.

Dvojrozmerné pole v C++

V C++ je dvojrozmerné pole zoskupením prvkov usporiadaných do riadkov a stĺpcov. Ku každému prvku sa pristupuje pomocou dvoch indexov: jeden pre riadok a jeden pre stĺpec, čo uľahčuje vizualizáciu ako tabuľku alebo mriežku.

Syntax 2D poľa

data_Type array_name[n][m];>

Kde,

• n: Počet riadkov.
• m: Počet stĺpcov.
  

Príklad: Program C++ na ilustráciu dvojrozmerného poľa

// 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>

Vysvetlenie

Vo vyššie uvedenom kóde sme deklarovali 2D pole so 4 riadkami a 4 stĺpcami, potom sme pole inicializovali s hodnotou (i+j) v každej iterácii cyklu. Potom vytlačíme 2D pole pomocou vnorenej slučky a na výstupe nižšie vidíme, že existujú 4 riadky a 4 stĺpce.

Trojrozmerné pole v C++

3D pole používa tri rozmery. Na jeho znázornenie možno použiť kolekciu rôznych dvojrozmerných polí nahromadených na sebe. Tri indexy – index riadku, index stĺpca a index hĺbky sa používajú na jedinečnú identifikáciu každého prvku v 3D poli.

Deklarácia trojrozmerného poľa v C++

Aby sme deklarovali 3D pole v C++, musíme zadať jeho tretí rozmer spolu s 2D rozmermi.

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

Kde,

• Dátový typ: Typ údajov, ktoré sa majú uložiť v každom prvku.
• Názov poľa: Názov poľa
• D: Počet 2D polí alebo Hĺbka poľa.
• R: Počet riadkov v každom 2D poli.
• C: Počet stĺpcov v každom 2D poli.

Príklad

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

Príklad: Program C++ na ilustráciu 3D poľa

// 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>

Vysvetlenie

Vo vyššie uvedenom kóde sme deklarovali 3D pole a potom sme ho inicializovali pomocou troch vnorených slučiek for. Potom sme znova vytlačili všetky vrstvy 3D poľa pomocou troch vnorených slučiek for, ako je vidieť na výstupe.

Súvisiace články

• Viacrozmerné polia v C++
• Vlastnosti poľa
• Array Decay