Discussion :

[oodini]

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 :

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

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 ?

[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.

[oodini]

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 :

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

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

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

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

Je tiens à garder mes fonctions libres.
No way, a priori.

[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.

[oodini]

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).

[Médinoc]

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

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

Code C++11 :

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

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

[Médinoc]

Personnellement, je verrais un truc du genre:

Code C++ :

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
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 C++ :

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

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]);