Comment le tas fonctionne en C ++ - les mannequins

Le tas est un bloc de mémoire amorphe auquel votre programme C ++ peut accéder si nécessaire. Découvrez pourquoi il existe et comment l'utiliser.

Tout comme il est possible de passer un pointeur sur une fonction, il est possible qu'une fonction renvoie un pointeur. Une fonction qui renvoie l'adresse d'un double est déclarée comme suit:

double * fn (void);

Cependant, vous devez être très prudent lorsque vous renvoyez un pointeur. Pour comprendre les dangers, vous devez savoir quelque chose sur la portée variable.

Portée limitée en C ++

Scope est la plage sur laquelle une variable est définie. Considérons l'extrait de code suivant:

// la variable suivante est accessible // à toutes les fonctions et définie tant que // le programme est en cours d'exécution (portée globale) int intGlobal; // la variable suivante intChild est accessible // uniquement à la fonction et est définie uniquement // tant que C ++ exécute child () ou // une fonction qui child () appelle (scope de fonction) void child (void) {int intChild;} // la variable suivante intParent a la fonction // portée void parent (void) {int intParent = 0; enfant(); int intLater = 0; intParent = intLater;} int main (int nArgs, char * pArgs []) {parent ();}

Ce fragment de programme commence par la déclaration d'une variable intGlobal. Cette variable existe à partir du moment où le programme commence à s'exécuter jusqu'à ce qu'il se termine. Vous dites que intGlobal "a une portée de programme. "Vous dites aussi que la variable" entre dans le champ "avant même que la fonction main () ne soit appelée.

La fonction main () appelle immédiatement parent (). La première chose que le processeur voit dans parent () est la déclaration de intParent. À ce stade, intParent entre dans la portée, c'est-à-dire que intParent est défini et disponible pour le reste de la fonction parent ().

La deuxième déclaration dans parent () est l'appel à child (). Encore une fois, la fonction child () déclare une variable locale, cette fois intChild. La portée de la variable intChild est limitée à la fonction child (). Techniquement, intParent n'est pas défini dans la portée de child () car child () n'a pas accès à intParent; cependant, la variable intParent continue d'exister pendant l'exécution de child ().

Quand exit () sort, la variable intChild est hors de portée. IntChild n'est plus seulement accessible, il n'existe plus. (La mémoire occupée par intChild est renvoyée dans le pool général pour être utilisée pour d'autres choses.)

Comme parent () continue à s'exécuter, la variable intLater entre dans la portée de la déclaration. Au moment où parent () retourne à main (), intParent et intLater sortent de la portée.

Comme intGlobal est déclaré globalement dans cet exemple, il est disponible pour les trois fonctions et reste disponible pendant toute la durée du programme.

Examen du problème d'étendue en C ++

Le segment de code suivant compile sans erreur mais ne fonctionne pas (ne détestez-vous pas ça?):

double * enfant (void) {double dLocalVariable; return & dLocalVariable;} void parent (void) {double * pdLocal; pdLocal = enfant (); * pdLocal = 1. 0;}

Le problème avec cette fonction est que dLocalVariable est défini uniquement dans la portée de la fonction child (). Ainsi, au moment où l'adresse mémoire de dLocalVariable est retournée par child (), elle fait référence à une variable qui n'existe plus. La mémoire que dLocalVariable occupait autrefois est probablement utilisée pour autre chose.

Cette erreur est très courante car elle peut se glisser de plusieurs façons. Malheureusement, cette erreur n'entraîne pas l'arrêt immédiat du programme. En fait, le programme peut fonctionner correctement la plupart du temps, c'est-à-dire que le programme continue à fonctionner tant que la mémoire précédemment occupée par dLocalVariable n'est pas réutilisée immédiatement. De tels problèmes intermittents sont les plus difficiles à résoudre.

Fournir une solution en utilisant le tas dans C ++

Le problème de portée est dû au fait que C ++ a récupéré la mémoire définie localement avant que le programmeur soit prêt. Ce dont on a besoin, c'est d'un bloc de mémoire contrôlé par le programmeur. Elle peut allouer la mémoire et la remettre quand elle le veut - pas parce que C ++ pense que c'est une bonne idée. Un tel bloc de mémoire s'appelle le tas.

La mémoire de tas est allouée en utilisant le nouveau mot-clé suivi du type d'objet à allouer. La nouvelle commande casse un morceau de mémoire du tas assez grand pour contenir le type d'objet spécifié et renvoie son adresse. Par exemple, le texte suivant attribue une variable double au tas:

double * enfant (void) {double * pdLocalVariable = new double; return pdLocalVariable;}

Cette fonction fonctionne maintenant correctement. Bien que la variable pdLocalVariable soit hors de portée lorsque la fonction child () renvoie, la mémoire à laquelle pdLocalVariable fait référence ne l'est pas. Un emplacement de mémoire retourné par new ne sort pas de sa portée tant qu'il n'est pas explicitement retourné au tas en utilisant le mot-clé delete, qui est spécifiquement conçu pour cela:

void parent (void) {// child () retourne l'adresse d'un bloc // de la mémoire de tas double * pdMyDouble = child (); // stocke une valeur ici * pdMyDouble = 1. 1; // … // retourne maintenant la mémoire sur le tas. Delete pdMyDouble; pdMyDouble = 0; // …}

Ici, le pointeur retourné par child () est utilisé pour stocker une valeur double. Une fois la fonction terminée avec l'emplacement de la mémoire, elle est renvoyée dans le tas. La fonction parent () met le pointeur à 0 après que la mémoire de tas a été retournée - ce n'est pas une exigence, mais c'est une très bonne idée.

Si le programmeur tente par erreur de stocker quelque chose dans * pdMyDouble après la suppression, le programme se bloque immédiatement avec un message d'erreur significatif.

Vous pouvez aussi utiliser new pour allouer des tableaux du tas, mais vous devez retourner un tableau en utilisant le mot-clé delete []:

int * nArray = new int [10]; nArray [0] = 0; delete [] nArray;

Techniquement nouveau int [10] invoque le nouvel opérateur [] mais il fonctionne de la même manière que le nouveau.