Allocazione dinamica della Memoria

Dopo aver dichiarato una variabile in C++ viene allocata la memoria necessaria per esso. Una volta che la funzione della variabile ha terminato il suo lavoro, la memoria viene liberata. Questa memoria è utilizzata per le variabili locali viene chiamata stack. Ma esiste un altro tipo di memoria che persiste indipendentemente dalle funzioni del programma. Tu, come programmatore sei incaricato di allocare e liberare questa memoria, collettivamente chiamata heap (o registro libero).

A questo punto si può pensare, “Perché utilizzare un tipo di memoria diversa? Lo stack funziona in modo ottimale per me, grazie.” Tuttavia usare la memoria dinamica del heap offre grandi benefici in termini di efficienza. Usando heap, si occupa la sola memoria necessaria al momento nel quale viene utilizzata, ad esempio se un livello del gioco ha cento nemici, si può allocare la memoria all'inizio del livello e liberarla subito dopo la conclusione dello stesso. Heap inoltre permette di creare un oggetto in una funzione, cui si possa accedere anche al termine della funzione stessa (senza dover restituire una copia dell'oggetto). Si può creare un oggetto a schermo in una funzione e ritornare al suo accesso. Lo strumento della memoria dinamica è molto importante nello sviluppo dei giochi.

Presentare il programma Heap

Il programma Heap è una dimostrazione della memoria dinamica. Il programma alloca la memoria dinamicamente per una variabile intera, ne assegna un valore e quindi la mostra a schermo. Successivamente viene richiamata una funzione che alloca memoria dinamica per un'altra variabile intera, ne assegna il valore e restituisce il puntatore ad essa. Il programma prende i valori del puntatore restituito e lo usa per visualizzare la variabile a schermo, quindi libera la memoria allocata nel heap. Infine vi sono due esempi di utilizzo scorretto della memoria dinamica.

//Heap

//Dimostra la memoria dinamica

#include<iostream>

using namespace std;

int* interosuHeap(); //restituisce intero su Heap

void perdita1(); //creano perdite di memoria

void perdita2();

int main()

{

    int* pHeap = new int;

    *pHeap = 30;

    cout << “*pHeap: ” << *pHeap << endl;

    int* pHeap2 = interosuHeap();

    cout << “*pHeap2: ” << *pHeap2 << endl;

    cout << “Liberare la memoria che punta a pHeap e pHeap2.” << endl;

         delete pHeap;

        delete pHeap2;

        pHeap =0;

       pHeap2 =0;

      return 0;

}

  

 int* interosuHeap()

  {

        int* pTemp = new int(30);

     return pTemp;

   }

void perdita1()

  {  int* dripeti1 = new int(40); }

void perdita2()

  { int* dripeti2 = new int(50);

     dripeti2 = new int(200);

     delete dripeti2;

  }

Uso dell'operatore new

L'operatore new alloca la memoria su heap e restituisce il suo indirizzo. Puoi usare new seguito dal tipo di valore che si vuole riservare lo spazio. Questo è ciò che viene scritto sulla prima linea di main ().

int* pHeap = new int;

La parte della dichiarazione new int alloca abbastanza memoria su heap necessaria per un solo intero e restituisce l'indirizzo di quel blocco di memoria su heap. L'altra parte della dichiarazione int*pHeap, dichiara un puntatore locale, pHeap, il quale punta alla locazione di memoria appena allocata sul blocco heap. Usando pHeap, si può manipolare il blocco di memoria riservato per l'intero. Quello che viene fatto nell'istruzione successiva è di assegnare il valore 30 al blocco di memoria e quindi mostrare il valore immagazzinato, usando pHeap, così come ogni altro puntatore all'intero. La sola differenza è che pHeap punta alla memoria su heap non allo stack.

Uno dei maggiori vantaggi della memoria su heap è che persiste oltre la funzione nella quale viene allocata, significa che creare un oggetto su heap in una funzione e restituire un puntatore o riferimento ad essa.

int* pHeap2 = interosuHeap();

La funzione richiamata interosuHeap(), alloca un blocco di memoria su heap per un intero ed assegna un valore di 30 ad esso.

int* interosuHeap()

{

int* pTemp = new int(30);

return pTemp;}

Quindi la funzione restituisce un puntatore a questo blocco di memoria. Tornando a main(), l'indirizzo del blocco di memoria viene assegnato a pHeap2. In seguito viene visualizzato il contenuto mediante l'istruzione.

cout << “*pHeap2: ” << *pHeap2 << endl;