Version imprimable
Bonjour,
Je me demandait comment en natif un langage sait comment désallouer en mémoire un type personnalisée, une classe etc, avec un pointeur et le mot clé delete ? est-ce que a la fin de la classe il y a le caractère spécial '/0' ou ça se passe autrement ?
Merci d'avance
Bonsoir,
Ça dépend de ce que tu appelles « désallouer un type personnalisé », et cela dépend aussi grandement du langage que tu utilises. Ces considérations ne seront pas du tout les mêmes si tu utilises un langage compilé ou s'il est interprété. Au passage, les « classes » et l'opérateur « delete » sont l'apanage du C++. Ils n'existe pas en langage C.
Lorsque tu définis une macro avec #define, tu peux l'oublier avec #undef. En revanche, tu ne peux pas annuler une déclaration de type menée avec typedef ou avec les mot-clé class ou struct. Par contre, ces définitions ont la même portée que les variables (et se déclarent suivant la même syntaxe), si bien que le type personnalisé ainsi déclaré ne sera défini qu'à l'intérieur du bloc où il a été déclaré. C'est pour cela qu'en général, on les définit au niveau global.
Si ce sont les instances de ces types que tu veux supprimer (c'est-à-dire les variables déclarées), alors il y a deux possibilités. Soit ce sont des variables locales ordinaires allouées dynamiquement sur la pile, soit ce sont des objets engendrés par new et delete (en C++ uniquement). Dans le premier cas, on réserve simplement la place nécessaire à ces variables sur la pile, et cette place est libéré en fin de bloc en vidant la pile.
Quand tu utilises, en C++, « un pointeur et le mot-clé delete », tu ne dois le faire que sur un objet qui a au préalable été alloué avec new. Il s'agit en fait de routines d'allocation mémoire similaire à malloc() et free() en langage C. Ça ne fonctionne pas avec un caractère « \0 » en fin de classe, mais ces routines tiennent à la place une liste des zones allouées avec des méta-données. Ces méta-données indiquent la taille de la zone allouée et la nature de l'objet qui y loge.
La différence, ici, entre C et C++, est que dans les deux cas, l'apparition d'un objet provoque l'appel automatique de son constructeur pour l'initialiser correctement (principe appelé RAII) et de son destructeur juste avant de libérer son espace, s'ils existent bien sûr.
Bonjour,
Si ton inquiétude est : comment le système sait-il où se termine l'instance qui doit disparaître?
Dans le cas d'une instance locale à un bloc, au moment de la sortie du bloc le compilateur connait bien le type et la localisation de la variable car il vient d'en générer le code, il en connait donc sa taille exacte.
Dans le cas d'une instance globale, la mémoire sera totalement libérée en quittant l'application, donc peu importe la taille.
Dans la cas d'une instance allouée par new ou par new[], le système retourne un pointeur mais en réalité il a alloué un bloc légèrement plus grand et a ajouté des informations qu'il utilisera lors de l'appel à delete ou delete[].
Code:
2
3
4
5Bloc alloué +--------+--------+---------------------------------------------------+ |LgTotale| NbItems| zone disponible pour les données | +--------+--------+---------------------------------------------------+ ^ \_________ Le pointeur qui est retourné par new et new[]
Dans la cas d'une instance allouée par new ou par new[], le système retourne un pointeur mais en réalité il a alloué un bloc légèrement plus grand et a ajouté des informations qu'il utilisera lors de l'appel à delete ou delete[].
Génial ça merci tu répond parfaitement à ma question donc il y a une petite structure de données avant l'objet ! je n'étais pas au courant ! c'est normaliser il y a une doc sur ça ? on peut la modifier ?
BonjourCitation:
Envoyé par hobouu
Un caractère spécial quel qu'il soit (\0, esc, point-virgule, pipe) n'a de sens "spécial" que dans un contexte où on ne risque pas de le trouver "par accident". Par exemple, une chaine de caractères ne contenant que des caractères "affichables" (donc avec un code ascii compris entre 0x40 et... je sais pas exactement mais on va dire 0xe0) n'aura aucune chance d'avoir de façon accidentelle un caractère 0x00. Donc ce caractère pourra servir de valeur "spéciale" indiquant un truc particulier (comme "fin de chaine").
Une classe (objet binaire) pouvant contenir toute la gamme du code ascii, pour elle, aucun caractère "spécial" quel qu'il soit ne pourra fonctionner...
En tout cas, ce n'est pas normalisé dans le standard C++. Lors d'un appel à delete[], le compilateur se débrouille comme il veut pour savoir combien d'objets il faut détruire puis combien d'octets il faut désallouer.Citation:
Envoyé par hobouu
Exemple de deux techniques possibles pour implémenter delete[] : https://isocpp.org/wiki/faq/freestor...s-in-new-array
Très intéressant ! j'aurais pensé qu'il y aurait quand même un consensus sur ce procédé mais non, merciCitation:
Envoyé par Pyramidev