Problème de functor

Version imprimable

Problème de functor

Bonjour à tous

Je viens en ces jours heureux solliciter votre aide. Voilà je souhaite faire un module de gestion du temps. Dans ce module je donne la possibilité à l'utilisateur d'envoyer des messages, retardés de x millisecondes, des messages périodiques (toutes les x millisecondes). Je fais de même avec des fonctions que je souhaite exécuter, ces fonctions pouvant être membres ou non.

J'ai donc une classe TimeFunction qui gère ces 2 types de fonction :

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
namespace Naos
{
    /** Base pour la représentation d'une fonction exécuter par le TimeSystem.
    */
    class _NaosExport_ BaseTimeFunction
    {
    public:
 
        /**
         * Constructeur par défaut.
         */
        BaseTimeFunction(void) {}
 
        /**
         * Destructeur.
         */
        virtual ~BaseTimeFunction(void) {}
 
        /**
         * Exécution de la fonction.
         */
        virtual void execute(void) = 0;
    };
 
    /** Fonction périodique simple.
    */
    class _NaosExport_ SimpleTimeFunction : public BaseTimeFunction
    {
    public:
 
        typedef void (*FunctionPtr)(void);
 
    private:
 
        /// Pointeur sur une fonction périodique.
        FunctionPtr mFunction;
 
    public:
 
        /**
         * Constructeur par défaut.
         */
        SimpleTimeFunction(FunctionPtr function):
        mFunction(function)
        {}
 
        /**
         * Destructeur.
         */
        virtual ~SimpleTimeFunction(void)
        {}
 
        /**
         * BaseTimeFunction::execute();
         */
        virtual void execute(void)
        {
            (*mFunction)();
        }
    };
 
    /**  Fonction membre périodique.
    */
    template<class T> class MemberTimeFunction : public BaseTimeFunction
    {
    public:
 
        typedef void (T::*FunctionPtr)(void);
 
    private:
 
        /// Object depuis lequel exécuter la fonction membre.
        T* mObject;
 
        /// Pointeur sur une fonction membre périodique.
        FunctionPtr mFunction;
 
    public:
 
        /**
         * Constructeur par défaut.
         */
        MemberTimeFunction(T* object, FunctionPtr function):
        mObject(object),
        mFunction(function)
        {}
 
        /**
         * Destructeur.
         */
        virtual ~MemberTimeFunction(void)
        {}
 
        /**
         * BaseTimeFunction::execute();
         */
        virtual void execute(void)
        {
            mObject->(*mFunction)();
        }
    };
 
    class _NaosExport_ TimeFunction
    {
    private:
 
        /// Pointeur sur l'enveloppe de la fonction à exécuter.
        BaseTimeFunction* mFunction;
 
    public:
 
        /**
         * Constructeur par défaut à partir d'un pointeur sur fonction simple.
         * @Param       function : pointeur sur la fonction.
         */
        TimeFunction(SimpleTimeFunction::FunctionPtr function):
        mFunction(new SimpleTimeFunction(function))
        {}
 
        /**
         * Constructeur par défaut à partir d'un pointeur sur fonction membre.
         * @Param       function : pointeur sur la fonction.
         */
        template<class T>
		TimeFunction(T* object, void (T::*FunctionPtr)(void)):
        mFunction(new MemberTimeFunction<T>(object, FunctionPtr))
        {}
 
        /**
         * Destructeur.
         */
        ~TimeFunction(void)
        {
            NAOS_DELETE(mFunction);
        }
 
		/**
         * Exécution de la fonction.
         */
        virtual void execute(void)
        {
			mFunction->execute();
        }
    };
}   // Naos.

Dans mon code de test j'enregistre une fonction périodique et une fonction membre périodique, le problème c'est que pour l'enregistrement d'une fonction périodique j'ai des erreurs

Code:

1
2
3
4
5
 
HelloMsg* mHelloMsg = new HelloMsg();
TimeSystem::getSingletonPtr()->addPeriodicFunction(new TimeFunction<HelloMsg>(mHelloMsg, &HelloMsg::message), 2000);
 
TimeSystem::getSingletonPtr()->addPeriodicFunction(new TimeFunction(&hello_function), 5000);

Et voici l'erreur que me sort le compilateur

Code:

1
2
 
error C2512: 'Naos::TimeFunction' : aucun constructeur par défaut approprié disponible

Sur la ligne

Code:

1
2
 
TimeSystem::getSingletonPtr()->addPeriodicFunction(new TimeFunction<HelloMsg>(mHelloMsg, &HelloMsg::message), 2000);

Je vois pas trop ou est l'erreur, si vous avez un petite idée, je suis preneur :)

Merci bien :D

10/01/2009, 13h17
loufoque

Ce que tu fais, c'est pas juste std::function en beaucoup moins bien ?
10/01/2009, 14h07
Kromagg

Je connais pas du tout, je regarde et je vais essayer de voir si je peux le faire avec ça :)

Merci bien :D
10/01/2009, 14h16
Kromagg

Je me suis renseigné et j'ai une petite question : quelle est la différence entre std::tr1::function et boost::function ?

De plus j'ai pu voir sur le forum que std:tr1 utilisé l'implementation du TR1 de Visual Studio 2008 Feature Pack. Ca signifie quoi : est-ce portable ou simplement fourni sous VC++ ?
10/01/2009, 15h33
koala01

Salut,

TR1 est une "mise à jour mineure" (enfin, si on peut la considérer comme mineure :aie:) de la norme entre deux refontes plus en profondeur...

Son but est d'apporter des ajouts / précisions / fonctionnalités dont l'expérience a montrer qu'ils (elles) étaient intéressant(e)s, sans nécessiter une refonte en profondeur de la norme ;)

TR1 fait, finalement, partie intégrante de la norme, et il s'agit donc de quelque chose de standard, et donc de portable ;)

Pour ce qui est de tr1::function, il s'agit d'une adaptation de boost::function ;)

L'"astuce", c'est qu'il n'y a finalement pas très longtemps que la firme de redmond a décidé de changer de politique en ce qui concerne le respect des différentes normes :aie:

De plus, il faut malgré tout avouer que la mise au point d'un compilateur n'est déjà pas chose aisée à la base, et que l'implémentation d'une norme telle que celle qui régit le C++ fait - certainement - figure de partie "particulièrement casse tête à mettre en oeuvre" :P

Ceci mis bout à bout devrait te permettre de comprendre qu'il n'est pas impossible que, malgré le fait que TR1 est apparu il y a déjà quelque temps, l'implémentation sous VC++ 2008 puisse ne pas être "satisfaisante" en date de sortie de VC2008 et qu'ils aient décidé de ne pas la donner à ce moment là, et d'attendre, avant de l'inclure, que leur implémentation tienne la route...

Evidemment, cela implique que, si tu veux en profiter, il faut que tu l'installe toi-même ;)
10/01/2009, 16h38
Kromagg

Merci beaucoup, je n'avais jamais cherché à savoir ce qu'était le TR1, c'est beaucoup plus clair maintenant :)

Par contre j'ai toujours cette même erreur et je ne vois pas d'où elle vient :s
10/01/2009, 22h17
koala01

Ben, il suffit de lire...

Le compilateur se plaint parce qu'il ne trouve aucun constructeur qui fonctionne avec ce que tu as mis ;)

En gros, le seul constructeur qui existe pour ta classe demande un pointeur sur un objet de type T et un pointeur sur une méthode de T qui ne prend aucun paramètre et qui ne renvoie rien, or, tu essaye de créer une nouvelle instance de TimeFunction en ne lui passant... qu'un pointeur sur la méthode de l'objet...