V C++ je pole datová struktura, která se používá k ukládání více hodnot podobných datových typů v souvislém paměťovém místě.

Například , pokud musíme uložit známky 4 nebo 5 studentů, pak je můžeme snadno uložit vytvořením 5 různých proměnných, ale co když chceme uložit známky 100 studentů nebo řekněme 500 studentů, pak je velmi náročné vytvořit takový počet proměnných a spravovat je. Nyní přicházejí na scénu pole, která to dokážou snadno vytvořit pouhým vytvořením pole požadované velikosti.

Vlastnosti polí v C++

• Pole je sbírka dat stejného typu dat uložená v souvislém paměťovém místě.
• Indexování pole začíná od 0. Znamená to, že první prvek je uložen na 0. indexu, druhý na 1. a tak dále.
• K prvkům pole lze přistupovat pomocí jejich indexů.
• Jakmile je pole deklarováno, jeho velikost zůstává v celém programu konstantní.
• Pole může mít více rozměrů.
• Velikost pole v bajtech může být určena operátorem sizeof, pomocí kterého můžeme také zjistit počet prvků v poli.
• Velikost typu prvků uložených v poli můžeme zjistit odečtením sousedních adres.

Deklarace pole v C++

V C++ můžeme deklarovat pole jednoduchým zadáním nejprve datového typu a poté názvu pole s jeho velikostí.

data_type array_name[Size_of_array];>

Příklad

int arr[5];>

Tady,

• int: Je to typ dat, která mají být uložena v poli. Můžeme také použít jiné datové typy, jako je char, float a double.
• arr: Je to název pole.
• 5: Je to velikost pole, což znamená, že do pole lze uložit pouze 5 prvků.

Inicializace Array v C++

V C++ můžeme pole inicializovat mnoha způsoby, ale probereme některé nejběžnější způsoby inicializace pole. Pole můžeme inicializovat v době deklarace nebo po deklaraci.

1. Inicializujte pole s hodnotami v C++

Inicializovali jsme pole s hodnotami. Hodnoty uzavřené ve složených závorkách ‚{}‘ jsou přiřazeny k poli. Zde je 1 uložena v arr[0], 2 v arr[1] a tak dále. Zde je velikost pole 5.

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

2. Inicializujte pole s hodnotami a bez velikosti v C++

Pole jsme inicializovali hodnotami, ale nedeklarovali jsme délku pole, proto je délka pole rovna počtu prvků ve složených závorkách.

java double to string

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

3. Inicializujte pole po deklaraci (pomocí smyček)

Po deklaraci pole jsme inicializovali pole pomocí smyčky. Tato metoda se obecně používá, když chceme převzít vstup od uživatele nebo nemůžeme přiřadit prvky jeden po druhém ke každému indexu pole. Můžeme upravit podmínky smyčky nebo změnit inicializační hodnoty podle požadavků.

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

4. Inicializujte pole částečně v C++

Zde jsme deklarovali pole „partialArray“ s velikostí „5“ a pouze s hodnotami „1“ a „2“. Tyto hodnoty jsou tedy uloženy u prvních dvou indexů a u zbývajících indexů je uložena „0“.

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

5. Inicializujte pole s nulou v C++

Pole se všemi prvky můžeme inicializovat jako ‚0‘ zadáním ‚0‘ uvnitř složených závorek. To se stane v případě nuly pouze tehdy, pokud se pokusíme inicializovat pole s jinou hodnotou, řekněme „2“ pomocí této metody, pak se „2“ uloží pouze na 0. index.

int zero_array[5] = {0};>

Přístup k prvku pole v C++

K prvkům pole lze přistupovat zadáním názvu pole a poté indexu prvku uzavřeného v operátoru dolního indexu pole []. Například arr[i].

Příklad 1: Program C++ pro ilustraci přístupu k prvkům pole

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

Aktualizovat prvek pole

K aktualizaci prvku v poli můžeme použít index, který chceme aktualizovat, uzavřený v operátoru dolního indexu pole a přiřadit mu novou hodnotu.

arr[i] = new_value;>

Procházet pole v C++

Přes pole můžeme procházet pomocí smyčky pomocí indexování v C++. Nejprve jsme inicializovali pole ‚table_of_two‘ s násobkem 2. Poté spustíme cyklus for od 0 do 9, protože indexování v poli začíná od nuly. Proto pomocí indexů vytiskneme všechny hodnoty uložené v poli.

Příklad 2: Program C++ pro ilustraci, jak procházet pole

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

Velikost pole v C++

V C++ nemáme funkci délky jako v Javě pro zjištění velikosti pole, ale můžeme vypočítat velikost pole pomocí operátoru sizeof(). trik. Nejprve zjistíme velikost obsazenou celým polem v paměti a poté ji vydělíme velikostí typu prvku uloženého v poli. To nám dá počet prvků uložených v poli.

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

Příklad 3: Program C++ pro ilustraci, jak zjistit velikost pole

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

Vztah mezi poli a ukazateli v C++

V C++ spolu pole a ukazatele úzce souvisejí. Název pole je považován za ukazatel, který uložil adresu paměti prvního prvku pole. Jak jsme diskutovali dříve, prvky pole In jsou uloženy na souvislých paměťových místech, proto můžeme přistupovat ke všem prvkům pole pomocí názvu pole.

Příklad 4: Znázornění vztahu mezi polem a ukazateli

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

Vysvětlení:

Ve výše uvedeném kódu nejprve definujeme pole arr a poté deklarujte ukazatel ptr a přiřaďte mu pole arr. Jsme schopni přiřadit arr k ptr, protože arr je také ukazatel. Poté vytiskneme adresu paměti arr pomocí referenčního operátoru ( & ) a také vytisknout adresu uloženou v ukazateli ptr a můžeme vidět arr a ptr, oba ukládají stejnou adresu paměti.

