Memoria dinamica in c. Allocazione della memoria in C (funzione malloc). Allocazione dinamica delle variabili

Abbiamo scoperto le possibilità di allocazione dinamica della memoria. Cosa significa? Ciò significa che con l'allocazione dinamica della memoria, la memoria è riservata non in fase di compilazione ma in fase di esecuzione del programma. E questo ci dà la possibilità di allocare la memoria in modo più efficiente, principalmente per gli array. Con l'allocazione dinamica della memoria, non è necessario impostare anticipatamente la dimensione dell'array, soprattutto perché non è sempre noto quale dimensione dell'array dovrebbe avere. Quindi, vediamo come è possibile allocare memoria.

Allocazione di memoria in C (funzione malloc)

La funzione malloc () è definita nel file di intestazione stdlib.h, viene utilizzata per inizializzare i puntatori con la quantità di memoria richiesta. La memoria viene allocata da un settore di RAM disponibile per tutti i programmi in esecuzione su una determinata macchina. L'argomento è il numero di byte di memoria da allocare, la funzione ritorna - un puntatore al blocco allocato in memoria. La funzione malloc () funziona esattamente come qualsiasi altra funzione, niente di nuovo.

Poiché diversi tipi di dati hanno requisiti di memoria diversi, in qualche modo dobbiamo imparare come ottenere la dimensione in byte per diversi tipi di dati. Ad esempio, abbiamo bisogno di un pezzo di memoria per un array di valori int: questa è una dimensione di memoria e se abbiamo bisogno di allocare memoria per un array della stessa dimensione, ma già del tipo char, questa è una dimensione diversa. Pertanto, è necessario in qualche modo calcolare la dimensione della memoria. Questo può essere fatto con l'operazione sizeof (), che accetta un'espressione e ne restituisce le dimensioni. Ad esempio, sizeof (int) restituirà il numero di byte richiesti per memorizzare un int. Consideriamo un esempio:

#includere int * ptrVar \u003d malloc (sizeof (int));

In questo esempio, in linea 3 al puntatore ptrVar viene assegnato un indirizzo a una posizione di memoria le cui dimensioni corrispondono al tipo di dati int. Automaticamente, questa area di memoria diventa inaccessibile ad altri programmi. Ciò significa che dopo che la memoria allocata diventa superflua, deve essere esplicitamente rilasciata. Se la memoria non viene esplicitamente rilasciata, quindi al termine del programma, la memoria non verrà liberata per il sistema operativo, questo si chiama perdita di memoria. Puoi anche determinare la dimensione della memoria allocata da allocare passando un puntatore nullo, ecco un esempio:

Int * ptrVar \u003d malloc (sizeof (* ptrVar));

Cosa sta succedendo qui? L'operazione sizeof (* ptrVar) stimerà la dimensione del blocco di memoria a cui fa riferimento il puntatore. Poiché ptrVar è un puntatore a un pezzo di memoria di tipo int, sizeof () restituirà la dimensione di un numero intero. Cioè, essenzialmente, basato sulla prima parte della definizione del puntatore, viene calcolata la dimensione per la seconda parte. Allora perché ne abbiamo bisogno? Ciò può essere necessario se improvvisamente è necessario modificare la definizione di un puntatore, int, ad esempio, in virgola mobile, quindi non è necessario modificare il tipo di dati in due parti della definizione del puntatore. Basterà cambiare la prima parte:

Float * ptrVar \u003d malloc (sizeof (* ptrVar));

Come puoi vedere, c'è un lato molto forte in questa notazione, non dovremmo chiamare la funzione malloc () usando sizeof (float). Invece, abbiamo passato un puntatore al tipo float a malloc (), nel qual caso la dimensione della memoria allocata sarà automaticamente determinata da sola!

Ciò è particolarmente utile se è necessario allocare memoria lontano dalla definizione del puntatore:

Float * ptrVar; / *. ... ... cento righe di codice * /. ... ... ptrVar \u003d malloc (sizeof (* ptrVar));

Se hai usato la costruzione dell'allocazione di memoria con l'operazione sizeof (), allora dovresti trovare la definizione di un puntatore nel codice, guardare il suo tipo di dati e solo allora sarai in grado di allocare correttamente la memoria.

Liberare memoria allocata

La memoria viene liberata usando la funzione free (). Ecco un esempio:

Gratuito (ptrVar);

Dopo aver liberato memoria, è buona norma reimpostare il puntatore su zero, ovvero assegnare * ptrVar \u003d 0. Se al puntatore viene assegnato 0, il puntatore diventa , in altre parole, non punta più da nessuna parte. Sempre dopo aver rilasciato la memoria, assegna 0 al puntatore, altrimenti, anche dopo aver liberato la memoria, il puntatore lo punta ancora, il che significa che puoi danneggiare accidentalmente altri programmi che potrebbero utilizzare questa memoria, ma non ne sai nemmeno nulla imparerai e penserai che il programma funzioni correttamente.

