bonjour,
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution de
ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et ensuite
appel à l'opérateur delete surchargé. mais y a t'il une libération
quelconque de mémoire ?
bonjour,
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution de
ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et ensuite
appel à l'opérateur delete surchargé. mais y a t'il une libération
quelconque de mémoire ?
bonjour,
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution de
ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et ensuite
appel à l'opérateur delete surchargé. mais y a t'il une libération
quelconque de mémoire ?
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution de
ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et ensuite
appel à l'opérateur delete surchargé. mais y a t'il une libération
quelconque de mémoire ?
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution de
ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et ensuite
appel à l'opérateur delete surchargé. mais y a t'il une libération
quelconque de mémoire ?
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution de
ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et ensuite
appel à l'opérateur delete surchargé. mais y a t'il une libération
quelconque de mémoire ?
En passant, la fonction membre operator delete est toujours statique. On
n'a pas le droit de le préciser.
En passant, la fonction membre operator delete est toujours statique. On
n'a pas le droit de le préciser.
En passant, la fonction membre operator delete est toujours statique. On
n'a pas le droit de le préciser.
"monk31" wrote in message
news:j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution
de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int en pointeur
vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le "new int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur, puis
l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator new(size_t)"
puis le constructeur.
"monk31" <bruno.rommens@laposte.net> wrote in message
news:3d509a44.0307240041.deb7651@posting.google.com...
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution
de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int en pointeur
vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le "new int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur, puis
l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator new(size_t)"
puis le constructeur.
"monk31" wrote in message
news:j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution
de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int en pointeur
vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le "new int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur, puis
l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator new(size_t)"
puis le constructeur.
writes:En passant, la fonction membre operator delete est toujours
statique. On n'a pas le droit de le préciser.
12.4/6 a l'air d'impliquer qu'on a le droit, et un des "Guidelines"
d'"Exceptional C++" est "Always explicitly declare operator new() and
operator delete() as static functions. They are neve non static member
functions."
kanze@gabi-soft.fr writes:
En passant, la fonction membre operator delete est toujours
statique. On n'a pas le droit de le préciser.
12.4/6 a l'air d'impliquer qu'on a le droit, et un des "Guidelines"
d'"Exceptional C++" est "Always explicitly declare operator new() and
operator delete() as static functions. They are neve non static member
functions."
writes:En passant, la fonction membre operator delete est toujours
statique. On n'a pas le droit de le préciser.
12.4/6 a l'air d'impliquer qu'on a le droit, et un des "Guidelines"
d'"Exceptional C++" est "Always explicitly declare operator new() and
operator delete() as static functions. They are neve non static member
functions."
"Frederic Lachasse" wrote in message
news:<WJ_Ta.12672$..."monk31" wrote in message
news:j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution
de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int en
pointeur
vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le "new
int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur, puis
l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator new(size_t)"
puis le constructeur.
C'est vrai, mais tu as oublié l'essentiel dans ce cas-ci : après le
delete ci-dessus, l'objet sp_int contient un pointeur à un objet deleté
(un « dangling pointer », en anglais). Étant donné que sp_int est une
variable locale, son destructeur serait appelé (une deuxième fois) quand
on qui sa portée. Ce qui n'est pas pour arranger des choses.
"Frederic Lachasse" <frederic.lachasse@verizon.net> wrote in message
news:<WJ_Ta.12672$634.4486@nwrdny03.gnilink.net>...
"monk31" <bruno.rommens@laposte.net> wrote in message
news:3d509a44.0307240041.deb7651@posting.google.com...
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution
de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int en
pointeur
vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le "new
int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur, puis
l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator new(size_t)"
puis le constructeur.
C'est vrai, mais tu as oublié l'essentiel dans ce cas-ci : après le
delete ci-dessus, l'objet sp_int contient un pointeur à un objet deleté
(un « dangling pointer », en anglais). Étant donné que sp_int est une
variable locale, son destructeur serait appelé (une deuxième fois) quand
on qui sa portée. Ce qui n'est pas pour arranger des choses.
"Frederic Lachasse" wrote in message
news:<WJ_Ta.12672$..."monk31" wrote in message
news:j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de l'exécution
de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int en
pointeur
vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le "new
int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur, puis
l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator new(size_t)"
puis le constructeur.
C'est vrai, mais tu as oublié l'essentiel dans ce cas-ci : après le
delete ci-dessus, l'objet sp_int contient un pointeur à un objet deleté
(un « dangling pointer », en anglais). Étant donné que sp_int est une
variable locale, son destructeur serait appelé (une deuxième fois) quand
on qui sa portée. Ce qui n'est pas pour arranger des choses.
wrote in message
news:"Frederic Lachasse" wrote in message
news:<WJ_Ta.12672$..."monk31" wrote in message
news:j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de
l'exécution de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int
en pointeur vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le
"new int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur,
puis l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator
new(size_t)" puis le constructeur.
C'est vrai, mais tu as oublié l'essentiel dans ce cas-ci : après le
delete ci-dessus, l'objet sp_int contient un pointeur à un objet
deleté (un « dangling pointer », en anglais). Étant donné que sp_int
est une variable locale, son destructeur serait appelé (une deuxième
fois) quand on qui sa portée. Ce qui n'est pas pour arranger des
choses.
Et bien non: bruno fait en (2.3) "m_pT = 0" dans son destructeur, donc
quand le destructeur est appelé une deuxième fois, rien ne cassera.
Cependant, je suis d'accord qu'appeler 2 fois un destructeur sur un
objet n'est pas propre du tout.
<kanze@gabi-soft.fr> wrote in message
news:d6652001.0307250017.68acf735@posting.google.com...
"Frederic Lachasse" <frederic.lachasse@verizon.net> wrote in message
news:<WJ_Ta.12672$634.4486@nwrdny03.gnilink.net>...
"monk31" <bruno.rommens@laposte.net> wrote in message
news:3d509a44.0307240041.deb7651@posting.google.com...
j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de
l'exécution de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int
en pointeur vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le
"new int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur,
puis l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator
new(size_t)" puis le constructeur.
C'est vrai, mais tu as oublié l'essentiel dans ce cas-ci : après le
delete ci-dessus, l'objet sp_int contient un pointeur à un objet
deleté (un « dangling pointer », en anglais). Étant donné que sp_int
est une variable locale, son destructeur serait appelé (une deuxième
fois) quand on qui sa portée. Ce qui n'est pas pour arranger des
choses.
Et bien non: bruno fait en (2.3) "m_pT = 0" dans son destructeur, donc
quand le destructeur est appelé une deuxième fois, rien ne cassera.
Cependant, je suis d'accord qu'appeler 2 fois un destructeur sur un
objet n'est pas propre du tout.
wrote in message
news:"Frederic Lachasse" wrote in message
news:<WJ_Ta.12672$..."monk31" wrote in message
news:j'ai codé le smart pointer suivant :
template <typename T> class smartpointer{
protected:
T* m_pT;
public:
smartpointer (T* pT=0):m_pT(pT) {}
~smartpointer ()
{delete(m_pT);m_pT=0;}
T* operator -> () {return(m_pT);}
T& operator * ()
{return(*m_pT);}
operator smartpointer* () {return(this);}
static void operator delete (void* pointer) {}
};
et je voulais savoir ce qui se passe réellement lors de
l'exécution de ce bout de code :
smartpointer<int> sp_int(new int);
delete sp_int;
je sais qu'il y a appel à l'opérateur de cast smartpointer* et
ensuite appel à l'opérateur delete surchargé. mais y a t'il une
libération quelconque de mémoire ?
En fait, il y a:
(1) appel à "operator smartpointer*()" pour convertir sp_int
en pointeur vers sp_int;
(2) appel au destructeur, ce qui:
(2.1) détruit l'objet pointé par m_pT
T étant un int, le destructeur ne fait rien;
(2.2) appelle l' "operator delete(void*)" sur m_pT
m_pT étant un int*, "::operator delete(void*)" est
appelé, ce qui libère la mémoire alloué par le
"new int";
(2.3) annulle m_pT;
(3) appel à "operator delete(void*)" de smartpointer<int>
qui ne fait rien.
Ne pas oublier que l'operateur "delete" appelle le destructeur,
puis l' "operator delete(void*)".
De la même façon, l'operateur "new" appelle l' "operator
new(size_t)" puis le constructeur.
C'est vrai, mais tu as oublié l'essentiel dans ce cas-ci : après le
delete ci-dessus, l'objet sp_int contient un pointeur à un objet
deleté (un « dangling pointer », en anglais). Étant donné que sp_int
est une variable locale, son destructeur serait appelé (une deuxième
fois) quand on qui sa portée. Ce qui n'est pas pour arranger des
choses.
Et bien non: bruno fait en (2.3) "m_pT = 0" dans son destructeur, donc
quand le destructeur est appelé une deuxième fois, rien ne cassera.
Cependant, je suis d'accord qu'appeler 2 fois un destructeur sur un
objet n'est pas propre du tout.