Příklad 5: Tisk prvků pole bez indexování v C++

K prvkům pole obecně přistupujeme a tiskneme je pomocí indexování. Například pro přístup k prvnímu prvku, který používáme název_pole[0]. Výše jsme diskutovali o tom, že název pole je ukazatel, který uložil adresu prvního prvku a prvky pole jsou uloženy na souvislých místech. Nyní budeme přistupovat k prvkům pole pouze pomocí názvu pole.

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

Vysvětlení

Ve výše uvedeném kódu jsme nejprve deklarovali pole arr se čtyřmi prvky. Poté vytiskneme prvky pole. Pojďme diskutovat o tom, jak to děláme. Diskutovali jsme o tom, že název pole je ukazatel, který ukládá adresu prvního prvku pole, takže pro tisk prvního prvku jsme tento ukazatel dereferencovali. (*arr) pomocí dereferencovacího operátoru (*) která vytiskne data uložená na dané adrese.

Chcete-li vytisknout druhý prvek pole, nejprve přidáme 1 na arr což je ekvivalentní (adresa arr + velikost_jednoho_prvku *1), která přenese ukazatel na adresu hned za prvním a poté tento ukazatel dereferencujeme, abychom vytiskli druhý prvek. Podobně vytiskneme zbytek prvků pole bez použití indexování.

Předání pole do funkce v C++

Abychom pole efektivně využívali, měli bychom vědět, jak pole předat funkci. Pole můžeme předávat funkcím jako argument stejně jako předáváme proměnné funkcím, ale víme, že s názvem pole se zachází jako s ukazatelem pomocí tohoto konceptu, můžeme pole předat funkcím jako argument a pak přistupovat ke všem prvkům tohoto pole pomocí ukazatel.

tak nakonec, pole jsou vždy předávána jako ukazatele na funkci. Podívejme se na 3 způsoby, jak předat pole funkci, které se většinou používají.

1. Předání pole jako ukazatele

V této metodě jednoduše předáme název pole ve volání funkce, což znamená, že předáme adresu prvnímu prvku pole. V této metodě můžeme upravit prvky pole ve funkci.

Syntax

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

2. Předávání pole jako pole bez velikosti

V této metodě funkce přijímá pole pomocí jednoduché deklarace pole bez velikosti jako argumentu.

Syntax

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

3. Předávání pole jako pole velikosti

V této metodě funkce přijímá pole pomocí jednoduché deklarace pole s velikostí jako argumentem. Tuto metodu používáme při nastavování velikosti pole pouze k označení velikosti pole.

Syntax

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

Poznámka: S polem bude zacházeno jako s ukazatelem v předané funkci bez ohledu na to, jakou metodu použijeme. Když jsou pole předávána jako ukazatele, ztratí informace o své velikosti, což vede k jevu nazvanému jako Array Decay.

Příklad: Znázornění různých způsobů předání polí do funkce

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

Vícerozměrná pole v C++

Pole deklarovaná s více než jednou dimenzí se nazývají vícerozměrná pole. Nejpoužívanějšími vícerozměrnými poli jsou 2D pole a 3D pole. Tato pole jsou obecně reprezentována ve formě řádků a sloupců.

Deklarace vícerozměrného pole

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

kde,

• Datový typ: Typ dat, která mají být uložena v poli.
• Název pole: Název pole.
• Velikost1, Velikost2,…, VelikostN: Velikost každého rozměru.

Dvourozměrné pole v C++

V C++ je dvourozměrné pole seskupení prvků uspořádaných do řádků a sloupců. Ke každému prvku se přistupuje pomocí dvou indexů: jednoho pro řádek a druhého pro sloupec, což usnadňuje vizualizaci jako tabulku nebo mřížku.

Syntaxe 2D pole

data_Type array_name[n][m];>

Kde,

• n: Počet řádků.
• m: Počet sloupců.
  

Příklad: Program C++ pro ilustraci dvourozměrného pole

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

Vysvětlení

Ve výše uvedeném kódu jsme deklarovali 2D pole se 4 řádky a 4 sloupci, poté jsme pole inicializovali s hodnotou (i+j) v každé iteraci cyklu. Poté tiskneme 2D pole pomocí vnořené smyčky a na níže uvedeném výstupu vidíme, že existují 4 řádky a 4 sloupce.

Trojrozměrné pole v C++

3D pole používá tři rozměry. K jeho znázornění lze použít sbírku různých dvourozměrných polí nahromaděných na sobě. Tři indexy – index řádku, index sloupce a index hloubky se používají k jedinečné identifikaci každého prvku v 3D poli.

Deklarace trojrozměrného pole v C++

Abychom deklarovali 3D pole v C++, musíme zadat jeho třetí rozměr spolu s 2D rozměry.

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

Kde,

• Datový typ: Typ dat, která mají být uložena v každém prvku.
• Název pole: Název pole
• D: Počet 2D polí nebo Hloubka pole.
• R: Počet řádků v každém 2D poli.
• C: Počet sloupců v každém 2D poli.

Příklad

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

Příklad: Program C++ pro ilustraci 3D pole

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

Vysvětlení

Ve výše uvedeném kódu jsme deklarovali 3D pole a poté jej inicializovali pomocí tří vnořených smyček for. Poté jsme znovu vytiskli všechny vrstvy 3D pole pomocí tří vnořených smyček for, jak je vidět na výstupu.

Související články

• Vícerozměrná pole v C++
• Vlastnosti pole
• Array Decay