L'allocazione dinamica della memoria in C/C++ si riferisce all'esecuzione manuale dell'allocazione della memoria da parte di un programmatore. La memoria allocata dinamicamente viene allocata su Mucchio, e le variabili non statiche e locali ricevono memoria allocata Pila (Fare riferimento a Programmi C per il layout della memoria per dettagli).

Cosa sono le applicazioni?

• Un utilizzo della memoria allocata dinamicamente consiste nell'allocare memoria di dimensione variabile, cosa non possibile con la memoria allocata dal compilatore ad eccezione di array di lunghezza variabile .
• L'utilizzo più importante è la flessibilità fornita ai programmatori. Siamo liberi di allocare e deallocare la memoria ogni volta che ne abbiamo bisogno e ogni volta che non ne abbiamo più bisogno. Ci sono molti casi in cui questa flessibilità aiuta. Esempi di tali casi sono Albero , eccetera.

In cosa differisce dalla memoria allocata alle variabili normali?

Per le variabili normali come int a, char str[10], ecc., la memoria viene allocata e deallocata automaticamente. Per la memoria allocata dinamicamente come int *p = new int[10], è responsabilità del programmatore deallocare la memoria quando non è più necessaria. Se il programmatore non dealloca la memoria, causa a perdita di memoria (la memoria non viene deallocata finché il programma non termina).

Come viene allocata/deallocata la memoria in C++?
C utilizza il malloc() e calloc() per allocare memoria dinamicamente in fase di esecuzione e utilizza una funzione free() per liberare memoria allocata dinamicamente. Il C++ supporta queste funzioni e ha anche due operatori nuovo E eliminare, che svolgono il compito di allocare e liberare la memoria in modo migliore e più semplice.

nuovo operatore

Il nuovo operatore denota una richiesta di allocazione di memoria sul Free Store. Se è disponibile memoria sufficiente, un nuovo operatore inizializza la memoria e restituisce l'indirizzo della memoria appena allocata e inizializzata alla variabile puntatore.

Sintassi per utilizzare l'operatore new

flusso di filtro Java

pointer-variable =   new   data-type;>

Qui, la variabile puntatore è il puntatore del tipo tipo-dati. Il tipo di dati può essere qualsiasi tipo di dati integrato, incluso l'array, o qualsiasi tipo di dati definito dall'utente, inclusa struttura e classe.
Esempio:

// Pointer initialized with NULL // Then request memory for the variable int *p = NULL;  p = new int;    OR  // Combine declaration of pointer  // and their assignment int *p = new int;>

// C++ program to demonstrate how to create dynamic variable // using new #include  #include  using namespace std; int main() {  // pointer to store the address returned by the new  int* ptr;  // allocating memory for integer  ptr = new int;  // assigning value using dereference operator  *ptr = 10;  // printing value and address  cout << 'Address: ' << ptr << endl;  cout << 'Value: ' << *ptr;  return 0; }>

Address: 0x162bc20 Value: 10>

Inizializza la memoria: Possiamo anche inizializzare la memoria per i tipi di dati incorporati utilizzando un nuovo operatore. Per i tipi di dati personalizzati, è richiesto un costruttore (con il tipo di dati come input) per inizializzare il valore. Ecco un esempio dell'inizializzazione di entrambi i tipi di dati:

pointer-variable =   new   data-type(value);>

Esempio:

// C++ program to illustrate how to initialize a dynamic // variable with allocation #include  #include  using namespace std; // Custom data type with constructor to take initial value struct cust {  int p;  cust(int q)  : p(q)  {  }  cust() = default; }; int main() {  // creating inbuit data types with initial value  int* p = new int(25);  float* q = new float(75.25);  // Works fine, doesn’t require constructor  cust* var1 = new cust;  // OR  // Works fine, doesn’t require constructor  var1 = new cust();  // Notice error if you comment this line  cust* var = new cust(25);  cout << *p << ' ' << *q << ' ' << var->P;  restituire 0; }>

25 75.25 25>

Allocare un blocco di memoria: un nuovo operatore viene utilizzato anche per allocare un blocco (un array) di memoria di tipo tipo di dati .

pointer-variable =   new   data-type[size];>

dove size(una variabile) specifica il numero di elementi in un array.

Esempio:

aggiornamento da join sql

int *p = new int[10]>

Alloca dinamicamente memoria per 10 numeri interi continui di tipo int e restituisce un puntatore al primo elemento della sequenza, a cui è assegnato top(un puntatore). p[0] si riferisce al primo elemento, p[1] si riferisce al secondo elemento e così via.

Dichiarazione di array normale rispetto all'utilizzo di new
C'è una differenza tra dichiarare un array normale e allocare un blocco di memoria utilizzando new. La differenza più importante è che gli array normali vengono deallocati dal compilatore (se l'array è locale, viene deallocato quando la funzione ritorna o viene completata). Tuttavia, gli array allocati dinamicamente rimangono sempre lì finché non vengono deallocati dal programmatore o finché il programma non termina.

Cosa succede se non è disponibile memoria sufficiente durante il runtime?
Se nell'heap non è disponibile memoria sufficiente da allocare, la nuova richiesta indica l'errore lanciando un'eccezione di tipo std::bad_alloc, a meno che non venga utilizzato nothrow con l'operatore new, nel qual caso restituisce un puntatore NULL (scorrere alla sezione Exception gestione del nuovo operatore in Questo articolo). Pertanto, potrebbe essere una buona idea verificare la variabile puntatore prodotta da new prima di utilizzare il suo programma.

industria e fabbrica

int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>

operatore cancella

Poiché è responsabilità del programmatore deallocare la memoria allocata dinamicamente, ai programmatori viene fornito l'operatore delete in linguaggio C++.

Sintassi:

// Release memory pointed by pointer-variable   delete   pointer-variable;>

Qui, la variabile puntatore è il puntatore che punta all'oggetto dati creato da nuovo .

Esempi:

delete p; delete q;>

Per liberare l'array allocato dinamicamente puntato dalla variabile puntatore, utilizzare il seguente formato di eliminare :

  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>

// C++ program to illustrate dynamic allocation // and deallocation of memory using new and delete #include  using namespace std; int main() {  // Pointer initialization to null  int* p = NULL;  // Request memory for the variable  // using new operator  p = new (nothrow) int;  if (!p)  cout << 'allocation of memory failed
';  else {  // Store value at allocated address  *p = 29;  cout << 'Value of p: ' << *p << endl;  }  // Request block of memory  // using new operator  float* r = new float(75.25);  cout << 'Value of r: ' << *r << endl;  // Request block of memory of size n  int n = 5;  int* q = new (nothrow) int[n];  if (!q)  cout << 'allocation of memory failed
';  else {  for (int i = 0; i < n; i++)  q[i] = i + 1;  cout << 'Value store in block of memory: ';  for (int i = 0; i < n; i++)  cout << q[i] << ' ';  }  // freed the allocated memory  delete p;  delete r;  // freed the block of allocated memory  delete[] q;  return 0; }>

Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>

Complessità temporale: O(n), dove n è la dimensione della memoria specificata.

Articoli Correlati:

• Quiz su nuovo ed eliminare
• elimina vs gratuito