templates

Version imprimable

27/08/2013, 17h02
oodini

Tableau d'appels de fonction / lambda / templates
Bonjour,

J'aimerais appeler en parallèle (multithreading) une série d'instanciation d'une fonction libre template dont la signature est (pour simplifier) :
Code:

1 2 template <typename T> int maFonction(std::string param1, T param2);
J'aimerais, pour lancer mes threads, utiliser une boucle, comme décrit sur cette page.

Je dois donc faire un tableau d'"appels de fonction". Tous les arguments de la fonction, pour chaque instanciation, sont connus à la construction du tableau. Je pense doncqu'il faut créer un tableau de std::function (mais bon... je maîtrise mal ces sujets).

M'orienté-je sur une bonne piste ?
27/08/2013, 17h27
Médinoc

Tu ne pourras pas créer un tableau sur fonctions de paramètres de types différents, par contre. Pour ça, il faudra de la virtualité en plus des templates.
27/08/2013, 17h31
oodini

Citation:

Envoyé par Médinoc

Tu ne pourras pas créer un tableau sur fonctions de paramètres de types différents, par contre.

Je n'arrive même pas à faire ça :

Code:

std::function<int(std::string, float)> monWrapper= maFonction<float>("une_chaine", 0.5);

Je ne comprend pas ce qui défrise le compilateur.

Citation:

Envoyé par Médinoc

Pour ça, il faudra de la virtualité en plus des templates.

Je tiens à garder mes fonctions libres.
No way, a priori.
27/08/2013, 17h33
Médinoc

Je viens de regarder parce que je ne connais pas std::function et Cie, et il semblerait que std::function ne mémorise qu'un pointeur de fonction, sans paramètres.

~~Regarde plutôt du côté de std::mem_fn qui semble mémoriser des paramètres en plus.~~Edit: Ben non plus, en fait.
27/08/2013, 17h37
oodini

Citation:

Envoyé par Médinoc

Je viens de regarder parce que je ne connais pas std::function et Cie, et il semblerait que std::function ne mémorise qu'un pointeur de fonction, sans paramètres.

Si. Regarde sur CPP Reference, le deuxième exemple (store a lambda).

Personnellement, je verrais un truc du genre:

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
class FunctionCallerBase
{
public:
	virtual ~FunctionCallerBase();
	virtual void call() = 0;
 
};
//Fonction statique facile à utiliser dans diverses APIs de multithreading
//Changer les types (void*, convention d'appel, etc.) au besoin.
void Call(FunctionCallerBase *p)
{
	p->call();
}
 
template< class T >
class MaFonction_Caller : FunctionCallerBase
{
	int (*m_pFonc)(std::string, T);
	std::string m_arg1;
	T m_arg2;
public:
	int ret;
public:
	MaFonction_Caller(int (*pFonc)(std::string, T), std::string arg1, T arg2)
	 : m_pFonc(pFonc), m_arg1(arg1), m_arg2(arg2) { }
 
	void call()
	{
		ret = m_pFonc(m_arg1, m_arg2);
	}
};
 
template<class T>
FunctionCallerBase* WrapMaFonction(std::string arg1, T arg2)
{
	return new MaFonction_Caller<T>(MaFonction<T>, arg1, arg2);
}

Et ça s'utiliserait ainsi:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
FunctionCallerBase* fonctions[] = { 
	WrapMaFonction("une_chaine", 0.5),
	WrapMaFonction("une_chaine", 42),
	WrapMaFonction("une_chaine", "toto")
};
 
...
 
for( i=0 ; i<ARRAYSIZE(functions) ; ++i )
	whatever_create_thread(Call, fonctions[i]);

27/08/2013, 17h50
Médinoc

Citation:

Envoyé par oodini

Si. Regarde sur CPP Reference, le deuxième exemple (store a lambda).

Ah, dans ce cas, ça s'utiliserait plutôt comme ça:

Code:

std::function<int()> monWrapper= []() { return maFonction<float>("une_chaine", 0.5); }
27/08/2013, 18h12
oodini

On avance : j'ai réussi à faire ça :

Code:

std::function<float()> test = []() -> float { return std::max(2.2, 5.7); };
27/08/2013, 18h15
Médinoc

Ce qui dans notre cas, donnerait:

Code:

std::function<int()> monWrapper= []() -> int { return maFonction<float>("une_chaine", 0.5); }

C'est là que ça se complique :
la fonction et un des arguments sont des membres de la classe créant le wrapper. :aie:

En gros, j'ai :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class A { std::string attribut1; std::string attribut2; template <typename T> int maFonction(std::string param1, T param2); void fonction_d_appel() { maFonction(attribut1, 0.5); maFonction(attribut2, 0.7); } }
C'est là que je m'aperçois que ma fonction n'est pas du tout libre (problème d'indentation). Et qu'elle n'est pas publique. Désolé !
Je pense donc que ça exclut les lambdas.

