Discussion :

[Clad3]

Bonjour,
ralala ces petites choses ... il faudra un jour que je m'y fasse ;o)

Juste histoire d'être sur :

Code :

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

1
2
3
4
5
6
 
{
int a = 0 ;
int * i ;
i = &a ;
}

Ce pointeur est détruit aprés mon acolade c'est ca ?

Sinon dans ce cas :

Code :

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

1
2
3
4
5
6
7
 
{
int * P ;
int * I = new int(6) ;
I = P;
// delete I ; -> provoque une erreur
}

C'est pas bon signe ca, non ?

[ ca va surement paraitre bête ce que je vais dire mais tant pis ^^ ]

Alors à chaque fois qu'on veux affecter un nouvel objet à un pointeur, il faut détruire le précédent, sinon la mémoire ne sera jamais libérée ?

Merci

[Mayti4]

Ce pointeur est détruit aprés mon acolade c'est ca ?

Oui.

Alors à chaque fois qu'on veux affecter un nouvel objet à un pointeur, il faut détruire le précédent, sinon la mémoire ne sera jamais libérée ?

Seulement si le précédent a été alloué avec new.

[diogene]

Code :

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

1
2
3
4
5
{
int a = 0 ;
int * i ;
i = &a ;
}

Ce pointeur est détruit aprés mon acolade c'est ca ?

Oui

Code :

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

1
2
3
4
5
6
{
int * P ;
int * I = new int(6) ;
I = P;
// delete I ; -> provoque une erreur
}

C'est pas bon signe ca, non ?

C'est normal. L'adresse retournée par new est perdue, on ne peut plus faire le delete correspondant au new. On fait un delete sur une adresse non obtenue par new (I contient avant le delete la valeur qui est dans P (donc n'importe quoi dans ce code) )

[Clad3]

Bien, bien, merci je vais faire plus attention à tout ca désormais

[xxiemeciel]

Salut,

Oui il faut effacer la memoire si tu veux reassigner ton pointeur, a condition que ton pointeur ait bien ete allouer par tes soins avec un new.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
f()
{
   int *P;  //ici P n'est pas initialisé donc son adresse est un truc du genre 0xfffffff
   int *I = new int(6); //adresse 0x00046c28 par exemple
 
   delete I; //efface la memoire allouée a l'adresse 0x00046c28
   I = P; // change l'adresse de I pour celle de P
   delete P; //provoque une erreur car P n'a pas ete initialisé et son adresse n'est pas valide
}

[Clad3]

Dans ton exemple xxiemeciel, le "delete I" efface les informations contenu dans la mémoire à l'adresse de I , donc à ce stade I contient toujours la même adresse ?

Hum je crois que dans ma méoire c'était confus , en fait les pointeurs eux même sont détruit à la sortie du scope mais pas les données pointés, ce qui représente effectivement un danger dans le cas d'une allocation dynamique .... dites, dites, j'ai bon ?

[diogene]

Dans ton exemple xxiemeciel, le "delete I" efface les informations contenu dans la mémoire à l'adresse de I , donc à ce stade I contient toujours la même adresse ?

plus exactement, le delete libère la mémoire attribuée et la rend ainsi disponible pour la suite

Hum je crois que dans ma méoire c'était confus , en fait les pointeurs eux même sont détruit à la sortie du scope mais pas les données pointés, ce qui représente effectivement un danger dans le cas d'une allocation dynamique .... dites, dites, j'ai bon ?

Oui!!! (si les pointeurs en question stockent l'adresse d'objets créés par new) Mais ce n'est pas un danger, il faut simplement comprendre ce qui se passe effectivement "en dessous" de ce qu'on écrit. Le C++ (comme le C) a un niveau d'abstraction qui nécessite la compréhension des mécanismes sous-jacents

[Rafy]

Le mieux pour ne pas toucher à de la mémoire interdite, quand tu créés un pointeur alors tu le fait pointer sur NULL, et tu te dis qu'avant tout new sur un vecteur, alors il doit être NULL. Ca va t'éviter de faire des bétises :

Code :

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

1
2
3
4
5
6
 
int* pI = NULL;    // Je le mets à NULL dès le départ
int I = 4;
pI = new int(4);
pI =  I;    // Ben la je me dis : j'ai pas le droit car pI ne pointe pas sur NULL
// Alors je me mets une claque :twisted:

C'est un truc mémotec... ou mnémotruc... J'ai pas dis qu'avant de faire un new il fallait vérifier si le pointeur était NULL, j'ai juste dis que si tu gardais toujours ça en tête alors ça peut te fair éviter des erreurs...

[Clad3]

Ce n'est pas pI = &I plutot ?
Enfin je pense retenir que "new" va avec "delete", et effctivement, penser à intialiser mes pointeur a NULL a leur création et aprés un delete me semble une bonne habitude à prendre .

[Luc Hermitte]

Code :

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

1
2
3
4
5
6
 
{
int a = 0 ;
int * i ;
i = &a ;
}

Ce pointeur est détruit aprés mon acolade c'est ca ?

euh ...
A la sortie de ton bloc, a n'existe plus, i n'existe plus.
i pointait vers a. En supposant que tu "exportes" la valeur de i (qui est une adresse!), cela serait une adresse vers une donnée qui n'existe plus.

Alors à chaque fois qu'on veux affecter un nouvel objet à un pointeur, il faut détruire le précédent, sinon la mémoire ne sera jamais libérée ?

C'est pour cela que les pointeurs intelligents (et le RAII de manière générale) sont nos amis.

Le mieux pour ne pas toucher à de la mémoire interdite, quand tu créés un pointeur alors tu le fait pointer sur NULL, et tu te dis qu'avant tout new sur un vecteur, alors il doit être NULL

Le mieux, c'est de faire comme pour toute variable : on la crée initialisée!
Quand vraiment on ne peut pas faire autrement (car elle sera initialisée dans un switch-case, ou autre structure de saut conditionnel), tu l'initialises à une valeur bidon connue comme telle (0 est fait pour ça chez les pointeurs) -- bien que je préfère avoir des petites fonctions qui retourneront le résultat de la construction conditionnelle, ce qui me permet de n'avoir qu'une seule construction/affectation, sans réaffectation ultérieure.

Et au fait, je ne fais JAMAIS de new sur des vecteurs. Mes vecteurs (std::vector) vivent sur la pile et leur mémoire est automatiquement gérée, même si il y a des exceptions.