PS: Chiunque sia appassionato di editing video potrebbe essere interessato a questo editor video di Windows 7. L'editor video si chiama Movavi, forse qualcuno lo conosce già o addirittura ci ha lavorato. Con questo programma in russo, puoi facilmente aggiungere video dalla fotocamera, migliorare la qualità e applicare bellissimi effetti video.

Prima di immergerci nello sviluppo orientato agli oggetti, dovremo fare una piccola digressione su come lavorare con la memoria in un programma C ++. Non possiamo scrivere programmi complessi senza essere in grado di allocare memoria in fase di esecuzione e accedervi.
In C ++, gli oggetti possono essere allocati staticamente in fase di compilazione o dinamicamente in fase di esecuzione chiamando le funzioni dalla libreria standard. La principale differenza nell'uso di questi metodi è la loro efficienza e flessibilità. L'allocazione statica è più efficiente perché la memoria viene allocata prima dell'esecuzione del programma, ma è molto meno flessibile perché dobbiamo conoscere in anticipo il tipo e la dimensione dell'oggetto da allocare. Ad esempio, non è affatto facile posizionare il contenuto di un file di testo in una matrice statica di stringhe: dobbiamo conoscerne le dimensioni in anticipo. Le attività che devono archiviare ed elaborare in anticipo un numero sconosciuto di elementi richiedono in genere l'allocazione dinamica della memoria.
Finora, tutti i nostri esempi hanno utilizzato l'allocazione di memoria statica. Diciamo la definizione della variabile ival

Int ival \u003d 1024;

impone al compilatore di allocare un'area in memoria abbastanza grande da memorizzare una variabile int, associare il nome ival a quest'area e posizionare lì il valore 1024. Tutto questo viene fatto in fase di compilazione, prima che il programma venga eseguito.
All'oggetto ival sono associati due valori: il valore effettivo della variabile, 1024 in questo caso e l'indirizzo dell'area di memoria in cui è memorizzato questo valore. Possiamo fare riferimento a una di queste due quantità. Quando scriviamo:

Int ival2 \u003d ival + 1;

quindi ci riferiamo al valore contenuto nella variabile ival: aggiungiamo 1 ad essa e inizializziamo la variabile ival2 con questo nuovo valore, 1025. Come possiamo fare riferimento all'indirizzo al quale si trova la variabile?
C ++ ha un tipo di puntatore incorporato, che viene utilizzato per memorizzare gli indirizzi degli oggetti. Per dichiarare un puntatore contenente l'indirizzo della variabile ival, dobbiamo scrivere:

Int * pint; // puntatore a un oggetto di tipo int

Esiste anche un'operazione speciale per prendere un indirizzo, indicata dal simbolo &. Il risultato è l'indirizzo dell'oggetto. La seguente istruzione assegna l'indirizzo della variabile ival al puntatore pinta:

Int * pint; pint \u003d // pint ottiene il valore dell'indirizzo ival

Possiamo fare riferimento all'oggetto il cui indirizzo contiene pinta (ival nel nostro caso) usando l'operazione dereferenziazionechiamato anche indirizzamento indiretto... Questa operazione è indicata da *. Ecco come aggiungerne uno indirettamente a ival usando il suo indirizzo:

* pint \u003d * pint + 1; // aumenta implicitamente l'ivalente

Questa espressione fa esattamente la stessa cosa di

Ival \u003d ival + 1; // aumenta esplicitamente l'ivalente

Questo esempio non ha alcun senso: usare un puntatore per manipolare indirettamente la variabile ival è meno efficiente e meno descrittivo. Abbiamo incluso solo questo esempio per darti una comprensione di base dei puntatori. In realtà, i puntatori sono spesso usati per manipolare oggetti posizionati dinamicamente.
Le principali differenze tra allocazione di memoria statica e dinamica sono le seguenti:

• gli oggetti statici sono designati da variabili nominate e le azioni su questi oggetti vengono eseguite direttamente usando i loro nomi. Gli oggetti dinamici non hanno i loro nomi e le azioni su di essi vengono eseguite indirettamente, usando i puntatori;
• l'allocazione e la liberazione della memoria per gli oggetti statici viene eseguita automaticamente dal compilatore. Il programmatore non deve occuparsene da solo. Allocare e liberare memoria per oggetti dinamici è interamente responsabilità del programmatore. Questo è un compito difficile ed è facile commettere errori nel risolverlo. Gli operatori new ed delete vengono utilizzati per manipolare la memoria allocata dinamicamente.

