In C++, un array è una struttura dati utilizzata per archiviare più valori di tipi di dati simili in una posizione di memoria contigua.

Per esempio , se dobbiamo memorizzare i voti di 4 o 5 studenti, possiamo facilmente memorizzarli creando 5 variabili diverse, ma cosa succede se vogliamo memorizzare i voti di 100 studenti o dire 500 studenti, allora diventa molto difficile creare quel numero di variabili e gestirli. Ora entrano in gioco gli array che possono farlo facilmente semplicemente creando un array della dimensione richiesta.

Proprietà degli array in C++

• Un array è una raccolta di dati dello stesso tipo, archiviati in una posizione di memoria contigua.
• L'indicizzazione di un array inizia da 0. Significa che il primo elemento è memorizzato all'indice 0, il secondo al 1 e così via.
• È possibile accedere agli elementi di un array utilizzando i relativi indici.
• Una volta dichiarato un array, la sua dimensione rimane costante in tutto il programma.
• Un array può avere più dimensioni.
• La dimensione dell'array in byte può essere determinata dall'operatore sizeof utilizzando il quale possiamo anche trovare il numero di elementi nell'array.
• Possiamo trovare la dimensione del tipo di elementi memorizzati in un array sottraendo gli indirizzi adiacenti.

Dichiarazione di array in C++

In C++ possiamo dichiarare un array semplicemente specificando prima il tipo di dati e poi il nome dell'array con la sua dimensione.

data_type array_name[Size_of_array];>

Esempio

int arr[5];>

Qui,

• int: È il tipo di dati da memorizzare nell'array. Possiamo anche utilizzare altri tipi di dati come char, float e double.
• arr: È il nome dell'array.
• 5: È la dimensione dell'array, il che significa che solo 5 elementi possono essere memorizzati nell'array.

Inizializzazione di array in C++

In C++ possiamo inizializzare un array in molti modi, ma discuteremo alcuni dei modi più comuni per inizializzare un array. Possiamo inizializzare un array al momento della dichiarazione o dopo la dichiarazione.

1. Inizializza l'array con valori in C++

Abbiamo inizializzato l'array con i valori. I valori racchiusi tra parentesi graffe '{}' vengono assegnati all'array. Qui, 1 è memorizzato in arr[0], 2 in arr[1] e così via. Qui la dimensione dell'array è 5.

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

2. Inizializza l'array con valori e senza dimensione in C++

Abbiamo inizializzato l'array con valori ma non abbiamo dichiarato la lunghezza dell'array, pertanto la lunghezza di un array è uguale al numero di elementi racchiusi tra parentesi graffe.

C#

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

3. Inizializza l'array dopo la dichiarazione (usando i loop)

Abbiamo inizializzato l'array utilizzando un ciclo dopo aver dichiarato l'array. Questo metodo viene generalmente utilizzato quando vogliamo ricevere input dall'utente o non possiamo assegnare gli elementi uno per uno a ciascun indice dell'array. Possiamo modificare le condizioni del loop o modificare i valori di inizializzazione in base alle esigenze.

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

4. Inizializzare parzialmente un array in C++

Qui abbiamo dichiarato un array 'partialArray' con dimensione '5' e solo con valori '1' e '2'. Pertanto, questi valori vengono memorizzati nei primi due indici e nel resto degli indici viene memorizzato '0'.

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

5. Inizializzare l'array con zero in C++

Possiamo inizializzare l'array con tutti gli elementi come '0' specificando '0' all'interno delle parentesi graffe. Ciò accadrà in caso di zero solo se proviamo a inizializzare l'array con un valore diverso, ad esempio '2' utilizzando questo metodo, quindi '2' viene memorizzato solo nell'indice 0.

int zero_array[5] = {0};>

Accesso a un elemento di un array in C++

È possibile accedere agli elementi di un array specificando il nome dell'array, quindi l'indice dell'elemento racchiuso nell'operatore indice dell'array []. Ad esempio, arr[i].

Esempio 1: il programma C++ per illustrare come accedere agli elementi dell'array

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

