'>

La mémoire dynamique au C++

 Jusqu'à présent, dans tous nos programmes, nous n'avons eu autant de mémoire disponible que nous avons déclaré à nos variables, ayant la taille de chacun d'eux doit être déterminée dans le code source, avant l'exécution du programme. Mais, si nous avons besoin d'une quantité variable de mémoire qui ne peut être déterminée au cours de l'exécution? Par exemple, dans le cas où nous avons besoin d'intervention de l'utilisateur pour déterminer la quantité nécessaire de l'espace mémoire.

La réponse est la mémoire dynamique, dont C + + intègre les opérateurs new et delete.

Les opérateurs et les nouveaux []
Pour demander mémoire dynamique que nous utilisons le nouvel opérateur. Nouvelle est suivie par un spécificateur de type de données et, si une séquence de plus d'un élément est nécessaire, le nombre de ceux-ci entre crochets []. Il renvoie un pointeur sur le début du nouveau bloc de mémoire alloué. Sa forme est:

pointeur = nouveau type
pointeur = new Type [nombre_d_elements]

La première expression est utilisée pour allouer de la mémoire pour contenir un seul élément de type type. Le second est utilisé pour attribuer un bloc (un tableau) des éléments de type de type, où nombre_d_elements est une valeur entière représentant le montant de ceux-ci. Par exemple:

1
 2


  

 int * bobby; bobby = new int [5];



Dans ce cas, le système attribue dynamiquement l'espace pour cinq éléments de type int et renvoie un pointeur sur le premier élément de la séquence, qui est associé à à cheveux. Par conséquent, maintenant, policier pointe sur un bloc valide de la mémoire de l'espace pour cinq éléments de type int.



Le premier élément pointé par bobby est accessible soit par l'expression bobby [0] ou l'expression * bobby. Tous les deux sont équivalents comme cela a été expliqué dans la section sur les pointeurs. Le deuxième élément est accessible soit avec bobby [1] ou * (bobby +1) et ainsi de suite ...

Vous pourriez vous demander la différence entre déclarer un tableau normal et affectant la mémoire dynamique à un pointeur, comme nous venons de le faire. La différence la plus importante est que la taille d'un tableau doit être une valeur constante, ce qui limite la taille de ce que nous décidons au moment de la conception du programme, avant son exécution, tandis que l'allocation dynamique de la mémoire nous permet d'assigner la mémoire au cours de l' exécution du programme (exécution) en utilisant une valeur variable ou constante que sa taille.

La mémoire dynamique demandée par notre programme est attribué par le système à partir du tas de mémoire. Toutefois, la mémoire de l'ordinateur est une ressource limitée, et il peut être épuisée. Par conséquent, il est important d'avoir un mécanisme pour vérifier si notre demande d'allouer de la mémoire a été un succès ou non.

C + + fournit deux méthodes courantes pour vérifier si l'allocation a été un succès:

L'une consiste à traiter les exceptions. En utilisant cette méthode une exception de type bad_alloc est levée lorsque l'allocation échoue. Les exceptions sont un puissant C + + caractéristique expliqué plus loin dans ce tutoriel. Mais pour l'instant vous devez savoir que si cette exception est levée et elle n'est pas gérée par un gestionnaire spécifique, l'exécution du programme est interrompue.

Cette méthode d'exception est la méthode par défaut utilisé par le nouveau, et il est celui qui est utilisé dans une telle déclaration:



  

 bobby = new int [5]; // if it fails an exception is thrown



L'autre méthode est connue comme nothrow, et ce qui arrive quand il est utilisé, c'est que quand une allocation de mémoire échoue, au lieu de lancer une exception bad_alloc ou arrêter le programme, le pointeur retourné par la nouvelle est un pointeur NULL, et le programme continue son exécution .

Cette méthode peut être spécifiée en utilisant un objet spécial appelé nothrow, a déclaré en tête <new>, comme argument pour les nouveaux:



  

 bobby = new (nothrow) int [5];



