Discussion :

[Raumfahrerralf]

Bonjour à tous.
J'ai une question :
Imaginons qu'il existe une bibliothèque de fonctions qui est gérée par une personne A. Toutes les fonction ont le même prototype, mais des noms différents.
La personne B ne connais pas le contenu précis de cette bibliothèque, mais il veut créer une méthode qui fait appel à une des fonctions de A sans connaitre son nom au moment où il écrit le code. La méthode de la personne B va lire un nom dans un fichier texte par exemple, et appel la fonction de A qui a ce nom.

Comment réalise-t-on ce type de mécanisme, où on veut appeller une fonction dont on ne connaitra le nom qu'au moment de l'éxécution et non au moment de la compilation ?

Merci de toute aide / lien / info.

[poukill]

Il va falloir passer par un mécanisme de "factory". En gros, il faut pré enregistrer tes fonctions...
Exemple (non testé, non compilé).

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
45
46
47
48
49
50
51
52
53
 
class CFunctionFactory : private boost::noncopyable
{
public:
        typedef boost::function<void()> my_function; // Ton prototype
	/**
        * \brief Get static instance of factory.
        */
	static CFunctionFactory & Instance()
	{
		static CFunctionFactory  instance;
		return instance;
	}
 
	/**
        * \brief Register a function
        */
	void RegisterFunction(const std::string& str, boost::function<my_function func)
	{
		m_map[str] = func;
	}
 
	/**
        * \brief Get the function
        */
	my_function GetFunction(const std::string& str)
	{
		return m_map[str];
	}
 
private:
	CFunctionFactory () {}
	std::map<std::string, my_function > m_map;
};
 
void coucou()
{
   std::cout << "coucou" << std::endl;
}
 
void hello()
{
   std::cout << "hello" << std::endl;
}
 
int main()
{
     CFunctionFactory::Instance().RegisterFunction("coucou", &coucou);
     CFunctionFactory::Instance().RegisterFunction("hello", &hello);
 
     CFunctionFactory::Instance().GetFunction("coucou")();
     CFunctionFactory::Instance().GetFunction("hello")();
}

[sopsag]

Excusez moi, je me greffe sur ce thread pour poser une petite question qui m'est venue en lisant :
poukill dans ton exemple de code tu écris :

Code :

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

typedef boost::function<void()> my_function;

--> c'est quoi le type "void()" que tu passes au template ?
Ça a l'air d'être le type d'une fonction sans arguement ni retour, mais dans ce cas, est-ce que ça ne devrait pas être "void(*)()" ?
Si ça n'est pas ça, qu'est ce que c'est ?

[poukill]

c'est quoi le type "void()" que tu passes au template ?

Si si, c'est bien le prototype de la fonction...

Code :

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

typedef boost::function<int(double)> my_function;

prend un double et retourne un int !

[atttchoum]

void(*f)() est un pointeur sur une fonction qui ne prend ni ne renvois d'argument mais, si je me souvient bien, void f() est équivalent. En effet les fonction ne sont pas des donnée que tu peux modifier, incrémenter, ect... le compilateur considère donc que c'est la même chose.

voir la faq

[sopsag]

Je me suis amusé à écrire ce truc là :

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
45
46
double titi ( double x ) { return x*x ;}
double tata ( double x ) { return x+1 ;}
double toto ( double x ) { return 1-x ;}
 
// pool de pointeurs de fonctions : <func> doit être un pointeur de fonction
template <class func> class FunctionPtrPool
    {
    public:
        FunctionPtrPool ()            { _nb = 0 ;}
        func operator[] ( int index ) { return( _table[index] ) ;}
        void operator += ( func f )   { _table[_nb++] = f ;}
    private:
        int  _nb ;
        func _table [5] ;
    } ;
 
// pool de fonctions : <func> doit être une fonction
// NB : cette classe est une copie de la précédante avec une '*' à tous les 'func'.
template <class func> class FunctionPool
    {
    public:
        FunctionPool ()                 { _nb = 0 ;}
        func * operator[] ( int index ) { return( * _table[index] ) ;}
        void   operator += ( func * f ) { _table[_nb++] = f ;}
    private:
        int    _nb ;
        func * _table [5] ;
    } ;
 
// on test tout ça...
void test_template_func_typed ()
    {
    FunctionPtrPool<double(*)(double)> f_double ;
    f_double += titi ;
    f_double += tata ;
    f_double += toto ;
 
    FunctionPool<double(double)> f_double_ptr ;
    f_double_ptr += tata ;
    f_double_ptr += toto ;
    f_double_ptr += titi ;
 
    double(*f)(double) = titi ;
 
    cout << f_double[0]( 3 ) + f_double_ptr[1]( 3 ) + f( 5 ) ;
    }

et je constate que double(double) est le type de la fonction elle même alors que double(*)(double) est le type du pointeur de fonction. Je n'avais jamais rencontré l'écriture double(double)...
Voilà, je me coucherai moins bête !