I C++ er et array en datastruktur, der bruges til at gemme flere værdier af lignende datatyper i en sammenhængende hukommelsesplacering.

For eksempel , hvis vi skal gemme karaktererne for 4 eller 5 elever, så kan vi nemt gemme dem ved at oprette 5 forskellige variabler, men hvad nu hvis vi vil gemme karakterer af 100 elever eller sige 500 elever, så bliver det meget udfordrende at skabe det antal variable og administrere dem. Nu kommer arrays ind i billedet, der nemt kan gøre det ved blot at oprette en array af den nødvendige størrelse.

Egenskaber for arrays i C++

• Et array er en samling af data af samme datatype, gemt på en sammenhængende hukommelsesplacering.
• Indeksering af et array starter fra 0. Det betyder, at det første element er gemt ved det 0. indeks, det andet ved det 1. og så videre.
• Elementer i et array kan tilgås ved hjælp af deres indekser.
• Når et array er erklæret, forbliver dets størrelse konstant gennem hele programmet.
• Et array kan have flere dimensioner.
• Størrelsen af ​​arrayet i bytes kan bestemmes af operatørens størrelse, hvorved vi også kan finde antallet af elementer i arrayet.
• Vi kan finde størrelsen af ​​den type elementer, der er gemt i et array ved at trække tilstødende adresser fra.

Array-erklæring i C++

I C++ kan vi erklære et array ved blot at angive datatypen først og derefter navnet på et array med dets størrelse.

data_type array_name[Size_of_array];>

Eksempel

int arr[5];>

Her,

• int: Det er den type data, der skal gemmes i arrayet. Vi kan også bruge andre datatyper såsom char, float og double.
• arr: Det er navnet på arrayet.
• 5: Det er størrelsen på arrayet, hvilket betyder, at kun 5 elementer kan gemmes i arrayet.

Initialisering af Array i C++

I C++ kan vi initialisere et array på mange måder, men vi vil diskutere nogle mest almindelige måder at initialisere et array på. Vi kan initialisere et array på tidspunktet for erklæringen eller efter erklæringen.

1. Initialiser Array med værdier i C++

Vi har initialiseret arrayet med værdier. Værdierne omgivet af krøllede klammer '{}' er tildelt arrayet. Her er 1 gemt i arr[0], 2 i arr[1] og så videre. Her er størrelsen af ​​arrayet 5.

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

2. Initialiser Array med værdier og uden størrelse i C++

Vi har initialiseret arrayet med værdier, men vi har ikke erklæret længden af ​​arrayet, derfor er længden af ​​et array lig med antallet af elementer inden i krøllede klammeparenteser.

Madhuri sagde kom nu

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

3. Initialiser array efter erklæring (ved hjælp af loops)

Vi har initialiseret arrayet ved hjælp af en loop efter at have erklæret arrayet. Denne metode bruges generelt, når vi ønsker at modtage input fra brugeren, eller vi ikke kan tildele elementer en efter en til hvert indeks i arrayet. Vi kan ændre sløjfebetingelserne eller ændre initialiseringsværdierne i henhold til kravene.

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

4. Initialiser et array delvist i C++

Her har vi erklæret et array 'partialArray' med størrelse '5' og kun med værdierne '1' og '2'. Så disse værdier er gemt ved de første to indekser, og ved resten af ​​indekserne er '0' gemt.

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

5. Initialiser arrayet med nul i C++

Vi kan initialisere arrayet med alle elementer som '0' ved at angive '0' inde i de krøllede klammeparenteser. Dette vil kun ske i tilfælde af nul, hvis vi forsøger at initialisere arrayet med en anden værdi, sig '2' ved hjælp af denne metode, så er '2' kun gemt ved det 0. indeks.

int zero_array[5] = {0};>

Adgang til et element i et array i C++

Elementer i et array kan tilgås ved at angive navnet på arrayet og derefter indekset for elementet indesluttet i array subscript-operatoren []. For eksempel arr[i].