Disons que j'ai 10 attributs, et 10 appels de fonction que je veux paralléliser.

Je ne pense pas que ça change grand-chose pour les lambdas.
Si tu n'es pas sûr, copie-les dans des variables locales d'abord.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class A
{
    std::string attribut1;
    std::string attribut2;
    template <typename T>
    int maFonction(std::string param1, T param2);
 
    void fonction_d_appel()
    {
        std::string attr1 = attribut1;
        std::string attr2 = attribut2;
 
        std::function<int()> monWrapper[10]; //Mettre ça sur le tas si nécessaire
        monWrapper[0] = []() -> int { return maFonction<float>(attr1, 0.5); };
        monWrapper[1] = []() -> int { return maFonction<float>(attr2, 0.7); };
    }
}

28/08/2013, 11h13
oodini

En fait, pour pouvoir se référer à des membres, il faut capturer this dans l'expression lambda.
28/08/2013, 11h30
oodini

Si je suis ta suggestion (voir plus haut), et que je rajoute this :

Code:

std::function<int()> monWrapper= [this]() -> int { return maFonction<float>("une_chaine", 0.5); }

Le compilateur me sort :

Code:

error C2062: type 'float' unexpected

Cela ne fonctionne pas non plus avec auto :

Code:

auto monWrapper= [this]() -> int { return maFonction<float>("une_chaine", 0.5); }

Il faut sûrement déclarer la nature template au début de l'instruction. Je cherche...

PS : fil de discussion à déplacer dans la section langage, je pense...
28/08/2013, 11h53
oodini

Enfer et damnation ! C'est un bug de VS 2010 !

http://connect.microsoft.com/VisualS...details/718297

Il faut donc faire :

Code:

std::function<int()> monWrapper= [this]() -> int { return this->maFonction<float>("une_chaine", 0.5); }
28/08/2013, 12h06
Médinoc

Attends, je croyais que c'était supposé être une fonction libre?
28/08/2013, 12h12
oodini

Mon message d'hier à 18h24 indiquait que finalement, non...
28/08/2013, 13h49
oodini

Bon, j'ai conjugué tout ça avec un vecteur de threads, et j'ai réussi à faire ce que je voulais.

Merci de t'être penché sur mon problème, Médinoc !
28/08/2013, 21h01
koala01
Salut,

Le problème, c'est que, que tu travailles avec un pointeur de fonction "classique" ( void (funptr *)(/* parametres*/ ) ) ou avec un std::function, la signature correspond à l'ensemble de la signature de la fonction (le type de retour, le type éventuel de l'objet au départ duquel tu veux appeler la fonction et le nombre et le type des paramètres à transmettre).

Si tu veux pouvoir faire varier l'une ou l'autre de ces parties, il faut que tu trouves le "plus grand élément commun" et que tu bindes le reste pour que cela fonctionne.

Si tu as deux fonctions, mettons
Code:

1 2 void foo( int); void bar(float);
tu pourras créer une collection de std:function (pointeurs sur fonction) sur void (*)(), mais tu devra "binder" le int ou le float.

Et pour pouvoir l'utiliser sur une fonction membre, il faudra que tu binde également l'objet au départ duquel la fonction est appelée ( this, pour faire simple).

A moins bien sur que tu crées une collection de fonctions prenant un int ( void (*)(int) ) en paramètre d'un coté et une collection de fonctions prenant un float ( void (*) (float) ) de l'autre coté, et ainsi de suite ;)

Ceci dit, je me souviens avoir abordé ce point il y a quelques mois en voyant comment il serait possible d'outiller des fonctions afin de savoir leurs temps d'exécutions...

Je ne sais plus de tête quelle était la discussion, mais tu devrais pouvoir la retrouver "assez facilement" (bon, mon utilisation ne s'intéressait pas aux lambda, mais tu devrais pouvoir adapter l'idée "assez facilement" ;))

PS : je le sais, ma bonté me perdra, mais j'ai même retrouvé l'intervention dont je te parlais... elle se trouve ici
29/08/2013, 14h04
oodini

Citation:

Envoyé par koala01

Si tu veux pouvoir faire varier l'une ou l'autre de ces parties, il faut que tu trouves le "plus grand élément commun" et que tu bindes le reste pour que cela fonctionne.

Oui, c'est ce que j'ai fait.

Citation:

Envoyé par koala01

Ceci dit, je me souviens avoir abordé ce point il y a quelques mois en voyant comment il serait possible d'outiller des fonctions afin de savoir leurs temps d'exécutions...

Comme j'ai réussi à faire ce que je voulais, je ne vais pas lire ta prose pour résoudre mon problème (qui n'en est plus un), mais ça reste un post très intéressant que je prendrai le temps de lire !