Salut a tous, en compilant mon projet j'obtient l'erreur :

"no match for 'operator=' in 'l->ListeAuteurs::it = ((const std::list<Auteur*, std::allocator<Auteur*> >*)l)->std::list<_Tp, _Alloc>::begin [with _Tp = Auteur*, _Alloc = std::allocator<Auteur*>]()'|"
L'erreur se situe dans le debut de fonction suivante :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
// affichage et saisie d'une liste d'auteurs
ostream & operator<< ( ostream & flux ,const ListeAuteurs & l )
{
    l.it=l.listeDesAuteurs.begin();  // Juste ici

    return (flux);
}
l est un conteneur contenant deux attributs privés :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
list<Auteur *> listeDesAuteurs; // conteneur des auteurs
list<Auteur *>::iterator it; // pour visiter la liste des auteurs
Pour ceux que ca interesse, je vous copie ici mon fichier. h et fichier .cpp

La specification :

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
114
115
116
117
118
119
120
121
122
123
124
125
126
#ifndef TP_AUTEUR_H_
#define TP_AUTEUR_H_
 
/*--- Inclusion des headers necessaires ---------------------------------*/
#include <list>
#include <string>
#include <fstream>
#include <iterator>
#include <iostream>
using namespace std;
 
//=========================================================================
// Classe Livre associee à la classe Auteur
//=========================================================================
 
class Livre
{
    private:
        string titre; // titre du livre
        string annee; // année de parution
    public:
        // constructeur par défaut et destructeur inline
        Livre(){}
        ~Livre() {} // inutile ici
 
        // opérateurs pour comparer des livres
        bool operator==(const Livre &) const;
        bool operator< (const Livre &) const; //Compare sur titres
        bool operator> (const Livre &) const; //Compare sur titres
 
        // pour créer un livre à partir du fichier
        int chargerUnLivre (ifstream &); //===========================================================================================
 
        // pour sauvegarder un livre dans le fichier
        void sauvegarderUnLivre(ofstream &) const;//==================================================================================
 
        // affichage et saisie d'un livre
        friend ostream & operator<<(ostream &,const Livre &);
        friend istream & operator>>(istream &,Livre &);
};
 
 
//=========================================================================
// Classe Auteur : Gestion des caracteristiques d' un auteur
//=========================================================================
 
class Auteur
{
    private:
        string Nom; // nom de l'auteur
        string Prenom; // Prenom de l'auteur
        string Nationalite; // Nationalité de l'auteur
        list<Livre> listeDesLivres; // conteneur des livres qu'il a écrit
        list<Livre>::iterator it; // itérateur pour visiter la liste
 
    public:
        // constructeurs et destructeur
        Auteur() {} //Constructeur par defaut
        Auteur (string n, string p, string nat) {Nom=n; Prenom=p; Nationalite=nat; } // Constructeur inline
        ~Auteur() { listeDesLivres.clear();} // Destructeur, supprime la liste des livres
 
        // opérateurs pour comparer des auteurs
        bool operator==(const Auteur &) const;
        bool operator!=(const Auteur &) const;
 
        // affiche les propriétés d'un auteur
        string getAuteur() const { return Prenom + " " + Nom; } // inline
 
        // ajout d'un livre à la liste des livres d'un auteur
        void ajouterUnLivre(const Livre &);
 
        // Recherche d'un livre
        Livre * rechercherUnLivre (const Livre &) ;//===========================================================================
 
 
        // sauvegarde d'un auteur et de ses livres dans le fichier
        void sauvegarderUnAuteur(ofstream &) ; //===============================================================================
 
        // restaurer un auteur depuis le fichier
        void chargerUnAuteur (ifstream &, int & i); // =========================================================================
 
        // affichage et saisie d'un auteur avec ses livres
        friend ostream & operator<< ( ostream & ,const Auteur & );
        friend istream & operator>> (istream & , Auteur & );
};
 
 
//=========================================================================
// Classe ListeAuteurs : Gestion d'une liste des Auteurs
//=========================================================================
 
class ListeAuteurs
{
    private:
        list<Auteur *> listeDesAuteurs; // conteneur des auteurs
        list<Auteur *>::iterator it; // pour visiter la liste des auteurs
 
    public:
        // constructeur par défaut et destructeur inline
        ListeAuteurs() {}
        ~ListeAuteurs() { listeDesAuteurs.clear(); }
 
        // ajout d'un auteur à la liste des auteurs
        void ajouterUnAuteur(Auteur *) ;
 
        // supprimer un auteur et la liste de ses livres
        bool supprimerUnAuteur(Auteur *);
 
        // rechercher un auteur dans la liste des auteurs
        Auteur * rechercherUnAuteur (const Auteur *);//===========================================================================
 
        // rechercher un livre dans l'ensemble de la liste des auteurs
        void rechercherUnLivre (const Livre &) ;//===========================================================================
 