Eksempel 1: C++-programmet til at illustrere, hvordan man får adgang til matrixelementer

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

Opdater Array Element

For at opdatere et element i et array kan vi bruge det indeks, som vi ønsker at opdatere indesluttet i array subscript-operatoren og tildele den nye værdi.

arr[i] = new_value;>

Gennemgå et array i C++

Vi kan krydse arrayet ved hjælp af en løkke ved hjælp af indeksering i C++. Først har vi initialiseret et array 'table_of_two' med et multiplum af 2. Derefter kører vi en for-løkke fra 0 til 9, fordi indeksering i et array starter fra nul. Derfor udskriver vi alle værdier gemt i et array ved hjælp af indeksene.

Eksempel 2: C++-programmet til at illustrere, hvordan man krydser et array

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

Størrelse af et array i C++

I C++ har vi ikke længdefunktionen som i Java til at finde matrixstørrelse men vi kan beregne størrelsen af ​​et array ved hjælp af sizeof() operator trick. Først finder vi størrelsen optaget af hele arrayet i hukommelsen og dividerer den derefter med størrelsen af ​​den type element, der er gemt i arrayet. Dette vil give os antallet af elementer, der er gemt i arrayet.

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

Eksempel 3: C++-programmet til at illustrere, hvordan man finder størrelsen af ​​et array

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

Relation mellem arrays og pointere i C++

I C++ er arrays og pointere tæt forbundet med hinanden. Arraynavnet behandles som en pointer, der lagrede hukommelsesadressen for det første element i arrayet. Som vi har diskuteret tidligere, er In-array-elementer gemt på sammenhængende hukommelsesplaceringer, hvorfor vi kan få adgang til alle elementerne i et array ved hjælp af array-navnet.

Eksempel 4: Illustrerer forholdet mellem array og pointere

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

Forklaring:

I ovenstående kode definerer vi først et array arr og erklær derefter en pointer ptr og tildel array arr til den. Vi er i stand til at tildele arr til ptr, fordi arr også er en pointer. Derefter udskriver vi hukommelsesadressen på arr ved hjælp af referenceoperator ( & ) og udskriv også adressen gemt i markøren ptr og vi kan se arr og ptr, begge gemmer den samme hukommelsesadresse.

Eksempel 5: Udskrivning af array-elementer uden indeksering i C++

Vi har generelt adgang til og udskriver array-elementerne ved hjælp af indeksering. For eksempel for at få adgang til det første element, vi bruger matrixnavn[0]. Vi har diskuteret ovenfor, at array-navnet er en pointer, der lagrer adressen på det første element, og array-elementer er gemt på sammenhængende steder. Nu skal vi få adgang til elementerne i et array ved kun at bruge array-navnet.

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

Forklaring

I ovenstående kode erklærede vi først et array arr med fire elementer. Derefter udskriver vi array-elementerne. Lad os diskutere, hvordan vi gør det. Vi diskuterede, at array-navnet er en pointer, der gemmer adressen på det første element i et array, så for at udskrive det første element har vi derefereret den pointer (*arr) ved hjælp af dereferencing-operator (*) som udskriver de data, der er gemt på den adresse.

For at udskrive det andet element i en matrix tilføjer vi først 1 til arr hvilket svarer til (adressen på arr + size_of_one_element *1), der tager markøren til adressen lige efter den første, og derefter derefererer vi markøren til at udskrive det andet element. På samme måde udskriver vi resten af ​​elementerne i et array uden at bruge indeksering.

Sender Array til Function i C++

For at bruge arrays effektivt bør vi vide, hvordan vi sender arrays til at fungere. Vi kan videregive arrays til funktioner som et argument på samme måde som vi videregiver variabler til funktioner, men vi ved, at arraynavnet behandles som en pointer ved hjælp af dette koncept, vi kan videregive arrayet til funktioner som et argument og derefter få adgang til alle elementer i det array vha. pointer.

Så i sidste ende, arrays sendes altid som pointere til funktionen. Lad os se 3 måder at overføre et array til en funktion, der er mest brugt.

1. Passer Array som en pointer

I denne metode sender vi simpelthen array-navnet i funktionskald, hvilket betyder, at vi sender adressen til det første element i arrayet. I denne metode kan vi ændre array-elementerne i funktionen.

Syntaks

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

2. Passer Array som en Unsized Array

I denne metode accepterer funktionen arrayet ved hjælp af en simpel array-erklæring uden størrelse som argument.

Syntaks

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

3. Passer Array som en Sized Array

I denne metode accepterer funktionen arrayet ved hjælp af en simpel array-erklæring med størrelse som argument. Vi bruger denne metode ved at dimensionere et array bare for at angive størrelsen af ​​et array.

Syntaks

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

Bemærk: Array vil blive behandlet som en pointer i den beståede funktion, uanset hvilken metode vi bruger. Efterhånden som arrayet sendes som pointere, vil de miste informationen om dets størrelse, hvilket fører til et fænomen kaldet som Array Decay.

Eksempel: Illustration af forskellige måder at overføre arrays til en funktion

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

Multidimensionelle arrays i C++

Arrays erklæret med mere end én dimension kaldes multidimensionelle arrays. De mest udbredte multidimensionelle arrays er 2D-arrays og 3D-arrays. Disse arrays er generelt repræsenteret i form af rækker og kolonner.

Multidimensional Array Declaration

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

hvor,

• Datatype: Type af data, der skal gemmes i arrayet.
• Array_Name: Navnet på arrayet.
• Størrelse1, Størrelse2,…, StørrelseN: Størrelse af hver dimension.

To dimensionelle array i C++

I C++ er et todimensionelt array en gruppering af elementer arrangeret i rækker og kolonner. Hvert element tilgås ved hjælp af to indekser: et for rækken og et for kolonnen, hvilket gør det nemt at visualisere som en tabel eller et gitter.

Syntaks for 2D-array

data_Type array_name[n][m];>

Hvor,

• n: Antal rækker.
• m: Antal kolonner.
  

Eksempel: C++-programmet til at illustrere det todimensionelle array

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

Forklaring

I ovenstående kode har vi erklæret et 2D-array med 4 rækker og 4 kolonner, hvorefter vi initialiserede arrayet med værdien (i+j) i hver iteration af løkken. Derefter udskriver vi 2D-arrayet ved hjælp af en indlejret løkke, og vi kan se i nedenstående output, at der er 4 rækker og 4 kolonner.

Tredimensionelt array i C++

3D-arrayet bruger tre dimensioner. En samling af forskellige todimensionelle arrays stablet oven på hinanden kan bruges til at repræsentere det. Tre indekser - rækkeindekset, kolonneindekset og dybdeindekset bruges til entydigt at identificere hvert element i et 3D-array.

Erklæring om tredimensionelt array i C++

For at erklære et 3D-array i C++ skal vi angive dets tredje dimension sammen med 2D-dimensioner.

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

Hvor,

• Datatype: Type data, der skal lagres i hvert element.
• Array_Name: Navnet på arrayet
• D: Antal 2D-arrays eller dybde af array.
• R: Antal rækker i hvert 2D-array.
• C: Antal kolonner i hvert 2D-array.

Eksempel

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

Eksempel: C++-programmet til at illustrere 3d-arrayet

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

Forklaring

I ovenstående kode har vi erklæret et 3D-array og derefter initialiseret det ved hjælp af tre indlejrede for-løkker. Derefter udskrev vi alle lag i 3D-arrayet igen ved at bruge tre indlejrede for-løkker som det ses i outputtet.

relaterede artikler

• Multidimensionelle arrays i C++
• Egenskaber for Array
• Array Decay