Aggiorna elemento dell'array

Per aggiornare un elemento in un array, possiamo utilizzare l'indice che vogliamo aggiornare racchiuso all'interno dell'operatore indice dell'array e assegnare il nuovo valore.

arr[i] = new_value;>

Attraversare un array in C++

Possiamo attraversare l'array con l'aiuto di un loop utilizzando l'indicizzazione in C++. Innanzitutto, abbiamo inizializzato un array 'tabella_di_due' con un multiplo di 2. Successivamente, eseguiamo un ciclo for da 0 a 9 perché in un array l'indicizzazione inizia da zero. Pertanto, utilizzando gli indici stampiamo tutti i valori memorizzati in un array.

Esempio 2: il programma C++ per illustrare come attraversare un 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>

Dimensione di un array in C++

In C++, non abbiamo la funzione length come in Java per trovare la dimensione dell'array ma possiamo calcolare la dimensione di un array utilizzando l'operatore sizeof() trucco. Per prima cosa troviamo la dimensione occupata dall'intero array in memoria e poi la dividiamo per la dimensione del tipo di elemento memorizzato nell'array. Questo ci darà il numero di elementi memorizzati nell'array.

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

Esempio 3: programma C++ per illustrare come trovare la dimensione di un 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>

Relazione tra array e puntatori in C++

In C++, array e puntatori sono strettamente correlati tra loro. Il nome dell'array viene trattato come un puntatore che memorizza l'indirizzo di memoria del primo elemento dell'array. Come abbiamo discusso in precedenza, gli elementi dell'array sono archiviati in posizioni di memoria contigue, ecco perché possiamo accedere a tutti gli elementi di un array utilizzando il nome dell'array.

Esempio 4: illustrare la relazione tra array e puntatori

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

Spiegazione:

Nel codice sopra, definiamo prima un array arr e quindi dichiarare un puntatore ptr e assegnargli l'array arr. Possiamo assegnare arr a ptr perché anche arr è un puntatore. Successivamente, stampiamo l'indirizzo di memoria di arr utilizzando l'operatore di riferimento ( & ) e stampa anche l'indirizzo memorizzato nel puntatore ptr e possiamo vedere arr e ptr, entrambi memorizzano lo stesso indirizzo di memoria.

Esempio 5: stampa di elementi di array senza indicizzazione in C++

Generalmente accediamo e stampiamo gli elementi dell'array utilizzando l'indicizzazione. Ad esempio per accedere al primo elemento che utilizziamo nome_array[0]. Abbiamo discusso in precedenza che il nome dell'array è un puntatore che memorizza l'indirizzo del primo elemento e che gli elementi dell'array sono archiviati in posizioni contigue. Ora accederemo agli elementi di un array utilizzando solo il nome dell'array.

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

Spiegazione

Nel codice sopra, abbiamo prima dichiarato un array arr con quattro elementi. Successivamente, stampiamo gli elementi dell'array. Parliamo di come lo facciamo. Abbiamo discusso del fatto che il nome dell'array è un puntatore che memorizza l'indirizzo del primo elemento di un array quindi, per stampare il primo elemento abbiamo dereferenziato quel puntatore (*arr) utilizzando l'operatore di dereferenziazione (*) che stampa i dati memorizzati a quell'indirizzo.

Per stampare il secondo elemento di un array dobbiamo prima aggiungere 1 A arr che è equivalente a (address of arr + size_of_one_element *1) che porta il puntatore all'indirizzo subito dopo il primo e successivamente dereferenziamo quel puntatore per stampare il secondo elemento. Allo stesso modo, stampiamo il resto degli elementi di un array senza utilizzare l'indicizzazione.

Passaggio di array a funzioni in C++

Per utilizzare gli array in modo efficiente dovremmo sapere come passare gli array alla funzione. Possiamo passare gli array alle funzioni come argomento nello stesso modo in cui passiamo le variabili alle funzioni ma sappiamo che il nome dell'array viene trattato come un puntatore usando questo concetto possiamo passare l'array alle funzioni come argomento e quindi accedere a tutti gli elementi di quell'array usando puntatore.

Quindi, in definitiva, gli array vengono sempre passati come puntatori alla funzione. Vediamo 3 modi per passare un array a una funzione maggiormente utilizzati.

1. Passaggio di array come puntatore

In questo metodo, passiamo semplicemente il nome dell'array nella chiamata di funzione, il che significa che passiamo l'indirizzo al primo elemento dell'array. In questo metodo possiamo modificare gli elementi dell'array all'interno della funzione.

Sintassi

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

2. Passaggio dell'array come array non dimensionato

In questo metodo, la funzione accetta l'array utilizzando una semplice dichiarazione di array senza dimensione come argomento.

Sintassi

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

3. Passaggio dell'array come array dimensionato

In questo metodo, la funzione accetta l'array utilizzando una semplice dichiarazione di array con size come argomento. Usiamo questo metodo dimensionando un array solo per indicare la dimensione di un array.

Sintassi

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

Nota: L'array verrà trattato come un puntatore nella funzione passata, indipendentemente dal metodo utilizzato. Poiché l'array viene passato come puntatore, perderà le informazioni sulla sua dimensione portando a un fenomeno denominato as Decadimento dell'array.

Esempio: illustrazione di diversi modi per passare gli array a una funzione

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

Array multidimensionali in C++

Gli array dichiarati con più di una dimensione sono chiamati array multidimensionali. Gli array multidimensionali più utilizzati sono gli array 2D e gli array 3D. Questi array sono generalmente rappresentati sotto forma di righe e colonne.

Dichiarazione di array multidimensionale

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

Dove,

• Tipo di dati: Tipo di dati da archiviare nell'array.
• Nome_array: Nome della matrice.
• Taglia1, Taglia2,…, TagliaN: Dimensioni di ciascuna dimensione.

Array bidimensionale in C++

In C++, un array bidimensionale è un raggruppamento di elementi disposti in righe e colonne. Si accede a ciascun elemento utilizzando due indici: uno per la riga e uno per la colonna, il che ne facilita la visualizzazione come tabella o griglia.

Sintassi dell'array 2D

data_Type array_name[n][m];>

Dove,

• N: Numero di righe.
• M: Numero di colonne.
  

Esempio: il programma C++ per illustrare l'array bidimensionale

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

Spiegazione

Nel codice sopra abbiamo dichiarato un array 2D con 4 righe e 4 colonne dopo di che abbiamo inizializzato l'array con il valore di (i+j) in ogni iterazione del ciclo. Quindi stampiamo l'array 2D utilizzando un ciclo annidato e possiamo vedere nell'output seguente che ci sono 4 righe e 4 colonne.

Array tridimensionale in C++

La matrice 3D utilizza tre dimensioni. Per rappresentarlo è possibile utilizzare una raccolta di vari array bidimensionali impilati uno sopra l'altro. Tre indici: l'indice di riga, l'indice di colonna e l'indice di profondità vengono utilizzati per identificare in modo univoco ciascun elemento in una matrice 3D.

Dichiarazione di array tridimensionale in C++

Per dichiarare un array 3D in C++, dobbiamo specificare la sua terza dimensione insieme alle dimensioni 2D.

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

Dove,

• Tipo di dati: Tipo di dati da memorizzare in ciascun elemento.
• Nome_array: Nome della matrice
• D: Numero di array 2D o profondità dell'array.
• R: Numero di righe in ciascuna matrice 2D.
• C: Numero di colonne in ciascuna matrice 2D.

Esempio

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

Esempio: il programma C++ per illustrare l'array 3d

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

Spiegazione

Nel codice precedente, abbiamo dichiarato un array 3D e quindi lo abbiamo inizializzato utilizzando tre cicli for nidificati. Successivamente, abbiamo stampato nuovamente tutti gli strati dell'array 3D utilizzando tre cicli for nidificati come mostrato nell'output.

articoli Correlati

• Array multidimensionali in C++
• Proprietà della matrice
• Decadimento dell'array