Initialisation Variable Statique

**mulfycrowh** · 13/01/2013, 23h53

Bonjour,

J'ai deux classes : TTimer et pedal dont voici les headers:

template_timer.h

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
#pragma once
#include <atlbase.h>
 
static void CALLBACK TimerProc(void*, BOOLEAN);
 
// **********************************************************
// * class CTimer 											*
// **********************************************************
class CTimer
{
public:
    CTimer()
    {
        m_hTimer = NULL;
        m_mutexCount = 0;
    }
 
    virtual ~CTimer()
    {
        Stop();
    }
 
    bool Start(unsigned int interval,   // interval in ms
               bool immediately = false,// true to call first event immediately
               bool once = false)       // true to call timed event only once
    {
        if( m_hTimer )
        {
            return false;
        }
 
        SetCount(0);
 
        BOOL success = CreateTimerQueueTimer( &m_hTimer,
                                              NULL,
                                              TimerProc,
                                              this,
                                              immediately ? 0 : interval,
                                              once ? 0 : interval,
                                              WT_EXECUTEINTIMERTHREAD);
 
        return( success != 0 );
    }
 
    void Stop()
    {
        DeleteTimerQueueTimer( NULL, m_hTimer, NULL );
        m_hTimer = NULL ;
    }
 
    virtual void OnTimedEvent()
    {
        // Override in derived class
    }
 
    void SetCount(int value)
    {
        InterlockedExchange( &m_mutexCount, value );
    }
 
    int GetCount()
    {
        return InterlockedExchangeAdd( &m_mutexCount, 0 );
    }
 
private:
    HANDLE m_hTimer;
    long m_mutexCount;
};
 
// **********************************************************
// * TimerProc    											*
// **********************************************************
void CALLBACK TimerProc(void* param, BOOLEAN timerCalled)
{
    CTimer* timer = static_cast<CTimer*>(param);
    timer->SetCount( timer->GetCount()+1 );
    timer->OnTimedEvent();
};
 
// **********************************************************
// * template class TTimer									*
// **********************************************************
template <class T> class TTimer : public CTimer
{
public:
    typedef private void (T::*TimedFunction)(void);
 
    TTimer()
    {
        m_pTimedFunction = NULL;
        m_pClass = NULL;
    }
 
    void SetTimedEvent(T *pClass, TimedFunction pFunc)
    {
        m_pClass         = pClass;
        m_pTimedFunction = pFunc;
    }
 
protected:
    void OnTimedEvent()  
    {
        if (m_pTimedFunction && m_pClass)
        {
            (m_pClass->*m_pTimedFunction)();
        }
    }
 
private:
    T *m_pClass;
    TimedFunction m_pTimedFunction;
};

pedal.h

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
#pragma once
 
#include <string>
 
#include "toolbox.h"
#include "template_timer.h"
#include "const_pedal.h"
#include "tserial_event.h"
#include "enumser.h"
 
class pedal
{
public:
 
	void													enumerate(void);
	void													activate(void);
	bool													search_pedal_port(void);
	void													deactivate(void);
 
	static char*											reply_iss_version;
	static char*											reply_serial_number;
	static char*											reply_configuration;
	static char*											reply_io_state;
 
	// state comes with UP or DOWN
	static bool												pedal_state;
 
 
private:
 
	void                                                    wait_for_reply(void);
	void													OnTimedEvent_PedalReply(void);
	void													OnTimedEvent_PedalRequest(void);
	void													OnTimedEvent_PedalEnumeration(void);
	// the callback function has to be a static one if any class member !
	static void												SerialEventManager(uint32 object, uint32 event);
	static void												OnDataArrival(int size, char *buffer);
	static void												todo_on_pedalchange(void);
	void													request_iss_version(void);
	void													request_pedal_state(void);
	void													request_serial_number(void);
	void													configure_io_mode(void);
 
 
	TTimer<pedal>											timer_pedal_request;
	static TTimer<pedal>									timer_pedal_reply;
	TTimer<pedal>											timer_pedal_enumeration;
 
	static char*											serial_number;
	static std::string 										firmware_revision_number;
	// status comes with OK or not 
	static bool												pedal_status;
 
	static bool												iss_version_received;	
	static bool												io_mode_received;
	static bool												pedal_state_received;
	static bool												pedal_state_mem;
	static bool												first_pedalrequest;
	bool													pedalreply_timeelapsed;
 
 
};

La variable timer_pedal_reply est statique car utilisée dans un callback.
Je ne vois pas comment l'initialiser pour que celà passe à l'édition de lien.

