Probléme de compilation

bonjour j'ai un probléme de compilation

voila le messages

Citation:

---

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

Citation:

---

#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

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;
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

Citation:

---

#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.

Code:

---

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:

---

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

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:

---

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.

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

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

Citation:

---

Envoyé par vdumont

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?