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 BP.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; // Sbaglio! 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(); ) ) )
Si noti che se un array viene solo dichiarato ma non inizializzato in modo esplicito, ogni elemento 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 verranno impostati su false) .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, "Hello", 13.7m ); // Stampa il tipo di ogni membro dell'array alla console foreach (oggetto in arrByObject) Console.WriteLine("Type (0) - (1)",me,me.GetType()); Console.ReadLine(); ) ) )
Quando si risolvono problemi con una grande quantità di dati dello stesso tipo, l'utilizzo di variabili con nomi diversi che non sono ordinate per indirizzi di memoria rende difficile la programmazione. In casi come questo, il linguaggio C utilizza oggetti chiamati array.
è un pezzo di memoria contiguo contenente una sequenza di oggetti dello stesso tipo, indicati con lo stesso nome.
Un array è caratterizzato dai seguenti concetti di base:
Elemento array (valore dell'elemento array)- il valore memorizzato in una specifica cella di memoria situata all'interno dell'array, nonché l'indirizzo di tale cella di memoria.
Ogni elemento dell'array è caratterizzato da tre valori:
- indirizzo dell'elemento - l'indirizzo della cella di memoria iniziale in cui si trova questo elemento;
- indice dell'elemento (numero di serie dell'elemento nell'array);
- valore dell'elemento.
L'indirizzo dell'array è l'indirizzo dell'elemento iniziale dell'array.
Il nome dell'array è un identificatore utilizzato per fare riferimento agli elementi dell'array.
Dimensione dell'array - numero di elementi dell'array
Dimensione elemento: il numero di byte occupati da un elemento dell'array.
Graficamente, la posizione dell'array nella memoria del computer può essere rappresentata come un nastro continuo di indirizzi.
L'array mostrato in figura contiene q elementi con indici da 0 a q-1 . Ogni elemento occupa k byte nella memoria del computer e la posizione degli elementi in memoria è sequenziale.
L'indirizzo dell'i-esimo elemento dell'array ha un valore
L'indirizzo di una matrice è l'indirizzo dell'elemento iniziale (zero) della matrice. Per accedere agli elementi di un array, viene utilizzato il numero ordinale (indice) dell'elemento, il cui valore iniziale è 0 . Quindi, se l'array contiene q elementi, gli indici degli elementi dell'array variano da 0 a q-1 .
Lunghezza dell'array: il numero di byte allocati in memoria per archiviare tutti gli elementi dell'array.
ArrayLength = ElementSize * Numero di elementi
La funzione può essere utilizzata per determinare la dimensione di un elemento dell'array.
int sizeof(tipo);
Per esempio,
dimensionedi(carattere) = 1;
dimensionedi(int) = 4;
sizeof(flottante) = 4;
sizeof(doppio) = 8;
Dichiarazione e inizializzazione di array
La sintassi per dichiarare un array in C è:
digitare nome[dimensione]=(inizializzazione);
L'inizializzazione è un insieme di valori iniziali di elementi dell'array, specificati tra parentesi graffe e separati da virgole.
int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // array a di 10 numeri interi
Se il numero di valori di inizializzazione specificato tra parentesi graffe è inferiore al numero di elementi dell'array specificato tra parentesi quadre, tutti gli elementi rimanenti nell'array (per i quali non erano presenti valori di inizializzazione sufficienti) saranno uguali a zero. Questa proprietà è utile per impostare valori zero su tutti gli elementi dell'array.
int b = (0); // array b di 10 elementi inizializzato a 0
Se un array viene inizializzato al momento della dichiarazione, i valori iniziali costanti dei suoi elementi vengono specificati separati da virgole tra parentesi graffe. In questo caso, il numero di elementi tra parentesi quadre può essere omesso.
int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);
Quando si accede agli elementi dell'array, l'indice dell'elemento richiesto viene specificato tra parentesi quadre.
Esempio in C
1
2
3
4
5
6
7
8
#includere
int principale()
{
int a = ( 5, 4, 3, 2, 1 ); // l'array a contiene 5 elementi
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
restituire 0;
}
Il risultato dell'esecuzione del programma:
Tuttavia, è spesso necessario impostare i valori degli elementi dell'array durante l'esecuzione del programma. Questo utilizza una dichiarazione di matrice senza inizializzazione. In questo caso è obbligatorio specificare il numero di elementi tra parentesi quadre.
int a;
Per impostare i valori iniziali degli elementi dell'array, molto spesso viene utilizzato un ciclo parametrico:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#includere
int principale()
{
int a;
int io;
// Immettere gli elementi dell'array
per (i = 0; io<5; i++)
{
printf("a[%d] = ", io);
scanf("%d" , &a[i]);
}
// Visualizza gli elementi dell'array
per (i = 0; io<5; i++)
printf("%d " , a[i]); // spazio richiesto nel formato di stampa
getchar(); getchar();
restituire 0;
}
Il risultato dell'esecuzione del programma 
Matrici multidimensionali
Nel linguaggio C si possono anche dichiarare array multidimensionali. La differenza tra un array multidimensionale e un array unidimensionale è che in un array unidimensionale, la posizione di un elemento è determinata da un indice e in un array multidimensionale da diversi. Un esempio di array multidimensionale è una matrice.
Forma generale di dichiarazione di un array multidimensionale
digitare nome[dimensione1][dimensione2]...[dimensionem];
Gli elementi di un array multidimensionale si trovano in celle RAM consecutive in ordine crescente di indirizzi. Nella memoria del computer, gli elementi di un array multidimensionale sono disposti in una riga, ad esempio un array che ha 2 righe e 3 colonne,
int a;
si troverà in memoria come segue
Il numero totale di elementi nella data matrice bidimensionale è definito come
Numero di righe * Numero di colonne = 2 * 3 = 6.
Il numero di byte di memoria necessari per allocare l'array è definito come
ItemNumber * ItemSize = 6 * 4 = 24 byte.
Inizializzazione di array multidimensionali
I valori degli elementi di un array multidimensionale, come nel caso unidimensionale, possono essere impostati a valori costanti quando dichiarati, racchiusi tra parentesi graffe (). Tuttavia, in questo caso, l'indicazione del numero di elementi in righe e colonne deve essere indicata tra parentesi quadre.
Esempio in C
1
2
3
4
5
6
7
8
9
#includere
int principale()
{
int a = ( 1, 2, 3, 4, 5, 6 );
printf("%d %d %d\n" , a, a, a);
getchar();
restituire 0;
}
Più spesso, invece, è necessario inserire i valori degli elementi di un array multidimensionale durante l'esecuzione del programma. A questo scopo, è conveniente utilizzare un ciclo parametrico nidificato.
Esempio in C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define _CRT_SECURE_NO_WARNINGS
#includere
int principale()
{
int a; // array con 2 righe e 3 colonne
int io, j;
// Immettere gli elementi dell'array
per (i = 0; io<2; i++) // scorre le righe
{
per (j = 0; j<3; j++) // scorre le colonne
{
printf("a[%d][%d] = ", io, j);
scanf("%d" , &a[i][j]);
}
}
// Visualizza gli elementi dell'array
per (i = 0; io<2; i++) // scorre le righe
{
per (j = 0; j<3; j++) // scorre le colonne
{
printf("%d " , a[i][j]);
}
printf("\n"); // trasferisci su una nuova riga
}
getchar(); getchar();
restituire 0;
}
Passaggio di un array a una funzione
È conveniente organizzare l'elaborazione degli array utilizzando funzioni speciali. Per elaborare un array come argomenti di funzione, devi passare
- indirizzo dell'array,
- dimensione della matrice.
L'eccezione sono le funzioni di elaborazione delle stringhe, in cui è sufficiente passare solo l'indirizzo.
Quando si passano variabili come argomenti di funzione, i dati vengono passati come copie. Ciò significa che se il valore di un parametro cambia all'interno della funzione, non influenzerà in alcun modo il suo valore all'interno della funzione chiamante.
Se l'indirizzo di una variabile (o l'indirizzo di un array) viene passato alla funzione, tutte le operazioni eseguite nella funzione con i dati che rientrano nell'ambito dell'indirizzo specificato vengono eseguite sui dati originali, quindi l'array originale ( o il valore della variabile) può essere modificato dalla funzione richiamata.
Esempio in C Dato un array di 10 elementi. Scambia gli elementi più grandi e iniziali di un array. Per le operazioni di ricerca dell'elemento massimo e scambio, utilizzare la funzione.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#define _CRT_SECURE_NO_WARNINGS
#includere
// Funzione di scambio
void change(int *x, int n)
{
// x - puntatore all'array (indirizzo dell'array)
// n - dimensione dell'array
int io;
int max, indice;
massimo=x;
indice = 0;
// Cerca l'elemento massimo
per (i = 1; io
se (x[i]>max)
{
massimo = x[i];
indice = io;
}
}
// Scambio
x = x;
x=massimo;
}
// funzione principale
int principale()
{
int a;
int io;
per (i = 0; io<10; i++)
{
printf("a[%d] = ", io);
scanf("%d" , &a[i]);
}
modifica(a, 10); // chiama la funzione di scambio
// Visualizza gli elementi dell'array
per (i = 0; io<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
Restituzione
p = p * x[i];
}
ritorno p;
}
// funzione principale
int principale()
{
int a; // array dichiarato a con 5 elementi
int io;
intpr;
// Immettere gli elementi dell'array
per (i = 0; io<5; i++)
{
printf("a[%d] = ", io);
scanf("%d" , &a[i]); // &a[i] - indirizzo dell'i-esimo elemento dell'array
}
pr = func(a, 5); // calcolo del prodotto
printf("\n pr = %d" , pr); // stampa il prodotto di elementi pari
getchar(); getchar();
restituire 0;
}
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, ma 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 ha ancora una 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 vuoi assegnare valori zero a tutti gli elementi di un 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
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
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
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?
Supponiamo di dover lavorare con una grande quantità di dati dello stesso tipo. Ad esempio, abbiamo mille misurazioni della coordinata del pendolo con un certo intervallo di tempo. Creare 1000 variabili per contenere tutti i valori è molto... ingombrante. Invece, molti dati dello stesso tipo possono essere combinati sotto un unico nome e ogni elemento specifico può essere indicato con il suo numero di serie.
Un array in C è definito come segue
<тип> <имя массива>[<размер>];
Per esempio,
int a;
Otterremo un array chiamato un, che contiene cento elementi di tipo int. Come con le variabili, un array contiene spazzatura.
Per accedere al primo elemento, scrivi il suo numero (indice) tra parentesi quadre. Per esempio
#includere
Il primo elemento ha il numero di indice 0. È importante capire perché. In futuro rappresenteremo la memoria di un computer sotto forma di nastro. Il nome di una matrice è un puntatore all'indirizzo di memoria in cui si trovano gli elementi della matrice.
Riso. 1 L'array contiene l'indirizzo del primo elemento. L'indice dell'elemento i è lo spostamento di i*sizeof(type) byte dall'inizio
L'indice dell'array indica quanti byte devono essere spostati dall'inizio dell'array per accedere all'elemento desiderato. Ad esempio, se l'array UN ha tipo int, quindi A significa che abbiamo spostato 10*sizeof(int) byte dall'inizio. Il primo elemento si trova proprio all'inizio e ha un offset di 0*sizeof(int) .
In C, un array non memorizza le sue dimensioni e non verifica la validità dell'indice dell'array. Ciò significa che puoi andare oltre l'array e accedere alla memoria che è più lontana dell'ultimo elemento dell'array (o più vicino).
L'inizializzazione iniziale dell'array.
Scriviamo un semplice programma. Creiamo un array e poi troviamo il suo elemento massimo.
#includere
Facciamo un esempio. Per prima cosa creiamo un array e lo inizializziamo al momento della creazione. Successivamente, assegniamo il valore del primo elemento dell'array all'elemento massimo trovato.
massimo=a;
Quindi esaminiamo l'array. Poiché abbiamo già esaminato il primo elemento (ha un indice di 1), non ha senso guardarlo di nuovo.
Stesso esempio, solo ora l'utente inserisce i valori
#includere
Nel caso in cui durante l'inizializzazione vengano specificati meno valori rispetto alla dimensione dell'array, gli elementi rimanenti vengono riempiti con zeri.
#includere
Se è necessario riempire l'intero array con zeri, scriviamo
Int a = (0);
Ad esempio, non è possibile impostare in modo esplicito la dimensione dell'array
int a = (1, 2, 3);
l'array avrà dimensione 3
Dimensione della matrice
Un array in C deve avere una dimensione costante. Ciò significa che è impossibile, ad esempio, chiedere all'utente una dimensione e quindi impostare questa dimensione su un array.
Printf("Inserisci la lunghezza dell'array"); scanf("%d", &lunghezza); ( galleggiante x; )
La creazione di array dinamici sarà discussa ulteriormente, quando si lavora con puntatori e memoria.
In alcuni casi, puoi scoprire la dimensione di un array usando la funzione taglia di.
#includere
Ma è improbabile che questo sia utile. Quando si passa un array, un puntatore verrà passato come argomento alla funzione, quindi sarà impossibile conoscere la dimensione dell'array.
Gli array statici sono utili quando il numero di elementi è noto in anticipo. Forniscono un accesso rapido ma non sicuro agli elementi.
Overflow dell'array
Per favore, hai questo codice
IntA; int io; per (i=0; i<=10; i++) { A[i] = 1; }
Qui ciclo per dato con un errore. In alcune versioni precedenti di compilatori, questo codice è stato eseguito in loop. Il punto è che la variabile io si trovava durante la compilazione immediatamente dopo l'array UN. Quando l'array era fuori limite, il contatore è stato trasferito a 1.
Gli array non sono sicuri, perché un lavoro errato con un indice può portare all'accesso a una posizione arbitraria nella memoria (teoricamente. I compilatori moderni stessi si prendono cura di non scavare nella memoria di qualcun altro).
Se si lavora con gli array, è necessario assicurarsi che il contatore non superi la dimensione dell'array e non sia negativo. Per questo, almeno
- 1. Utilizzare il tipo size_t per l'indicizzazione. Ti proteggerà dai valori negativi e sarà sempre sufficiente per un array di qualsiasi dimensione.
- 2. Ricorda che l'array parte da zero.
- 3. L'ultimo elemento dell'array ha un indice (dimensione dell'array - 1)
Esempi
Ora alcuni esempi tipici di lavoro con gli array
1. Capovolgere l'array.
#includere
Ecco un design sconosciuto per te
#definisci TAGLIA 10u
macro. In tutto il codice, il preprocessore sostituirà automaticamente tutte le occorrenze di SIZE con 10u.
2. Eliminazione dell'elemento selezionato dall'utente.
#includere
La cancellazione dell'elemento in questo caso, ovviamente, non si verifica. L'array rimane della stessa dimensione di prima. Sovrascriviamo semplicemente l'elemento successivo da rimuovere e restituiamo elementi SIZE-1.
3. L'utente inserisce i valori nell'array. Successivamente, emetti tutti i diversi valori che ha inserito.
Lascia che l'utente inserisca un numero finito di elementi, diciamo 10. Quindi è noto in anticipo che non ci saranno più di 10 valori diversi.Ogni volta che l'utente inserisce un numero, esamineremo l'array e verificheremo se tale il numero è stato inserito.
#includere
4. L'utente inserisce un numero - il numero di misurazioni (da 2 a 10). Dopo di che entra in tutte le misurazioni. Il programma fornisce il valore medio, varianza, errore.
#includere
5. Matrice di ordinamento a bolle
#includere
6. Mescolare l'array. Per questo utilizziamo l'algoritmo