Merci pour votre aide

**Bousk** · 14/01/2013, 00h24

Bonjour,

dans le .cpp :

Code :

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

bool pedal::pedal_state = 0;

**mulfycrowh** · 14/01/2013, 00h44

Je ne parle pas de pedal_state mais de timer_pedal_reply ...

**Iradrille** · 14/01/2013, 01h06

Envoyé par mulfycrowh

template_timer.h

Code :

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

1
2
3
4
5
6
7
8
9
...
// **********************************************************
// * template class TTimer									*
// **********************************************************
template <class T> class TTimer : public CTimer
{
public:
    typedef private void (T::*TimedFunction)(void);
...

Hello,

ton typedef est chelou, jamais vu un typedef avec un private dedans (compile pas sous gcc 4.8 en tout cas), de plus le "T::" je vois pas trop comment l'interpréter (j'ai toujours eu de mal avec la syntaxe des pointeurs sur fonctions.)

Mais en le remplaçant par :
typedef void (*TimedFunction)(void);

J'ai pas de problèmes de link, un simple
TTimer<pedal> pedal::timer_pedal_reply;
dans pedal.cpp, comme pour tout membre static suffit.

**koala01** · 14/01/2013, 04h14

salut;

Envoyé par Iradrille

de plus le "T::" je vois pas trop comment l'interpréter (j'ai toujours eu de mal avec la syntaxe des pointeurs sur fonctions.)

En fait, typedef void (T::*TimedFunction)(void);indique que l'on aura un pointeur sur une fonction membre de T qui sera connue comme ne prenant aucun argument et ne renvoyant aucune valeur sous le nom de TimedFunction

C'est presque comme les pointeurs de fonctions "classiques" si ce n'est que c'est pour les fonctions membes de classe, car les uns (les pointeurs de fonctions classiques) ne peuvent pas être utilisés les autres (les pointeurs de fonctions membres) ni inversement

Ceci dit, en beau C++, on préférerais sans doute utiliser un fonctieur, voir, si on dispose de C++ de la fantastique class function, disponible (comme tout ce qui est fournit en standard) dans l'espace de noms std par inclusion de <functionnal>

**Bousk** · 14/01/2013, 10h16

Envoyé par mulfycrowh

Je ne parle pas de pedal_state mais de timer_pedal_reply ...

Exactement de la même manière puisque timer_pedal_reply n'est pas template.

Il est de toutes façons déjà initialisé avec le constructeur par défaut.

**mulfycrowh** · 14/01/2013, 11h32

Lorsque j'initialise à 0, j'obtiens naturellement cette erreur de compil :

error C2440: 'initializing' : cannot convert from 'int' to 'TTimer<T>'

Ce n'est donc pas la solution.
Il est nécessaire d'initialiser la variable car elle est statique sinin ne passe pas à l'édition de lien

**Bousk** · 14/01/2013, 12h32

Ta variable est un TTimer<pedal> dont effectivement si tu essayes de l'initialiser avec une affectation d'un int, c'est une double erreur.
L'initialisation d'un objet c'est via le constructeur.
Et static ou pas, un objet a toujours un appel à son constructeur par défaut qui est fait. L'initialisation n'est nécessaire que si
- tu veux utiliser un constructeur avec des paramètres (autres que les paramètres par défaut).
- ne possède pas de constructeur par défaut (par extension au premier point)
Ton problème à l'édition des liens n'est en rien lié au statut static de la variable.

**mulfycrowh** · 14/01/2013, 14h20

Lorsque la variable n'est pas static le programme compile très bien.
Lorque je la déclare en static la compil donne :

1>pedal.obj : error LNK2001: unresolved external symbol "private: static class TTimer<class pedal> pedal::timer_pedal_reply" (?timer_pedal_reply@pedal@@0V?$TTimer@Vpedal@@@@A)
1>E:\C & M Project\Project.exe : fatal error LNK1120: 1 unresolved externals

**white_tentacle** · 15/01/2013, 10h51

Tu l’as rajoutée dans le .cpp comme te l’a suggéré Bousk ?

**mulfycrowh** · 15/01/2013, 11h23

Oui tout à fait.
Je pense que je vais rendre la méthode call back non static

**mulfycrowh** · 15/01/2013, 12h20

J'ai réussi à passer le callback en non static en utilisant une fonction wrapper et un pointeur local sur la classe.
Je peux donc utiliser ce pointeur pour appeler mes méthodes et mes attributs qui n'ont plus besoin d'être static.

Initialisation Variable Statique

Langage C++

Discussions similaires

Partager

Partager