Latest web development tutorials

mémoire dynamique de C

Comprendre la mémoire dynamique en C ++, il est comment le travail est de devenir un C ++ programmeurs qualifiés essentiels. C ++ mémoire de programme est divisé en deux parties:

  • Stack: toutes les variables déclarées dans une fonction prendront la mémoire de la pile.
  • Heap: Ceci est lamémoire de programme ne sont pas utilisées, les pistes du programme peut être utilisé pour allouer dynamiquement la mémoire.

Plusieurs fois, vous ne pouvez pas prévoir à l'avance la quantité de mémoire est nécessaire pour stocker une variable définie dans les informations spécifiques requises pour déterminer la taille de la mémoire nécessaire à l'exécution.

En C ++, vous pouvez utiliser un opérateur spécial est affecté à une variable d'un type donné de la mémoire dans le tas lors de l'exécution, elle renvoie l'espace d'adressage alloué. Cet opérateur est en cours denouvel opérateur.

Si vous n'avez pas besoin d'allouer dynamiquement la mémoire, vous pouvez utiliser l'opérateurdelete, supprimé par le nouvel opérateur avant la mémoire allouée.

opérateurs new et delete

Voici le nouvel opérateur d'être toute syntaxe générale du type de données allocation dynamique de la mémoire: 

new data-type;

Ici, type de données peut être tout construit dans les types de données, y compris les tableaux, peut être tout type de données , y compris une classe ou une structure, y compris définie par l' utilisateur.Examinons d'abord les types de données intégrés. Par exemple, nous pouvons définir un pointeur vers un pointeur de type double, puis demande la mémoire, la mémoire est allouée au moment de l'exécution. Nous pouvons utiliser lenouvel opérateur, conformément à la déclaration suivante pour accomplir ceci:

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

Si les zones de stockage libres ont été épuisés, il ne peut pas allouer de la mémoire avec succès. Il est conseillé de vérifier si le nouvel opérateur renvoie un pointeur NULL, et prendre les mesures appropriées de ce qui suit: 

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

}

fonctionmalloc () dans le langage C est apparu en C ++ est toujours présent, mais il est recommandé de ne pas utiliser malloc (fonction).fonction et malloc () de nouveau par rapport à son principal avantage est que, non seulement d'allouer une nouvelle mémoire, elle a aussi créé l'objet.

A tout moment, quand vous vous sentez qu'une des variables dynamiques mémoire déjà allouée est plus nécessaire, vous pouvez utiliser l'opérateur delete pour libérer la mémoire qu'il utilise, comme suit: 

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

Utilisé dans le concept ci-dessus, l'exemple suivant montre comment utiliser la nouvelle et supprimer les opérateurs: 

#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;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

Value of pvalue : 29495

Un tableau d'allocation dynamique de mémoire

Supposons que nous voulons un tableau de caractères (une chaîne de 20 caractères) pour allouer de la mémoire, nous pouvons utiliser l'exemple ci-dessus de la syntaxe de tableau pour allouer dynamiquement la mémoire, comme suit: 

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

Pour supprimer un tableau que nous venons de créer, la déclaration est la suivante: 

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

Voici la syntaxe générale nouvel opérateur peut allouer de la mémoire pour les tableaux multidimensionnels, comme suit: 

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

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

Relâchez mémoire de tableau multidimensionnel: 

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

objet d'allocation de mémoire dynamique

L'objet ne diffère pas de types de données simples. Par exemple, considérons le code suivant, nous allons utiliser un tableau d'objets pour clarifier ce concept: 

#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;
}

Si vous voulez une boîte contient quatre objets allouent réseau de mémoire, le constructeur sera appelé quatre fois, de la même manière, lorsque vous supprimez ces objets, le destructeur sera appelé le même nombre de fois (quatre fois).

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

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