Si prega di mettere in pausa AdBlock su questo sito.

Un array è il tipo di dati composito più semplice. Quando abbiamo discusso delle variabili, abbiamo avuto una buona analogia con una scatola. Torniamo a lei. Se una variabile è una casella, un array è costituito da più caselle identiche numerate che hanno lo stesso nome e differiscono l'una dall'altra solo per un numero di serie.

Fig.1 Variabili e array. Analogia con la scatola.

L'immagine sopra mostra tre array:

• matrice intera di 8 elementi denominata arr_int
• array reale di 11 elementi denominato arr_float
• array di caratteri di 6 elementi denominato arr_char

Un array, come una variabile, ha il proprio nome e tipo di dati. Inoltre, l'array ne ha uno in più caratteristica aggiuntivaè la dimensione dell'array. La dimensione di un array è il numero di elementi che possono essere archiviati in esso. Nella nostra analogia con le caselle, questo è il numero di caselle.

Nota!

La numerazione degli elementi dell'array parte da zero, non da uno.

Dichiarazione e inizializzazione di un array

Una dichiarazione di matrice è molto simile a una dichiarazione di variabile. L'unica differenza è che è necessario specificare ulteriormente la dimensione dell'array tra parentesi quadre. Ecco alcuni esempi:

Elenco 1.

int arr_int; doppio arr_float; numero variabile;

Un nome di matrice è soggetto a restrizioni simili a quelle imposte a un nome di variabile.

Regola di denominazione degli array

Un nome di matrice è qualsiasi sequenza di caratteri, numeri e il carattere di sottolineatura "_" che inizia con una lettera. Il caso delle lettere è importante.

Ecco alcuni altri esempi di dichiarazioni di array:

Listato 2.

int gradi, ordine; doppio prezzo;

A un array, come qualsiasi variabile, possono essere assegnati valori iniziali quando dichiarato. Se agli elementi dell'array non viene assegnato alcun valore, memorizzeranno immondizia, come nelle variabili ordinarie.

Listato 3.

int arr_int = (2, 5, 5, 3, 4); double arr_float = (1.2, -2.3, 4.5, 3.83, 0.01, -0.12, 44.2, 123.7, 23.44, -3.7, 7);

Se hai bisogno di assegnare valori nulli tutti gli elementi dell'array, puoi farlo:

Listato 4.

doppio arr = (0);

Lavorare con i singoli elementi dell'array

Per fare riferimento a un singolo elemento dell'array, è necessario scriverne il nome e il numero ordinale tra parentesi quadre. Ricorda che la numerazione parte da zero, non da uno.

Ad esempio, visualizziamo sullo schermo gli elementi di una matrice di cinque elementi.

Listato 5.

#includere int main(void)( int arr = (2, 4, 3, 5, 5); printf("%d %d %d %d %d\n",arr, arr, arr, arr, arr); return (0); )

Naturalmente, se l'array è molto grande, visualizzarlo elemento per elemento in modo simile è comunque un piacere. E nessuno lo fa con piccoli array. È meglio e più corretto utilizzare i cicli. Per esempio:

Listato 6.

#includere int main(void)( int arr = (0); for(int i = 0; i< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

Il programma nel primo ciclo memorizza i primi cento numeri pari nell'array e nel secondo ciclo li visualizza sullo schermo.

Armati dei nuovi strumenti, riscriviamo il nostro programma dall'inizio del tutorial per utilizzare un array per memorizzare le statistiche dei numeri casuali.

Listato 7.

#includere #includere #includere int main(void) ( srand(time(NULL)); int count = (0); int rand_number; for (int i = 0; i< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Prestare attenzione alla tecnica utilizzata in questo programma.
L' elemento zero dell'array memorizza il numero di occorrenze del numero 0 , il primo elemento - il numero di occorrenze del numero 1 , il secondo elemento - il numero 2 . Cioè, il numero generato stesso ti consente di determinare a quale elemento dell'array devi aggiungerne uno. Pertanto, non è necessaria un'istruzione switch. Comodo, vero?

Ultimo aggiornamento: 17/09/2017

Un array rappresenta un insieme di dati dello stesso tipo. La definizione formale di un array è la seguente:

Tipo_variabile nome_array [lunghezza_array]

Il tipo di variabile è seguito dal nome dell'array, seguito dalla sua dimensione tra parentesi quadre. Ad esempio, definiamo una matrice di 4 numeri:

numeri interi;

Questa matrice ha quattro numeri, ma tutti questi numeri hanno un valore indefinito. Tuttavia, possiamo inizializzare e assegnare alcuni valori iniziali a questi numeri tramite parentesi graffe:

