appel d'une fonction dont on ne connais le nom qu'au runtime

Version imprimable

13/04/2010, 10h25
Raumfahrerralf

appel d'une fonction dont on ne connais le nom qu'au runtime

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.

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

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
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")();
}

13/04/2010, 11h04
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:

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 ?
13/04/2010, 11h12
poukill

Citation:

Envoyé par sopsag

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

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

Code:

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

prend un double et retourne un int ! ;)
13/04/2010, 12h17
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

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

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
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 !