Discussion :

[coyotte507]

sinon avec boost serialization, on peut par exemple stocker une classe dans un fichier archive, puis la restorer plus tard.

Ce que je veux dire, c'est qu'on peut alors récupérer une classe d'après le nom de fichier simplement. (enfin son instance)

Mais j'ai regardé le code, la vache!

[bouzaidi]

PierroElmilito:
J'ai ajouté le fichier boost avec tous son contenu et j'ai toujours d'erreur de compil il trouve pas le chemin au fichier boost/lexical_cast sacahat que j'ai ajouté la clause
#include <boost/lexical_cast.hpp>

dans mon fichier.. L) j'avoue je comprend plus rien

[PierroElMito]

tu as bien rajouté et vérifié chemin vers les includes de boost dans les "include directories"?

[loufoque]

Tu ne peux pas faire de réflexion dynamique en C++, tout simplement parce que les types, et donc les classes, le nom des membres etc. disparaissent après la compilation (quoiqu'en fait c'est peut-être dans certaines infos de débogage).

Avoir de la réflexion à la compilation ne te suffit pas ?

[bouzaidi]

loufoque, je n'ai pas compris ta question: pourrais tu m'expliquer ce ke tu voulé dire stp??

[Xorgnem]

Je vous annonce que ca a l'air de fonctionner le getProcAddress meme sous windows CE!
Il reste maintenant a appeler la fonction et lui passer des parametres a partir de son adresse.
J'ai trouvé quelque chose sur le net a propos de ca, ca ne marche pas du premier coup helas je le debogue et je vous presenterai une solution (si j'y arrive )



pour l'histoire des fichiers, je vois pas pourquoi on utiliserait de l'XML. Mais il reste le probleme de comment executer ce fichier, il faudrait aue ce soit un executable et pour ca le compiler, ca me parait un peu barbare...

[loufoque]

Je ne vois pas comment expliquer plus clairement.
Puisqu'à la compilation, les types existent, pourquoi ne pas faire la réflexion à ce moment là avec les techniques de méta-programmation usuelles ?

[Médinoc]

Parce que la métaprogrammation risque d'être trop statique pour ce que l'on cherche à faire (appels dynamiques).
C'est peut-être possible au sein d'un même module (le module expose une version "texte" de sa propre interface), mais j'ai quand même des doutes.

[Matthieu Brucher]

Bonjour,
Y aurait il un truc en C++ qui me permet de faire la reflexion?? C'est a dire étant donné un objet o, et des NOMS de champs et méthodes en chaines de caracteres, Est ce qu'on peut appliquer ces methodes sur cet objet o et tirer aussi les valeurs des attributs donné en chaine de caractere de cet objet aussi??
Plus precisement:
j ai une classe point avec deux attribut x et y et une methode translater...
j'ai les variables string suivantes:s1='x' et s2='y' et s3="translater". L'objet point étant créé p. Comment faire p.x et et p.y et p.translater????

Je sais qu'en C# ca existe, mais j'en ai besoin de ça en C++... Merci d'avance.

Ca n'existe pas en C++ natif, ce n'est pas possible.

[loufoque]

S'il s'agit de chaînes littérales et non de chaînes acquises via entrées/sorties ça ne devrait pas poser de problèmes.

[coyotte507]

Comme l'a dit l'auteur, malheureusement, ce sont des chaines qu'un utilisateur peut envoyer via internet..

[epsilon68]

peut etre utiliser Qt et son moteur javascript non ?

[Matthieu Brucher]

Mais là aussi, toutes les classes qui veulent utiliser ce principe doivent hériter de la classe parente, donc on revient exactement au même problème.

[Médinoc]

Après examen du problème, je pense qu'un module peut exposer ses méthodes avec des templates et une map.

Un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
bool parseParam(istream &str, int &value);
bool parseParam(istream &str, short &value);
bool parseParam(istream &str, string &value);
bool parseParam(istream &str, int* &value);
//etc.
 
class FunctionCall
{
virtual string Invoke(void *obj, string param);
};
 
template< class Obj, class Ret, class A, class B, class C >
class TFunctionCall3
{
typedef Ret (Obj::*func_type)(A, B, C);
TFunctionCall3(func_type f);
virtual string Invoke(void *obj, string param);
 
func_type m_f;
};
 
template< class Obj, class Ret, class A, class B, class C >
string TFunctionCall3::Invoke(void *obj, string param)
{
   Obj *pObj = static_cast< Obj * >(obj);
 
   A a;
   B b;
   C c;
   istringstream iss(param);
   if(!parseParam(iss, a)) throw exception("invalid parameter");
   if(!parseParam(iss, b)) throw exception("invalid parameter");
   if(!parseParam(iss, c)) throw exception("invalid parameter");
 
   Ret ret = (pObj->*m_f)(a, b, c);
   return to_string(ret);
};
 
+ TFunctionCall0, TFunctionCall1, TFunctionCall2, TFunctionCall3, etc.

Et ça s'utiliserait ainsi dans le module:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class UneClasse
{
int UneMethode(char const *unPointeurSurChar);
string UneAutreMethode(int unEntier, int unAutreEntier);
};
 