numeri int = (1,2,3,4);

I valori tra parentesi graffe sono anche chiamati inizializzatori. Se sono presenti meno inizializzatori di quanti sono gli elementi nell'array, gli inizializzatori vengono utilizzati per i primi elementi. Se ci sono più inizializzatori di quanti sono gli elementi nell'array, si verificherà un errore durante la compilazione:

numeri int = (1, 2, 3, 4, 5, 6);

Qui l'array ha dimensione 4, tuttavia gli vengono passati 6 valori.

Se la dimensione dell'array non è specificata in modo esplicito, viene dedotta dal numero di inizializzatori:

numeri int = (1, 2, 3, 4, 5, 6);

In questo caso, l'array ha 6 elementi.

L'inizializzazione degli array di caratteri ha le sue peculiarità. Possiamo passare sia un set di inizializzatori che una stringa a un array di caratteri:

Char s1 = ("h", "e", "l", "l", "o"); carattere s2 = "mondo";

Inoltre, nel secondo caso, l'array s2 non avrà 5 elementi, ma 6, poiché il carattere zero "\0" viene aggiunto automaticamente all'array di caratteri quando viene inizializzato con una stringa.

In questo caso, l'assegnazione a un array di un altro array non è consentita:

int numeri1 = (1,2,3,4,5); int numeri2 = numeri1; // errore nums2 = nums1; // errore

Una volta definito un array, possiamo accedere ai suoi singoli elementi in base all'indice. Gli indici iniziano da zero, quindi per accedere al primo elemento, devi usare l'indice 0. Accedendo a un elemento per indice, possiamo ottenerne il valore, oppure cambiarlo:

#includere int main() ( int numeri = (1,2,3,4); int numero_primo = numeri; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Il numero di elementi dell'array può essere determinato anche tramite una costante:

Costante int n = 4; numeri int[n] = (1,2,3,4);

Iterazione su array

Usando i loop, puoi scorrere l'intero array e accedere ai suoi elementi tramite gli indici:

#includere int main() ( int numeri = (1,2,3,4); int size = sizeof(numeri)/sizeof(numeri); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Per scorrere un array, devi prima trovare la lunghezza dell'array. L'operatore sizeof viene utilizzato per trovare la lunghezza. Infatti, la lunghezza di un array è uguale alla lunghezza totale dei suoi elementi. Tutti gli elementi rappresentano lo stesso tipo e occupano la stessa dimensione in memoria. Pertanto, usando l'espressione sizeof(numbers), troviamo la lunghezza dell'intero array in byte, e usando l'espressione sizeof(numbers), troviamo la lunghezza di un elemento in byte. Dividendo i due valori, puoi ottenere il numero di elementi nell'array. E poi, usando il ciclo for, scorrere tutti gli elementi finché il contatore i diventa uguale alla lunghezza dell'array. Di conseguenza, tutti gli elementi dell'array verranno visualizzati sulla console:

Ma esiste anche un'altra forma del ciclo for che è specificamente progettata per funzionare con le raccolte, inclusi gli array. Questo modulo ha la seguente definizione formale:

For(tipo di variabile: raccolta) ( istruzioni; )

Usiamo questo modulo per iterare su un array:

#includere int main() ( numeri int = (1,2,3,4); for(numero int: numeri) std::cout<< number << std::endl; return 0; }

Quando si esegue l'iterazione su un array, ogni elemento da iterare verrà inserito nella variabile number, il cui valore viene visualizzato sulla console in un ciclo.

Se non conosciamo il tipo degli oggetti nell'array, possiamo usare l'identificatore automatico per determinare il tipo:

Per(numero automatico: numeri) std::cout<< number << std::endl;

Matrici multidimensionali

Oltre alle matrici unidimensionali, C++ ha matrici multidimensionali. Gli elementi di tali array sono essi stessi array, in cui gli elementi possono anche essere array. Ad esempio, definiamo una matrice bidimensionale di numeri:

numeri interi;

Tale matrice è composta da tre elementi, con ogni elemento che rappresenta una matrice di due elementi. Inizializziamo un array come questo:

Numeri int = ( (1, 2), (4, 5), (7, 8) );

Le parentesi graffe nidificate delimitano gli elementi per ogni sottoarray. Tale array può anche essere rappresentato come una tabella:

Puoi anche omettere parentesi graffe durante l'inizializzazione:

numeri int = ( 1, 2, 4, 5, 7, 8 );

È anche possibile inizializzare non tutti gli elementi, ma solo alcuni:

