Pointeur sur méthode + héritage

Bonjour,

j'ai une classe mère d'interface comme suit (je ne garde que la partie qui nous intéresse) :

Code:

---

1 2 3 4 5 6 7 8 9

namespace ZenZiAPI { class IModule { public: typedef bool (IModule::*p_callback)(ITools&); } }

---

et une classe fille avec 2 méthode comme suit (les méthode sont simplifiées):

Code:

---

1 2 3 4 5 6 7 8 9 10

bool ModulePHP::GetPHP(Tools &_EOTools) { return (true); }   const std::vector<std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition>>& ModulePHP::getCallbacks() { this->_LPHook.first = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP); }

---

L'erreur se situe sur la ligne suivante :

Code:

---

1 2	static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP);

---

Erreur Compilo :

Error 4 error C2440: 'static_cast' : cannot convert from 'bool (__thiscall ModulePHP::* )(Tools &)' to 'ZenZiAPI::IModule::p_callback'

J'ai passer la journée dessus je vois pas comment résoudre ce problème

Est ce que quelqu'un saurait pourquoi ?

merci

Bonjour
Pourrais tu expliqué exactement ce que tu veux faire ?
Je pense qu en utilisant simplement le polymorphisme on peut resoudre ton probleme.

Pour la petite histoire c'est un serveur web.

Je dois faire plusieurs modules héritant obligatoirement de cette interface :

Code:

---

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

namespace ZenZiAPI { class IModule { public: typedef bool (IModule::*p_callback)(ITools&); /**< callbacks typedef */ virtual ~IModule() {}; virtual const std::vector<std::pair<p_callback, hookPosition> >& getCallbacks() = 0; virtual bool onLoad(void) = 0; virtual void onUnLoad(void) = 0; }; } #endif //_IMODULE_H_

---

Ces modules seront des DLL présentées comme cela (voici un exemple de module PHP) :

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

#include "ModulePHP.h"   ModulePHP::ModulePHP() {}   ModulePHP::~ModulePHP() {}   bool ModulePHP::GetPHP(Tools &_EOTools) { return true; }   bool ModulePHP::onLoad() { std::cout << "Module PHP Load" << std::endl; return (true); }   void ModulePHP::onUnLoad() { std::cout << "Module PHP Unload" << std::endl; }   const std::vector<std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition>>& ModulePHP::getCallbacks() { /*!!!!*/ this->_LPHook.first = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP); this->_LPHook.second = ZenZiAPI::hookPosition::LAST; this->_LVPair[3].push_back(this->_LPHook);   return *this->_LVPair; }   extern "C" DLL_EXPORT ZenZiAPI::IModule *create() { ModulePHP *_LOModulePHP = new ModulePHP(); std::cout << "ModulePHP Destroy Method" << std::endl; return (static_cast<ZenZiAPI::IModule*>(_LOModulePHP)); }   extern "C" DLL_EXPORT void destroy(void* p) { std::cout << "ModulePHP Create Method" << std::endl; delete (static_cast<ModulePHP*>(p)); }

---

La gestion de tout ces modules coté serveur se fait aussi à l'aide d'une API qui m'impose un modèle de conception, le cast que je souhaite faire est un pointeur sur méthode de type IModule que je souhaite stocké dans une map coté serveur.

Afin d'appeler les modules dans le code en utilisant leur méthode d'entrée que j'aurai défini (mais qui ne compile pas) et leur instance récupérée au préalable.

Ces module seront chargés à chaud à l'aide de LoadLibrary et GetProcAddress.

Je ne peu malheureusement pas utilisé de polymorphisme car coté serveur l'appel aux méthode des modules se fait à l'aide d'un vecteur de pair défini comme tel :

Code:

---

1 2	std::vector<std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition>>

---

Faut faire un reinterpret_cast

J'avais eu le même soucis, et c'est tout ce que j'ai trouvé

Bonjour
Je pense que ça pourra t'aider

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