map<string, CFunctionCall*> theMap;
map<string, void*> objects;
 
void Init()
{
   theMap["UneClasse::UneMethode"] = new TFunctionCall1< UneClasse, int, char const * >(&UneClasse::UneMethode);
   theMap["UneClasse::UneAutreMethode"] = new TFunctionCall2< UneClasse, string, int, int >(&UneClasse::UneAutreMethode);
}
 
string CallFunction(string objectName, string functionName, string parameters)
{
   void * obj = objects[objectName];
   if(obj==nullptr) throw exception("Object not found");
   CFunctionCall *pFunc = theMap[functionName];
   if(pFunc==nullptr) throw exception("Function not found");
   return func->Invoke(obj, parameters);
}

Et le module n'aurait plus qu'à exporter la fonction CallFunction()...
Bref, le module construit manuellement sa base de réflexion et ses stubs d'appels de méthode...

[loufoque]

Éventuellement mieux car n'existe qu'à la compilation (ce qui n'empêche pas de comparer les chaînes à des chaînes dynamiques, en fait)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
template<typename T>
struct reflection
{
};
 
struct TonType
{
	int value;
 
	void something(int a)
	{
		...
	}
};
 
struct reflection<TonType>
{
	typedef boost::mpl::map<
		boost::mpl::pair<
			boost::mpl::vector_c<char, 's', 'o', 'm', 'e', 't', 'h', 'i', 'n', 'g'>,
			void (int)
		>,
		boost::mpl::pair<
			boost::mpl::vector_c<char, 'v', 'a', 'l', 'u', 'e'>,
			int
		>
	> type;
};

Bien entendu ça nécessite pas mal d'outils de méta-programmation pour pouvoir être manipulé de manière correcte.
(En particulier il faut pouvoir extraire des informations du type "void (int)" par exemple)

[bafman]

comme proposé au debut, personnelement, je partirait plus sur une solution Lua + luaBind qui permet d'enregistrer les class/methode hyper simplement et de les appeler de façon totalement dynamique avec verification de type à l'execution, et, le tout, de façon totalement non intrusive dans le programme de depart

[coyotte507]

Peut-tu nous donner un lien stp?

Le seul truc que j'ai trouvé avec tolua++ c'est qqchose qui permet d'implémenter du c++ dans du python.

[Alp]

Je me dirigerais personnellement plutôt vers la solution donnée par loufoque. Boost.MPL fournit vraiment pas mal d'outils.

[bafman]

http://www.rasterbar.com/products/luabind.html
et
http://www.rasterbar.com/products/luabind/docs.html
pour la doc. c'est vraiment un truc super puissant, car on peut très bien l'integrer dans un projet sans changer une ligne du projet d'origine (la seule limitation que j'ai trouvé est qu'il a besoin d'avoir acces au constructeur, ce qui est parfois génant pour les singletons...)

[Xorgnem]

Salut a tous,

j'ai reussi à appeler ma fonction par un message générique.
On fait appel à getProcAddress, on caste ca en pointeur, et on a plus qu'a appeler la fonction presque normalement. Seul inconveniant, apparement il faut déclarer un pointeur pour chaque "prototype" de fonctions, c'est a dire qu' il en faut un pour une fonction qui prend un char et un int en parametres, et il en faut un autre pour une fonction qui prend un int et un booleen... vous voyez l'inconveniant ?

Je vous mets le code que j'ai trouvé pour le cast

l'adresse c'est : http://perso.orange.fr/philippe.bauc...namicload.html

le code, je l'ai changé car ne fonctionne pas chez moi avec la "visual studio 2005 command prompt"

le voici, j'ai simplement enlevé le __stdcall a la ligne 6

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 <windows.h>
#include <string.h>
#include <stdio.h>
 
// FCTX is a pointer to a function waiting an int, char * etc.
typedef int (*FCTX)(int hWnd, char *Texte, char *Titre, unsigned int Type);
 
// Name off the function we want to call
#define FUNCTION_NAME "MessageBoxA"
 
// Name of the DLL to load
#define MODULE_NAME "user32.dll"
 
 
//----------------------------------------------------------------------------
int main (int argc, char *argv[]) {
 
  static char ModPath[255]="C:\\WINDOWS\\SYSTEM32\\";
  int         Status;
  FCTX         Fn_Ptr;
  HMODULE     ModId;
 
  strcat(ModPath, MODULE_NAME);
 
  // Load the DLL
  ModId = LoadLibrary(ModPath);
 
  // Get the adr of the function to call
  Fn_Ptr = (FCTX)GetProcAddress(ModId, FUNCTION_NAME);
 
  // Use the pointer in order to call the function and passing parameters
  Status = Fn_Ptr(0, "Le texte de la boite de dialogue", "Le tire", MB_OK);
 
  // Unload the DLL and free memory
  FreeLibrary(ModId);
 
  // Reports information about the function call return value
  printf ("Après appel de la fonction dans le module, le status = %i\n", Status);
 
  printf("Strike ENTER to exit :");
  getchar();
  return 0;
}

Par contre, en quittant le programme j'ai une ecriture ds un emplacement memoire interdit, vous voyez d'ou ca peut venir? Avez-vous la meme erreur quand vous l'executez?