L'allocation dynamique de mémoire en C/C++ fait référence à l'exécution manuelle d'une allocation de mémoire par un programmeur. La mémoire allouée dynamiquement est allouée sur Tas, et les variables non statiques et locales obtiennent de la mémoire allouée sur Empiler (Faire référence à Programmes C de configuration de la mémoire pour plus de détails).

Que sont les candidatures ?

• Une utilisation de la mémoire allouée dynamiquement consiste à allouer de la mémoire de taille variable, ce qui n'est pas possible avec la mémoire allouée par le compilateur, sauf pour tableaux de longueur variable .
• L'utilisation la plus importante est la flexibilité offerte aux programmeurs. Nous sommes libres d’allouer et de libérer de la mémoire quand nous en avons besoin et quand nous n’en avons plus besoin. Il existe de nombreux cas où cette flexibilité est utile. Des exemples de tels cas sont Arbre , etc.

En quoi est-ce différent de la mémoire allouée aux variables normales ?

Pour les variables normales comme int a, char str[10], etc., la mémoire est automatiquement allouée et désallouée. Pour la mémoire allouée dynamiquement comme int *p = new int[10], il est de la responsabilité du programmeur de libérer la mémoire lorsqu'elle n'est plus nécessaire. Si le programmeur ne libère pas de mémoire, cela provoque un fuite de mémoire (la mémoire n'est pas libérée jusqu'à la fin du programme).

Comment la mémoire est-elle allouée/libérée en C++ ?
C utilise le malloc() et calloc() fonction pour allouer de la mémoire dynamiquement au moment de l'exécution et utilise une fonction free() pour libérer la mémoire allouée dynamiquement. C++ prend en charge ces fonctions et dispose également de deux opérateurs nouveau et supprimer, qui effectuent la tâche d’allocation et de libération de la mémoire d’une manière meilleure et plus simple.

nouvel opérateur

L'opérateur new désigne une demande d'allocation de mémoire sur le Free Store. Si suffisamment de mémoire est disponible, un nouvel opérateur initialise la mémoire et renvoie l'adresse de la mémoire nouvellement allouée et initialisée à la variable de pointeur.

Syntaxe pour utiliser le nouvel opérateur

convertir de char en int java

pointer-variable =   new   data-type;>

Ici, la variable pointeur est le pointeur de type type-données. Le type de données peut être n'importe quel type de données intégré, y compris un tableau, ou tout type de données défini par l'utilisateur, y compris une structure et une classe.
Exemple:

// 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>

Initialiser la mémoire : Nous pouvons également initialiser la mémoire pour les types de données intégrés à l'aide d'un nouvel opérateur. Pour les types de données personnalisés, un constructeur est requis (avec le type de données en entrée) pour initialiser la valeur. Voici un exemple d’initialisation des deux types de données :

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

Exemple:

// 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;  renvoie 0 ; }>

25 75.25 25>

Allouez un bloc de mémoire : un nouvel opérateur est également utilisé pour allouer un bloc (un tableau) de mémoire de type Type de données .

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

où size(a variable) spécifie le nombre d'éléments dans un tableau.

Exemple:

obj en java

int *p = new int[10]>

Alloue dynamiquement de la mémoire pour 10 entiers en continu de type int et renvoie un pointeur vers le premier élément de la séquence, qui est attribué en haut (un pointeur). p[0] fait référence au premier élément, p[1] fait référence au deuxième élément, et ainsi de suite.

Déclaration de tableau normale vs utilisation de new
Il y a une différence entre déclarer un tableau normal et allouer un bloc de mémoire en utilisant new. La différence la plus importante est que les tableaux normaux sont libérés par le compilateur (si le tableau est local, ils sont libérés lorsque la fonction retourne ou se termine). Cependant, les tableaux alloués dynamiquement restent toujours là jusqu'à ce qu'ils soient libérés par le programmeur ou que le programme se termine.

Que se passe-t-il si suffisamment de mémoire n'est pas disponible pendant l'exécution ?
Si suffisamment de mémoire n'est pas disponible dans le tas à allouer, la nouvelle requête indique un échec en lançant une exception de type std::bad_alloc, à moins que nothrow ne soit utilisé avec l'opérateur new, auquel cas elle renvoie un pointeur NULL (faites défiler jusqu'à la section Exception gestion du nouvel opérateur dans ce article). Par conséquent, il peut être judicieux de vérifier la variable de pointeur produite par le nouveau avant d'utiliser son programme.

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

supprimer l'opérateur

Puisqu'il est de la responsabilité du programmeur de désallouer la mémoire allouée dynamiquement, les programmeurs disposent d'un opérateur de suppression en langage C++.

Syntaxe:

chaîne.sous-chaîne java

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

Ici, la variable pointeur est le pointeur qui pointe vers l'objet de données créé par nouveau .

Exemples:

delete p; delete q;>

Pour libérer le tableau alloué dynamiquement pointé par la variable pointeur, utilisez la forme suivante de supprimer :

  // 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>

Complexité temporelle : O(n), où n est la taille de mémoire donnée.

Articles Liés:

• Quiz sur les nouveaux et les supprimés
• supprimer vs gratuit