class ITools { public:   };   class CToolsImpl : public ITools { public:   };       class IModule { public: typedef bool (IModule::*p_callback)(ITools&); virtual IModule::p_callback getCallbacks() const =0; }; class ModulePHP: public IModule { public :   bool ModulePHP::GetPHP(ITools &_EOTools) { return (true); } virtual IModule::p_callback getCallbacks() const { return static_cast<IModule::p_callback>(&ModulePHP::GetPHP); }   }; #define callMemberFunction(object,ptrToMember) ((object).*(ptrToMember))     int main(int argc, char* argv[]) { ITools* tools = new CToolsImpl();   IModule* module = new ModulePHP(); IModule::p_callback pm =module->getCallbacks(); callMemberFunction(*module,pm)(*tools); }

---

Tiens t'as réussit avec un static_cast ?


J'vais le tenter,

merci

Oui, ca marche avec static_cast.
VS2005 sort ca quand il n y'a pas de cast, du coup j ai essayé le static_cast :D

Citation:

---

1>.\base\main.cpp(46) : error C2440: 'return'*: impossible de convertir de 'bool (__thiscall ModulePHP::* )(ITools &)' en 'IModule::p_callback'

1> Cast de base en derived requiert dynamic_cast ou static_cast

---

Ha non ç y'est je m'en rappel de mon soucis.

Je voulais transformer un pointeur de fonction retournant une classe concrète en un pointeur de membre retournant sa classe de base.


Au temps pour moi ;)

Citation:

---

Envoyé par damess67

Oui, ca marche avec static_cast.
VS2005 sort ca quand il n y'a pas de cast, du coup j ai essayé le static_cast :D

---

Bonjour Damess,

Il y'avait un static_cast car c'est justement la dessus que le compilo me jète :

Code:

---

1 2	this->_LPHook.first = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP);

---

La seul différence c'est que au lieu de le return je le stock dans une pair.
Mon pointeur sur méthode est le même que le tient puisque j'hérite de IModule :

Code:

---

1 2	typedef bool (IModule::*p_callback)(ITools&);

---

et ma méthode GetPHP est également preske la meme, à la différence que moi je recois en pramètre des Tools au lieu de ITools avec Tools qui hérite de ITools :

Code:

---

1 2 3 4 5

bool ModulePHP::GetPHP(Tools &_EOTools) { return (true); }

---

Malgré tout ca j'ai quand même l'erreur :

Code:

---

1 2	Error 4 error C2440: 'static_cast' : cannot convert from 'bool (__thiscall ModulePHP::* )(Tools &)' to 'ZenZiAPI::IModule::p_callback'

---

Bonjour

peut etre est ce le type du vecteur qui pose problème

séparez ce code

Code:

---

1 2	this->_LPHook.first = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP);

---

en

Code:

---

1 2 3

ZenZiAPI::IModule::p_callback pm = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP); this->_LPHook.first = pm;

---

et dites moi ou vous rencontrez une erreur

Code:

---

1 2	ZenZiAPI::IModule::p_callback pm = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP);

---

Le problème vient de cette ligne maintenant, je pense donc que ce n'est pas le type du vecteur le problème. l'erreur reste également la même :

Error 4 error C2440: 'static_cast' : cannot convert from 'bool (__thiscall ModulePHP::* )(Tools &)' to 'ZenZiAPI::IModule::p_callback'

la methode ModulePHP::GetPHP est bien virtuelle pure dans IModule ?

repostez le code entier ca sera simple

ModulePHP.cpp

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

#include "ModulePHP.h"   ModulePHP::ModulePHP() {}   ModulePHP::~ModulePHP() {}   bool ModulePHP::GetPHP(Tools &_EOTools) { return true; }   bool ModulePHP::onLoad() { std::cout << "Module PHP Load" << std::endl; return (true); }   void ModulePHP::onUnLoad() { std::cout << "Module PHP Unload" << std::endl; }   const std::vector<std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition>>& ModulePHP::getCallbacks() { ZenZiAPI::IModule::p_callback pm = static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP); this->_LPHook.first = pm; this->_LPHook.second = ZenZiAPI::hookPosition::LAST; this->_LVPair[3].push_back(this->_LPHook);   return *this->_LVPair; }   extern "C" DLL_EXPORT ZenZiAPI::IModule *create() { ModulePHP *_LOModulePHP = new ModulePHP(); std::cout << "ModulePHP Create Method" << std::endl; return (static_cast<ZenZiAPI::IModule*>(_LOModulePHP)); }   extern "C" DLL_EXPORT void destroy(void* p) { std::cout << "ModulePHP Create Method" << std::endl; delete (static_cast<ModulePHP*>(p)); }