numeri int = ( (1, 2), (), (7) );

E per accedere agli elementi di un array nidificato, sono necessari due indici:

Numeri int = ( (1, 2), (3, 4), (5, 6) ); std::fuori<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Eseguiamo un'iterazione su un array bidimensionale:

#includere int main() ( const int righe = 3, colonne = 2; int numeri = ( (1, 2), (3, 4), (5, 6) ); for(int i=0; i< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

Puoi anche usare un'altra forma di ciclo for per scorrere gli elementi di un array multidimensionale:

#includere int main() ( const int righe = 3, colonne = 2; int numeri = ( (1, 2), (3, 4), (5, 6) ); for(auto &sottonumeri: numeri) ( for(int numero : sottonumeri) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

I riferimenti vengono utilizzati per scorrere gli array che fanno parte di un array. Cioè, nel ciclo esterno for(auto &subnumbers: numbers), &subnumbers rappresenta un riferimento a un sottoarray nell'array. Nel ciclo interno for(int number: subnumbers), da ogni sottoarray in sottonumeri, otteniamo i suoi singoli elementi nella variabile number e ne stampiamo il valore sulla console.

Cosa sono gli array in C?

Come dichiarare gli array in C?

Come inizializzare gli array in C?

Matrici in C per manichini.

Matrici in C

Un array in C è una raccolta di elementi dello stesso tipo a cui è possibile accedere tramite l'indice. Gli elementi degli array in C sono disposti uno dopo l'altro nella memoria del computer.

Un semplice esempio di creazione e compilazione di un array in C:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0 ; )

Noi abbiamo:

Nell'esempio dichiariamo un array contenente elementi di tipo int:

qui il nome dell'array è nArr, il numero di elementi dell'array è tre, il tipo degli elementi dell'array è int.

Un array è una raccolta di elementi. È possibile accedere a ciascun elemento in un array in base al suo numero. Il numero è chiamato indice. Gli elementi della matrice sono numerati da zero. Assegniamo un valore al primo elemento dell'array e il primo elemento ha indice zero:

Assegniamo un valore al secondo elemento dell'array e il secondo elemento ha indice uno:

Assegniamo un valore al terzo elemento dell'array e il terzo elemento ha un indice di due:

Quando visualizziamo gli elementi dell'array, otteniamo i loro valori. Come questo:

printf("nArr\t=\t%d\n", nArr);

Per ottenere un elemento di un array, è necessario specificare il nome dell'array e l'indice dell'elemento:

questo è il primo elemento dell'array, perché il primo elemento ha un indice pari a zero.

Assegniamo il valore del terzo elemento dell'array alla variabile int a:

l'indice del terzo elemento dell'array è uguale a due, poiché gli indici vengono contati da zero.

Ora la regola generale per dichiarare gli array in C è: quando si dichiara un array, è necessario specificarne il nome, il tipo di elementi, il numero di elementi. Il numero di elementi è un numero naturale, cioè intero è positivo. Zero non può essere il numero di elementi. Non è possibile specificare un numero variabile di elementi dell'array. Ecco alcuni esempi di dichiarazioni di array in C:

int nArr; // Dichiarato un array progettato per memorizzare cento numeri interi;
galleggiante fArr; // Dichiarato un array progettato per memorizzare 5 numeri float;
char cArr; // Dichiarato un array progettato per memorizzare due caratteri;

Sarebbe un errore dichiarare un array con un numero variabile di elementi:

int varElem;
int nArr; // Errore! Il numero di elementi non può essere impostato su una variabile;

Ma puoi impostare il numero di elementi con un valore costante: un intero positivo diretto 1, 2, 3... o una costante:

Costante int arrayLength = 3;
int nArr;

Quando si dichiara un array in C, è possibile inizializzarlo immediatamente:

int nArray = (1, 2, 3);

È possibile omettere il numero di elementi dell'array tra parentesi quadre se tutti gli elementi dell'array sono inizializzati:

int nArray = (1, 2, 3);

il numero di elementi sarà determinato automaticamente in questo caso.

Puoi definire solo una parte degli elementi di un array quando lo dichiari:

int nArray = (1, 2);

in questo esempio, i primi due elementi dell'array vengono inizializzati e il terzo non è definito.

Esempio di array di caratteri:

char cArr = ("S", "B", "P");

Quando si dichiara un array, non è possibile specificare il numero di elementi in una variabile. Ma puoi usare le variabili quando accedi agli elementi dell'array:

int ind = 0;
char cr = cArr;

Viene utilizzato quando si lavora con i loop. Esempio:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

