In C++ is een array een gegevensstructuur die wordt gebruikt om meerdere waarden van vergelijkbare gegevenstypen op een aaneengesloten geheugenlocatie op te slaan.

Bijvoorbeeld , als we de cijfers van 4 of 5 studenten moeten opslaan, kunnen we ze gemakkelijk opslaan door 5 verschillende variabelen te maken, maar wat als we de cijfers van 100 studenten of bijvoorbeeld 500 studenten willen opslaan, dan wordt het een hele uitdaging om dat aantal variabelen te maken en beheer ze. Nu komen er arrays in beeld die dit eenvoudig kunnen doen door simpelweg een array van de vereiste grootte te maken.

Eigenschappen van arrays in C++

• Een array is een verzameling gegevens van hetzelfde gegevenstype, opgeslagen op een aaneengesloten geheugenlocatie.
• Het indexeren van een array begint vanaf 0. Dit betekent dat het eerste element wordt opgeslagen op de 0e index, het tweede op de 1e, enzovoort.
• Elementen van een array zijn toegankelijk via hun indices.
• Zodra een array is gedeclareerd, blijft de grootte ervan gedurende het hele programma constant.
• Een array kan meerdere dimensies hebben.
• De grootte van de array in bytes kan worden bepaald door de operator sizeof, waarmee we ook het aantal elementen in de array kunnen vinden.
• We kunnen de grootte van het type elementen vinden dat in een array is opgeslagen door aangrenzende adressen af ​​te trekken.

Arraydeclaratie in C++

In C++ kunnen we een array declareren door eenvoudigweg eerst het gegevenstype op te geven en vervolgens de naam van een array met de grootte ervan.

data_type array_name[Size_of_array];>

Voorbeeld

int arr[5];>

Hier,

• int.: Het is het type gegevens dat in de array moet worden opgeslagen. We kunnen ook andere gegevenstypen gebruiken, zoals char, float en double.
• arr: Het is de naam van de array.
• 5: Het is de grootte van de array, wat betekent dat er slechts 5 elementen in de array kunnen worden opgeslagen.

Initialisatie van array in C++

In C++ kunnen we een array op veel manieren initialiseren, maar we zullen enkele meest voorkomende manieren bespreken om een ​​array te initialiseren. We kunnen een array initialiseren op het moment van declaratie of na de declaratie.

1. Initialiseer de array met waarden in C++

We hebben de array met waarden geïnitialiseerd. De waarden tussen accolades ‘{}’ worden aan de array toegewezen. Hier wordt 1 opgeslagen in arr[0], 2 in arr[1], enzovoort. Hier is de grootte van de array 5.

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

2. Initialiseer de array met waarden en zonder grootte in C++

We hebben de array geïnitialiseerd met waarden, maar we hebben de lengte van de array niet aangegeven. Daarom is de lengte van een array gelijk aan het aantal elementen tussen accolades.

scannerscan java

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

3. Initialiseer de array na declaratie (met behulp van lussen)

We hebben de array geïnitialiseerd met behulp van een lus nadat de array is gedeclareerd. Deze methode wordt over het algemeen gebruikt als we input van de gebruiker willen ontvangen of als we de elementen niet één voor één aan elke index van de array kunnen toewijzen. We kunnen de lusvoorwaarden wijzigen of de initialisatiewaarden wijzigen volgens de vereisten.

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

4. Initialiseer een array gedeeltelijk in C++

Hier hebben we een array ‘partialArray’ gedeclareerd met de grootte ‘5’ en alleen met de waarden ‘1’ en ‘2’. Deze waarden worden dus opgeslagen bij de eerste twee indices, en bij de rest van de indices wordt ‘0’ opgeslagen.

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

5. Initialiseer de array met nul in C++

We kunnen de array met alle elementen als ‘0’ initialiseren door ‘0’ binnen de accolades op te geven. Dit gebeurt alleen in het geval van nul als we met deze methode proberen de array te initialiseren met een andere waarde, bijvoorbeeld '2', dan wordt '2' alleen op de 0e index opgeslagen.

int zero_array[5] = {0};>

Toegang krijgen tot een element van een array in C++

