Allocazione dinamica della memoria. Le istruzioni C++.

Dopo l’articolo introduttivo sull’allocazione dinamica della memoria in C++ (a cui si rimanda link), vediamo la sintassi di alcune funzioni di libreria C++ che ci permettono di operare con essa.

Sintassi C++ per l’allocazione e la deallocazione dinamica della memoria

Per l’allocazione dinamica di una variabile il linguaggio C++ mette a disposizione due sintassi.

1. La prima consiste nell’utilizzo della funzione seguente:
   
   void* malloc(size_t numero_bytes);

   1	void* malloc(size_t numero_bytes);

   Essa alloca nella area dell’heap un blocco di memoria costituito da un numero di bytes pari al valore del parametro numero_bytes passato e restituisce al chiamante un puntatore al primo byte del blocco allocato. Si noti che questo puntatore è generico (void*) e che su di esso bisogna sempre eseguire un casting esplicito verso il tipo della variabile che si vuole allocare.

   Esempio 1. Creazione di un vettore 'al volo'

   C++

   #include <iostream> using namespace std; int main() { int n, num; cout << "Quanti sono gli interi da caricare?" << endl; cin >> n; //Allocazione dinamica di un blocco di memoria pari a n int int* v = (int*) malloc(sizeof(int)*n); if (v==NULL) exit(1); //Allocazione non andata a buon fine! for(int i=0; i<n; i++) { cout<<"Inserisci l'intero n. "<<i+1<<": "; cin>>v[i]; } cout<<"Sono stati memorizzati i seguenti "<<n<<" interi:"; for(int i=0; i<n; i++) cout<<" " << v[i]; cout<<endl; //Dealloca l'intero blocco di memoria puntato da v free(v); return 0; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   #include <iostream> using namespace std;   int main() {     int n, num;     cout << "Quanti sono gli interi da caricare?" << endl;     cin >> n;     //Allocazione dinamica di un blocco di memoria pari a n int     int* v = (int*) malloc(sizeof(int)*n);     if (v==NULL) exit(1); //Allocazione non andata a buon fine!       for(int i=0; i<n; i++) {         cout<<"Inserisci l'intero n. "<<i+1<<": ";         cin>>v[i];     }     cout<<"Sono stati memorizzati i seguenti "<<n<<" interi:";     for(int i=0; i<n; i++)         cout<<" " << v[i];     cout<<endl;     //Dealloca l'intero blocco di memoria puntato da v     free(v);     return 0; }

   Nell’esempio è stata utilizzata anche la funzione free() (riga 21) per deallocare (liberare e rendere di nuovo disponibile) il blocco di memoria creato nell’heap e puntato dal puntatore v. Si fa notare che se il blocco richiesto non può essere allocato, ad esempio perché lo spazio disponibile nell’heap non è sufficiente, in tal caso il puntatore restituito dalla funzione malloc() vale NULL.

2. Una seconda possibilità consiste nell’utilizzo dell’operatore new, come viene mostrato nell’esempio seguente (riga 13):
   
   Esempio 2. Creazione di una stringa casuale

   C++

   #include <iostream> #include <stdlib.h> // srand, rand #include <time.h> // time using namespace std; int main() { int n; int i; cout<<"Quanti caratteri deve essere lunga la stringa casuale? "; cin>>n; /*Allocazione dinamica di un blocco di memoria sufficiente ad accogliere n char, più 1 per il carattere di fine stringa*/ char* s = (char*) new char[n+1]; if(s==NULL) exit(1); //allocazione dinamica non andata a buon fine! srand (time(NULL)); //inizializza il seme per la funzione rand() for(i=0; i<n; i++) { //generea una lettera casuale e l'aggiunge alla stringa s s[i] = rand()%26 + 'A'; } s[i]='\0'; cout<<"La stringa casuale di "<<n<<" caratteri prodotta e': "<<s<< endl; //Dealloca l'intero blocco di memoria puntato da s; delete [] s; return 0; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   #include <iostream> #include <stdlib.h> // srand, rand #include <time.h>   // time using namespace std; int main() {    int n;    int i;    cout<<"Quanti caratteri deve essere lunga la stringa casuale? ";    cin>>n;      /*Allocazione dinamica di un blocco di memoria sufficiente ad    accogliere n char, più 1 per il carattere di fine stringa*/    char* s = (char*) new char[n+1];    if(s==NULL) exit(1); //allocazione dinamica non andata a buon fine!      srand (time(NULL)); //inizializza il seme per la funzione rand()    for(i=0; i<n; i++) {         //generea una lettera casuale e l'aggiunge alla stringa s         s[i] = rand()%26 + 'A';    }    s[i]='\0';    cout<<"La stringa casuale di "<<n<<" caratteri prodotta e': "<<s<< endl;    //Dealloca l'intero blocco di memoria puntato da s;    delete [] s;    return 0; }

   L’operatore new richiede di specificare il tipo di variabile che si vuole allocare nell’heap (nel caso del nostro esempio un vettore di n+1 char) e restituisce il puntatore al primo byte del blocco di memoria allocato. Anche in questo caso il puntatore restituito è generico (void*) e, pertanto, su di esso bisogna sempre eseguire un casting esplicito verso il tipo della variabile che si vuole allocare; e, ancora, se il blocco richiesto non può essere allocato il puntatore vale NULL. Nell’esempio è stato utilizzato anche l’operatore delete [] (riga 24) che in modo equivalente alla funzione free() utilizzata nell’esempio 1), dealloca (libera e rende di nuovo disponibile) il blocco di memoria creato nell’heap e puntato da s.

Sintassi C++ per modificare la dimensione di un blocco di memoria allocato nell’heap

In C++ un blocco di memoria dell’heap può essere riallocato modificandone la dimensione utilizzando la seguente funzione di libreria:

La funzione realloc() richiede come parametri il puntatore al blocco da riallocare (ptr) e la nuova dimensione (numero_bytes) da assegnare al blocco riallocato. Se la nuova dimensione è maggiore di quella di partenza, la dimensione del blocco viene modificata preservandone anche il contenuto. La funzione realloc() restituisce un puntatore al primo byte del blocco riallocato. Nel caso in cui ptr vale NULL, la funzione realloc() si comporta come la funzione malloc(), allocando un nuovo blocco di dimensione pari a numero_bytes e restituendo un puntatore al nuovo blocco allocato. Come già visto per le funzioni di libreria precedenti, anche la funzione realloc() restituisce un puntatore ad un tipo generico (void*) e, pertanto, su di esso bisogna sempre eseguire un casting esplicito verso il tipo della variabile riallocata; e, ancora, se il blocco richiesto non può essere riallocato il puntatore restituito vale NULL.

Segue un semplice programma di esempio in cui la funzione realloc() viene utilizzata per creare un vettore dinamico a dimensione variabile, la cui dimensione è riportata sempre sul numero di elementi strettamente necessario a runtime.