Discussion :

[guillaumec38]

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

[guillaumec38]

PS : en retirant le const des parametres, je perd l'erreur.
Une explication ?

[3DArchi]

Bonjour et bienvenu,
En préambule, pourquoi utiliser une liste de pointeur? C'est souvent source de problèmes.

Pour répondre strictement à ta question, si je reprend ton code :

Code :

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

1
2
3
4
5
6
7
 
ostream & operator<< ( ostream & flux ,const ListeAuteurs & l )
{
    l.it=l.listeDesAuteurs.begin();  // Juste ici
 
    return (flux);
}

Si tu déclares 'l' comme const, alors tu ne peux le modifier. C'est pourquoi le compilateur râle quant tu essaies de modifier 'l.it'.

D'ailleurs, une autre remarque, on ne s'attend pas à ce que l'opérateur '<<' sur le flux modifie le paramètre. Donc ta première version avec const est la bonne. Tu as un problème de conception à vouloir modifier l dans cette méthode !

Autre remarque : il est très étrange de maintenir un itérateur dans ListeAuteurs. C'est courir un bien grand risque d'erreur car dès que ta liste sera modifiée, l'itérateur ne sera plus valide.

[guillaumec38]

Merci beaucoup pour ta réponse. Tu as brillamment resolu mon probleme.
Concernant tes conseil je ne peux pas les suivre, c'est mon prof de C++ qui a fait le sujet, et je pense laisser tomber cette fonction, car je ne vois pas comment afficher tout mon conteneur sans me servir de mon iterateur.

Je me suis rendu compte de pas mal d'autres aussi aussi XD.

Enfin bref merci a toi, j'avais pas trop réalisé le problème du const.

A bientot.

[koala01]

Merci beaucoup pour ta réponse. Tu as brillamment resolu mon probleme.
Concernant tes conseil je ne peux pas les suivre, c'est mon prof de C++ qui a fait le sujet, et je pense laisser tomber cette fonction, car je ne vois pas comment afficher tout mon conteneur sans me servir de mon iterateur.

Ben, de manière assez simple, en utilisant un iterateur externe

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
 
ostream & operator<< ( ostream & flux ,const ListeAuteurs & l )
{
    /* ou begin() est une méthode constante renvoyant un const_iterator
     * sur le début de la liste
     * et ou end() renvoye un const_iterator sur... ce qui suit le dernier
     */
    /*la méthode itérative */
    for(std::list<typeApproprie>::const_iterator it=l.begin();it!=l.end();++it)
        flux<<(*it);
    /* ou la méthode "sympa", pour laquelle je suis pris d'un doute :D */
    std::copy( l.begin(), l.end, std::ostream_iterator<int>(flux, " "));
 
 
 
    return (flux);
}