---

ModulePHP.h

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

#ifndef __MODULEPHP_H__ #define __MODULEPHP_H__   #include <string> #include <iostream> #include <vector> #include <algorithm> #include <stdexcept> #include <cstdio> #include <cstdlib> #include <io.h> #include "IModule.hpp" #include "ITools.hpp" #include "HookManager.h"   #ifdef WIN32 #define DLL_EXPORT __declspec(dllexport) #else #define DLL_EXPORT #endif   class DLL_EXPORT ModulePHP : public virtual ZenZiAPI::IModule { public: virtual ~ModulePHP(); bool GetPHP(Tools &); const std::vector<std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition>>& getCallbacks(); bool onLoad(); void onUnLoad(); private: std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition> _LPHook; std::vector<std::pair<ZenZiAPI::IModule::p_callback, ZenZiAPI::hookPosition>> _LVPair[ZenZiAPI::hookPointsNumber]; };   #endif /* __MODULEPHP_H__ */

---

IModule.hpp

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

#ifndef _IMODULE_H_ # define _IMODULE_H_   #include <iostream> #include <vector>   #include "defines.hpp" #include "ITools.hpp"     namespace ZenZiAPI { class IModule { public: typedef bool (ZenZiAPI::IModule::*p_callback)(ITools&); /**< callbacks typedef */ virtual ~IModule() {}; virtual const std::vector<std::pair<p_callback, hookPosition> >& getCallbacks() = 0; virtual bool onLoad(void) = 0; virtual void onUnLoad(void) = 0; }; }   #endif //_IMODULE_H_

---

Je ne crée pas un pointeur sur getcallback, je crée un pointeur sur GetPHP

Code:

---

bool ModulePHP::GetPHP(Tools &_EOTools)

---

Code:

---

static_cast<ZenZiAPI::IModule::p_callback>(&ModulePHP::GetPHP);

---

qui correspond tout à fait aux norme du pointeur :

Code:

---

typedef bool (ZenZiAPI::IModule::*p_callback)(ITools&);

---

oui je m etais trompé
je pense avoir trouvé

remplacez Tools par ITools dans

Code:

---

1 2 3 4

bool ModulePHP::GetPHP(Tools &_EOTools) { return true; }

---

J'avais malheursement déjà essayé cette alternative, mais Tools hérite de ITools je ne pense que ce sois la cause de l'erreur, aprés remplacement voici le message d'erreur :

Error 4 error C2440: 'static_cast' : cannot convert from 'bool (__thiscall ModulePHP::* )(ZenZiAPI::ITools &)' to 'ZenZiAPI::IModule::p_callback'

Avez vous vraiment essayé ?

Car j obtiens la meme erreur
error C2440: 'static_cast'*: impossible de convertir de 'bool (__thiscall ModulePHP::* )(CToolsImpl &)' en 'IModule::p_callback'
avec

Code:

---

1 2 3 4

bool ModulePHP::GetPHP(Tools &_EOTools) { return (true); }

---

meme si Tools hérite de ITools

Oui à l'instant je viens de copier le message d'erreur aprés essai dans le post précédent au point en j'en suis j'essaye ce qu'on me dit même si je l'avais déjà testé pas de soucis.

Je vien de trouver le problème venais de l'héritage où j'ecrivais :

Code:

---

1 2	class DLL_EXPORT Module_PHP : public virtual IModule

---

au lieu de (sans le virtual) :

Code:

---

1 2	class DLL_EXPORT Module_PHP : public IModule

---

Visual ne supporte apparemment pas les paramètres contravariants pour les pointeurs de fonction, il faut donc rester en ITools pour toutes les fonctions.

Une note aussi à propos des pointeurs de fonctions: Si un static_cast<> ne suffit pas, alors c'est que la fonction n'est pas compatible. SURTOUT quand on joue avec de l'héritage de classes, ne pas tenter le coup quand un reinterpret_cast<> entre en jeu.