Allocazione di memoria dinamica in C ++

L'allocazione della memoria è determinata al momento della dichiarazione variabile. Ma nella maggior parte dei casi, non sappiamo quanta memoria è richiesta per una variabile specifica. In tal caso, l'allocazione della memoria deve essere eseguita in fase di esecuzione. L'allocazione della memoria di runtime del programma è nota come allocazione di memoria dinamica. Nell'allocazione della memoria dinamica, non conosciamo la dimensione effettiva della variabile. Assegniamo manualmente la memoria per quella variabile e può anche essere un array o un oggetto di una classe. I puntatori svolgono un ruolo chiave nell'allocazione della memoria dinamica. Quando assegniamo dinamicamente la memoria, il "nuovo"La parola chiave viene utilizzata per dire al compilatore che stiamo allocando dinamicamente la memoria. Quando abbiamo finito con l'assegnazione della memoria, alla fine, dobbiamo manualmente "eliminare"Quella memoria dinamica riservata. In altri linguaggi di programmazione come Python e Java, non dobbiamo allocare dinamicamente la memoria perché il compilatore lo fa automaticamente. Ma in C e C ++, lo facciamo manualmente usando il nuovo (per riservare lo spazio) e eliminare (allo spazio libero) Parole chiave.

Perché assegniamo dinamicamente la memoria?

In C ++, l'allocazione della memoria dinamica viene eseguita quando non conosciamo la dimensione effettiva della variabile o degli elementi che vogliamo archiviare in una variabile. I valori totali che devono essere archiviati sono decisi in fase di esecuzione. Heap alloca la memoria dinamica ma nel caso di statico, la memoria viene assegnata in uno stack. Quindi, quando non conosciamo la dimensione esatta delle variabili e deve essere fatta in fase di esecuzione, allocare la memoria dinamicamente.

Sintassi:

Riserva memoria
Pointer_variable = new Data_Type;

Innanzitutto, dobbiamo prenotare la memoria in un mucchio. A tale scopo, definiamo una variabile di tipo puntatore uguale a "nuovo"Parola chiave e quindi definire il tipo di variabile. IL "nuovo"La parola chiave si riserva la memoria nel heap.

Possiamo anche definire una variabile di tipo array.

Pointer_variable = new data_type [size];

Per inizializzare la variabile, inseriamo il valore nella parentesi dopo data_type () in questo modo:

Pointer_variable = new data_type (value);
Memoria libera
Elimina Pointer_variable;

Quando abbiamo finito con l'allocazione dinamica della memoria, si occupa della memoria per salvare i dati dalla perdita di memoria. IL "eliminare"La parola chiave con il nome della variabile puntatore rilascia la memoria dinamica.

Allocazione di memoria dinamica di variabile

Spieghiamo il processo di allocazione e deallocazione della memoria dinamica di una variabile di tipo intero.

Codice:

#includere
Utilizzo dello spazio dei nomi std;
int main ()
int* p_value = null;
p_value = new int;
*p_value = 674;
cout<< "Value of p_valueis : " << *p_value<Elimina p_value;
restituzione 0;

Avvia questo codice includendo il file di intestazione per accedere ai metodi di input e output della libreria. Questa libreria ha metodi integrati a cui possiamo accedere al nostro programma. Ora, chiama il metodo principale () e definisci una variabile puntatore “*p_value” per tenere l'indirizzo heap poiché l'allocazione della memoria dinamica viene eseguita nel heap. L'allocazione statica viene eseguita nello stack perché sappiamo già che la quantità di dati significa la dimensione della variabile. Inizializza il puntatore intero con "null".

Successivamente, allocare la memoria dinamica della variabile "P_Value" puntatore con la parola chiave "nuova" e il tipo di dati "int" della variabile. Usando il termine "nuovo", il compilatore viene chiesto di allocare la memoria heap per la variabile del tipo intero. Inoltre, memorizzare un valore di "674" nel tipo di punta "*P_Value". Quindi, esegui il comando "cout" per stampare la riga "Valore di P_Value" e il valore della variabile intera "*P_Value" che viene archiviata dinamicamente nel mucchio. Per recuperare i dati salvati nel heap, utilizziamo il puntatore. Il puntatore memorizza e accede ai dati nel heap; Non accede direttamente ai dati. Quindi, utilizzare il comando "Elimina" per eliminare la variabile "P_Value" del tipo puntatore in modo da non perdere i nostri dati o nessun'altra persona può accedere ai nostri dati.

Produzione:

Il valore di p_value è: 674

Allocazione di memoria dinamica di un oggetto di classe

Definiamo una classe e assegniamo dinamicamente la memoria ai suoi oggetti in questa illustrazione.

Codice:

#includere
Utilizzo dello spazio dei nomi std;
Class Program_0
pubblico:
Programma_0 ()
cout<< "I am Constructor" <
~ Program_0 ()
cout<< "I am Destructor" <
;
int main ()
Programma_0* myArray = new Program_0 [3];
elimina [] MyArray;
restituzione 0;

In questo codice, integrare la libreria per utilizzare il metodo "cout". Quindi, usa lo spazio dei nomi standard. Definisci una classe "Program_0" e imposta questa classe come pubblica. È possibile accedere ai metodi di classe pubblica al di fuori della classe. Le altre classi possono anche accedere ai metodi di questa classe. Definisci il costruttore e il distruttore all'interno di questa classe. Inizializziamo i membri dei dati della classe nel costruttore. Il distruttore distrugge gli oggetti una volta eseguito il programma. Libera la memoria dopo che l'attività è terminata. Entrambi sono definiti dal nome della classe.

Nel costruttore Program_0 (), scriviamo una riga di codice per stampare un messaggio sul terminale. Allo stesso modo, nel Destructor ~ Program_0 (), visualizza un messaggio eseguendo l'istruzione "Cout". Ogni volta che viene creato l'oggetto di classe, vengono chiamati costruttori e distruttori. Quando chiamiamo la classe particolare, esegue il costruttore e quindi esegue altre operazioni che ci assegniamo. Dopo aver terminato il processo, viene chiamato il distruttore e distrugge tutti gli oggetti creati per accedere ai metodi di classe e ai membri dei dati.

Inoltre, esegui la funzione principale () di questo codice. Ogni classe viene chiamata e i suoi oggetti sono creati all'interno di questo metodo. Crea un oggetto "*myarray" del tipo puntatore della classe "Program_0" e alloca la memoria dinamica utilizzando la parola chiave "nuova". Qui, definiamo le dimensioni dell'array 3. La classe è chiamata tre volte e il costruttore esegue anche tre volte. Dopo tutto ciò, il distruttore è chiamato tre volte per liberare lo spazio. Il distruttore elimina l'oggetto che chiama tre volte la classe.

Produzione:

Sono costruttore
Sono costruttore
Sono costruttore
Sono distruttore
Sono distruttore
Sono distruttore

Conclusione

Questo documento analizza l'allocazione di memoria dinamica in C++. Osserviamo anche perché allochiamo dinamicamente la memoria. L'allocazione della memoria dinamica è importante quando non conosciamo la dimensione effettiva dei dati da archiviare. In altri linguaggi come Python, i programmatori non devono allocare manualmente la memoria perché il compilatore lo fa automaticamente. Dopo aver assegnato la memoria, memorizzare i dati lì e averne fornito un accesso, la memoria viene deallocata. La trasformazione è importante perché se non si affrettiamo la memoria, c'è la possibilità di perdite di memoria. L'allocazione della memoria dinamica di una variabile intera e un oggetto di classe è spiegata nei codici di questa guida.