Considerando che, nell'allocazione dinamica della memoria, la memoria viene allocata mentre l'esecuzione è iniziata. Questa memoria viene allocata manualmente dal programmatore in fase di esecuzione, nota anche come allocazione di memoria in fase di esecuzione in C++. La dimensione della memoria dinamica può essere modificata in qualsiasi posizione nel programma perché al momento della dichiarazione non viene menzionata una dimensione che può essere fissata. Forniamo solo il valore direttamente alla variabile.
Differenza di allocazione della memoria alle variabili normali
Nelle variabili normali, la memoria allocata da un compilatore viene allocata e deallocata automaticamente. Quando la memoria viene allocata dinamicamente dal programmatore, deve quindi rimuovere o deallocare la memoria quando non è di alcuna utilità nell'ulteriore esecuzione del codice sorgente. Questa situazione provoca una 'perdita di memoria' quando il programma viene terminato mentre la memoria non viene deallocata.
Operatori per l'allocazione dinamica
In C++, due operatori aiutano nell'allocazione e deallocazione della memoria: 'new' e 'delete' che vengono utilizzati per l'allocazione e deallocazione della memoria in un modo migliore.
Nuovo operatore
Indica la richiesta di allocazione di memoria. L'operatore new inizializza la memoria e restituisce l'indirizzo di quella memoria allocata alla variabile puntatore se è disponibile memoria sufficiente.
Oggetto puntatore = nuovo dati - genere ;
Elimina operatore
Proprio come l'operatore new, un operatore delete viene utilizzato per rimuovere la memoria allocata. In C++, il programmatore può utilizzare questo operatore per la deallocazione.
# Elimina variabile_puntatore;
Esempio 1
In questo esempio, introdurremo due puntatori: uno è un puntatore di tipo intero e l'altro è un puntatore float. I puntatori vengono inizializzati utilizzando un segno di asterisco con essi.
# Int * puntoInt;# Float *pointfloat;
Utilizzando queste due stampanti, allocheremo dinamicamente la memoria.
Ruolo dei puntatori nell'allocazione dinamica:
La memoria dello spazio di archiviazione si sviluppa sotto forma di blocchi. Ogni volta che eseguiamo un programma o eseguiamo qualsiasi operazione, la memoria viene allocata per quello scopo specifico. Quella memoria ha un indirizzo speciale associato al programma che identifica quale processo o programma è autorizzato a quella memoria. Si accede a qualsiasi slot di memoria tramite l'indirizzo a cui appartiene. Quindi questo indirizzo viene memorizzato tramite i puntatori. In breve, abbiamo bisogno di puntatori per accedere alla memoria e, allo stesso modo, per allocare una parte specifica della memoria a qualsiasi attività. I puntatori sono necessari per memorizzare gli indirizzi.
Poiché la parola chiave 'new' viene utilizzata per l'allocazione dinamica della memoria nell'allocazione manuale, la memoria viene allocata dal compilatore. Non è necessario allocare memoria in fase di esecuzione. Ma poiché l'allocazione dinamica è casuale, dobbiamo identificare i puntatori e per il processo di associazione viene utilizzato questo nuovo operatore.
# Pointint = new int;Allo stesso modo, il puntatore mobile è associato allo stesso modo. Dopo il processo di associazione, assegneremo qualsiasi valore alla memoria che vogliamo prenotare per qualsiasi operazione. Dichiarando il puntatore, assegniamo un valore specifico alla memoria.
# *puntoInt = 50;Viene anche dichiarato un valore float per i point float. Visualizza i valori dopo l'assegnazione.
Come abbiamo discusso, l'operatore 'new' viene utilizzato per allocare mentre 'delete' viene utilizzato per deallocare la memoria. Quindi, una volta completata l'attività o l'operazione nel codice, rimuoveremo la memoria che abbiamo assegnato all'attività.
È meglio deallocare quella parte della memoria in modo che qualsiasi altro processo possa avvalersene. Applicheremo questa allocazione a entrambi i puntatori.
Elimina punto galleggiante ; 
Una volta salvato il codice sull'editor di testo, il terminale di Ubuntu permette di eseguire il codice sorgente all'interno del file tramite un compilatore g++.
$ g++ -o mem mem.c$ ./mem
All'esecuzione, vedrai i valori assegnati alla memoria.
Esempio 2
Questo esempio prevede il coinvolgimento dell'interazione dell'utente. Prenderemo una variabile numerica che conterrà un valore dall'utente. Questo programma memorizzerà il risultato nel GPA degli studenti. Tutti i risultati verranno salvati in fase di esecuzione.
Quando l'utente immette il numero di studenti, la memoria viene assegnata a ciascun numero. Qui viene inizializzato un puntatore di tipo float che verrà utilizzato nell'allocazione di memoria dei risultati.
Prendiamo il puntatore in float poiché GPA è in notazione decimale. Prendiamo un array di tipo puntatore per il GPA poiché può risultare per un numero di studenti.
Questo array di puntatori con la parola chiave 'new' legherà l'esecuzione alla memoria. Il GPA sarà inserito per ogni studente. Poiché non abbiamo familiarità con il numero di studenti che l'utente desidera aggiungere, abbiamo utilizzato un ciclo for per inserire il GPA fino al numero inserito. In ogni ripetizione del ciclo, all'utente viene chiesto di inserire il risultato che identifica lo studente. Una volta salvato il risultato, utilizzeremo nuovamente un loop per visualizzare tutti i GPA degli studenti. Alla fine, l'array del tipo di puntatore viene eliminato, poiché è stato raggiunto lo scopo dell'archiviazione dinamica.
Elimina [ ] ptr ;Ora eseguiremo il codice sopra menzionato. All'utente verrà prima richiesto di inserire il numero di studenti. Quindi verrà inserito il GPA per ogni studente.
Esempio 3
Questo esempio utilizza gli operatori new e delete per l'oggetto della classe. Questa classe contiene una variabile privata di tipo intero che memorizza l'età. Nella parte pubblica di una classe, viene creato il costruttore che inizializzerà l'età a un numero '10'. Qui viene utilizzata un'altra funzione che visualizzerà l'età inizializzata nel costruttore.
Ora andremo verso il programma principale per l'allocazione dinamica. L'oggetto della classe viene creato dinamicamente.
Alunno * ptr = nuovo alunno ( ) ; 
Quando l'oggetto è formato, il costruttore verrà implementato automaticamente. Verrà effettuata una chiamata di funzione per ottenere l'età. Questo sarà fatto attraverso il ptr.
Ptr - > getAge ( ) ;E alla fine, il ricordo verrà rilasciato.
Conclusione
L'allocazione dinamica della memoria viene allocata durante l'esecuzione in fase di esecuzione dal programmatore invece della memoria fissa identificata dal compilatore. Questa allocazione avviene su base casuale e può essere eliminata dopo l'utilizzo. Considerando che, nella maggior parte dei casi, prima della rimozione, il processo di esecuzione si interrompe e questa allocazione dinamica provoca quindi perdite di memoria. Abbiamo implementato questo fenomeno in diversi approcci nel sistema Ubuntu Linux utilizzando il linguaggio di programmazione C++.