Array allocato dinamicamente C ++

Gli array sono una struttura di dati molto importante in C ++ che servono allo scopo di contenere tipi simili di elementi. Gli array sono principalmente divisi in due diversi tipi i.e. statico e dinamico. Gli array statici sono quelli le cui dimensioni sono pre-definite all'interno del codice mentre le array dinamiche sono quelle le cui dimensioni sono definite in fase di esecuzione. In questo articolo, parleremo esplicitamente degli array dinamici in C++. Inoltre, presteremo particolare attenzione alla loro allocazione e allocazione condividendo un esempio dettagliato con te in Ubuntu 20.04.

Array allocato dinamicamente in c++

Abbiamo già affermato che la dimensione di un array dinamico è definita in fase di esecuzione. Tuttavia, si potrebbe chiedere perché abbiamo bisogno degli array allocati dinamicamente in primo luogo quando possiamo usare comodamente gli array statici? Bene, a volte, incontri tali situazioni in cui inizialmente la dimensione di un array non è nota. In questi casi, è possibile acquisire la dimensione dell'array come input dall'utente in fase di esecuzione.

Ma ciò non è possibile con gli array statici poiché le dimensioni di un array statico una volta definite all'interno di un codice non possono essere modificate. È qui che entrano in gioco gli array allocati dinamicamente che possono definire le matrici di qualsiasi dimensione desiderata in fase di esecuzione. Gli array dinamici in C ++ possono essere facilmente creati con la "nuova" parola chiave. La sintassi esatta sarà chiarita più avanti in questo articolo.

Tuttavia, un punto importante da notare qui è che gli array statici vengono sempre creati nello stack del tuo sistema e il tuo sistema stesso si assume la responsabilità di liberare il suo stack quando il programma termina. D'altra parte, gli array allocati dinamicamente vengono sempre creati sul mucchio e devi liberare manualmente la memoria occupata da un array dinamico. Ora, devi vedere l'esempio discusso di seguito per comprendere l'uso degli array allocati dinamicamente.

Usando gli array allocati dinamicamente in C ++ in Ubuntu 20.04

In questo esempio, vogliamo insegnarti l'uso degli array allocati dinamicamente in C++. Ti diremo come puoi dichiarare e inizializzare un array dinamico in fase di esecuzione. Quindi, visualizzeremo gli elementi dell'array allocato dinamicamente. Infine, ti mostreremo come puoi trattare la memoria occupata dall'array dinamico in C++. Per imparare tutto questo, dovrai vedere il codice mostrato nella seguente immagine:

In questo programma C ++, abbiamo la nostra funzione "principale ()" in cui abbiamo definito un numero intero "num". Questo numero intero corrisponderà alle dimensioni del nostro array dinamico che creeremo in seguito. Quindi, abbiamo visualizzato un messaggio sul terminale che chiede all'utente di inserire qualsiasi dimensione a scelta per l'array dinamico. Successivamente, abbiamo preso quella dimensione come input dall'utente. Quindi, con l'aiuto dell'affermazione "int *array = new int (num)", abbiamo dichiarato un array dinamico in fase di esecuzione che ha la dimensione uguale alla variabile "num". "Array" si riferisce al nome di questo array.

Successivamente, abbiamo visualizzato nuovamente un messaggio sul terminale chiedendo all'utente di inserire gli elementi di quell'array. Questo messaggio è seguito da un ciclo "per" che itera fino alle dimensioni dell'array i.e. Num. All'interno di questo ciclo, abbiamo preso gli elementi di quell'array dinamico come input dell'utente.

Una volta popolato l'array dinamico, volevamo visualizzare i suoi elementi sul terminale per il quale abbiamo prima visualizzato un messaggio con l'aiuto della dichiarazione "cout". Quindi, abbiamo un altro ciclo "per" che si iterato attraverso le dimensioni dell'array dinamico. All'interno di questo ciclo, abbiamo semplicemente visualizzato gli elementi dell'array sul terminale. Successivamente, volevamo trattare la memoria occupata da questo array dinamico per la quale abbiamo usato l'istruzione "Elimina [] array". Infine, per essere al sicuro, abbiamo usato l'istruzione "array = null" per eliminare anche il riferimento null dell'array dinamico la cui memoria abbiamo appena trattato.

Dopo aver scritto questo codice, quando l'abbiamo compilato ed eseguito, ci è stato chiesto per la prima volta di inserire le dimensioni dell'array dinamico. Volevamo che il nostro array dinamico fosse di dimensioni "5" come mostrato nell'immagine qui sotto:

Non appena siamo entrati nelle dimensioni del nostro array dinamico, ci è stato chiesto di popolarlo. Per fare ciò, abbiamo inserito i numeri da 1 a 5 come mostrato nella seguente immagine:

Non appena abbiamo premuto il tasto Invio dopo aver popolato il nostro array dinamico, i suoi elementi sono stati stampati sul terminale. Inoltre, si è verificata anche il traffico della memoria dinamica a causa della quale una notifica al riguardo è apparsa anche sul terminale come mostrato nell'immagine seguente:

Ora, modificheremo leggermente lo stesso codice. Fino ad ora, abbiamo imparato come possiamo inizializzare un array dinamico in C ++ e visualizzare i suoi elementi sul terminale. Sebbene, abbiamo anche incorporato il codice per il traffico di questa memoria nel nostro programma, tuttavia, non siamo ancora sicuri se la memoria dinamica occupata sia stata trafficata con successo o no. Per fare ciò, cercheremo di accedere a una parte di quella memoria dinamica dopo averlo trattato. Se si accede correttamente, significherà che il traffico di memoria non ha avuto luogo correttamente.

Tuttavia, se incontriamo un messaggio di errore durante l'accesso a quella memoria dopo averlo trattato, ciò significherà che la nostra memoria dinamica occupata è stata ora trattata con successo. Devi dare un'occhiata al seguente codice modificato per capire questo:

In questo codice C ++ modificato, abbiamo semplicemente aggiunto una riga alla fine del nostro programma I.e. cout<

Quando abbiamo compilato ed eseguito questo codice, ha funzionato perfettamente, tuttavia, non appena l'ultima riga è stata eseguita, è stato generato un errore riferendosi a un errore di segmentazione che in realtà significa che si sta cercando di accedere a una posizione di memoria che non esiste più. Questo viene visualizzato nell'immagine allegata.

Significa che il traffico del nostro array dinamico ha avuto luogo con successo. Questo output implica anche che il tentativo di accedere a una posizione di memoria che non esiste più si traduce solo in un errore di runtime e non in un errore di compilazione. Significa che un tale codice verrà sempre compilato correttamente e non sarai in grado di catturare un tale errore fino a quando non esegui effettivamente il codice.

Conclusione

Questo articolo mirava a insegnarti l'uso degli array allocati dinamicamente in C ++ in Ubuntu 20.04. Per questo, abbiamo prima evidenziato la necessità di utilizzare gli array allocati dinamicamente in C++. Quindi, ti abbiamo guidato attraverso un esempio dettagliato che ha spiegato come puoi creare e gestire array dinamici in C++. Inoltre, abbiamo anche condiviso il metodo di trattare gli array dinamici. Dopo aver attraversato questa guida, avrai sicuramente una comprensione di base del trattare con array dinamici in C++.