Problèmes de compréhension avec les fonctions 'virtual'

Version imprimable

Bonjour,

je suis en train de construire un ensemble de classes comportant des classes dérivées.

J'ai une classe 'MCODE_Module', de laquelle je dérive une classe 'MCODE_Camera'.

Dans MCODE_Module, je définis deux fonctions (disons MaFonctionA et MaFonctionB) comme:
Code:

1 2 3 4 5 6 7 8 9 10 11 virtual short MaFonctionA(int param1, int *param 2) { //...(opérations diverses) return SUCCESS; }; virtual short MaFonctionB(int param1, int *param 2) { //...(opérations diverses) return SUCCESS; };
Dans ma classe MCODE_Camera, j'override MaFonctionB:
Code:

1 2 3 4 5 6 7 virtual short MaFonctionB(int param1, int *param 2) { ... MaFonctionA(param1, param2); ... return SUCCESS; };
Le problème est que lorsque je passe sur l'exécution de MaFonctionA, rien n'a l'air de se passer.

En plus, si je mets un point d'arrêt dans MaFonctionA, à l'exécution en mode Debug, VS me dit qu'aucun code ne fait appel à cette fonction et donc le point d'arrêt est désactivé (cercle rouge avec un point d'exclamation).

De toute évidence y'a un truc que j'ai pas compris...

Merci d'avance à celui (ceeux) qui pourrai(en)t m'éclairer.

Gorgo Treize.

25/11/2012, 20h01
Neckara

Bonjour,

Pourrais-tu nous montrer :
- les deux headers complets ;
- la fonction dans laquelle tu tente d'appeler la méthode A.

Bonsoir Neckara, merci pour l'intervention... voici la source pour MCODE_Module (désolé je mets tout, c'est un peu long et pas utile, mais bon...):

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
class MCODE_Module
{
public:
	///< Constructor Function: MCODE_Module
	MCODE_Module(MCODE_LogManager *Log = NULL,CHAR* Name = "NoName\0",CHAR* ConfigFileName = NULL);
 
	///< Destrcutor Function: ~MCODE_Module
	virtual ~MCODE_Module();
 
public:
	typedef struct _MCODE_Plug
	{
		INT32 ID;
		MCODE_Module *pModule;
		struct _MCODE_Plug *pPrev;
		struct _MCODE_Plug *pNext;
	} MCODE_Plug;
 
	MCODE_Plug PluggedInModule;
	MCODE_Plug PluggedToModule;
 
	INT32 test;
 
protected:
	MCODE_LogManager *Log;
	CHAR LogMessage[512];
	CHAR ModuleClass[64];
	CHAR ModuleName[64];
 
	INT16 LinkStatus;
 
public:
	virtual INT16 GetLinkStatus();			///< Returns the MCODE_LinkStatus state
	virtual INT16 LinkModule();				///< Links the module to the main application
	virtual INT16 UnlinkModule();			///< Unlinks the module to the main application
	virtual CHAR* GetModuleClass();
	virtual CHAR* GetModuleName();
	virtual INT16 PlugTo(MCODE_Module *Module);
	virtual INT16 GetPlugPermission(MCODE_Module *Module);
 
public:
	virtual INT16 AddPluggedInModule(MCODE_Module *Module);
	virtual INT16 RemovePluggedInModule(MCODE_Module *Module);
 
	virtual INT16 AddPluggedToModule(MCODE_Module *Module);
	virtual INT16 RemovePluggedToModule(MCODE_Module *Module);
};

Voici la source pour MCODE_Camera:

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
class MCODE_Camera : public MCODE_Module
{
public:
	///< Constructor Function: MCODE_Module
	MCODE_Camera(MCODE_LogManager *Log = NULL, CHAR _ModuleName[64] = "NoName\0");
 
	///< Destrcutor Function: ~MCODE_Module
	virtual ~MCODE_Camera();
 
public:
	HANDLE hAcquisitionDone;
 
protected:		// CAN BE ACCESSED BY DERIVED CLASSES
	struct _SensorCommons
	{
		enum		Type { CCD, EMCCD, CMOS, sCMOS };
		string		CameraName;
		string		CameraModel;
		string		SerialNumber;
		string		FirmwareVersion;
		string		DriverVersion;
		INT32		PhysicalXSize;
		INT32		PhysicalYSize;
		FLOAT64		PixelSizeX_um;
		FLOAT64		PixelSizeY_um;
		FLOAT64		ElectronsPerADU;
		FLOAT64		FullWellCapacity;
		INT32		MaxADU;
		INT32		BitsPerPixel;
		FLOAT64		ReadoutNoise;
		INT32		ActiveXSize_min;
		INT32		ActiveXSize_max;
		INT32		ActiveYSize_min;
		INT32		ActiveYSize_max;
		FLOAT64		Exptime_ms_min;
		FLOAT64		Exptime_ms_max;
	} SensorCommons;
 
	typedef struct _ThreadParams_CameraOperation
	{
		bool		bEndThread;
		HANDLE		hTerminateThread;
		HANDLE		hThreadCreated;
 
		HANDLE		hStartAcquisition;
		HANDLE		hSoftwareTrigger;
		INT32		XStart;
		INT32		YStart;
		INT32		DX;
		INT32		DY;
		INT32		BinX;
		INT32		BinY;
		FLOAT64		ExpTime_ms;
		INT32		FrameType;
		INT32		RunMode;
		INT32		TimeResolution_ms;
		INT32		FrameCounter;
		INT32		TotalFrames;
	} ThreadParams_CameraOperation;
 
	ThreadParams_CameraOperation TP_CameraOperation;
	DWORD Thread_CameraOperationID;
	HANDLE hThread_CameraOperation;
 
	HANDLE hAbortAcquisition;
 
	enum enumFrameType { MCODE_FRAMETYPE_BIAS, MCODE_FRAMETYPE_DARK_ONLY, MCODE_FRAMETYPE_DARK_AND_LIGHT, MCODE_FRAMETYPE_LIGHT };
 
	enum enumRunMode { MCODE_RUNMODE_SYNCHRONOUS, MCODE_RUNMODE_ASYNCHRONOUS, MCODE_RUNMODE_SW_TRIGGER, MCODE_RUNMODE_HW_TRIGGER };
 
	enum enumCameraState { MCODE_CAMERA_STATE_IDLE, MCODE_CAMERA_STATE_EXPOSING, MCODE_CAMERA_STATE_READOUT, MCODE_CAMERA_STATE_DOWNLOADING };
 
	bool bConnected;
 
	INT32 CameraState;
 
	bool bFlushSensor;
 
	bool bAcquisitionAborted;
 
// PUBLIC METHODS
public:
	virtual INT16 Connect();
	virtual INT16 ReConnect();
	virtual INT16 Disconnect();
 
	virtual bool IsConnected();
	virtual INT16 AcquireFrame(FLOAT64 ExpTime,INT32 NumFrames = 1,
		INT32 FrameType = MCODE_FRAMETYPE_LIGHT,INT32 _RunMode = MCODE_RUNMODE_SYNCHRONOUS);
	virtual INT16 AbortAcquisition();
	virtual INT16 WaitForAcquisitionDone();
 
	virtual INT16 PlugTo(MCODE_Module *Module);
	virtual INT16 GetPlugPermission(MCODE_Module *Module);
 
protected:
	virtual INT16 StartThread_CameraOperation();
	virtual INT16 EndThread_CameraOperation();
 
	DWORD Thread_CameraOperation();
	static DWORD WINAPI Thread_CameraOperation(void *pParam);
 
	virtual INT16 GetSensorParameters();		// GET ALL AVAILABLE CAMERA PARAMETERS TO FILL THE Sensor STRUCTURE.
	virtual INT16 StartExposure(FLOAT64 ExpTime_ms,INT32 FrameType);
	virtual INT16 AbortExposure();
	virtual bool CanFlush();
	virtual bool DoAbort();
};

Voici les codes de la fonction MCODE_Camera:: PlugTo,

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
INT16 MCODE_Camera::PlugTo(MCODE_Module *Module)
{
	if (strcmp(Module->GetModuleClass(),"MCODE_DataDisplay") == 0)
	{
		if (Module->GetPlugPermission(this) == SUCCESS)
		{
			this->AddPluggedToModule(Module);
 
			sprintf_s(LogMessage,sizeof(LogMessage),"[%s]::%s, plugged to MCODE_DataDisplay module successfully.",
				this->ModuleClass,__FUNCTION__);
			Log->StackAddMsg(LOG_INFORMATION,0,__LINE__,__FILE__,LogMessage);
		}
		else
		{
			sprintf_s(LogMessage,sizeof(LogMessage),"[%s]::%s, module %s did not grant permission to be plugged in.",
				this->ModuleClass,__FUNCTION__,Module->GetModuleClass());
			Log->StackAddMsg(LOG_WARNING,0,__LINE__,__FILE__,LogMessage);
			return WARNING;
		}
	}
 
	MCODE_Module::PlugTo(Module);
 
	return SUCCESS;
}

et la fameuse fonction qui ne semble pas s'exécuter MCODE_Module:: AddPluggedToModule,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
INT16 MCODE_Module::AddPluggedToModule(MCODE_Module *Module)
{
	MCODE_Plug *ptr = &this->PluggedToModule;
	MCODE_Plug *tmp = NULL;
 
	while(ptr->pNext != NULL)
	{
		ptr = ptr->pNext;
	}
 
	ptr->pNext = new MCODE_Plug;
	tmp = ptr;
	ptr = ptr->pNext;
	ptr->pPrev = tmp;
	ptr->pModule = Module;
	ptr->pNext = NULL;
 
	return SUCCESS;
}

Merci. G.T.

25/11/2012, 21h02
Neckara

Je pense avoir compris ton problème.

Ta méthode plugTo est défini dans ta classe mère et tu veux la réutiliser dans ta classe fille.
Or tu dis dans ta classe fille que tu va redéfinir plugTo (l.93) et tu ne donne pas de nouvelle implémentation (?).
Lors d'un héritage, la classe fille hérite de tous les membres non-privés de la classe mère.

Virtual sert à dire : si tu vois un pointeur sur A / référence sur A, n'utilise pas la méthode de A mais execute celle de l'objet pointé (qui peut être un A ou une instance d'une classe héritant de A).
25/11/2012, 21h19
Gorgo13

Neckara,

Citation:

Envoyé par Neckara

Ta méthode plugTo est défini dans ta classe mère et tu veux la réutiliser dans ta classe fille.
Or tu dis dans ta classe fille que tu va redéfinir plugTo (l.93) et tu ne donne pas de nouvelle implémentation (?).

Si si, le code que j'ai donné pour PlugTo est bien celui redéfini dans la classe fille (MCODE_Camera).

Lorsque je debug, je peux tracer le code source sans problème dans 'PlugTo' de MCODE_Camera.
C'est au niveau de AddPluggedToModule que ça coince: si je fais un F11 alors que je suis à la ligne 7 de MCODE_Camera:: PlugTo (3ième fenêtre code de mon message), impossible d'entrer dans la fonction AddPluggedToModule, qui retourne tout de suite sans que rien ne se passe.

Je n'arrive pas à comprendre: y a-t-il des contraintes à utiliser une fonction d'une classe mère (non 'overridée' dans la classe fille, ici AddPluggedToModule) dans une fonction overridée d'une classe fille (ici PlugTo)?

G. 13.

Citation:

Envoyé par Gorgo13

Si si, le code que j'ai donné pour PlugTo est bien celui redéfini dans la classe fille (MCODE_Camera).

Autant pour moi.

J'ai essayé de faire un code minimal :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include<iostream> class A { public : virtual void foo(void){} virtual void toto(void){ std::cout << "marche" << std::endl; } }; class B : public A { public : virtual void foo(void){ this->toto(); } }; int main(void) { B * b = new B(); b->foo(); return 0; }
Mais il marche bien.
Est-ce que j'ai oublié quelque chose?

Essaye de me passer un code minimal (une seule page) qui ne marche pas chez toi et j'essayerais de le compiler demain.

25/11/2012, 22h01
Gorgo13

Oui ça a bien l'air de correspondre à mon cas... OK je vais essayer de faire un code minimal qui ne marche pas.

Merci. Gorgo 13
26/11/2012, 09h26
Bousk

Bonjour,

comment est appelé la méthode ?
Tu n'aurais tout de même pas fait une copie dans un MCODE_Module de ton objet réel ? :aie:
26/11/2012, 09h44
Gorgo13

Bonjour,

en fait je crois que c'est plus un problème de Visual Studio que du code lui-même. En revérifiant j'ai constaté que le code était bien exécuté, mais que je n'arrive ni à tracer dans le code source en mode debug, ni à faire fonctionner le 'intellisense' (autocompletion) pour le MCODE_Module...

Je suis en train de chercher.

G13
26/11/2012, 10h23
Bousk

Si le "problème" est de ne pas pouvoir faire de breakpoint, oui ça peut venir uniquement de l'IDE.
Mais dans ce cas un simple cout et tu seras fixé..
Ca arrive parfois sur des fonctions template ou implémentées dans un header.
26/11/2012, 10h45
Gorgo13

Ca y est, j'ai réolu le problème, qui était bien celui de mon projets sous VS2010. J'ai supprimé et recréé le sous-projet MCODE_Module, et ça a suffi à résoudre le pb.

Bizarrement, le problème venait aussi du fait que je n'avais pas déclaré la librairie relative à ce sous-projet dans mon code test (j'utilise les directives #pragma comment(lib,<nom librairie>): lorsque j'ai effectué l'opération de suppression/rajout du sous-projet MCODE_Module, j'ai vu soudain apparaître plein d'erreurs LNK2001 relatives à MCODE_Module dans mon projet test.

Bref j'ai dû faire une fausse manip dans les configs de projet...

Merci à vous pour les réponses.

G. Treize.