Bonjour,
j'ai une classe de base BaseClass et N classe dérivées DerClass1,
DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
en n'importe quel autre DerClass_j à l'éxécution du programme. Une
solution pourrait être d'implémenter tous les cast possible mais du
coup, à chaque fois que je rajoute une DerClass, ça me fait beaucoup
de boulot en plus car je dois écrire tous les cast possibles. Sinon,
je peux isoler la partie qui change d'une DerClass à l'autre et en
faire une classe SubClass pour chaque DerClass. Ensuite, chaque
DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
changer le type de DerClass, je détruit le pointeur de SubClass et
j'en recréé un qui à le bon type.
Quelles sont vos suggestions compte-tenu de votre (longue)
expérience ?
Bonjour,
j'ai une classe de base BaseClass et N classe dérivées DerClass1,
DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
en n'importe quel autre DerClass_j à l'éxécution du programme. Une
solution pourrait être d'implémenter tous les cast possible mais du
coup, à chaque fois que je rajoute une DerClass, ça me fait beaucoup
de boulot en plus car je dois écrire tous les cast possibles. Sinon,
je peux isoler la partie qui change d'une DerClass à l'autre et en
faire une classe SubClass pour chaque DerClass. Ensuite, chaque
DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
changer le type de DerClass, je détruit le pointeur de SubClass et
j'en recréé un qui à le bon type.
Quelles sont vos suggestions compte-tenu de votre (longue)
expérience ?
Bonjour,
j'ai une classe de base BaseClass et N classe dérivées DerClass1,
DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
en n'importe quel autre DerClass_j à l'éxécution du programme. Une
solution pourrait être d'implémenter tous les cast possible mais du
coup, à chaque fois que je rajoute une DerClass, ça me fait beaucoup
de boulot en plus car je dois écrire tous les cast possibles. Sinon,
je peux isoler la partie qui change d'une DerClass à l'autre et en
faire une classe SubClass pour chaque DerClass. Ensuite, chaque
DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
changer le type de DerClass, je détruit le pointeur de SubClass et
j'en recréé un qui à le bon type.
Quelles sont vos suggestions compte-tenu de votre (longue)
expérience ?
j'ai une classe de base BaseClass et N classe dérivées DerClass1,
DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
en n'importe quel autre DerClass_j à l'éxécution du programme.
Une
solution pourrait être d'implémenter tous les cast possible mais du
coup, à chaque fois que je rajoute une DerClass, ça me fait beaucoup
de boulot en plus car je dois écrire tous les cast possibles. Sinon,
je peux isoler la partie qui change d'une DerClass à l'autre et en
faire une classe SubClass pour chaque DerClass.
Ensuite, chaque
DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
changer le type de DerClass, je détruit le pointeur de SubClass et
j'en recréé un qui à le bon type.
Quelles sont vos suggestions compte-tenu de votre (longue)
expérience ?
j'ai une classe de base BaseClass et N classe dérivées DerClass1,
DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
en n'importe quel autre DerClass_j à l'éxécution du programme.
Une
solution pourrait être d'implémenter tous les cast possible mais du
coup, à chaque fois que je rajoute une DerClass, ça me fait beaucoup
de boulot en plus car je dois écrire tous les cast possibles. Sinon,
je peux isoler la partie qui change d'une DerClass à l'autre et en
faire une classe SubClass pour chaque DerClass.
Ensuite, chaque
DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
changer le type de DerClass, je détruit le pointeur de SubClass et
j'en recréé un qui à le bon type.
Quelles sont vos suggestions compte-tenu de votre (longue)
expérience ?
j'ai une classe de base BaseClass et N classe dérivées DerClass1,
DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
en n'importe quel autre DerClass_j à l'éxécution du programme.
Une
solution pourrait être d'implémenter tous les cast possible mais du
coup, à chaque fois que je rajoute une DerClass, ça me fait beaucoup
de boulot en plus car je dois écrire tous les cast possibles. Sinon,
je peux isoler la partie qui change d'une DerClass à l'autre et en
faire une classe SubClass pour chaque DerClass.
Ensuite, chaque
DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
changer le type de DerClass, je détruit le pointeur de SubClass et
j'en recréé un qui à le bon type.
Quelles sont vos suggestions compte-tenu de votre (longue)
expérience ?
Implémente le "state design pattern" aka "strategy design pattern" aka
"policy design pattern". En deux mots, ne change pas la classe de
l'objet en question, mais change un objet avec lequel il est en
relation, et surlequel il se base pour adapter son comportement.
[Bien sur, l'alternative supersimple, c'est d'utiliser CLOS où les
objets peuvent changer de classe comme on veut avec:
(change-class instance 'nouvelle-class)
mais c'est HS ici... Enfin pas tant que ça. Des MOP ont été
implémentés pour C++, par exemple:
http://www.csg.is.titech.ac.jp/~chiba/openc++.html
donc il devrait être possible d'implémenter un système objet o ù
changeClass est possible. (Notez que le MOP OpenC++ contient une
méthode changeBaseClasses pour les meta classes).]
Implémente le "state design pattern" aka "strategy design pattern" aka
"policy design pattern". En deux mots, ne change pas la classe de
l'objet en question, mais change un objet avec lequel il est en
relation, et surlequel il se base pour adapter son comportement.
[Bien sur, l'alternative supersimple, c'est d'utiliser CLOS où les
objets peuvent changer de classe comme on veut avec:
(change-class instance 'nouvelle-class)
mais c'est HS ici... Enfin pas tant que ça. Des MOP ont été
implémentés pour C++, par exemple:
http://www.csg.is.titech.ac.jp/~chiba/openc++.html
donc il devrait être possible d'implémenter un système objet o ù
changeClass est possible. (Notez que le MOP OpenC++ contient une
méthode changeBaseClasses pour les meta classes).]
Implémente le "state design pattern" aka "strategy design pattern" aka
"policy design pattern". En deux mots, ne change pas la classe de
l'objet en question, mais change un objet avec lequel il est en
relation, et surlequel il se base pour adapter son comportement.
[Bien sur, l'alternative supersimple, c'est d'utiliser CLOS où les
objets peuvent changer de classe comme on veut avec:
(change-class instance 'nouvelle-class)
mais c'est HS ici... Enfin pas tant que ça. Des MOP ont été
implémentés pour C++, par exemple:
http://www.csg.is.titech.ac.jp/~chiba/openc++.html
donc il devrait être possible d'implémenter un système objet o ù
changeClass est possible. (Notez que le MOP OpenC++ contient une
méthode changeBaseClasses pour les meta classes).]
Tu veux changer le type d'une instance ou remplacer un élément de ton
tableau ?
Si tu peux faire ça, est ce que tu ne peux pas avoir une classe
intermédiaire DerClass qui met en commun les éléments qui ne change nt
pas entre DerClass_x.
> Ensuite, chaque
> DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
> changer le type de DerClass, je détruit le pointeur de SubClass et
> j'en recréé un qui à le bon type.
Le détruire, ça veut dire que tu n'en a pas besoin pour initialiser l a
nouvelle instance ?
Tu veux changer le type d'une instance ou remplacer un élément de ton
tableau ?
Si tu peux faire ça, est ce que tu ne peux pas avoir une classe
intermédiaire DerClass qui met en commun les éléments qui ne change nt
pas entre DerClass_x.
> Ensuite, chaque
> DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
> changer le type de DerClass, je détruit le pointeur de SubClass et
> j'en recréé un qui à le bon type.
Le détruire, ça veut dire que tu n'en a pas besoin pour initialiser l a
nouvelle instance ?
Tu veux changer le type d'une instance ou remplacer un élément de ton
tableau ?
Si tu peux faire ça, est ce que tu ne peux pas avoir une classe
intermédiaire DerClass qui met en commun les éléments qui ne change nt
pas entre DerClass_x.
> Ensuite, chaque
> DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
> changer le type de DerClass, je détruit le pointeur de SubClass et
> j'en recréé un qui à le bon type.
Le détruire, ça veut dire que tu n'en a pas besoin pour initialiser l a
nouvelle instance ?
Korchkidu writes:
> Bonjour,
> j'ai une classe de base BaseClass et N classe dérivées DerClass1,
> DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
> et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
> en n'importe quel autre DerClass_j à l'éxécution du programme. Un e
> solution pourrait être d'implémenter tous les cast possible mais du
> coup, à chaque fois que je rajoute une DerClass, ça me fait beaucou p
> de boulot en plus car je dois écrire tous les cast possibles. Sinon,
> je peux isoler la partie qui change d'une DerClass à l'autre et en
> faire une classe SubClass pour chaque DerClass. Ensuite, chaque
> DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
> changer le type de DerClass, je détruit le pointeur de SubClass et
> j'en recréé un qui à le bon type.
> Quelles sont vos suggestions compte-tenu de votre (longue)
> expérience ?
Implémente le "state design pattern" aka "strategy design pattern" aka
"policy design pattern".
En deux mots, ne change pas la classe de
l'objet en question, mais change un objet avec lequel il est en
relation, et surlequel il se base pour adapter son comportement.
Korchkidu <korchk...@gmail.com> writes:
> Bonjour,
> j'ai une classe de base BaseClass et N classe dérivées DerClass1,
> DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
> et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
> en n'importe quel autre DerClass_j à l'éxécution du programme. Un e
> solution pourrait être d'implémenter tous les cast possible mais du
> coup, à chaque fois que je rajoute une DerClass, ça me fait beaucou p
> de boulot en plus car je dois écrire tous les cast possibles. Sinon,
> je peux isoler la partie qui change d'une DerClass à l'autre et en
> faire une classe SubClass pour chaque DerClass. Ensuite, chaque
> DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
> changer le type de DerClass, je détruit le pointeur de SubClass et
> j'en recréé un qui à le bon type.
> Quelles sont vos suggestions compte-tenu de votre (longue)
> expérience ?
Implémente le "state design pattern" aka "strategy design pattern" aka
"policy design pattern".
En deux mots, ne change pas la classe de
l'objet en question, mais change un objet avec lequel il est en
relation, et surlequel il se base pour adapter son comportement.
Korchkidu writes:
> Bonjour,
> j'ai une classe de base BaseClass et N classe dérivées DerClass1,
> DerClass2, etc. Mon programme travaille sur un std::vector<BaseClass*>
> et j'ai besoin de pouvoir facilement changer n'importe quel DerClass_i
> en n'importe quel autre DerClass_j à l'éxécution du programme. Un e
> solution pourrait être d'implémenter tous les cast possible mais du
> coup, à chaque fois que je rajoute une DerClass, ça me fait beaucou p
> de boulot en plus car je dois écrire tous les cast possibles. Sinon,
> je peux isoler la partie qui change d'une DerClass à l'autre et en
> faire une classe SubClass pour chaque DerClass. Ensuite, chaque
> DerCLass contiendra un pointeur sur le bon SubClass et lorsque je dois
> changer le type de DerClass, je détruit le pointeur de SubClass et
> j'en recréé un qui à le bon type.
> Quelles sont vos suggestions compte-tenu de votre (longue)
> expérience ?
Implémente le "state design pattern" aka "strategy design pattern" aka
"policy design pattern".
En deux mots, ne change pas la classe de
l'objet en question, mais change un objet avec lequel il est en
relation, et surlequel il se base pour adapter son comportement.
On Jul 23, 2:19 pm, Michael Doubez wrote:> Tu veux changer le type d'une instance ou remplacer un élément de ton
> tableau ?
Non, il faut changer le type de l'instance.
> Si tu peux faire ça, est ce que tu ne peux pas avoir une classe
> intermédiaire DerClass qui met en commun les éléments qui ne chan gent
> pas entre DerClass_x.
Oui, c'est la solution que je proposais mais je n'ai pas été très
clair, je l'avoue^^
> > Ensuite, chaque
> > DerCLass contiendra un pointeur sur le bon SubClass et lorsque je doi s
> > changer le type de DerClass, je détruit le pointeur de SubClass et
> > j'en recréé un qui à le bon type.
> Le détruire, ça veut dire que tu n'en a pas besoin pour initialiser la
> nouvelle instance ?
Oups, tu as raison. Il faut inverse les étapes car oui, j'ai besoin de
l'ancienne instance pour initialiser la nouvelle.
On Jul 23, 2:19 pm, Michael Doubez <michael.dou...@free.fr> wrote:> Tu veux changer le type d'une instance ou remplacer un élément de ton
> tableau ?
Non, il faut changer le type de l'instance.
> Si tu peux faire ça, est ce que tu ne peux pas avoir une classe
> intermédiaire DerClass qui met en commun les éléments qui ne chan gent
> pas entre DerClass_x.
Oui, c'est la solution que je proposais mais je n'ai pas été très
clair, je l'avoue^^
> > Ensuite, chaque
> > DerCLass contiendra un pointeur sur le bon SubClass et lorsque je doi s
> > changer le type de DerClass, je détruit le pointeur de SubClass et
> > j'en recréé un qui à le bon type.
> Le détruire, ça veut dire que tu n'en a pas besoin pour initialiser la
> nouvelle instance ?
Oups, tu as raison. Il faut inverse les étapes car oui, j'ai besoin de
l'ancienne instance pour initialiser la nouvelle.
On Jul 23, 2:19 pm, Michael Doubez wrote:> Tu veux changer le type d'une instance ou remplacer un élément de ton
> tableau ?
Non, il faut changer le type de l'instance.
> Si tu peux faire ça, est ce que tu ne peux pas avoir une classe
> intermédiaire DerClass qui met en commun les éléments qui ne chan gent
> pas entre DerClass_x.
Oui, c'est la solution que je proposais mais je n'ai pas été très
clair, je l'avoue^^
> > Ensuite, chaque
> > DerCLass contiendra un pointeur sur le bon SubClass et lorsque je doi s
> > changer le type de DerClass, je détruit le pointeur de SubClass et
> > j'en recréé un qui à le bon type.
> Le détruire, ça veut dire que tu n'en a pas besoin pour initialiser la
> nouvelle instance ?
Oups, tu as raison. Il faut inverse les étapes car oui, j'ai besoin de
l'ancienne instance pour initialiser la nouvelle.
Tu veux dire que l'état interne SubClass de l'instance sert à
initialiser le nouveau SubClass ?
Dans ce cas, ne seras tu pas obligé de coder les fonctions de
transtypage ?
Tu veux dire que l'état interne SubClass de l'instance sert à
initialiser le nouveau SubClass ?
Dans ce cas, ne seras tu pas obligé de coder les fonctions de
transtypage ?
Tu veux dire que l'état interne SubClass de l'instance sert à
initialiser le nouveau SubClass ?
Dans ce cas, ne seras tu pas obligé de coder les fonctions de
transtypage ?
On Jul 23, 2:43 pm, Michael Doubez wrote:
> Tu veux dire que l'état interne SubClass de l'instance sert à
> initialiser le nouveau SubClass ?
> Dans ce cas, ne seras tu pas obligé de coder les fonctions de
> transtypage ?
Je ne pense pas. Il suffit. au changement d'état, de faire moi même l a
conversion et d'appeler le constructeur du nouvelle état avec les bon
arguments. Ça devrait marcher comme ça je pense non ?
On Jul 23, 2:43 pm, Michael Doubez <michael.dou...@free.fr> wrote:
> Tu veux dire que l'état interne SubClass de l'instance sert à
> initialiser le nouveau SubClass ?
> Dans ce cas, ne seras tu pas obligé de coder les fonctions de
> transtypage ?
Je ne pense pas. Il suffit. au changement d'état, de faire moi même l a
conversion et d'appeler le constructeur du nouvelle état avec les bon
arguments. Ça devrait marcher comme ça je pense non ?
On Jul 23, 2:43 pm, Michael Doubez wrote:
> Tu veux dire que l'état interne SubClass de l'instance sert à
> initialiser le nouveau SubClass ?
> Dans ce cas, ne seras tu pas obligé de coder les fonctions de
> transtypage ?
Je ne pense pas. Il suffit. au changement d'état, de faire moi même l a
conversion et d'appeler le constructeur du nouvelle état avec les bon
arguments. Ça devrait marcher comme ça je pense non ?
On 23 juil, 14:50, Korchkidu wrote:
> On Jul 23, 2:43 pm, Michael Doubez wrote:
> > Tu veux dire que l'état interne SubClass de l'instance sert à
> > initialiser le nouveau SubClass ?
> > Dans ce cas, ne seras tu pas obligé de coder les fonctions de
> > transtypage ?
> Je ne pense pas. Il suffit. au changement d'état, de faire moi même la
> conversion et d'appeler le constructeur du nouvelle état avec les bon
> arguments. Ça devrait marcher comme ça je pense non ?
C'est toi qui sais.
Mais tu vas avoir quelquechose du genre:
struct SubClass
{
virtual ~SubClass();
virtual void foo()=0;
}:
struct DerClass
{
void foo(){ state->foo(); }
std::auto_ptr<SubClass> state;
};
DerClass instance;
instance.state.reset(new SubClass_1(42));
instance.foo();
Si tu veux construire un SubClass_2 à partir de SubClass_1, il faut
bien que tu aies une fonction de conversion / de dispatch:
instance.state.reset(new SubClass_2( ??? ) );
On 23 juil, 14:50, Korchkidu <korchk...@gmail.com> wrote:
> On Jul 23, 2:43 pm, Michael Doubez <michael.dou...@free.fr> wrote:
> > Tu veux dire que l'état interne SubClass de l'instance sert à
> > initialiser le nouveau SubClass ?
> > Dans ce cas, ne seras tu pas obligé de coder les fonctions de
> > transtypage ?
> Je ne pense pas. Il suffit. au changement d'état, de faire moi même la
> conversion et d'appeler le constructeur du nouvelle état avec les bon
> arguments. Ça devrait marcher comme ça je pense non ?
C'est toi qui sais.
Mais tu vas avoir quelquechose du genre:
struct SubClass
{
virtual ~SubClass();
virtual void foo()=0;
}:
struct DerClass
{
void foo(){ state->foo(); }
std::auto_ptr<SubClass> state;
};
DerClass instance;
instance.state.reset(new SubClass_1(42));
instance.foo();
Si tu veux construire un SubClass_2 à partir de SubClass_1, il faut
bien que tu aies une fonction de conversion / de dispatch:
instance.state.reset(new SubClass_2( ??? ) );
On 23 juil, 14:50, Korchkidu wrote:
> On Jul 23, 2:43 pm, Michael Doubez wrote:
> > Tu veux dire que l'état interne SubClass de l'instance sert à
> > initialiser le nouveau SubClass ?
> > Dans ce cas, ne seras tu pas obligé de coder les fonctions de
> > transtypage ?
> Je ne pense pas. Il suffit. au changement d'état, de faire moi même la
> conversion et d'appeler le constructeur du nouvelle état avec les bon
> arguments. Ça devrait marcher comme ça je pense non ?
C'est toi qui sais.
Mais tu vas avoir quelquechose du genre:
struct SubClass
{
virtual ~SubClass();
virtual void foo()=0;
}:
struct DerClass
{
void foo(){ state->foo(); }
std::auto_ptr<SubClass> state;
};
DerClass instance;
instance.state.reset(new SubClass_1(42));
instance.foo();
Si tu veux construire un SubClass_2 à partir de SubClass_1, il faut
bien que tu aies une fonction de conversion / de dispatch:
instance.state.reset(new SubClass_2( ??? ) );
> Si tu veux construire un SubClass_2 à partir de SubClass_1, il faut
bien que tu aies une fonction de conversion / de dispatch:
instance.state.reset(new SubClass_2( ??? ) );
> Si tu veux construire un SubClass_2 à partir de SubClass_1, il faut
bien que tu aies une fonction de conversion / de dispatch:
instance.state.reset(new SubClass_2( ??? ) );
> Si tu veux construire un SubClass_2 à partir de SubClass_1, il faut
bien que tu aies une fonction de conversion / de dispatch:
instance.state.reset(new SubClass_2( ??? ) );