Discussion :

[prsieux]

bonjour j'ai un probléme de compilation

voila le messages

prsieux@prsieux-laptop:~/info/Project/Jeux/Pong$ g++ -c InitEngine.o InitEngine.cpp
Engine.hpp: In member function «Engine& Engine::operator=(const Engine&)»:
Engine.hpp:11: erreur: non-static reference member «EventGestion& Engine::EventBoucleMain», can't use default assignment operator
InitEngine.cpp: In constructor «InitEngine::InitEngine()»:
InitEngine.cpp:20: note: synthesized method «Engine& Engine::operator=(const Engine&)» first required here

voila le code

InitEngine.hpp

#ifndef _INIT_ENGINE_HPP_
#define _INIT_ENGINE_HPP_

#include <vector>

#include "EventGestion.hpp"
class Engine;
/*
Cette classe vas initialisé tout les moteur du jeux
*/
class InitEngine
{
public:
InitEngine();
~InitEngine();

protected:
EventGestion EventBoucle;
std::vector<Engine> TabEngine;


};

#endif //end _INIT_ENGINE_HPP_

InitEngine.cpp

#include <vector>

#include "InitEngine.hpp"
#include "EventGestion.hpp"
#include "Engine.hpp"
/*
#include "EngineGraphics.hpp"
#include "EnginePhy.hpp"
#include "EngineIn.hpp"
*/

InitEngine::InitEngine()
{
const int numberEngine = 3;


EventBoucle;
TabEngine.reserve(numberEngine);

TabEngine[0] = Engine(EventBoucle);
TabEngine[1] = Engine(EventBoucle);
TabEngine[2] = Engine(EventBoucle);

EventBoucle.addrEngine(TabEngine);
EventBoucle.main();
}

InitEngine::~InitEngine()
{
}

et Engine.hpp les autres ne pose pas de probléme

#ifndef _ENGINE_HPP_
#define _ENGINE_HPP_

#include <queue>

//#include "MsgEngine.hpp"
#include "EventGestion.hpp"


class Engine
{
public:
Engine(EventGestion& EventBoucle);
// bool DealMsg(MsgEngine& MsgDeal);



protected:
EventGestion& EventBoucleMain;
// std::queue<MsgEngine> MsgEngineQueue;
// bool AddMsg(MsgEngine& MsgAdd);
};

#endif // end _ENGINE_HPP_

si je met EventGestion& EventBoucleMain static sa compile mais sa me sert a rien de le maitre en static. Et je voudrait eviter un pointeur mais je veut pas copier l'objet.

[vdumont]

Code :

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

EventBoucle;

?


En gros tu n'as pas d'instance de la classe EventBoucle, tu fais simplement appeler EventBoucle.main() et EventBoucle.addrEngine, donc tu fais des appels static aux méthodes et c'est ce que le compilateur te spécifie, pour faire des appels comme ca il faut que tes méthodes soient statiques. Si ce n'est pas ce que tu veux, il faut que tu t'insancie un objet de la classe EventBoucle.

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
InitEngine.cpp
Citation:
#include <vector>
 
#include "InitEngine.hpp"
#include "EventGestion.hpp"
#include "Engine.hpp"
/*
#include "EngineGraphics.hpp"
#include "EnginePhy.hpp"
#include "EngineIn.hpp"
*/
 
InitEngine::InitEngine()
{
const int numberEngine = 3;
 
 
EventBoucle eb;
TabEngine.reserve(numberEngine);
 
TabEngine[0] = Engine(eb);
TabEngine[1] = Engine(eb);
TabEngine[2] = Engine(eb);
 
eb.addrEngine(TabEngine);
eb.main();
}
 
InitEngine::~InitEngine()
{
}

Note bien qu'il faut que tu aies un constructeur d'Engine qui accepte un EventBoucle en argument

[screetch]

euh certes. enfin la vraie erreur specifiée, c'est que tu n'as pas créé d'operateur de copie pour la classe Engine. Du coup le compilateur va en générer une automatiquement et il n'y arrive pas car tu as un de tes membres qui est une référence. on ne peut pas copier une référence (on ne peut pas la reinitialiser a autre chose) donc ca ne marche pas.

Tu utilises cet operateur = a la ligne

Code :

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

TabEngine[0] = Engine(eb);

Soit tu travailles ici avec des pointeurs pour ne pas faire de recopie, soit tu specifies un operateur de recopie toi même.

[prsieux]

merci pour vos je vais definir le = ensuite EventBoucle et definit dans InitEngine.hpp
ligne 18 : EventGestion EventBoucle;

[vdumont]

Oh j'avais pas vu. Alors ouais fait seulement définir ton constructeur de copie (ou vas y par pointeur).

[corrector]

Oh j'avais pas vu. Alors ouais fait seulement définir ton constructeur de copie (ou vas y par pointeur).

Mais le constructeur par copie est généré par le compilateur, sans problèmes.

C'est l'affectation que le compilateur ne sait pas faire (à cause de la référence, qui n'est pas ré-affectable).

D'ailleurs, qu'est-ce qu'un opérateur d'affectation de la classe Engine défini par l'utilisateur devrait faire au juste?