Discussion :

[webshaker]

Bonjour,

Je cherche a appeler une méthode d'un objet, sauf que je ne connais ni le type de l'objet, ni même si la méthode existe (au moment de l'appel).
Je sais, dis comme cela, ça ne semble pas possible

Donc ce que j'aimerai faire est une collection de méthodes rangées dans un std::map.

J'ai vu qu'il était possible de récupérer le pointeur d'une méthode

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
class test
{
public:
	int a;
	test() { a = 10; }
 
	int draw()
	{
		return a;
	}
};
 
 
...
 
int main(int _argc, char **_argv)
{
	int (test::*pt2Method)(void) = NULL;            // C++ method
	pt2Method = &test::draw;
...
}

Sauf que j'ai pas bien compris quel est le type de pt2Method.

Comment créer une collection std::map<const char*, ???> _methods; pour y ranger les méthodes.

Supposons que j'arrive à mettre mon pt2Method dans _methods["test::draw"], il devrait être possible de faire

Code :

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

1
2
3
 
	test _obj;
	int result = (_obj.*_methods["test::draw"])();

Sauf que là, c'est trop facile.
Moi ce que je voudrai faire c'est

Code :

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

1
2
3
4
 
	test _obj;
	void *o = &_obj;
	int result = (o->*_methods["test::draw"])();

Ne sachant pas que o est un pointeur de type <b>test *</b>

Y a t-il moyen de caster dynamiquement o en <b>test *</b> ?

Merci.

[ternel]

Code :

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

int (test::*pt2Method)(void) = NULL;

il y a un truc contenant un type à gauche d'une affectation, c'est une déclaration.

Voici comment je lis ce type.

• int ...: J'ai moyen d'avoir un int à partir de cette variable
• int ...(void): Je peux avoir un int en utilisant () sur cette variable
• int (test::*pt2Method)(void): l'expression @(test::*pt2Method) désigne une fonction void vers int
• test::*pt2Method: l'expression *pt2Method appartient au nom test.
• *pt2Method: l'expression pt2Method est un pointeur.

Remis dans l'ordre, ca donne pt2Method est un pointeur dans test de fonction void vers int.
Son type est int (test::*)(void).
Autrement dit, il existe une (seule) classe test visible dans main, et elle pourrait bien contenir une fonction membre qui retourne un int.

J'ajoute que la fonction dont tu pourras prendre l'adresse dans pt2Method n'est pas une fonction constante.

Tu peux écrire un using pour simplifier l'utilisation de ce type.

Code :

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

1
2
3
4
using pt2Method_type = int (test::*)(void);
int main() {
    std::map<std::string, pt2Method_type> methods;
}

L'ordre défini sur const char* est celui des pointeurs. Deux chaines de même valeur ne sont pas forcément stockées au même endroit.


Concernant le cast.
Oui, tu peux violer le système de type par un cast (dynamic_cast<...>, je crois).
La bonne question est comment en est-tu arrivé à avoir un void* dont tu supposes qu'il est un test*?

[webshaker]

Ce code fonctionne en effet.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main(int _argc, char **_argv)
{
	std::map<std::string, int (test::*)(void)> _methods;
	_methods.insert(std::make_pair("test:draw", &test::draw ));
 
	test _obj;
	int result = (_obj.*_methods["test:draw"])();  
	printf("%d\n", result);
 
	return 0;
}

Mais j'avais un peu espéré que ma collection allait être indépendante de ma class.
En fait std::map<std::string, int (test::*)(void)> _methods; implique que mon map ne pourra pas accueillir une méthode ni d'un autre objet, ni prenant d'autre paramètre...

Puisqu'une fonction (ou une méthode) n'est finalement rien d'autre qu'une adresse en mémoire, j'avais un espéré pouvoir n'avoir qu'une seule collection pour toutes les méthodes de toutes mes class...

En ce qui concerne l'"auto casting" d'un void* en test*, j'avais espéré (la aussi) que puisque j'indique dans _methods.insert(std::make_pair("test:draw", &test::draw )); que test:draw appel la méthode draw de la class test il serait possible de caster mon void* en test*

Je vais réfléchir...

[ternel]

Quel est ton contexte?
Quand la solution est basée sur des "j'espère", c'est que ce n'est pas la bonne.

Par exemple, il y a des outils comme std::function, les foncteurs et les lambdas.

[webshaker]

Le contexte c'est toujours mon variant dans lequel je voudrais pouvoir assigner l'instance d'un objet et pouvoir ensuite appeler ses méthodes.
Un truc un peu plus proche (mais moins orienté objet) de ce que je cherche a faire serait

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
using namespace std;
#include <string>
#include <map>
#include <stdio.h>
 
class test
{
public:
	int a;
 
	test()
	{
		a = 10;
	}
 
	int draw()
	{
		return a;
	}
};
 
int test_draw(void *vo)
{
	test *o = (test *)vo;
	return o->draw();
}
 
int main(int _argc, char **_argv)
{
	std::map<std::string, int (*)(void *)> _methods;
	_methods.insert(std::make_pair("test::draw", &test_draw));
 
	test _obj;
	void *o = &_obj;
	int result = _methods["test::draw"](o);  
	printf("%d\n", result);
	return 0;
}

Dans cet exemple,
L'appel de la méthode se fera bien sur un objet dont je ne connais pas le type (le type lui sera donné ici par la fonction globale).
Quant à ma collection, elle pourra à présent accueillir toutes les méthodes (enfin dans la limite des paramètre reçus et retournés).

J'aurai juste aimé trouver une solution plus C++ qui m'évite la function globale test_draw.

Remarque :
Pour être bien clair sur ce que je cherche a faire:
Je souhaite pouvoir passer l'instance d'un objet A à un objet V, puis appeler une méthode de A au travers de V tout en sachant que V en connait pas la définition de A
Un truc genre

Code :

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

1
2
3
4
5
6
7
8
9
 
int main(int _argc, char **_argv)
{
	A _a;
	V _v;
 
	_v.SetObject((void *)&_a);		// le passage par un cast en void * est obligatoire puisque V ne connait pas A
	_v.callMethod("draw");		// ici on souhaites tester que draw est bien une méthode de A et l'appeler si cela est le cas.
}

Voilà. Si j'arrive a faire çà c'est jackpot.

[ternel]

Ton problème, c'est qu'un variant, c'est une valeur d'un type parmi plusieurs, et que si lui sait son type, pas nous.
Pour pouvoir en faire quelque chose de précis, il faut le matérialiser dans le type qu'on espère, et avant, vérifier que c'est du bon type.

Ne redirige pas les fonctions vers lui-même, mais exporte sa valeur comme une référence, constante ou non.


Par ailleurs, ce que tu exposes, c'est un contexte technique (très ponctuel, d'ailleurs).
Quel est le contexte fonctionnel/métier.
Quel problème souhaite-tu résoudre par l'outil Variant. (et optionnellement, pourquoi n'utilises-tu pas boost::variant?)

[webshaker]

Mon objectif est de convertir (plus ou moins automatiquement) un code PHP en C++.
Alors certes, http://hhvm.com/ le fera 1000 fois mieux que moi.

Mais je fais aussi ça pour me remettre au C++ (ça fait longtemps que j'en fait plus).
J'essaye donc déjà de simuler le comportement des variables PHP ! d'où mon intérêt particulier pour les variants !

Disons je c'est de l’expérimentation...