I C++ är en array en datastruktur som används för att lagra flera värden av liknande datatyper i en sammanhängande minnesplats.

Till exempel , om vi måste lagra poängen för 4 eller 5 elever så kan vi enkelt lagra dem genom att skapa 5 olika variabler, men tänk om vi vill lagra poäng för 100 elever eller säga 500 elever då blir det mycket utmanande att skapa det antalet variabler och hantera dem. Nu kommer arrayer in i bilden som kan göra det enkelt genom att bara skapa en array med önskad storlek.

Egenskaper för arrayer i C++

• En array är en samling data av samma datatyp, lagrad på en sammanhängande minnesplats.
• Indexering av en array börjar från 0. Det betyder att det första elementet lagras vid 0:e indexet, det andra vid 1:a, och så vidare.
• Element i en array kan nås med deras index.
• När en array har deklarerats förblir dess storlek konstant under hela programmet.
• En array kan ha flera dimensioner.
• Storleken på arrayen i byte kan bestämmas av storleken på operatorn med vilken vi också kan hitta antalet element i arrayen.
• Vi kan hitta storleken på den typ av element som lagras i en array genom att subtrahera intilliggande adresser.

Array-deklaration i C++

I C++ kan vi deklarera en array genom att helt enkelt ange datatypen först och sedan namnet på en array med dess storlek.

data_type array_name[Size_of_array];>

Exempel

int arr[5];>

Här,

• int: Det är den typ av data som ska lagras i arrayen. Vi kan också använda andra datatyper som char, float och double.
• arr: Det är namnet på arrayen.
• 5: Det är storleken på arrayen vilket innebär att endast 5 element kan lagras i arrayen.

Initiering av Array i C++

I C++ kan vi initiera en array på många sätt, men vi kommer att diskutera några vanligaste sätt att initiera en array. Vi kan initiera en array vid tidpunkten för deklarationen eller efter deklarationen.

1. Initiera Array med värden i C++

Vi har initierat arrayen med värden. Värdena som omges av klammerparenteser '{}' tilldelas arrayen. Här lagras 1 i arr[0], 2 i arr[1] och så vidare. Här är storleken på arrayen 5.

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

2. Initiera Array med värden och utan storlek i C++

Vi har initierat arrayen med värden men vi har inte deklarerat längden på arrayen, därför är längden på en array lika med antalet element inuti lockiga klammerparenteser.

stlc

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

3. Initiera array efter deklaration (med loopar)

Vi har initierat arrayen med en loop efter att ha deklarerat arrayen. Denna metod används vanligtvis när vi vill ta emot input från användaren eller om vi inte kan tilldela element en efter en till varje index i arrayen. Vi kan modifiera loopvillkoren eller ändra initialiseringsvärdena enligt kraven.

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

4. Initiera en array delvis i C++

Här har vi deklarerat en array som 'partialArray' med storleken '5' och endast med värdena '1' och '2'. Så dessa värden lagras vid de två första indexen, och i resten av indexen lagras '0'.

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

5. Initiera arrayen med noll i C++

Vi kan initiera arrayen med alla element som '0' genom att ange '0' inuti de lockiga klammerparenteserna. Detta kommer att hända i fallet med noll endast om vi försöker initiera arrayen med ett annat värde, säg '2' med den här metoden, då lagras '2' endast vid det 0:e indexet.

int zero_array[5] = {0};>

Åtkomst till ett element i en array i C++

Element i en array kan nås genom att ange namnet på arrayen och sedan indexet för elementet som ingår i array-underskriftsoperatorn []. Till exempel, arr[i].

Exempel 1: C++-programmet för att illustrera hur man kommer åt matriselement

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

Uppdatera Array Element

För att uppdatera ett element i en array kan vi använda indexet som vi vill uppdatera inneslutet i array subscript operatorn och tilldela det nya värdet.

arr[i] = new_value;>

Traversera en Array i C++

Vi kan korsa över arrayen med hjälp av en slinga använder indexering i C++. Först har vi initierat en array 'table_of_two' med en multipel av 2. Efter det kör vi en for-loop från 0 till 9 eftersom indexeringen i en array börjar från noll. Därför, med hjälp av indexen, skriver vi ut alla värden som är lagrade i en array.

Exempel 2: C++-programmet för att illustrera hur man korsar en 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>

Storleken på en array i C++

I C++ har vi inte längdfunktionen som i Java för att hitta arraystorlek men vi kan beräkna storleken på en array med operatorn sizeof(). lura. Först hittar vi storleken som upptas av hela arrayen i minnet och dividerar den sedan med storleken på den typ av element som lagras i arrayen. Detta kommer att ge oss antalet element lagrade i arrayen.

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

Exempel 3: C++-programmet för att illustrera hur man hittar storleken på en matris

// 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 mellan matriser och pekare i C++

I C++ är arrayer och pekare nära relaterade till varandra. Arraynamnet behandlas som en pekare som lagrade minnesadressen för det första elementet i arrayen. Som vi har diskuterat tidigare lagras In array-element på sammanhängande minnesplatser, det är därför vi kan komma åt alla element i en array med hjälp av arraynamnet.

Exempel 4: Illustrerar förhållandet mellan Array och 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>

Förklaring:

I ovanstående kod definierar vi först en array arr och deklarera sedan en pekare ptr och tilldela arrayen arr till den. Vi kan tilldela arr till ptr eftersom arr också är en pekare. Efter det skriver vi ut minnesadressen för arr använder referensoperator ( & ) och även skriva ut adressen som är lagrad i pekaren ptr och vi kan se arr och ptr, båda lagrar samma minnesadress.

Exempel 5: Skriva ut matriselement utan indexering i C++

Vi kommer i allmänhet åt och skriver ut arrayelementen med hjälp av indexering. Till exempel för att komma åt det första elementet vi använder array_name[0]. Vi har diskuterat ovan att arraynamnet är en pekare som lagrade adressen för det första elementet och arrayelementen lagras på sammanhängande platser. Nu ska vi komma åt elementen i en array med endast arraynamnet.

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

Förklaring

I ovanstående kod deklarerade vi först en array arr med fyra element. Efter det skriver vi ut arrayelementen. Låt oss diskutera hur vi gör det. Vi diskuterade att arraynamnet är en pekare som lagrar adressen till det första elementet i en array, så för att skriva ut det första elementet har vi avreferenserat den pekaren (*arr) använder dereferencing operator (*) som skriver ut data som lagrats på den adressen.

För att skriva ut det andra elementet i en array lägger vi först till 1 till arr vilket är ekvivalent med (adressen till arr + size_of_one_element *1) som tar pekaren till adressen precis efter den första och efter det refererar vi den pekaren för att skriva ut det andra elementet. På samma sätt skriver vi ut resten av elementen i en array utan att använda indexering.

Skickar Array till Function i C++

För att använda arrayer effektivt bör vi veta hur vi skickar arrayer för att fungera. Vi kan skicka arrayer till funktioner som ett argument på samma sätt som vi skickar variabler till funktioner men vi vet att arraynamnet behandlas som en pekare med detta koncept. Vi kan skicka arrayen till funktioner som ett argument och sedan komma åt alla element i den arrayen med pekare.

Så till slut, arrayer skickas alltid som pekare till funktionen. Låt oss se tre sätt att skicka en array till en funktion som används mest.

1. Passar Array som en pekare

I den här metoden skickar vi helt enkelt arraynamnet i funktionsanrop vilket betyder att vi skickar adressen till det första elementet i arrayen. I den här metoden kan vi modifiera arrayelementen i funktionen.

Syntax

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

2. Skicka Array som en Unsized Array

I den här metoden accepterar funktionen matrisen med en enkel matrisdeklaration utan storlek som argument.

Syntax

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

3. Att skicka Array som en Sized Array

I den här metoden accepterar funktionen matrisen med en enkel matrisdeklaration med storlek som argument. Vi använder den här metoden genom att dimensionera en array bara för att ange storleken på en array.

Syntax

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

Notera: Array kommer att behandlas som en pekare i den godkända funktionen oavsett vilken metod vi använder. När arrayen skickas som pekare kommer de att förlora informationen om dess storlek vilket leder till ett fenomen som heter som Array Decay.

Exempel: Illustrera olika sätt att skicka arrayer till 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>

Flerdimensionella arrayer i C++

Matriser som deklareras med mer än en dimension kallas flerdimensionella matriser. De mest använda flerdimensionella arrayerna är 2D-arrayer och 3D-arrayer. Dessa arrayer representeras vanligtvis i form av rader och kolumner.

Flerdimensionell matrisdeklaration

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

var,

• Data typ: Typ av data som ska lagras i arrayen.
• Array_Name: Arrayens namn.
• Storlek1, Storlek2,…, StorlekN: Storlek på varje dimension.

Tvådimensionell array i C++

I C++ är en tvådimensionell array en gruppering av element ordnade i rader och kolumner. Varje element nås med hjälp av två index: ett för raden och ett för kolumnen, vilket gör det enkelt att visualisera som en tabell eller ett rutnät.

Syntax för 2D-array

data_Type array_name[n][m];>

Var,

• n: Antal rader.
• m: Antal kolumner.
  

Exempel: C++-programmet för att illustrera den tvådimensionella arrayen

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

Förklaring

I ovanstående kod har vi deklarerat en 2D-array med 4 rader och 4 kolumner efter att vi initierat arrayen med värdet (i+j) i varje iteration av slingan. Sedan skriver vi ut 2D-matrisen med en kapslad slinga och vi kan se i utgången nedan att det finns 4 rader och 4 kolumner.

Tredimensionell array i C++

3D-matrisen använder tre dimensioner. En samling av olika tvådimensionella arrayer staplade ovanpå varandra kan användas för att representera den. Tre index – radindex, kolumnindex och djupindex används för att unikt identifiera varje element i en 3D-array.

Deklaration av tredimensionell array i C++

För att deklarera en 3D-array i C++ måste vi ange dess tredje dimension tillsammans med 2D-dimensioner.

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

Var,

• Data typ: Typ av data som ska lagras i varje element.
• Array_Name: Arrayens namn
• D: Antal 2D-arrayer eller djup av array.
• R: Antal rader i varje 2D-array.
• C: Antal kolumner i varje 2D-array.

Exempel

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

Exempel: C++-programmet för att illustrera 3d-arrayen

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

Förklaring

I ovanstående kod har vi deklarerat en 3D-array och sedan initierat den med tre kapslade för loopar. Efter det skrev vi ut alla lager i 3D-arrayen igen med tre kapslade för loopar som ses i utdata.

relaterade artiklar

• Flerdimensionella arrayer i C++
• Egenskaper för Array
• Array Decay