Discussion :

[burndev]

bonjour,

avec les lectures pour ma formation, je lis:

après utilisation, la zone mémoire définie à l'aide du mot clé new doit être libérée pour être rendu au système. Pour cela appelez le mot clé delete sur le pointeur.

de mon coté je test ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
int main()
{
    using namespace std;
    int variableLocale = 5;
    int * pLocal = &variableLocale;
    int * pTas = new int;
    *pTas = 7;
 
    cout << "VariableLocale : " << variableLocale << endl;
    cout << "*pLocal : " << *pLocal << endl;
    cout << "*pTas : " << *pTas << " => " << pTas << endl;
 
    delete pTas;
    pTas = new int;
    *pTas = 9;
 
    cout << "*pTas : " << *pTas << " => " << pTas << endl;
    delete pTas;
 
    cout << "*pTas : " << *pTas << " => " << pTas << endl;
    return 0;
}

delete supprime bien la mémoire réservé pour l'objet, mais le pointeur en lui même il existe toujours a l'adresse de stockage.

la dernière sortie de flux : *pTas : 6164688 => 0x5e1058

est-il possible de le supprimé ou simplement de le rendre null avec *pPointeur = 0;
merci

[koala01]

Salut,

Il ne faut pas confondre le fait de modifier la variable pointée par un pointeur et celui de modifier l'adresse vers laquelle pointe le pointeur.

Si tu écrit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*pTas = 0;

tu affecte la valeur 0 à... ce qui est pointé par pTas.

Dans l'exemple que tu montres, cela fonctionnera uniquement parce que pTas est un pointeur sur... un entier, et que les entiers sont... compatibles avec la valeur 0.

Dés que tu travailleras avec des types personnalisés, il y a de fortes chances que le compilateur t'envoie gentiment balader parce qu'il est dans l'impossibilité d'assigner la valeur 0 à une variable de ton type personnalisé (avec cependant une exception que je tairai ici pour ne pas rendre les choses plus compliquées à comprendre que ce qu'elles ne le sont déjà )

Par contre, il faut savoir qu'un pointeur n'est jamais qu'une variable numérique comme une autre (dans le sens où la valeur qu'elle représente ne change normalement pas toute seule), un peu particulière dans le sens où elle ... permet simplement de représenter l'adresse mémoire à laquelle se trouve la variable du type indiqué.

Ainsi, lorsque tu écris le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ptas = new int;

tu donne à ptas la valeur numérique entière correspondant à l'adresse à laquelle se trouve... un espace mémoire (alloué de manière dynamique) suffisant grand pour représenter un int.

A l'inverse, lorsque tu écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

delete ptas;

tu ne fais rien d'autre que de demander au système de libérer la mémoire allouée (grace à l'instruction new dont je viens de parler) pour représenter ce int...

Cela ne modifie en rien l'adresse représentée par pTas: cela ne fait réellement qu'invalider ce qui se trouve à l'adresse en question

Si, par la suite, tu essaye d'utiliser pTas, il contiendra donc... toujours l'adresse à laquelle se trouvait le int alors que celui-ci n'existe plus, et que l'adresse mémoire est potentiellement utilisée par autre chose.

Ce qu'il faut donc faire, c'est donner à pTas (et non à "ce qui est pointé par" pTas) une valeur qui puisse être reconnue comme étant invalide, et qui pourra donc être testée.

Cette adresse, c'est NULL ou 0.

Mais il faut donc veiller à écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pTas = NULL; /* ou pTas = 0; */

et non

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*pTas = NULLL; /* ou pTas = 0; */

dont je t'ai expliqué plus haut que ca ne faisait absolument pas la même chose, et que cela a même de grandes chances d'être refusé par le compilateur pour les types que tu auras toi-même définis.

[EDIT]Il est d'ailleurs de bon ton, lorsque tu déclare un pointeur, de veiller à lui affecter la valeur NULL si tu ne lui affecte pas directement une adresse correcte et quand tu libère la mémoire correspndante et, si tu as des raisons de croire qu'il peut ne pas pointer vers une adresse mémoire correcte, de veiller à tester systématiquement s'il est égal ou non à NULL...

[bacelar]

Une simple MACRO peu appeler le delete et réinitialiser le pointeur à null.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
#define SAFEDELETE(pointer) if((pointer)) \ 
                           { delete (pointer); pointer = NULL; }

[Goten]

Pourquoi tester si le pointeur n'est pas null? C'est couteux pour rien.

[koala01]

Une simple MACRO peu appeler le delete et réinitialiser le pointeur à null.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
#define SAFEDELETE(pointer) if((pointer)) \ 
                           { delete (pointer); pointer = NULL; }

Pourquoi tester si le pointeur n'est pas null? C'est couteux pour rien.

En effet, delete sur NULL est garanti sans danger

Ce qui est dangereux, c'est n'importe quel accès (y compris par delete) à une adresse déjà libérée, car cela provoque un comportement non défini