polymorphisme c(++) compliqué

Bonjour,

j'ai un problème qui me bloque depuis 48 heures, j'ai décidé de finalement vous soumettre la question :

pour la figure suivante :

mes classes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

/* virtual */class WeightKernel { public: WeightKernel(); virtual ~WeightKernel() { } ; virtual void init(int)=0;   //virtual void initializeWeight(void) =0; };   class Convolutional : public WeightKernel { int _kernelNumero ; int _predecessorMapNumber; .....   public: Convolutional(); ~Convolutional(); void init(int); ....... };

---

déclaration dans le main :

Code:

---

WeightKernel* kernelTable ;

---

mon problème se situe au niveau de l'instanciation :

Code:

---

1 2 3 4 5

...... kernelTable = new Convolutional[6] ; // 6 par ex   for ( int i = 0 ; i < 6 ; i++ ) kernelTable[i].init(i);

---

le fait est que kernelTable[i] n'accède pas aux méthodes de la classe Convolutional mais uniquement celles de la classe abstraite de départ. (je veux bien car j'ai pas casté dynamiquement). En scrutant les rapport d'erreurs, le vftable n'occure que pour kerneltable[0]. Là se situe ma question comment se fait il que le vftable est appelé uniquement pour la première boucle autrement dit, la boucle marche pour l'unique première itération mais pas pour les autres. Pourquoi ?

dans l'attente de vos réponse, je vous en remercie d'avance ;) !

Bonjour,

J'ai repris ton code et j'ai modifié ta déclaration

Code:

---

WeightKernel* kernelTable ;

---

par ceci

Code:

---

Convolutional* kernelTable ;

---

Le code marche et la boucle s'exécute 6 fois.
Je ne peux pas expliquer tout de suite ce qui c'est passé, mais ça nous donne au moins un indice .

Bonjour,

le bug vient du fait que tu traites un tableau de façon polymorphique, ce qui est source de bugs en c++,

pour cette ligne :

Code:

---

kernelTable[i].init(i);

---

il s'agit de :

Code:

---

(((classe de base*) kernelTable ) + i *sizeof(classe de base)).Init(i)

---

or la taille de la classe dérivée n'est pas la même que celle de la classe de base

résultat : on rate le pointeur d'objet et celui des fonctions virtuelles à partir de l'itération 1

Salut,
Ca marcherai bien mieux avec un tableau de pointeurs sur ta classe, qu'avec un tableau d'instances de ta classe.
Lecture conseillée : là

wassihma>

Merci pour ton intervention mais là n'était pas vraiment la question (je veux jouer justement sur le polymorphisme)

kessoufi>
j'ai compris ton idée , je t'en remercie. Par contre tu voulais sans doute dire ((classe derivee *)kernelweight .... parce que j'ai bien instancié un objet Convolutional même si je l'ai déclaré en tant que classe de base weightkernell... autrement je ne comprends pas pourquoi la première itération même devrait marcher ?

non, kessoufi a raison:

Code:

---

(((classe de base*) kernelTable ) + i *sizeof(classe de base)).Init(i)

---

le premier va donc être

Code:

---

((classe de base*) kernelTable ).Init(i)

---

et a cet endroit on a un Convolutional donc ca marche

pour le deuxieme:

Code:

---

(((classe de base*) kernelTable ) + sizeof(classe de base)).Init(i)

---

or a cet endroit on a rien de valable. Pour avoir le prochain Convolutional il faudrait faire

Code:

---

(((classe de base*) kernelTable ) + sizeof(classe derivée)).Init(i)

---

on aurait un pointeur sur une classe de base qui est en fait une classe dérivée et ca marchera

super, merci screetch , c'est clair comme de l'eau de roche :ccool:

Sinon std::vector c'est bon. Il faut en manger, ca fait grandir :D

Davidbrcz>

habituellement je suis friand des éléments de la STL (vector et list surtout) mais on m'a demandé de virer tous mes
vector et de les remplacer directement par des tableaux pour de simples raisons de rapidité car je suis sur
un projet qui demande une certaine performance à l’exécution. D'autant plus les tailles sont connues à l'avance
donc j'ai pas spécialement besoin de structure de pile (empiler par push_back par exemple) ou bien de rajouter des itérateurs pour indexer un élément... je ramène pas du tout la STL mais succinctement je me dois de coder le plus légèrement possible ^^

Par contre je reviens un peu sur mon problème d'hier , à part utiliser l'expression assez longue à écrire :D de screetch et kessoufi :

Code:

---

(((classe de base*) kernelTable ) + sizeof(classe derivée)).Init(i)

---

Y aurait il un autre moyen de réaliser le polymorphisme interprété par les instructions :
(dans ce cas le dynamic_cast tient il lieu) ?

Code:

---

1 2 3 4

kernelTable = new Convolutional[6] ;   for ( int i = 0 ; i < 6 ; i++ ) kernelTable[i].init(i);

---

je ne sais pas qui a dit d'optimiser en retirant les vector mais ca me parait être du vent, a moins d'avoir soigneusement profilé avant.
vector en soit est rapide, et si tu connais la taille a l'avance, le plus simple est d'utiliser reserve().

et si on passe par une gestion manuelle, on a des problèmes (la preuve, sinon tu serais pas la)

il peut y avoir de bonnes raisons hein, mais ca me parait pas le cas.

je suis avec screetch sur le fait que la classe vecteur est plus appropriée ici,

d'un autre coté même en forçant le cast avec :

Code:

---

1 2	(((classe de base*) kernelTable ) + i*sizeof(classe derivée)).Init(i);

---

ca ne passera pas car on n'est pas sûr que le tableau contient les mêmes types de classe dérivée (si d'autres dérivations sont faites ultérieurement)

