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 : 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
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
error C2512: 'Naos::TimeFunction' : aucun constructeur par défaut approprié disponible
Sur la ligne
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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