Discussion :

[LiquidHuk]

L'idée du code suivant est d'itérer sur un tuple pour appeler une fonction membre ensuite avec les valeurs contenues dans le tuple. Je cherche à rendre le tout compatible dans le cas de fonction qui ne retourne aucune valeur (dans ce cas là, il ne faut pas push de valeur sur le stack lua). Le code ci-dessous ne fonctionne pas, quelque soit la fonction sur laquelle le pointeur pointe, l'implémentation utilisant "push()" est toujours utilisée.

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
template <typename Ret, typename ClassName, typename... Args, std::size_t... N>
	void callFunctionWithTuple(Ret (ClassName::*fun)(Args...),
			  std::tuple<Args...> args,
			  _indices<N...>) {
		ClassName * obj = l_CheckClass<ClassName>(1);
		push((obj->*fun)(std::get<N>(args)...));
	}
 
	template <typename Ret, typename ClassName, typename... Args, std::size_t... N>
	void callFunctionWithTuple(void (ClassName::*fun)(Args...),
			  std::tuple<Args...> args,
			  _indices<N...>) {
		ClassName * obj = l_CheckClass<ClassName>(1);
		(obj->*fun)(std::get<N>(args)...);
	}
 
	template <typename Ret, typename ClassName, typename... Args>
	void callFunctionWithTuple(Ret (ClassName::*fun)(Args...),
			  std::tuple<Args...> args) {
		callFunctionWithTuple(fun, args, typename _indices_builder<sizeof...(Args)>::type());
	}
 
	template <typename Ret, typename ClassName, typename... Args>
	void callFunctionWithTuple(void (ClassName::*fun)(Args...),
			  std::tuple<Args...> args) {
		callFunctionWithTuple(fun, args, typename _indices_builder<sizeof...(Args)>::type());
	}

EDIT :
Au cas où quelqu'un chercherait une solution à ce problème, j'ai pu le résoudre en utilisant SFINAE :

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
template <typename Ret, typename ClassName, typename... Args, std::size_t... N>
	typename std::enable_if<!std::is_void<Ret>::value>::type
	callFunctionWithTuple(Ret (ClassName::*fun)(Args...),
			  std::tuple<Args...> args,
			  _indices<N...>) 
	{
		ClassName * obj = l_CheckClass<ClassName>(1);
		push((obj->*fun)(std::get<N>(args)...));
	}
 
	template <typename Ret, typename ClassName, typename... Args, std::size_t... N>
	typename std::enable_if<std::is_void<Ret>::value>::type
	callFunctionWithTuple(Ret (ClassName::*fun)(Args...),
			  std::tuple<Args...> args,
			  _indices<N...>) 
	{
		ClassName * obj = l_CheckClass<ClassName>(1);
		(obj->*fun)(std::get<N>(args)...);
	}

[Médinoc]

C'est du full C++11, ça, non? Je ne vois pas le rapport avec le langage C++/CLI...

[LiquidHuk]

En effet, je n'ai pas vérifié après avoir cliqué sur "c++" sur l'accueil du forum, le lien renvoie directement dans c++/CLI...

[Médinoc]

Ah, tu veux dire le sous-lien "C++" qui est dans la section DotNet?

Je n'avais même pas remarqué son existence, mais ça explique bien des choses. Merci beaucoup, c'est l'information critique qui me manquait. Je vais demander aux responsables du forum de corriger cela.

[jblecanard]

Dommage de ne pas utiliser std::function

[LiquidHuk]

Ah, tu veux dire le sous-lien "C++" qui est dans la section DotNet?

Je n'avais même pas remarqué son existence, mais ça explique bien des choses. Merci beaucoup, c'est l'information critique qui me manquait. Je vais demander aux responsables du forum de corriger cela.

ctrl-f "c++" mène directement sur ce lien et avec le titre "langage" je n'avais même pas remarqué la section DotNet.

Dommage de ne pas utiliser std::function

J'ai décidé de ne pas utiliser std::function à cause du nombre variable de paramètres qui doivent être initialisés à l'aide de valeurs récupéré sur la stack lua, non connues au moment de la compilation, de plus, la fonction membre est appelé depuis une instance de l'objet également récupéré sur le stack Lua. Je ne voyais pas comment utiliser std::bind pour passer mes pointeurs de fonctions membre en paramètre de template.

[jblecanard]

J'ai décidé de ne pas utiliser std::function à cause du nombre variable de paramètres qui doivent être initialisés à l'aide de valeurs récupéré sur la stack lua, non connues au moment de la compilation, de plus, la fonction membre est appelé depuis une instance de l'objet également récupéré sur le stack Lua. Je ne voyais pas comment utiliser std::bind pour passer mes pointeurs de fonctions membre en paramètre de template.

D'accord mais une signature comme celle-ci

Code :

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

Ret (ClassName::*fun)(Args...)

Est bien résolue à la compilation, de même que l'appel que tu montres dans le corps de callFunctionWithTuple. Du coup je comprend pas trop ton explication ? Mais soit, je ne suis pas dans le contexte, je dois manquer quelque chose.

[LiquidHuk]

Si mes souvenirs sont bon, il faut utiliser std::bind pour passer en argument une fonction membre là où une fonction attend un std::function. Il me semble que std::bind a besoin d'une instance de l'objet, et attend en paramètre quelque chose du genre.

Code :

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

&instance::fonction

J'obtiens l'instance de l'objet dans callFunctionWithTuple, si mes souvenirs sont exact, je ne peux donc pas utiliser std::function ici ?

Ou alors il faudrait récpérer l'instance de l'objet plus tôt, mais ça ne fait que décaler le problème.

[jblecanard]

Ha oui c'est une fonction membre suis-je bête ! Tu aurais pu utiliser std::mem_fn pour transformer la fonction membre en une fonction qui prend en premier paramètre l'objet et les arguments dans les paramètres restants, ce qui fonctionnerait dans ton cas. Mais bon ta solution fonctionne aussi.