Dans ce cas, si l'attribution de ce bloc de mémoire a échoué, l'échec peut être détecté en vérifiant si Bobby a une valeur de pointeur nul:

 1
 2
 3
 4
 5


  

 int * bobby; bobby = new (nothrow) int [5]; if (bobby == 0) { // error assigning memory. Take measures. };



Cette méthode nothrow exige plus de travail que la méthode d'exception, puisque la valeur retournée doit être vérifié après chaque allocation de mémoire, mais je vais l'utiliser dans nos exemples en raison de sa simplicité. Quoi qu'il en soit, cette méthode peut devenir fastidieux pour les gros projets, où la méthode d'exception est généralement préférée. La méthode d'exception sera expliqué en détail plus loin dans ce tutoriel.

Les opérateurs delete et delete []
Depuis la nécessité de la mémoire dynamique est généralement limitée à des moments spécifiques dans un programme, une fois qu'il n'est plus nécessaire, il doit être libéré afin que la mémoire est à nouveau disponible pour d'autres demandes de la mémoire dynamique. C'est le but de la suppression de l'opérateur, dont le format est le suivant:

 1
 2


  

 delete pointer; delete [] pointer;



La première expression doit être utilisée pour supprimer la mémoire allouée à un seul élément, et le second pour une mémoire allouée à des réseaux d'éléments.

La valeur passée comme argument pour supprimer doit être soit un pointeur vers un bloc de mémoire alloué préalablement à nouveau, ou un pointeur nul (dans le cas d'un pointeur null, supprimer produit pas d'effet).

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28


  

 // rememb-o-matic #include <iostream> #include <new> using namespace std; int main () { int i,n; int * p; cout << "How many numbers would you like to type? " ; cin >> i; p= new (nothrow) int [i]; if (p == 0) cout << "Error: memory could not be allocated" ; else { for (n=0; n<i; n++) { cout << "Enter number: " ; cin >> p[n]; } cout << "You have entered: " ; for (n=0; n<i; n++) cout << p[n] << ", " ; delete [] p; } return 0; }

  

  Combien de numéros aimeriez-vous saisissez?  5
  Entrez le nombre: 75
  Entrer le numéro: 436
  Entrez le numéro 1067
  Entrez le nombre: 8
  Entrez le nombre: 32
  Vous avez saisi: 75, 436, 1067, 8, 32,



Remarquez comment la valeur entre crochets dans la nouvelle déclaration est une valeur variable entré par l'utilisateur (i), pas une valeur constante:



  

 p= new (nothrow) int [i];



Mais l'utilisateur pourrait avoir entré une valeur pour i si grand que notre système n'a pas pu le supporter. Par exemple, quand j'ai essayé de donner une valeur de 1 milliard à la «Combien de numéros" question, mon système ne peut pas allouer autant de mémoire pour le programme et j'ai obtenu le message texte que nous avons préparé pour ce cas (Erreur: mémoire ne peut pas attribuer). Rappelez-vous que dans le cas que nous avons essayé d'allouer la mémoire sans spécifier le paramètre nothrow dans la nouvelle expression, une exception sera levée, qui si elle n'est pas traitée termine le programme.

C'est une bonne pratique de toujours vérifier si un bloc de mémoire dynamique a été alloué avec succès. Par conséquent, si vous utilisez la méthode de nothrow, vous devriez toujours vérifier la valeur du pointeur retourné. Sinon, utilisez la méthode d'exception, même si vous ne gérez pas l'exception. De cette façon, le programme prendra fin à ce moment-là sans que les résultats inattendus de la poursuite de l'exécution d'un code qui suppose un bloc de mémoire ayant été alloué alors qu'en fait il n'en a pas.

La mémoire dynamique en ANSI-C

Les opérateurs new et delete sont exclusive de C + +. Ils ne sont pas disponibles dans la langue C. Mais l'utilisation de pur langage C et sa bibliothèque, la mémoire dynamique peut également être utilisé par les fonctions malloc , calloc , realloc et libre , qui sont également disponibles en C + +, y compris le fichier d'en-tête <cstdlib> (voir cstdlib pour plus d'info).

Les blocs de mémoire alloués par ces fonctions ne sont pas nécessairement compatibles avec ceux retournés par la nouvelle, de sorte que chacun doit être manipulé avec son propre ensemble de fonctions ou opérateurs.
Publié par Drupal Study