Dimensione dell'array di modifica C ++

Una volta assegnato un array, non esiste un meccanismo integrato per ridimensionarlo nel linguaggio di programmazione C ++. Pertanto, possiamo evitare questo problema generando dinamicamente un nuovo array, copiando il contenuto e quindi eliminando il vecchio array. Questo articolo si concentra su come allocare la memoria dinamicamente in un array e regolare la dimensione dell'array in base all'input dell'utente. È una strategia molto importante nella programmazione poiché assicura un efficiente utilizzo della memoria. Quando proviamo a inserire un nuovo elemento in un array dinamico, aumenta automaticamente fino a quando non c'è più spazio per il nuovo articolo. In genere, la regione raddoppia di dimensioni.

Cos'è un array dinamico?

Un array dinamico è identico a un array standard in apparenza, ma le sue dimensioni possono essere modificate mentre il codice è in esecuzione. I componenti dell'array dinamico occupano un blocco di memoria contiguo. Dopo che è stato definito un array, non è possibile modificarne le dimensioni. Al contrario, un array dinamico non è come un array statico. Anche dopo che è stato occupato, un array dinamico può estendere le sue dimensioni. Gli elementi possono essere aggiunti costantemente nella posizione terminale dell'array dinamico utilizzando lo spazio riservato fino a quando non è completamente occupato.

Fattori chiave dell'array dinamico in C ++:

Le prestazioni dell'array sono determinate dalla dimensione iniziale e dal fattore di crescita. Prendi nota dei seguenti punti:

• Se un array ha dimensioni modeste e ha un fattore di crescita più lento, continuerà a riallocare la memoria più spesso. Di conseguenza, le prestazioni dell'array soffriranno.
• Se un array è più grande e ha un fattore di crescita elevato, avrà una grande quantità di memoria inutilizzata. Di conseguenza, i processi di ridimensionamento possono richiedere più tempo. Anche le prestazioni dell'array ne soffriranno

Esempio 1:

La nuova parola chiave viene utilizzata per creare un array dinamico nel seguente programma C ++. Successivamente, la parola chiave restituisce un riferimento al primo elemento. La sezione di intestazione ha il file della libreria iostream incluso per utilizzare i suoi metodi. Il file dello spazio dei nomi è anche incluso che consente l'utilizzo della sua classe senza essere chiamato. Quindi la funzione principale viene invocata in cui abbiamo dichiarato due variabili "P" e "num" del tipo di dati interi.

Nel passaggio successivo, l'istruzione COUT stampa l'istruzione "Immettere i numeri". Il comando CIN prende input dall'utente e lo assegna alla variabile "NUM". Il passo successivo ha la variabile puntatore "array" che contiene i valori interi della variabile "num". Il numero di immissione dell'utente verrà stampato utilizzando il comando Cout. Poi abbiamo per le condizioni del ciclo che itera su ciascun elemento inserito dall'utente. L'array come "array" è dichiarato nel comando CIN che legge l'input inserito dall'utente.

Dopo la risoluzione del ciclo, l'istruzione "I tuoi numeri sono" stamparrà sulla schermata della console. Ancora una volta, abbiamo un per le condizioni del ciclo Ma questa volta questo per le condizioni del ciclo iterate su una serie di elementi. Si noti che abbiamo permesso a un utente di impostare la dimensione dell'array. Di conseguenza, la dimensione dell'array è definita in fase di esecuzione.