la raison est que pour traduite l'expression kernelTable[i] le compilateur ne connait que le type statique (WeightKernel) et pas le type dynamique (Convolutional)
qui ne peut être connu qu'en runtime.

une alternative est d'utiliser un tableau de pointeurs :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

WeightKernel** kernelTable[6]; for(int i = 0; i < 6; ++i) { kernelTable[6] = new Convolutional(); } .... for(int i = 0; i < 6; ++i) { kernelTable[i]->init(i); }

---

là il n'y a plus besoin de down_caster

Cdt

Citation:

---

Envoyé par screetch

je ne sais pas qui a dit d'optimiser en retirant les vector mais ca me parait être du vent, a moins d'avoir soigneusement profilé avant.
vector en soit est rapide, et si tu connais la taille a l'avance, le plus simple est d'utiliser reserve().

et si on passe par une gestion manuelle, on a des problèmes (la preuve, sinon tu serais pas la)

il peut y avoir de bonnes raisons hein, mais ca me parait pas le cas.

---

Globalement je plussois, la micro optimisation sans profling précis c'est s'emmerder à coup sûr sans garantie de résultat.

Mais si la taille est vraiment connue à la compilation, pourquoi utiliser new ? std::array si tu as un compilateur pas trop ancien qui dispose du tr1 ou plus simplement T* foo[N];

je vais devoir être plus explicite
en gros, je peux pas détaillé tout le projet non plus, mais j'ai une autre classe fille de weightkernel

Code:

---

1 2 3

class Produit: public WeightKernel { }

---

et la classe appelante :

Code:

---

1 2 3 4 5 6 7 8 9

class X { ..... bool conv_ou_produit; int nombreWeightKernel ; WeightKernel* kernelTable; ....   }

---

dans la construction de celle-ci
je dois creer

"nombreWeightKernel" de type soit Convolutional soit Produit
que je stocke dans kernelTable.

la structure est telle quelle, je ne peux pas la changer à priori donc c'est pour cela que je n'ai que peu de marge de manoeuvre ...
Vous pourriez me proposer ce constructeur ?

Citation:

---

je dois creer "nombreWeightKernel" de type soit Convolutional soit Produit que je stocke dans kernelTable.

---

Donc le nombre n'est pas connu à la compilation ?
Car sinon, je persiste dans la direction de mon message précédant.

Citation:

---

la structure est telle quelle, je ne peux pas la changer à priori donc c'est pour cela que je n'ai que peu de marche de manoeuvre ...

---

C'est con, car avec un peu plus de contexte, y'a potentiellement moyen de beaucoup simplifier le code.

Davidbrcz>

je me suis mal exprimé, autant pour moi, c'est vrai c'est pas connu à l'avance, je vais instancier plusieurs classes avec diverses tailles ... Du coup, à part la STL, comment ?
Vous pourriez me proposer ce constructeur ? :?

sinon qu'est ce qui est recommandé comme changement dans la classe X pour simplifier le cast sinon ?

L'énoncé change en cours de route, si la taille est dynamique, ce n'est plus pareil

Si je ne m'abuse, ce n'est ni plus ni moins une Pattern Factory (peut-être même une petite registry avec indice numérique)

Code:

---

WeightKernel* kernelTable

---

c'est en général un objet alloué dynamiquement mais si l'on utilise comme tableau ça devient une série d'objet statique (ce qui est dynamique ce n'est plus l'objet mais la taille du tableau car l'arithmétique [] utilise le pointeur et renvoie une référence)

Pour que la taille et les objets soit dynamique
il faut utiliser cette syntaxe de déclaration et ce n'est pas une "alternative" d'utiliser un tableau de pointeurs mais c'est la seule solution lors de Collection polymorphique !

Code:

---