Nell'esempio, nel primo ciclo riempiamo l'array con elementi di tipo int e nel secondo ciclo visualizziamo questi elementi sullo schermo.

Matrici

Vettoreè una raccolta di variabili dello stesso tipo con un nome comune per accedervi. In C#, le matrici possono essere unidimensionali o multidimensionali. Gli array servono a un'ampia varietà di scopi perché forniscono un mezzo conveniente per raggruppare insieme variabili correlate.

Gli array in C# possono essere usati più o meno allo stesso modo di altri linguaggi di programmazione. Tuttavia, hanno una particolarità: sono implementati come oggetti.

L'uso di una matrice in un programma richiede una procedura in due passaggi perché C# implementa le matrici come oggetti. Innanzitutto, devi dichiarare una variabile che può accedere a un array. E in secondo luogo, è necessario creare un'istanza dell'array utilizzando l'operatore new.

Utilizzo del sistema; utilizzando System.Collections.Generic; utilizzando System.Linq; usando System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Dichiara un array int myArr = new int; // Inizializza manualmente ogni elemento dell'array myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 ; foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); ) ) )

Tieni presente che se un array viene solo dichiarato ma non inizializzato in modo esplicito, ciascuno dei suoi elementi verrà impostato sul valore predefinito per il tipo di dati corrispondente (ad esempio, gli elementi dell'array bool verranno impostati su false e gli elementi dell'array int saranno impostato su falso). 0).

Inizializzazione dell'array

Oltre a riempire un elemento dell'array per elemento (come mostrato nell'esempio precedente), puoi anche riempirlo usando una speciale sintassi di inizializzazione dell'array. A tale scopo, enumera gli elementi da includere nell'array tra parentesi graffe ( ). Questa sintassi è utile quando si crea un array di dimensioni note, quando è necessario impostarne rapidamente i valori iniziali:

// Sintassi per inizializzare un array usando // la parola chiave new int myArr = new int (10,20,30,40,50); // Sintassi dell'inizializzazione dell'array senza utilizzare // la parola chiave new string info = ( "Cognome", "Nome", "Patronimico" ); // Usa la nuova parola chiave e la dimensione desiderata char symbol = new char ("X","Y","Z","M" );

Si noti che quando si utilizza la sintassi delle parentesi graffe, non è necessario specificare la dimensione dell'array (come mostrato nell'esempio di creazione della variabile myArr), poiché questa dimensione viene calcolata automaticamente in base al numero di elementi all'interno delle parentesi graffe. Inoltre, usa la parola chiave nuovo facoltativo (come quando si crea un array di informazioni).

La parola chiave var consente di definire una variabile in modo che il tipo sottostante venga dedotto dal compilatore. Allo stesso modo, puoi anche definire array locali tipizzati in modo implicito. Usando questo approccio, puoi definire una nuova variabile di matrice senza specificare il tipo di elementi contenuti nella matrice. Diamo un'occhiata a un esempio:

Utilizzo del sistema; utilizzando System.Collections.Generic; utilizzando System.Linq; usando System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( var arr1 = new ( 1, 2, 3 ); Console.WriteLine("arr1 array type - (0)",arr1.GetType()); var arr2 = new ("Uno", "Due", "Tre" ); Console.WriteLine("Tipo di array arr2 - (0)", arr2.GetType()); Console.ReadLine(); ) ) )

Naturalmente, proprio come quando si crea un array utilizzando la sintassi C# esplicita, gli elementi specificati nell'elenco di inizializzazione di un array devono necessariamente avere lo stesso tipo di base (ovvero devono essere tutti int, string o MyCar).

Definizione di una matrice di oggetti

Nella maggior parte dei casi, quando si definisce un array, il tipo dell'elemento contenuto nell'array viene specificato in modo esplicito. Anche se a prima vista sembra abbastanza chiaro, c'è una caratteristica importante. Ogni tipo nel sistema di tipi .NET (inclusi i tipi di dati fondamentali) è in definitiva basato sulla classe base System.Object. Di conseguenza, risulta che nel caso di definizione di un array di oggetti, gli elementi al suo interno possono essere qualsiasi cosa:

Utilizzo del sistema; utilizzando System.Collections.Generic; utilizzando System.Linq; usando System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Dichiara e inizializza un array di oggetti object arrByObject = ( true, 10, "Hi", 13.7m ); // Stampa il tipo di ciascun membro dell'array alla console foreach (oggetto in arrByObject) Console.WriteLine("Type (0) - (1)",me,me.GetType()); Console.ReadLine(); ) ) )