j'ai une petite question concernant la différence entre un objet alloué de
manière statique ou dynamique :
exemple:
class A {... };
A static_a; // (1)
A* dynamic_a = new A; // (2)
Une fois que je me retrouve avec un a ou a*, y a t'-il moyen de savoir si
cet objet a été crée comme (1) ou comme (2) ? Je pense a priori que non,
peut-être par surcharge de l'opérateur new mais ça ne me semble pas très
joli...qu'en pensez-vous ?
Merci pour vos réponses !
--
----------------------------------------------------------------------
Thomas Parle : tparle chez free.fr
j'ai une petite question concernant la différence entre un objet alloué de manière statique ou dynamique :
exemple:
class A {... };
A static_a; // (1) A* dynamic_a = new A; // (2)
Une fois que je me retrouve avec un a ou a*, y a t'-il moyen de savoir si cet objet a été crée comme (1) ou comme (2) ? Je pense a priori que non, peut-être par surcharge de l'opérateur new mais ça ne me semble pas très joli...qu'en pensez-vous ?
Alexandrescu (je viens de l'acheter et j'en suis très content!) propose d'implementer un Pointer Trait en utilisant la spécialisation et le pattern matching des templates :
template <typename T> class TypeTraits { /* Suivant le livre mais simplifié */ private: template <class U> struct PointerTraits { //appelée si type static enum { result = false }; }; template <class U> struct PointerTraits<U*> {// appelée si type dyn enum { result = true }; }; public: enum { isPointer = PointerTraits<T>::result }; };
Dans le livre, il garde le type et alloue + ou - un objet de type T.
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et typeof( dynamic_a ) == typeof( A* ) ) Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il s'agit d'un pointer (quel interêt d'ailleur ?)
ou enfin faire un test sur sizeof( static_a ) et sizeof( dyn_a ) qui ne marchera pas à tous les coups, mais qui est une façon simple et rapide... sizeof( dyn_a ) aura la taille d'un entier (?)
-------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Thomas Parle wrote:
Bonjour à tous,
j'ai une petite question concernant la différence entre un objet alloué de
manière statique ou dynamique :
exemple:
class A {... };
A static_a; // (1)
A* dynamic_a = new A; // (2)
Une fois que je me retrouve avec un a ou a*, y a t'-il moyen de savoir si
cet objet a été crée comme (1) ou comme (2) ? Je pense a priori que non,
peut-être par surcharge de l'opérateur new mais ça ne me semble pas très
joli...qu'en pensez-vous ?
Alexandrescu (je viens de l'acheter et j'en suis très content!) propose
d'implementer un Pointer Trait en utilisant la spécialisation et le
pattern matching des templates :
template <typename T>
class TypeTraits { /* Suivant le livre mais simplifié */
private:
template <class U> struct PointerTraits { //appelée si type static
enum { result = false };
};
template <class U> struct PointerTraits<U*> {// appelée si type dyn
enum { result = true };
};
public:
enum { isPointer = PointerTraits<T>::result };
};
Dans le livre, il garde le type et alloue + ou - un objet de type T.
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et
typeof( dynamic_a ) == typeof( A* ) )
Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il
s'agit d'un pointer (quel interêt d'ailleur ?)
ou enfin faire un test sur sizeof( static_a ) et sizeof( dyn_a ) qui ne
marchera pas à tous les coups, mais qui est une façon simple et
rapide... sizeof( dyn_a ) aura la taille d'un entier (?)
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
j'ai une petite question concernant la différence entre un objet alloué de manière statique ou dynamique :
exemple:
class A {... };
A static_a; // (1) A* dynamic_a = new A; // (2)
Une fois que je me retrouve avec un a ou a*, y a t'-il moyen de savoir si cet objet a été crée comme (1) ou comme (2) ? Je pense a priori que non, peut-être par surcharge de l'opérateur new mais ça ne me semble pas très joli...qu'en pensez-vous ?
Alexandrescu (je viens de l'acheter et j'en suis très content!) propose d'implementer un Pointer Trait en utilisant la spécialisation et le pattern matching des templates :
template <typename T> class TypeTraits { /* Suivant le livre mais simplifié */ private: template <class U> struct PointerTraits { //appelée si type static enum { result = false }; }; template <class U> struct PointerTraits<U*> {// appelée si type dyn enum { result = true }; }; public: enum { isPointer = PointerTraits<T>::result }; };
Dans le livre, il garde le type et alloue + ou - un objet de type T.
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et typeof( dynamic_a ) == typeof( A* ) ) Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il s'agit d'un pointer (quel interêt d'ailleur ?)
ou enfin faire un test sur sizeof( static_a ) et sizeof( dyn_a ) qui ne marchera pas à tous les coups, mais qui est une façon simple et rapide... sizeof( dyn_a ) aura la taille d'un entier (?)
-------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Thomas Parle
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et typeof( dynamic_a ) == typeof( A* ) ) Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il s'agit d'un pointer (quel interêt d'ailleur ?)
Merci de ta réponse, mais en fait je n'ai pas besoin de savoir si j'ai un objet de type T ou T* (ce qui n'aurait que peu d'intérêt comme tu le soulignes), je voudrais savoir, pour une instance d'un objet donné, si cette instance a été crée de manière statique (T object; ) ou de manière dynamique (T* pObject = new T; ) ?
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et
typeof( dynamic_a ) == typeof( A* ) )
Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il
s'agit d'un pointer (quel interêt d'ailleur ?)
Merci de ta réponse, mais en fait je n'ai pas besoin de savoir si j'ai un
objet de type T ou T* (ce qui n'aurait que peu d'intérêt comme tu le
soulignes), je voudrais savoir, pour une instance d'un objet donné, si cette
instance a été crée de manière statique (T object; ) ou de manière dynamique
(T* pObject = new T; ) ?
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et typeof( dynamic_a ) == typeof( A* ) ) Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il s'agit d'un pointer (quel interêt d'ailleur ?)
Merci de ta réponse, mais en fait je n'ai pas besoin de savoir si j'ai un objet de type T ou T* (ce qui n'aurait que peu d'intérêt comme tu le soulignes), je voudrais savoir, pour une instance d'un objet donné, si cette instance a été crée de manière statique (T object; ) ou de manière dynamique (T* pObject = new T; ) ?
Christophe Lephay
Thomas Parle wrote:
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et typeof( dynamic_a ) == typeof( A* ) ) Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il s'agit d'un pointer (quel interêt d'ailleur ?)
Merci de ta réponse, mais en fait je n'ai pas besoin de savoir si j'ai un objet de type T ou T* (ce qui n'aurait que peu d'intérêt comme tu le soulignes), je voudrais savoir, pour une instance d'un objet donné, si cette instance a été crée de manière statique (T object; ) ou de manière dynamique (T* pObject = new T; ) ?
Ce qui ne présente guère plus d'intéret, du reste...
Chris
Thomas Parle wrote:
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et
typeof( dynamic_a ) == typeof( A* ) )
Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il
s'agit d'un pointer (quel interêt d'ailleur ?)
Merci de ta réponse, mais en fait je n'ai pas besoin de savoir si
j'ai un objet de type T ou T* (ce qui n'aurait que peu d'intérêt
comme tu le soulignes), je voudrais savoir, pour une instance d'un
objet donné, si cette instance a été crée de manière statique (T
object; ) ou de manière dynamique (T* pObject = new T; ) ?
Ce qui ne présente guère plus d'intéret, du reste...
Tu peux aussi essayer (typeof( static_a ) == typeof( A )) et typeof( dynamic_a ) == typeof( A* ) ) Là tu sais si il s'agit d'un objet de type A* ou A, mais pas si il s'agit d'un pointer (quel interêt d'ailleur ?)
Merci de ta réponse, mais en fait je n'ai pas besoin de savoir si j'ai un objet de type T ou T* (ce qui n'aurait que peu d'intérêt comme tu le soulignes), je voudrais savoir, pour une instance d'un objet donné, si cette instance a été crée de manière statique (T object; ) ou de manière dynamique (T* pObject = new T; ) ?
Ce qui ne présente guère plus d'intéret, du reste...
Chris
Thomas Parle
"Christophe Lephay" a écrit dans le message de news: bp2lk3$6cv$
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
"Christophe Lephay" <christophe-lephay@wanadoo.fr> a écrit dans le message
de news: bp2lk3$6cv$1@news-reader1.wanadoo.fr...
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si
ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un
tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la
construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de
créer des instances statiques mais je voudrais éviter d'être trop
contraigant.
"Christophe Lephay" a écrit dans le message de news: bp2lk3$6cv$
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Marc Boyer
Thomas Parle wrote:
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Tu veux pas utiliser des pointeurs intelligents ? T'as des contraintes telles qu'aucun des pointeur intelligent codé à ce jour ne résoud ton problème ? Parce qu'il est assez facile, pour les objets d'une hiérarchie donnée, de ne permettre leur création dynamique qu'à travers un pointeur intelligent. Non ?
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
Thomas Parle wrote:
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si
ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un
tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la
construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de
créer des instances statiques mais je voudrais éviter d'être trop
contraigant.
Tu veux pas utiliser des pointeurs intelligents ? T'as
des contraintes telles qu'aucun des pointeur intelligent codé
à ce jour ne résoud ton problème ?
Parce qu'il est assez facile, pour les objets d'une
hiérarchie donnée, de ne permettre leur création dynamique
qu'à travers un pointeur intelligent. Non ?
Marc Boyer
--
Lying for having sex or lying for making war? Trust US presidents :-(
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Tu veux pas utiliser des pointeurs intelligents ? T'as des contraintes telles qu'aucun des pointeur intelligent codé à ce jour ne résoud ton problème ? Parce qu'il est assez facile, pour les objets d'une hiérarchie donnée, de ne permettre leur création dynamique qu'à travers un pointeur intelligent. Non ?
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
Thomas Parle
"Marc Boyer" a écrit dans le message de news: bp332l$9dt$
Thomas Parle wrote:
Tu veux pas utiliser des pointeurs intelligents ? T'as des contraintes telles qu'aucun des pointeur intelligent codé à ce jour ne résoud ton problème ? Parce qu'il est assez facile, pour les objets d'une hiérarchie donnée, de ne permettre leur création dynamique qu'à travers un pointeur intelligent. Non ?
Merci pour ta réponse, je suis d'accord avec toi pour l'utilisation de tels pointeurs je voulais juste savoir si il existait une autre technique pour connaitre le type d'allocation d'un objet, voilà !
"Marc Boyer" <Marc.Boyer@enseeiht.yahoo.fr.invalid> a écrit dans le message
de news: bp332l$9dt$1@news.cict.fr...
Thomas Parle wrote:
Tu veux pas utiliser des pointeurs intelligents ? T'as
des contraintes telles qu'aucun des pointeur intelligent codé
à ce jour ne résoud ton problème ?
Parce qu'il est assez facile, pour les objets d'une
hiérarchie donnée, de ne permettre leur création dynamique
qu'à travers un pointeur intelligent. Non ?
Merci pour ta réponse, je suis d'accord avec toi pour l'utilisation de tels
pointeurs je voulais juste savoir si il existait une autre technique pour
connaitre le type d'allocation d'un objet, voilà !
"Marc Boyer" a écrit dans le message de news: bp332l$9dt$
Thomas Parle wrote:
Tu veux pas utiliser des pointeurs intelligents ? T'as des contraintes telles qu'aucun des pointeur intelligent codé à ce jour ne résoud ton problème ? Parce qu'il est assez facile, pour les objets d'une hiérarchie donnée, de ne permettre leur création dynamique qu'à travers un pointeur intelligent. Non ?
Merci pour ta réponse, je suis d'accord avec toi pour l'utilisation de tels pointeurs je voulais juste savoir si il existait une autre technique pour connaitre le type d'allocation d'un objet, voilà !
Benoit Rousseau
Thomas Parle wrote:
"Christophe Lephay" a écrit dans le message de news: bp2lk3$6cv$
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Comment ferrais tu pour que le manager stocke au même endroit (même container) des A et des A* ? Si ton container utilise des pointeurs et que tu fais passer l'adresse en paramètre pour les objets statics, tu risques de pointer sur des objets dont la durée de vie est expirée, non ?
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Thomas Parle wrote:
"Christophe Lephay" <christophe-lephay@wanadoo.fr> a écrit dans le message
de news: bp2lk3$6cv$1@news-reader1.wanadoo.fr...
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si
ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un
tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la
construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de
créer des instances statiques mais je voudrais éviter d'être trop
contraigant.
Comment ferrais tu pour que le manager stocke au même endroit (même
container) des A et des A* ?
Si ton container utilise des pointeurs et que tu fais passer l'adresse
en paramètre pour les objets statics, tu risques de pointer sur des
objets dont la durée de vie est expirée, non ?
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
"Christophe Lephay" a écrit dans le message de news: bp2lk3$6cv$
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Comment ferrais tu pour que le manager stocke au même endroit (même container) des A et des A* ? Si ton container utilise des pointeurs et que tu fais passer l'adresse en paramètre pour les objets statics, tu risques de pointer sur des objets dont la durée de vie est expirée, non ?
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Christophe Lephay
Thomas Parle wrote:
"Christophe Lephay" a écrit dans le message de news: bp2lk3$6cv$
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Il me semble que tu dois spécifier d'une manière ou d'une autre à ton manager les objets qu'il doit gérer...
Chris
Thomas Parle wrote:
"Christophe Lephay" <christophe-lephay@wanadoo.fr> a écrit dans le
message de news: bp2lk3$6cv$1@news-reader1.wanadoo.fr...
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf
si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de
delete sur un tel objet. Je voudrais donc pouvoir faire la différence
entre les deux à la construction, d'où ma question. Je pourrais aussi
empêcher l'utilisateur de créer des instances statiques mais je
voudrais éviter d'être trop contraigant.
Il me semble que tu dois spécifier d'une manière ou d'une autre à ton
manager les objets qu'il doit gérer...
"Christophe Lephay" a écrit dans le message de news: bp2lk3$6cv$
Thomas Parle wrote:
Ce qui ne présente guère plus d'intéret, du reste...
Si, j'utilise un manager qui détruit des objets automatiquement, sauf si ceux-ci sont crées statiquement vu qu'on ne peut pas faire de delete sur un tel objet. Je voudrais donc pouvoir faire la différence entre les deux à la construction, d'où ma question. Je pourrais aussi empêcher l'utilisateur de créer des instances statiques mais je voudrais éviter d'être trop contraigant.
Il me semble que tu dois spécifier d'une manière ou d'une autre à ton manager les objets qu'il doit gérer...
Chris
Thomas Parle
"Benoit Rousseau" a écrit dans le message de news: 3fb5163a$0$14698$
Thomas Parle wrote:
"Christophe Lephay" a écrit dans le message
de news: bp2lk3$6cv$
Comment ferrais tu pour que le manager stocke au même endroit (même container) des A et des A* ? Si ton container utilise des pointeurs et que tu fais passer l'adresse en paramètre pour les objets statics, tu risques de pointer sur des objets dont la durée de vie est expirée, non ?
Oui, tout à fait. Sauf si l'objet en question a terminé sa tâche et que je veux le détruire avant (en fait pour te répondre chaque objet donne son pointeur sur this au manager en question dans son constructeur). Evidemment la solution à tout cela est bien sûr d'utiliser des pointeurs intelligents comme on me l'a fait remarqué, je voulais surtout savoir si je pouvais automatiquement prévenir un delete malencontreux sur un pointeur, pointant sur un objet dont je pourrais savoir si il a été alloué statiquement ou dynamiquement.
"Benoit Rousseau" <not.provided@no.spam> a écrit dans le message de news:
3fb5163a$0$14698$ba620e4c@reader1.news.skynet.be...
Thomas Parle wrote:
"Christophe Lephay" <christophe-lephay@wanadoo.fr> a écrit dans le
message
de news: bp2lk3$6cv$1@news-reader1.wanadoo.fr...
Comment ferrais tu pour que le manager stocke au même endroit (même
container) des A et des A* ?
Si ton container utilise des pointeurs et que tu fais passer l'adresse
en paramètre pour les objets statics, tu risques de pointer sur des
objets dont la durée de vie est expirée, non ?
Oui, tout à fait. Sauf si l'objet en question a terminé sa tâche et que je
veux le détruire avant (en fait pour te répondre chaque objet donne son
pointeur sur this au manager en question dans son constructeur). Evidemment
la solution à tout cela est bien sûr d'utiliser des pointeurs intelligents
comme on me l'a fait remarqué, je voulais surtout savoir si je pouvais
automatiquement prévenir un delete malencontreux sur un pointeur, pointant
sur un objet dont je pourrais savoir si il a été alloué statiquement ou
dynamiquement.
"Benoit Rousseau" a écrit dans le message de news: 3fb5163a$0$14698$
Thomas Parle wrote:
"Christophe Lephay" a écrit dans le message
de news: bp2lk3$6cv$
Comment ferrais tu pour que le manager stocke au même endroit (même container) des A et des A* ? Si ton container utilise des pointeurs et que tu fais passer l'adresse en paramètre pour les objets statics, tu risques de pointer sur des objets dont la durée de vie est expirée, non ?
Oui, tout à fait. Sauf si l'objet en question a terminé sa tâche et que je veux le détruire avant (en fait pour te répondre chaque objet donne son pointeur sur this au manager en question dans son constructeur). Evidemment la solution à tout cela est bien sûr d'utiliser des pointeurs intelligents comme on me l'a fait remarqué, je voulais surtout savoir si je pouvais automatiquement prévenir un delete malencontreux sur un pointeur, pointant sur un objet dont je pourrais savoir si il a été alloué statiquement ou dynamiquement.
Michel Michaud
Dans news:3fb4b023$0$27026$, Thomas
Une fois que je me retrouve avec un a ou a*, y a t'-il moyen de savoir si cet objet a été crée comme (1) ou comme (2) ? Je pense a
Scott Meyers en parle... La réponse courte : non.
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:3fb4b023$0$27026$626a54ce@news.free.fr, Thomas
Une fois que je me retrouve avec un a ou a*, y a t'-il moyen de
savoir si cet objet a été crée comme (1) ou comme (2) ? Je pense a
Scott Meyers en parle... La réponse courte : non.
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
