memoria dinamica C ++

Comprendere la memoria dinamica in C ++ è come il lavoro è quello di diventare un qualificato C ++ programmatori essenziali. memoria di programma C ++ è diviso in due parti:

• Stack: tutte le variabili dichiarate all'interno di una funzione prenderanno la memoria dello stack.
• Heap: Questa è lamemoria di programma non viene utilizzato, viene eseguito il programma può essere utilizzato per allocare dinamicamente la memoria.

Molte volte, non è possibile prevedere in anticipo quanto è richiesta molta memoria per memorizzare una variabile definita nelle informazioni specifiche necessarie per determinare la dimensione di memoria necessaria in fase di esecuzione.

In C ++, è possibile utilizzare un operatore speciale viene assegnato a una variabile di un dato tipo di memoria all'interno del cumulo in fase di esecuzione, restituisce lo spazio di indirizzamento assegnato. Questo operatore è esserenuovo operatore.

Se non è necessario allocare dinamicamente la memoria, è possibile utilizzare l'operatoredelete, cancellato dal nuovo operatore prima che la memoria allocata.

gli operatori new e delete

Ecco l'operatore new per essere qualsiasi sintassi generale del tipo di dati allocazione dinamica della memoria:

new data-type;

Qui, tipo di dati può essere qualsiasi built-in tipi di dati, compresi gli array, può essere qualsiasi tipo di dati tra cui una classe o una struttura, compresi definita dall'utente.Vediamo prima guardiamo i tipi di dati incorporati. Ad esempio, possiamo definire un puntatore a un puntatore di tipo double, quindi le richieste di memoria, la memoria viene allocata in fase di esecuzione. Siamo in grado di utilizzare ilnuovo operatore in conformità con la seguente dichiarazione per ottenere questo risultato:

double* pvalue  = NULL; // 初始化为 null 的指针
pvalue  = new double;   // 为变量请求内存

Se le aree di stoccaggio libere sono state esaurite, non può allocare correttamente la memoria. Si consiglia di verificare se il nuovo operatore restituisce un puntatore NULL, e prendere l'azione appropriata la seguente:

double* pvalue  = NULL;
if( !(pvalue  = new double ))
{
   cout << "Error: out of memory." <<endl;
   exit(1);

}

funzionemalloc () nel linguaggio C è apparso in C ++ è ancora presente, ma si consiglia di non utilizzare malloc (funzione).funzione di nuovo e malloc () rispetto al suo principale vantaggio è che, non solo allocare nuova memoria, ma ha anche creato l'oggetto.

In qualsiasi momento, quando si sente che un variabili dinamiche di memoria già allocata non è più necessario, è possibile utilizzare l'operatore delete per liberare la memoria ha usato, come segue:

delete pvalue;        // 释放 pvalue 所指向的内存

Utilizzato nel concetto di cui sopra, di seguito viene illustrato come utilizzare il nuovo e cancellare gli operatori:

#include <iostream>
using namespace std;

int main ()
{
   double* pvalue  = NULL; // 初始化为 null 的指针
   pvalue  = new double;   // 为变量请求内存
 
   *pvalue = 29494.99;     // 在分配的地址存储值
   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // 释放内存

   return 0;
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

Value of pvalue : 29495

Una serie di allocazione dinamica della memoria

Supponiamo di voler un array di caratteri (una stringa di 20 caratteri) per allocare la memoria, possiamo usare l'esempio precedente della sintassi array per allocare dinamicamente la memoria, come segue:

char* pvalue  = NULL;   // 初始化为 null 的指针
pvalue  = new char[20]; // 为变量请求内存

Per eliminare una matrice che abbiamo appena creato, la dichiarazione è la seguente:

delete [] pvalue;        // 删除 pvalue 所指向的数组

Ecco la sintassi generale nuovo operatore può allocare memoria per gli array multidimensionali, come segue:

int ROW = 2;
int COL = 3;
double **pvalue  = new double* [ROW]; // 为行分配内存

// 为列分配内存
for(int i = 0; i < COL; i++) {
    pvalue[i] = new double[COL];
}

Rilasciare memoria array multidimensionale:

for(int i = 0; i < COL; i++) {
    delete[] pvalue[i];
}
delete [] pvalue; 

oggetto allocazione dinamica della memoria

L'oggetto non è diversa da tipi di dati semplici. Ad esempio, si consideri il seguente codice, useremo un array di oggetti per chiarire questo concetto:

#include <iostream>
using namespace std;

class Box
{
   public:
      Box() { 
         cout << "调用构造函数！" <<endl; 
      }
      ~Box() { 
         cout << "调用析构函数！" <<endl; 
      }
};

int main( )
{
   Box* myBoxArray = new Box[4];

   delete [] myBoxArray; // Delete array

   return 0;
}

Se si desidera una scatola contiene quattro oggetti allocare array di memoria, il costruttore sarà chiamato quattro volte, nello stesso modo, quando si eliminano questi oggetti, il distruttore sarà chiamato lo stesso numero di volte (quattro volte).

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:

调用构造函数！
调用构造函数！
调用构造函数！
调用构造函数！
调用析构函数！
调用析构函数！
调用析构函数！
调用析构函数！