WeightKernel** kernelTable;

---

Ensuite le code de kessoufi avec les boucles est tout à fait valable !
Si l'on pense au à la boucle de delete

Tu vas devoir dans Class X gérer manuellement la taille du tableau, son allocation et sa libération, ainsi que des objets contenus !

Tu pourrais imaginer une classe intermédiaire WeightKernelCollection
qui fonctionne comme un vector mais à sa destruction, elle détruit implicitement les pointeurs objets qu'on lui a ajoutés !

petit rappel
vector<obj> - détruit les obj (qui sont des copies des originaux, si ces derniers sont statiques, il sont libérés à la sortie de bloc, les copies persistent aux originaux si le vecteur a été déclaré avec une portée plus importante, membre d'un objet par exemple)
vector<*obj> - ne touche pas aux objets

Et encore, tu vas allouer tous les objets de la même classe, on pourrait imaginer que demain, tu puisses allouer 4 Produit et 2 Convolutional dans le même tableau, en théorie, cela doit fonctionner avec le polymorphisme !

Citation:

---

pour de simples raisons de rapidité car je suis sur
un projet qui demande une certaine performance à l’exécution

---

J'ignore quel est ton projet, mais ce n'est pas une petite indirection objet de la STL qui va changer grand chose !
Tu risques juste de produit un code moins maintenable !
Surtout qu'un Vector, il faut rappeler que c'est un template qui utilise un tableau, on va juste économiser des CALL :roll: et encore !

Salut,
Je plussoies mes camarades sur du std::vector et std::array.
Sinon, DP Stratégie :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

#include <boost/scoped_ptr.hpp>   struct WeightKernelStategie { virtual ~WeightKernelStategie()=0; inline void action()const { do_action(); } private: virtual void do_action()const=0; }; WeightKernelStategie::~WeightKernelStategie() {}   struct WeightKernel { WeightKernel(WeightKernelStategie *p=0):p_strategie(p) {}   void resetStrategie(WeightKernelStategie *p=0) { p_strategie.reset(p); }   inline void action()const { p_strategie->action(); }   private:   boost::scoped_ptr<WeightKernelStategie> p_strategie;   WeightKernel(WeightKernel const&); // =delete WeightKernel& operator=(WeightKernel const&); // =delete };   #include <iostream> struct Convolutional : public WeightKernelStategie { virtual ~Convolutional(){} private: virtual void do_action()const {   std::cout<<"Convolutional\n"; } }; struct Produit : public WeightKernelStategie { virtual ~Produit(){} private: virtual void do_action()const {   std::cout<<"Produit\n"; } };   #include <functional> #include <algorithm>   struct X { X(int nombreWeightKernel_) :nombreWeightKernel(nombreWeightKernel_) ,kernelTable(new WeightKernel[nombreWeightKernel_]) { for(int i=0;i<nombreWeightKernel;++i) {   if(0==(i%2)) { kernelTable[i].resetStrategie(new Convolutional); } else { kernelTable[i].resetStrategie(new Produit); } } }   void action()const { std::for_each( kernelTable ,kernelTable + nombreWeightKernel ,std::mem_fun_ref(&WeightKernel::action) ); } ~X() { delete []kernelTable; } private: X(X const&); X&operator=(X const&); private: const int nombreWeightKernel ; WeightKernel* kernelTable; };   int main() { X x(10); x.action(); return 0;   }

---

Il doit y avoir des boulettes mais l'idée est là je pense.

alors la blague de benner vector pour des histoires de perfs alors qu'on stocke des types bourrés de virtual, c'est assez lolesk.

Remplacer les conteneurs de la STD n'aide que rarement sur des archi exotiques. Et en general, ca passe par resevre() et modifier l'allocator si c'est vraiment la que le bas blesse.

BRef, encore des FUDs de gens incompetents ^^

Citation:

---

Envoyé par Joel F

alors la blague de benner vector pour des histoires de perfs alors qu'on stocke des types bourrés de virtual, c'est assez lolesk

---

Il me semble que ce c'est ce qui est dit depuis l'intervention de david: ne pas utiliser les conteneurs (vecteur ou array) sous prétexte d'optimisation est probablement une bêtise ;)

ShaileTroll>

Bien entendu, il m'a fallu changer WeightKernel*en WeightKernel** kernelTable en attendant votre réponse car j'ai pas pu faire autrement en effet... Merci.

Sinon par rapport à tous les autres posts, je vous dis bien que le choix ou non de la vitesse d'execution par rapport à l'incorporation ou non de conteneur n'est pas une certitude pour ma part, par contre c'est bien un des avantages qu'offre C++ , c'est de pouvoir manipuler sur un concept de C procédural bien qu'en étant en C++, ça ne peut pas être plus lent .... :ccool: