surcharger -> pour un vector de pointeur.

Bonjour,

Alors je continue mon petit chemin d'apprentissage en C++ et je suis encore confronté à un problème de vector vers des pointeurs...
J'aimerais pouvoir faire :

Code:

---

1 2	vector <*truc> test; test->affiche();

---

Mais pour cela il faut que je surcharge mon opérateur -> de sorte qu'il applique à chaque pointeur de mon vector test la méthode affiche() de la class Truc...

Comment faire ???
J'ai beau cherché, je ne trouve pas comment je peux faire pour surcharge -> vers une fonction...
après je pensais à un truc du genre :

Code:

---

1 2 3 4

template <typename S> void operator->(const vector<S> & hop, FONCTION fonc() ){ for(size_t i=0;i<(hop.size());++i) (hop[i])->fonc(); }

---

Mais voilà, que dois-je mettre pour fonction ??

Bonjour,

tout d'abord, ce n'est pas:

Code:

---

vector <*truc> test;

---

mais

Code:

---

vector <truc*> test;

---

Ensuite, tu te compliques trop la vie. vector est une classe de la bibliothèque standard, n'y touche pas.

De plus, le c++ permet une approche objet, il serait dommage de s'en passer. Cela signifie qu'en fait, pour faire simple, chaque objet doit se débrouiller tout seul. Un objet doit donc s'afficher lui-même (en lui fournissant ce dont il a besoin pour le faire). C'est la raison pour laquelle, concrètement, habituellement on fait quelque chose dans le style:

Code:

---

1 2 3 4 5 6 7 8 9

// un opérateur d'indirection de flux pour ton objet ostream & operator << ( ostream& ostr, const Truc & t ) { ostr << /* ce qu'il faut afficher ici */; return ostr; }   // et pour l'affichage (avec vt un vector<Truc>): copy( vt.begin(), vt.end(), ostream_iterator<Truc>(cout, " ")); // cette ligne utilise l'operator << implémenté ci-dessus

---

Le code ci-dessus fonctionne pour un vector<Truc>. Toi tu as un vector<Truc*>, il faudra donc adapter le code. Ça devrait donner quelque chose dans le style:

Code:

---

1 2 3 4 5 6 7 8 9

// l'opérateur d'indirection de flux ostream & operator << ( ostream& ostr, const Truc * t ) { ostr << /* ce qu'il faut afficher ici */; return ostr; }   // l'affichage sur la console (avec vt un vector<Truc*>): copy( vt.begin(), vt.end(), ostream_iterator<const Truc*>(cout, " "));

---

Non, ce n'est pas ça du tout mon problème, j'ai évidemment surchargé cout << de manière à ce que mon affichage fonctionne bien... Je l'ai même fait de manière polymorphique comme indiqué dans la FAQ :mrgreen:

J'ai pris la méthode affiche() en exemple, en réalité j'aimerais que l'ensemble de mon vector de pointeur puisse accéder à une méthode quelconque de la classe des pointeurs en surchargeant une fois pour toute un opérateur binaire ^^'

Mon problème c'est vraiment pour appeler une méthode qui se trouve dans tous les pointeurs de mon vector<Truc*> !!!

J'ai une méthode nommée bouger() dans ma class voiture:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class Voiture : public Vehicule { public: ... void afficher(); void bouger(double); ... protected: ... double[3] position; ... };

---

Ensuite j'ai dans ma class circuit un attribut qui se trouve être la liste des voitures présentes sur le circuit...

Code:

---

1 2 3 4 5 6 7 8 9

class Circuit{ ... public: void evolue(); ... protected: vector<Voiture*> listeVoiture; ... };

---

Maintenant j'ai un soucis avec ma fonction evolue() de mon circuit :
j'aimerais que pour chaque voiture contenue dans mon vector de pointeur vers des voitures, l'appel

Code:

---

listeVoiture[i]->bouger(dt);

---

se fasse... Mais voilà, tant qu'à faire je préférerais surcharger -> pour les vector de sorte qu'il fasse appel à chaque pointeur contenu à la fonction que je mettrais après, avec les arguments que je lui donnerais...

De sorte à pouvoir écrire :

Code:

---

1 2 3 4 5 6 7 8 9

void evolue(){ double dt(0.1); //mon pas de temps, j'ai implémenté un truc qui ressemble à la dérivée pour calculer mes vitesses et inversement un truc qui se trouve être l'intégrale pour mettre à jour mes positions en fonction d'une vitesse. listeVoiture->bouger(dt);   if(vainqueur()) {...} else evolue(); }

---

Et j'y tiens, j'aimerais surcharger un opérateur de sorte à rendre l'appel à une fonction pour l'ensemble des pointeurs d'un vector plus aisée :mouarf:

Je sais, je suis têtu, mais bon ^^' J'apprends ;)

Donc pas moyen de faire un truc du genre :

Code:

---

1 2 3 4 5

template <typename S> void operator->(const vector<S> & hop, FONCTION fonc(ARG) ){ for(size_t y=0;y<(hop.size());++y) (hop[y])->fonc(ARG); }

---

Ou alors via une macro peut-être??
Mais ça je connais pas du tout du tout, j'ai juste vu le mot en fouinant dans le forum :aie:

PS : les fautes du genre *Truc au lieu de Truc* ne sont pas relevantes, après tout j'écris les codes d'exemple à la volée sans les passer au compilateur ^^'
Donc faute de frappe :oops:

std::for_each svp :o

http://www.cplusplus.com/reference/algorithm/for_each/

Non, pas vraiment : j'ai déjà repéré le for_each, mais à moins que je ne les aie mal compris, lui et son fonctionnement, ce n'est pas ce que je cherche... ou bien ?
En effet, avec for_each, on arrive à appliquer une fonction avec comme argument les éléments contenus dans le vector... Mais on y arrive pas à appeler une méthode de l'objet contenu dans mon vector... !!! :cry:

Si vraiment :aie:

http://codepad.org/JxpSIb4v

Ah !!!
I get it !

Je vois, en effet ça passe, mais tu utilises un foncteur... :mrgreen:

Je ne connais pas bien les foncteurs, j'ai juste lu un chapitre là-dessus dans un bouquin et j'ai jamais trouvé l'utilité que ça pouvait avoir, mais là, je comprends mieux.
:mrgreen:

C'est génial comme technique ^^ :ccool:


Mais j'ai encore un soucis :
j'ai un template vector<typename V>
j'ai une classe voiture...
et une autre moto...
j'ai un operator ->*

Et maintenant j'aimerai que dans mon circuit, je puisse faire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class circuit { vector<Voiture*> listV; vector<Moto*> listM;   void remplir_list() { listV/M.push_back(...); ... }   void evolue { listV->*bouger(); listM->*bouger(); ... }

---

Donc je pensais à un truc du genre :

Code:

---

1 2 3 4

struct inter { void operator()(pointeur_type_quelconque const& c) { c.some_methods(); } };

---

Mais pour faire ce pointeur d'un type quelconque, il faut que je fasse un template du genre:

Code:

---

1 2	template<typename A> typedef A* pointe;

---

Donc ça donnerait :


et ensuite pour mon opérateur le mélange de tout ça :

Code:

---

1 2 3 4 5 6 7 8

template <typename N> void operator->*(const vector<N> & vec, UnaryFunction fonc){ struct inter { void operator()(N const& c) { c->fonc(); } };   for_each(vec.begin(), vec.end(),inter())}

---

En effet, j'aimerais donner simplement le nom de la méthode à mon opérateur et qu'il me fasse tout ça, mais là, je suis vraiment pas sur de moi...

Rahhh, alors j'ai découvert que je ne pouvais pas faire de surcharge externe de -> a priori...
Donc c'est pour ça que j'aimerai le faire avec ->* mais j'y arrive vraiment pas : comment dois-je prototyper ma surcharge ???
J'en suis à :

Code:

---

1 2 3 4 5 6 7 8

template <typename A> unary_function operator->*(const vector<A> & vehic, unary_function fonc()){   struct fait{ void operator()(A const& v) { v->fonc(); } }   for_each(vehic.begin(),vehic.end(),fait()); }

---

Et là, il me dit " 2 : expected constructor, destructor, or type conversion before ‘operator’"

Alors, comment faire pour faire ma surcharge ??

Tu ne peux pas du tout surcharger ->* (ni .* d'ailleurs)... Mais vraiment il n'y a aucun interet à utiliser un operateur ici (les opérateur s'utilisent 'as builtin does', or je n'ai jamais vu d'operateur pour boucler sur un tableau intégré).
Par contre tu peux faire ce que tu veux très simplement avec adapter, binder & co :

Code:

---

std::for_each(moto.begin(), moto.end(), std::mem_fun(&Moto::fonction_membre_a_appeler));

---

Moui, le problème c'est que j'ai beaucoup de collection hétérogène, avec des pointeurs donc et que j'ai beaucoup de méthodes à appeler dans mes classes ^^'

Typiquement, moto à 5 méthodes, j'ai au moins 3 vector<Moto*> et je dois faire à peu près une 12aine d'appel à des méthodes de moto pour l’entièreté de mes vector...
Et c'est juste dans une fonction...
Après j'en au d'autre, Voiture, F2000, Avion, Helico, Circuit, Virage, Bout_Droit, Chicane

Et à chaque fois j'ai des vector de pointeurs et à chaque fois je dois faire appel à une méthode précise pour chacun des membres de mon vector... :cry:
Typiquement dans ma fonction evolue(), tous mes vehicules doivent faire appel à leur methode bouger()... et ça me fait un tas de pointeurs qui doivent appeler la methode en question... :aie:

D'où mon envie de surcharger un opérateur, je m'en fiche lequel, pour ça faire !!
:mouarf:

PS: -> et ->* peuvent être surcharger : http://msdn.microsoft.com/en-us/libr...(v=vs.71).aspx
Par contre le "." ne peut pas l'être... mais "," oui...

revois ton design, il a l'air bancal

Moui, bin disons que c'est un programme qui tient actuellement en 63 fichiers (.h et .cc confondus) et que ça m’embêterait de revoir les quelques 38 fichiers qui sont concernés par mon soucis... ^^' :aie:

Donc ça m'arrangerait si on m'aidait à trouver une solution concrète et non simplement me dire de "revoir mon design" parce que ça fait beaucoup là... :cry:

Tiens, par exemple je pourrais faire un template pour une fonction binaire et laisser tomber ma surcharge... non ??

Salut,

Pourquoi ne pas, tout simplement, créer une classe "collection" personnelle, qui te permettrait d'encapsuler tes vecteurs de pointeurs :question:
Cela pourrait prendre une forme proche de

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

class MyMotoCollection { /* just for simplicity */ typedef std::vector<Moto*> vector; public: typedef vector::const_iterator const_iterator; /* ctors and dtors should be defined according to yours memory and   * copy managment rules   */ void computeEvolution() const { for( const_iterator it = tab_.begin(); it!= tab_.end(); ++it) { (*it)->foo(); // calls Moto::foo (*it)->bar(); /* ...*/ } } /* other stuffs */ void push_back(Moto *); void remove(Moto *); bool exists(Moto *) const; /* ... are them usefull ?*/ const_iterator begin() const{return tab_.begin();} const_iterator end() const{return tab_.end();} size_t size() const{return tab_.size();} private: vector tab_ };

---

Même si tu surchargeais -> (ce qui est effectivement possible) ça ne te permettrait pas de faire ce que tu souhaites. Si tu essaies d'imaginer comment programmer un tel truc, tu tomberais sur un problème : ce qu'il y a à droite de la flèche n'est pas un paramètre, c'est un identifiant qui n'a de sens qu'en tant que tel et qui ne peut donc pas être réutilisé. Ce que tu souhaites faire nécessite de la méta-programmation qui n'est possible en C++ qu'avec l'usage des macros et dans une moindre mesure avec des templates.

Si tu ne veux/peux pas revoir le design à ce point ci, c'est peut être qu'il est déjà trop tard et que tu dois te résigner à utiliser la solution la plus directe qui te tombe sous la main, quitte à utiliser beaucoup (trop) d'iterateurs pénibles ou de foncteurs lourdingues. Tant pis, la vie est ainsi faite.

Sinon, si tu acceptes des modifications de quelque envergure, une piste à visiter : si tu as plusieurs objets qui ont les mêmes méthodes, et sur qui tu fais les mêmes opérations (ce qui est le cas dans ton exemple) alors, ça signifie que ces objets doivent être des instances d'une même classe de base, et que sous réserve que les méthodes que tu appelles soient virtuelles, tu peux les stocker dans une seule et unique collection. Tu perdrais alors le fait que tu sais trouver rapidement tous les objets d'une même classe, bien que tu puisses conserver des collections redondantes pour ça, avec l'intégrité à maintenir. Mais tu pourras regrouper plus facilement les traitements similaires entre objets de la même classe, ce qui est l'une des principales choses qui a inspiré la programmation objet.

Citation:

---

Envoyé par Blustuff

Ce que tu souhaites faire nécessite de la méta-programmation qui n'est possible en C++ qu'avec l'usage des macros et dans une moindre mesure avec des templates.

---

C'est plutot template avant macros

Citation:

---

Envoyé par Blustuff

Si tu ne veux/peux pas revoir le design à ce point ci, c'est peut être qu'il est déjà trop tard et que tu dois te résigner à utiliser la solution la plus directe qui te tombe sous la main, quitte à utiliser beaucoup (trop) d'iterateurs pénibles ou de foncteurs lourdingues. Tant pis, la vie est ainsi faite.

Sinon, si tu acceptes des modifications de quelque envergure, une piste à visiter : si tu as plusieurs objets qui ont les mêmes méthodes, et sur qui tu fais les mêmes opérations (ce qui est le cas dans ton exemple) alors, ça signifie que ces objets doivent être des instances d'une même classe de base, et que sous réserve que les méthodes que tu appelles soient virtuelles, tu peux les stocker dans une seule et unique collection. Tu perdrais alors le fait que tu sais trouver rapidement tous les objets d'une même classe, bien que tu puisses conserver des collections redondantes pour ça, avec l'intégrité à maintenir. Mais tu pourras regrouper plus facilement les traitements similaires entre objets de la même classe, ce qui est l'une des principales choses qui a inspiré la programmation objet.

---

Ou bien definir un concept et beneficier des avantages du polymorphisme statique. L'objet c'est bien en abusé ca craint

Hello, alors finalement j'ai trouvé une solution qui fonctionne assez bien, tant que je n'ai pas recours à plus d'un argument dans mes méthodes :

j'ai fait un

Code:

---

1 2 3 4

template<typename A, typename B, typename C> void applique(const & A truc, B metho, C param){ for_each(truc.begin(),truc.end(),bind2nd(mem_fun(metho),param)); }

---

Et ensuite j'ai qu'a passé ma méthode en faisait attention à bien résoudre la porté de ma méthode et d'en donner l'adresse genre si j'ai :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class D { private : double puissance;   public : D(double p) : puissance(p){};   void explose(double freq){ for(int i(0); i< freq; ++i) cout << "boum : " << p << endl;}   void charge(){ ++puissance; };   vector<*D> chose ;

---

alors j'écris :

applique(chose, &D::explose, 2);

par exemple...
Mais j'ai un problème quand je veux pas mettre d'argument, si je prends pas de double par exemple dans ma fonction charge()... Je sais pas comment faire pour l'appeler sans prendre d'argument, si je fais juste un mem_fun() sans bind2nd ça fonctionne pas...

boost::bind pour un vrai binder qui marche

Citation:

---

Envoyé par Joel F

C'est plutot template avant macros

---

Non, les templates permettent moins à cause des restrictions syntaxiques. Il reste toujours des choses qui ne se font qu'avec des macros.

Citation:

---

Ou bien definir un concept et beneficier des avantages du polymorphisme statique. L'objet c'est bien en abusé ca craint

---

Hors sujet.

@Blustuff: Joel a pas dit que les macros ne servaient jamais, il a dit que quand on fait de la méta-prog, on pense d'abord aux templates, c'est eux qui permettent à la méta-prog C++ d'exister comme un "vrai" langage.

Citation:

---

Envoyé par Blustuff

Non, les templates permettent moins à cause des restrictions syntaxiques. Il reste toujours des choses qui ne se font qu'avec des macros.

---

Le forum C c'est le lien d'a coté

Citation:

---

Envoyé par Flob90

@Blustuff: Joel a pas dit que les macros ne servaient jamais, il a dit que quand on fait de la méta-prog, on pense d'abord aux templates, c'est eux qui permettent à la méta-prog C++ d'exister comme un "vrai" langage.

---

Il va falloir apprendre à lire. Sa réponse aurait été une contradiction si j'avais un jour prétendu qu'on pensait à faire des macros avant de faire templates. Or quand je parle de moindre mesure, ce n'est évidemment pas l'usage qui se fait dans une moindre mesure (rien ne le sous-entend dans ma phrase) mais la méta-programmation. La méta-programmation se fait effectivement dans une moindre mesure avec des templates parce que si on peut quasiment tout faire avec des macros, une partie des usages en méta-programmation ne peut pas se faire avec des templates. Encore une fois, ça ne sous-entend absolument pas qu'il faut utiliser des macros ou que l'usage courant est d'en utiliser.