Il nuovo operatore ha due forme. Il primo modulo alloca memoria per un singolo oggetto di un certo tipo:

Int * pint \u003d new int (1024);

Qui il nuovo operatore alloca memoria per un oggetto senza nome di tipo int, lo inizializza su 1024 e restituisce l'indirizzo dell'oggetto creato. Questo indirizzo viene utilizzato per inizializzare il puntatore pinta. Tutte le azioni su un tale oggetto senza nome vengono eseguite dereferenziando questo puntatore, da allora non è possibile manipolare esplicitamente un oggetto dinamico.
La seconda forma del nuovo operatore alloca memoria per un array di una determinata dimensione, costituito da elementi di un certo tipo:

Int * pia \u003d new int;

In questo esempio, la memoria è allocata per un array di quattro elementi int. Sfortunatamente, questa forma del nuovo operatore non consente l'inizializzazione di elementi dell'array.
Una certa confusione è causata dal fatto che entrambe le forme del nuovo operatore restituiscono lo stesso puntatore, nel nostro esempio è un puntatore a un numero intero. Sia pint che pia sono dichiarate esattamente uguali, ma pint indica un singolo int e pia indica il primo elemento di una matrice di quattro oggetti int.
Quando l'oggetto dinamico non è più necessario, dobbiamo liberare esplicitamente la memoria allocata per esso. Questo viene fatto usando l'operatore delete, che, come nuovo, ha due forme: per un singolo oggetto e per un array:

// rilascia un singolo oggetto delete pint; // libera l'array delete pia;

Cosa succede se dimentichiamo di liberare la memoria allocata? La memoria sarà sprecata, non sarà utilizzata, ma non può essere restituita al sistema perché non abbiamo un puntatore. Questo fenomeno ha ricevuto un nome speciale perdita di memoria... Alla fine, il programma si arresterà in modo anomalo a causa di memoria insufficiente (supponendo, ovviamente, funzionerà abbastanza a lungo). Una piccola perdita è difficile da rilevare, ma esistono utilità per aiutarti a farlo.
La nostra breve panoramica sull'allocazione dinamica della memoria e sull'utilizzo del puntatore ha probabilmente sollevato più domande di quelle a cui ha risposto. La sezione 8.4 tratterà le questioni sollevate in dettaglio. Tuttavia, non potremmo fare a meno di questa digressione, poiché la classe Array, che progetteremo nelle sezioni seguenti, si basa sull'uso della memoria allocata dinamicamente.

Esercizio 2.3

Spiega la differenza tra i quattro oggetti:

(a) int ival \u003d 1024; (b) int * pi \u003d (c) int * pi2 \u003d new int (1024); (d) int * pi3 \u003d new int;

Esercizio 2.4

Cosa fa il seguente codice? Qual è l'errore logico? (Si noti che l'operazione di acquisizione dell'indice () è correttamente applicata al puntatore pia. Una spiegazione di questo fatto è riportata nella Sezione 3.9.2.)

Int * pi \u003d new int (10); int * pia \u003d new int;
while (* pi< 10) {
pia [* pi] \u003d * pi; * pi \u003d * pi + 1;
) elimina pi; elimina pia;

Così. il terzo tipo, il più interessante in questo argomento per noi, è il tipo di memoria dinamica.

Come abbiamo lavorato con gli array prima? int a Come lavoriamo ora? Selezioniamo quanti ne abbiamo bisogno:

#includere < stdio.h> #includere < stdlib.h> int main () (size_t size; // Crea un puntatore a int // è essenzialmente un array vuoto. int * list; scanf ( "% lu", & taglia); // Alloca memoria per gli elementi size int // e il nostro "array vuoto" ora fa riferimento a questa memoria. list \u003d (int *) malloc (size * sizeof (int)); per (int i \u003d 0; i< size; ++i) { scanf ("% d" < size; ++i) { printf ("% d", * (elenco + i)); ) // Non dimenticare di ripulire dopo noi stessi! gratuito (elenco); ) // *

Void * malloc (size_t size);

Ma in generale, questa è una funzione che alloca byte di dimensioni di memoria non inizializzata (non zeri, ma immondizia).

Se l'allocazione ha esito positivo, viene restituito un puntatore al primo byte della memoria allocata.

In caso di esito negativo - NULL. Inoltre, errno eguaglierà ENOMEM (vedremo più avanti questa meravigliosa variabile). Cioè, era più corretto scrivere:

#includere < stdio.h> #includere < stdlib.h> int main () (size_t size; int * list; scanf ( "% lu", & taglia); list \u003d (int *) malloc (size * sizeof (int)); if (list \u003d\u003d NULL) (vai a errore;) per (int i \u003d 0; i< size; ++i) { scanf ("% d", elenco + i); ) per (int i \u003d 0; i< size; ++i) { printf ("% d", * (elenco + i)); ) gratuito (elenco); ritorna 0; errore: ritorno 1; ) // *

Non è necessario cancellare un puntatore NULL

#includere < stdlib.h> int main () (gratuito (NULL);)

- nello stesso clang tutto andrà bene (niente andrà bene), ma in casi più esotici potrebbe andare in crash il programma.

Accanto a malloc e gratuito in mana, puoi anche vedere:

void * calloc (size_t count, size_t size);

Oltre a malloc alloca memoria per oggetti conteggio di byte di dimensioni. La memoria allocata viene inizializzata con zeri.

void * realloc (void * ptr, size_t size);

Alloca nuovamente (se è possibile) la memoria indicata da ptr in byte di dimensioni. Se non c'è spazio sufficiente per aumentare la memoria allocata indicata da ptr, realloc crea una nuova allocazione, copia i vecchi dati indicati da ptr, libera la vecchia allocazione e restituisce un puntatore alla memoria allocata.

Se ptr è NULL, realloc è identico a chiamare malloc.

Se size è zero e ptr non è NULL, viene allocata la porzione di memoria minima della dimensione e quella originale viene liberata.

void * reallocf (void * ptr, size_t size);

Una nozione dall'API di FreeBSD. Come realloc, ma se non riesce a riassegnare, cancella il puntatore ricevuto.

void * valloc (size_t size);

Come malloc, ma la memoria allocata è allineata alla pagina.

Il programma può archiviare informazioni nella memoria principale di un computer in due modi principali. Il primo utilizza variabili globali e locali, tra cui array, strutture e classi. Nel caso di variabili locali globali e statiche, il percorso di archiviazione è fisso per l'intera durata dell'esecuzione del programma. Nel caso di variabili locali, la memoria viene allocata nello stack. Sebbene Borland C ++ implementi queste variabili in modo molto efficiente, il loro utilizzo richiede al programmatore di conoscere in anticipo la quantità di memoria che sarà richiesta durante l'esecuzione del programma.

Il secondo modo di archiviare le informazioni consiste nell'utilizzare il sistema di allocazione dinamica della memoria C ++ di Borland. In questo metodo, la memoria per l'archiviazione delle informazioni viene allocata dall'area di memoria libera secondo necessità e restituita, ad es. viene rilasciato quando il bisogno è scomparso. L'area della memoria libera si trova tra l'area della memoria in cui si trova il programma e lo stack. Questa area è chiamata heap e viene utilizzata per le richieste di heap.

Il vantaggio dell'utilizzo della memoria dinamica è che la stessa memoria può essere utilizzata per memorizzare informazioni diverse durante l'esecuzione del programma. Poiché la memoria viene allocata per uno scopo specifico e liberata al termine dell'utilizzo, è possibile utilizzare la stessa memoria in un momento diverso per scopi diversi in un'altra parte del programma. Un altro vantaggio dell'allocazione dinamica della memoria è la sua capacità di creare elenchi collegati, alberi binari e altre strutture di dati dinamici.

Il nucleo dell'allocazione dinamica della memoria C è malloc () e free (), che fanno parte della libreria standard. Ogni volta che una richiesta di allocazione della memoria viene effettuata da malloc (), viene allocata una porzione di memoria libera disponibile. Ogni volta che questa memoria viene liberata usando la funzione free (), questa memoria viene restituita al sistema.

Il linguaggio C ++ definisce due operatori di allocazione dinamica della memoria, new ed delete.

Lo standard ANSI C definisce solo quattro funzioni di allocazione dinamica della memoria: calloc (), malloc (), free () e realloc (). Tuttavia, Borland C ++ contiene diverse altre funzionalità di allocazione dinamica della memoria. Quando si compila il codice per il moderno modello di memoria a 32 bit, la memoria è piatta e di solito vengono utilizzate solo quattro funzioni standard di allocazione della memoria.

Lo standard ANSI C specifica che le informazioni di intestazione richieste per l'allocazione dinamica della memoria sono contenute nel file stdlib.h. Borland C ++, tuttavia, consente di utilizzare le intestazioni stdlib.h o alloc.h. Usiamo il file di intestazione stdlib.h qui perché fornisce portabilità. Alcune altre funzioni di allocazione dinamica della memoria richiedono i file di intestazione alloc.h, malloc.h o dos.h. È necessario prestare particolare attenzione a quale file di intestazione è necessario per utilizzare ciascuna funzione.