J'ai deux classes :
La premiere est une classe R qui contient un constructeur par default, un par copie, un destructeur, un operateur d'affectation et deux methodes.
R.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
 
 #include "message.h"
 
class R {
 
 public:
  //Constructeur par default
  R();
  //Constructeur par copie
  R(const R &source);
  //Destructeur
  virtual ~R();
  //Operateur d'affectation
  virtual R& operator = (const R &source);
  //Methode de reception d'un message.
  void recevoir_msg(const Message *m);
 
 protected:
  //Methode de traitement d'un message.
  virtual void traiter_msg(const Message *m) = 0;
 
};
R.cpp :
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
 
#include "R.h"
 
R::R() {}
 
R::R(const R &source) {}
 
R::~R() {}
 
R& R::operator = (const R &source) { return *this; }
 
void R::recevoir_msg(const Message *m) {
  //Recevoir un message consiste juste à le traiter
  //et cela quelque soit le receveur. 
  traiter_msg(m);
}
La seconde est une classe E qui contient un constructeur par default, un par copie, un destructeur, un operateur d'affectation et trois methodes.
Elle a comme membre une liste de R* de la STL.
E.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
 
#include "message.h"
#include "R.h"
#include <list>
 
class E {
 
 public:
  //Constructeur par default
  E();
  //Constructeur par copie
  E(const E &source);
  //Destructeur
  virtual ~E();
  //Operateur d'affectation
  virtual E& operator = (const E &source);
  //Methode d'ajout d'un recepteur.
  void ajouter_recepteur(const R *recepteur);
  //Methode de suppression d'un recepteur.
  void supprimer_recepteur(const R *recepteur);
  //Methode d'envoi d'un message
  void envoyer_msg(const Message *m) const;
 
 private:
  //Liste des recepteurs
  std::list<R *> L_R;  
 
};
E.cpp
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
 
#include "E.h"
 
E::E() {}
 
E::E(const E &source):L_R(source.L_R) {}
 
E::~E() {}
 
E& E::operator = (const E &source) {
  if (this != &source) 
    L_R.assign((source.L_R).begin(),(source.L_R).end());
  return *this;
}
 
void E::ajouter_recepteur(const R *recepteur) {
  L_R.push_front(recepteur);
}
 
void E::supprimer_recepteur(const R *recepteur) {
  L_R.remove(recepteur);
}
 
void E::envoyer_msg(const Message *m) const {
  std::list<R *>::iterator iter;
  for (iter = L_R.begin(); iter != L_R.end(); iter++)
    (*iter)->recevoir_msg(m);
}
Un message est une structure.
message.h
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
//Declaration du type Message.
struct Message {
  int id;
  std::vector<float> tab;
};
//***************************
Avec ce code à la compilation, je me retrouve avec ce message d'erreur :

E.cpp: In member function «void E::ajouter_recepteur(const R*)»:
E.cpp:16: erreur: no matching function for call to «std::list<R*, std::allocator<R*> >::push_front(const R*&)»
/usr/lib/gcc/i486-linux-gnu/4.0.3/../../../../include/c++/4.0.3/bits/stl_list.h:743: note: candidats sont: void std::list<_Tp, _Alloc>::push_front(const _Tp&) [with _Tp = R*, _Alloc = std::allocator<R*>] <près d'une concordance>
E.cpp: In member function «void E::supprimer_recepteur(const R*)»:
E.cpp:20: erreur: no matching function for call to «std::list<R*, std::allocator<R*> >::remove(const R*&)»
/usr/lib/gcc/i486-linux-gnu/4.0.3/../../../../include/c++/4.0.3/bits/list.tcc:174: note: candidats sont: void std::list<_Tp, _Alloc>::remove(const _Tp&) [with _Tp = R*, _Alloc = std::allocator<R*>] <près d'une concordance>
E.cpp: In member function «void E::envoyer_msg(const Message*) const»:
E.cpp:25: erreur: no match for «operator=» in «iter = ((const E*)this)->E::L_R. std::list<_Tp, _Alloc>::begin [with _Tp = R*, _Alloc = std::allocator<R*>]()»
/usr/lib/gcc/i486-linux-gnu/4.0.3/../../../../include/c++/4.0.3/bits/stl_list.h:112: note: candidats sont: std::_List_iterator<R*>& std::_List_iterator<R*>::operator=(const std::_List_iterator<R*>&)
make: *** [E.o] Erreur 1
Est-ce que quelqu'un pourrait m'expliquer l'erreur que j'ai faite ?

Merci d'avance.