Elementen van een array zijn toegankelijk door de naam van de array op te geven, en vervolgens de index van het element ingesloten in de array-subscriptoperator []. Bijvoorbeeld arr[i].

Voorbeeld 1: Het C++-programma om te illustreren hoe u toegang krijgt tot array-elementen

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

Array-element bijwerken

Om een ​​element in een array bij te werken, kunnen we de index die we willen bijwerken, ingesloten in de array-subscriptoperator, gebruiken en de nieuwe waarde toewijzen.

arr[i] = new_value;>

Doorkruis een array in C++

We kunnen de array doorlopen met behulp van een lus met behulp van indexering in C++. Eerst hebben we een array ‘table_of_two’ geïnitialiseerd met een veelvoud van 2. Daarna voeren we een for-lus uit van 0 tot 9, omdat in een array de indexering vanaf nul begint. Daarom drukken we met behulp van de indices alle waarden af ​​die in een array zijn opgeslagen.

Voorbeeld 2: Het C++-programma om te illustreren hoe een array moet worden doorlopen

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

Grootte van een array in C++

In C++ hebben we niet de lengtefunctie zoals in Java om de arraygrootte te vinden, maar we kunnen de grootte van een array berekenen met de operator sizeof(). truc. Eerst vinden we de grootte die door de hele array in het geheugen wordt ingenomen en delen we deze vervolgens door de grootte van het type element dat in de array is opgeslagen. Dit geeft ons het aantal elementen dat in de array is opgeslagen.

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

Voorbeeld 3: Het C++-programma om te illustreren hoe u de grootte van een array kunt vinden

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

Relatie tussen arrays en pointers in C++

In C++ zijn arrays en pointers nauw verwant aan elkaar. De arraynaam wordt behandeld als een pointer die het geheugenadres van het eerste element van de array heeft opgeslagen. Zoals we eerder hebben besproken, worden In array-elementen opgeslagen op aangrenzende geheugenlocaties. Daarom hebben we toegang tot alle elementen van een array met behulp van de arraynaam.

Voorbeeld 4: Illustratie van de relatie tussen array en pointers

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

Uitleg:

In de bovenstaande code definiëren we eerst een array arr en declareer vervolgens een pointer ptr en wijs er de array arr aan toe. We kunnen arr aan ptr toewijzen omdat arr ook een pointer is. Daarna printen we het geheugenadres van arr met behulp van referentie-operator ( & ) en druk ook het adres af dat is opgeslagen in de aanwijzer ptr en we kunnen arr en ptr zien, beide slaan hetzelfde geheugenadres op.

Voorbeeld 5: Array-elementen afdrukken zonder indexering in C++

Over het algemeen openen en printen we de array-elementen met behulp van indexering. Bijvoorbeeld om toegang te krijgen tot het eerste element dat we gebruiken array_naam[0]. We hebben hierboven besproken dat de arraynaam een ​​pointer is die het adres van het eerste element opslaat en dat array-elementen op aangrenzende locaties worden opgeslagen. Nu gaan we toegang krijgen tot de elementen van een array met alleen de arraynaam.

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

Uitleg

In de bovenstaande code hebben we eerst een array gedeclareerd arr met vier elementen. Daarna drukken we de array-elementen af. Laten we bespreken hoe we het doen. We hebben besproken dat de arraynaam een ​​pointer is die het adres van het eerste element van een array opslaat, dus om het eerste element af te drukken hebben we de verwijzing naar die pointer verwijderd (*arr) met behulp van dereferentie-operator (*) die de gegevens afdrukt die op dat adres zijn opgeslagen.

Om het tweede element van een array af te drukken, voegen we eerst toe 1 naar arr wat equivalent is aan (adres van arr + size_of_one_element *1) dat de pointer naar het adres net na het eerste brengt en daarna derefereren we die pointer om het tweede element af te drukken. Op dezelfde manier drukken we de rest van de elementen van een array af zonder indexering te gebruiken.

Array doorgeven aan functie in C++

Om arrays efficiënt te gebruiken, moeten we weten hoe we arrays moeten doorgeven aan de functie. We kunnen arrays doorgeven aan functies als een argument, net zoals we variabelen doorgeven aan functies, maar we weten dat de arraynaam wordt behandeld als een pointer. Met dit concept kunnen we de array doorgeven aan functies als een argument en vervolgens toegang krijgen tot alle elementen van die array met behulp van wijzer.

Dus uiteindelijk, arrays worden altijd doorgegeven als verwijzingen naar de functie. Laten we drie manieren bekijken om een ​​array door te geven aan een functie die veel wordt gebruikt.

1. Array doorgeven als aanwijzer

Bij deze methode geven we eenvoudigweg de arraynaam door in de functieaanroep, wat betekent dat we het adres doorgeven aan het eerste element van de array. Bij deze methode kunnen we de array-elementen binnen de functie wijzigen.

Syntaxis

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

2. Array doorgeven als een array zonder grootte

Bij deze methode accepteert de functie de array met behulp van een eenvoudige arraydeclaratie zonder grootte als argument.

Syntaxis

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

3. Array doorgeven als een array met grootte

Bij deze methode accepteert de functie de array met behulp van een eenvoudige arraydeclaratie met size als argument. We gebruiken deze methode door een array te dimensioneren, alleen maar om de grootte van een array aan te geven.

Syntaxis

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

Opmerking: Array wordt behandeld als een aanwijzer in de doorgegeven functie, ongeacht welke methode we gebruiken. Terwijl de array als pointers wordt doorgegeven, verliezen ze de informatie over de grootte ervan, wat leidt tot een fenomeen met de naam Array verval.

Voorbeeld: verschillende manieren illustreren om arrays aan een functie door te geven

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

Multidimensionale arrays in C++

Arrays die met meer dan één dimensie zijn gedeclareerd, worden multidimensionale arrays genoemd. De meest gebruikte multidimensionale arrays zijn 2D-arrays en 3D-arrays. Deze arrays worden doorgaans weergegeven in de vorm van rijen en kolommen.

Multidimensionale array-verklaring

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

waar,

• Data type: Type gegevens dat in de array moet worden opgeslagen.
• Arraynaam: Naam van de array.
• Maat1, Maat2,…, MaatN: Grootte van elke dimensie.

Tweedimensionale array in C++

In C++ is een tweedimensionale array een groep elementen die in rijen en kolommen zijn gerangschikt. Elk element is toegankelijk via twee indices: één voor de rij en één voor de kolom, waardoor het gemakkelijk te visualiseren is als tabel of raster.

Syntaxis van 2D-array

data_Type array_name[n][m];>

Waar,

• N: Aantal rijen.
• M: Aantal columns.
  

Voorbeeld: het C++-programma om de tweedimensionale array te illustreren

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

Uitleg

In de bovenstaande code hebben we een 2D-array gedeclareerd met 4 rijen en 4 kolommen, waarna we de array hebben geïnitialiseerd met de waarde van (i+j) in elke iteratie van de lus. Vervolgens drukken we de 2D-array af met behulp van een geneste lus en kunnen we in de onderstaande uitvoer zien dat er 4 rijen en 4 kolommen zijn.

Driedimensionale array in C++

De 3D-array gebruikt drie dimensies. Om dit weer te geven, kan een verzameling van verschillende op elkaar gestapelde tweedimensionale arrays worden gebruikt. Drie indices: de rij-index, kolom-index en diepte-index worden gebruikt om elk element in een 3D-array op unieke wijze te identificeren.

Verklaring van driedimensionale array in C++

Om een ​​3D-array in C++ te declareren, moeten we de derde dimensie ervan specificeren, samen met de 2D-dimensies.

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

Waar,

• Data type: Type gegevens dat in elk element moet worden opgeslagen.
• Arraynaam: Naam van de array
• D: Aantal 2D-arrays of diepte van de array.
• R: Aantal rijen in elke 2D-array.
• C: Aantal kolommen in elke 2D-array.

Voorbeeld

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

Voorbeeld: het C++-programma om de 3D-array te illustreren

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

Uitleg

In de bovenstaande code hebben we een 3D-array gedeclareerd en deze vervolgens geïnitialiseerd met behulp van drie geneste for-lussen. Daarna hebben we alle lagen van de 3D-array opnieuw afgedrukt met behulp van drie geneste for-lussen, zoals te zien in de uitvoer.

gerelateerde artikelen

• Multidimensionale arrays in C++
• Eigenschappen van matrix
• Array verval