        // sauvegarder la liste des auteurs dans le fichier
        void sauvegarderListeAuteur(char * Path);//===========================================================================
 
        // restaurer la liste des auteurs depuis le fichier
        void chargerListeAuteur (char * Path);//===========================================================================
 
        // affichage et saisie d'une liste d'auteurs
        friend ostream & operator<< ( ostream & ,const ListeAuteurs & );
        friend istream & operator>> (istream & , ListeAuteurs & );
};
 
#endif







Et l'implementation
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
//=========================================================================
// Classe Livre associee à la classe Auteur
//=========================================================================
 
//=============== opérateurs pour comparer des livres =====================
 
bool Livre::operator==(const Livre & livre2) const
{
    return ((livre2.annee==annee)&&(livre2.titre==titre));
}
 
bool Livre::operator<(const Livre & livre2) const
{
    return((livre2.titre>titre)? true : false);
}
 
bool Livre::operator>(const Livre & livre2) const
{
    return((livre2.titre<titre)? true : false);
}
 
//================ affichage et saisie d'un livre =========================
 
ostream & operator<<(ostream & flux,const Livre & bouquin)
{
    flux<<"==== Informations du Livre ====="<<endl;
    flux<<"Titre du livre : "<<bouquin.titre<<endl;
    flux<<"Annee de parution : "<<bouquin.annee<<endl;
    return flux;
}
 
istream & operator>>(istream & flux,Livre & bouquin)
{
    cout << "\n Saisir le titre : ";
	flux >> bouquin.titre;
	cout << "\n Saisir l'annee de parution : ";
	flux >> bouquin.annee;
	return flux;
}
 
 
 
//=========================================================================
// Classe Auteur : Gestion des caracteristiques d' un auteur
//=========================================================================
 
//============ opérateurs pour comparer des auteurs =======================
 
bool Auteur::operator==(const Auteur & auteur) const
{
    return ((auteur.Nom==Nom)&&(auteur.Prenom==Prenom));
}
 
 
bool Auteur::operator!=(const Auteur & auteur) const
{
    return (!(auteur==(*this)));
}
 
//========== affichage et saisie d'un auteur avec ses livres ==============
 
ostream & operator<< ( ostream & flux ,const Auteur & auteur )
{
    flux<<"===== Informations de l'auteur ====="<<endl;
    flux<<"Nom : "<<auteur.Nom<<endl;
    flux<<"Prenom : "<<auteur.Prenom<<endl;
    flux<<"Nationalite : "<<auteur.Nationalite;
    return flux;
}
 
istream & operator>> (istream & flux , Auteur & auteur)
{
    cout<<"Saisir le Nom : "<<endl;
    cin>>auteur.Nom;
    cout<<"Saisir le Prenom : "<<endl;
    cin>>auteur.Prenom;
    cout<<"Saisir la Nationalite : "<<endl;
    cin>>auteur.Nationalite;
    return flux;
}
 
void Auteur::ajouterUnLivre(const Livre & bouquin)
{
    (*this).listeDesLivres.push_front(bouquin);
    //auteur>ListeDeSesLivre>on y ajoute : bouquin
    // ajouter un tri?
}
 
Livre * Auteur::rechercherUnLivre(const Livre & bouquin)
{
    for (it=listeDesLivres.begin();it!=listeDesLivres.end();it++)
        if ((*it)==bouquin) return (&(*it));
    //if(it==listeDesLivres.end()) Gerer une exception pour quitter la fonction
}
 
 
//=========================================================================
// Classe ListeAuteurs : Gestion d'une liste des Auteurs
//=========================================================================
 
 
// ajout d'un auteur à la liste des auteurs
 
void ListeAuteurs::ajouterUnAuteur(Auteur * ecrivain)
{
    (*this).listeDesAuteurs.push_back(ecrivain);
    //ListeDesAuteur(conteneur principale)>listeDesAuteurs>on y ajoute : ecrivain
}
 
// supprimer un auteur et la liste de ses livres
 
bool ListeAuteurs::supprimerUnAuteur(Auteur *)
{
    (*this).listeDesAuteurs.clear();
    return ((*this).listeDesAuteurs.empty());
}
 
// rechercher un auteur dans la liste des auteurs
Auteur * rechercherUnAuteur (const Auteur *);
 
// rechercher un livre dans l'ensemble de la liste des auteurs
void rechercherUnLivre (const Livre &) ;
 
// sauvegarder la liste des auteurs dans le fichier
void sauvegarderListeAuteur(char * Path);
 
// restaurer la liste des auteurs depuis le fichier
void chargerListeAuteur (char * Path);
 
// affichage et saisie d'une liste d'auteurs
ostream & operator<< ( ostream & flux ,const ListeAuteurs & l )
{
    l.it=l.listeDesAuteurs.begin();
 
    return (flux);
}
istream & operator>> (istream & , ListeAuteurs & );
Je vous remercie par avance.

Guillaumec38