#includere
Utilizzo dello spazio dei nomi std;
int main ()
int p, num;
cout<< "Enter the numbers:" num;
int *array = new int (num);
cout<< "Enter " << num << " numbers" <per (p = 0; p> array [p];

cout<< "Your numbers are: ";
per (p = 0; p < num; p++)
cout<< Array[p] << " ";

cout<< "\n ";
restituzione 0;

All'utente viene richiesto di inserire il numero nel prompt della console. Dopo l'input, il numero per la dimensione dell'array visualizza i numeri di dimensione dell'array specificata. L'array risultante è mostrato nella prompt della console di Ubuntu.

Esempio 2:

Un elenco di inizializzatori può essere utilizzato per impostare un array dinamico. Illustriamo questo con un esempio per vedere come funziona. Innanzitutto, abbiamo aggiunto il file iostream e il file dello spazio dei nomi STD nella sezione di intestazione. In seguito, abbiamo invocato la funzione principale. La logica del programma dovrebbe essere inclusa nel corpo della funzione. Quindi abbiamo definito una variabile come "A" di tipo di dati interi.

Dopo aver dichiarato la variabile intera, abbiamo una dichiarazione di array dinamica come "ARR" che utilizza un elenco di inizializzatori. Abbiamo quattro voci interi nell'array. Il comando Cout stamperà l'istruzione "Elements of Array" prima di visualizzare gli elementi dell'array.

Nel prossimo passaggio, abbiamo a per loop che itera sugli elementi presenti in un array specificato. Attraverso il comando Cout, gli elementi dell'array dato verranno stampati sul prompt della console.

#includere
Utilizzo dello spazio dei nomi std;
int main (void)
int a;
int *arr new int [4] 9, 23, 1, 17;
cout<< "Elements of Array: " <per (a = 0; a < 4; a++)
cout<
restituzione 0;

Quello che segue è il risultato che abbiamo ottenuto dall'esecuzione del programma sopra:

Esempio 3:

Una volta raggiunto l'obiettivo dell'array dinamico, dovrebbe essere rimosso dalla memoria del computer. L'espressione di eliminazione può essere utilizzata per fare in questo modo che lo spazio di memoria sia gratuito e utilizzato per archiviare dati aggiuntivi. Dobbiamo usare Elimina [] per rimuovere l'array dinamico dalla memoria del sistema. La fascia quadrata [] con la parola chiave elimina comanda la CPU per rimuovere molte variabili anziché una sola.

Iniziamo l'implementazione del programma. Abbiamo importato il file richiesto nella sezione di intestazione. Quindi, la funzione principale si chiama. Le variabili interi "io" e "no" sono dichiarate nella funzione principale. Dopo aver definito queste variabili, abbiamo l'istruzione Cout "Numero di input" che è per l'utente immettere il numero. Riceviamo un numero dall'utente e lo salviamo nella variabile "No" usando il comando CIN.

Quindi, dichiara una variabile puntatore "myarr" che memorizza i numeri interi nella memoria. Il numero inserito dall'utente verrà stampato nel secondo comando cout di questo programma. IL per loop L'istruzione viene utilizzata per l'iterazione rispetto al numero inserito dall'utente. Alla fine, abbiamo costruito l'istruzione ELETE [] che cancella l'array fornito nel programma e libera spazio nella memoria.

#includere
Utilizzo dello spazio dei nomi std;
int main ()
int i, no;
cout<< "Input Number:" no;
int *myarr = new int (no);
cout<< "Input " << no << " numbers" <per (i = 0; i> myarr [i];

cout<< "Input numbers are: ";
per (i = 0; i< no; i++)
cout<
cout<elimina [] myarr;
restituzione 0;

All'esecuzione del programma, abbiamo ottenuto il seguente output. Quando il programma viene chiuso, l'array verrà eliminato.

Esempio 4:

Possiamo definire un array di puntatore di dimensioni "x" in modo dinamico e quindi allocare la memoria della dimensione "y" dinamicamente per ogni culo di riga visto nell'esempio seguente. Inizialmente, abbiamo definito la matrice nella sezione intestazione. Nel passaggio successivo, abbiamo la funzione principale in cui abbiamo una variabile puntatore "arr". La variabile puntatore contiene l'array di dimensioni "x".

Ora il per la dichiarazione Loop Assegna ogni riga una dimensione della memoria "Y". Quindi, abbiamo un ciclo nidificato per assegnare dinamicamente i valori a una memoria che è stata assegnata. La funzione RAND genererà un numero casuale per l'array 2D. Nel prossimo ciclo nidificato, abbiamo stampato l'array 2D tramite la dichiarazione STD :: Cout. Al termine della risoluzione del programma, l'array 2D specificato verrà cancellato dallo spazio di memoria allocato mentre abbiamo usato elimina [] alla fine.

#includere
#define x 3
#define y 4
int main ()

int ** arr = new int*[x];
per (int i = 0; i< X; i++)
arr [i] = new int [y];

per (int i = 0; i< X; i++)

per (int j = 0; j < Y; j++)
arr [i] [j] = rand () % 10;


per (int i = 0; i< X; i++)

per (int j = 0; j < Y; j++)
std :: cout<
std :: cout<< std::endl;

per (int i = 0; i< X; i++)
elimina [] arr [i];

elimina [] arr;
restituzione 0;

L'array 2D è stato generato e mostrato nella schermata della console in basso.

Conclusione

Si tratta dell'array ridimensionato in C++. Siamo venuti a sapere che gli array C ++ non hanno un metodo integrato per ridimensionare. Ma attraverso l'allocazione dell'array dinamico in C ++, la dimensione dell'array può essere modificata. Abbiamo illustrato nell'esempio per modificare le dimensioni dell'array dinamico utilizzando una nuova parola chiave. Inoltre, possiamo utilizzare un elenco di inizializzatori per inizializzare un array. Dopo il ridimensionamento possiamo anche liberare spazio in memoria usando ELETE []. Questo articolo ti mostrerà come ridimensionare un array in c++.