map< string, map<string, vector<float> > >

**dauphin11** · 09/11/2011, 18h40

Bonjour

J'ai besoin d'utiliser une map de map mais j'ai bcp de soucis à la compilation; avec l'itérateur de map< string, map<string, vector<float> > >, et aussi pour accéder aux éléments du vector<float>>...

Voici mon code:

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
#include <fstream>
#include <string> 
#include <iostream>
#include <map>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <iterator>
using namespace std;

vector<float> notes;
vector<string> noms;
vector<string> matieres;
typedef  map < string, vector<float> >  mapstrvect;

typedef map < string, mapstrvect > Nom_Notes_mat;

string nom;
string matiere;
float note;

int s = sizeof(matieres);
int t = sizeof(noms);
vector< vector<float> > synthese((s+1)*(t+1));

void afficher_synthese() {

  map<string,mapstrvect>::iterator itn=Nom_Notes_mat.begin();
  for(;itn!= Nom_Notes_mat.end();++itn){
    if ( (*itn).first == ((*(itn++)).first) && ((*itn).second).first == (((*(itn++)).second))).first))
    ((*itn).second).push_back( ( (*itn++).second ).second );
    Nom_Notes_mat.erase(itn++);}

for(int j=0;j<t+1;++j){
  for(int i=0;i<s;++i){
    vector<float> v1 = (Nom_Notes_mat[matieres[j]])[noms[i]];
    int size = s*t;
    string mat = matieres[j];
    string name = noms[i];
    int l = 0;
    float sum;
	
    for (int k=0; k<size; k++){
      sum = sum+ ((Nom_Notes_mat[mat])[name])[k];
      l++;}
    float moy = sum/l;
  }
 }
}

J'obtiens les erreurs suivantes:

In function ‘void afficher_synthese()’:
forum.cpp:32:53: error: expected primary-expression before ‘.’ token
forum.cpp:33:27: error: expected primary-expression before ‘.’ token
forum.cpp:34:64: error: ‘class std::map<std::basic_string<char>, std::vector<float> >’ has no member named ‘first’
forum.cpp:34:95: error: expected primary-expression before ‘.' token
forum.cpp:36:18: error: expected unqualified-id before ‘.’ token
forum.cpp:40:50: error: size of array has non-integral type ‘std::basic_string<char>’
forum.cpp:40:50: error: size of array has non-integral type ‘std::basic_string<char>’
forum.cpp:40:38: error: expected primary-expression before ‘[’ token
forum.cpp:48:37: error: size of array has non-integral type ‘std::string’
forum.cpp:48:37: error: size of array has non-integral type ‘std::string’
forum.cpp:48:33: error: expected primary-expression before ‘[’ token

pourtant la syntaxe de déclaration de l'itérateur itn est bonne!!!!
et je ne comprend pas la signification du message d'erreur size of array has non-integral type ‘std::basic_string<char>’bref si quelqu'un pourrait m'aider, parce que là je vois pas du tout !

merci beaucoup

**Bousk** · 09/11/2011, 19h38

Bonjour,

pourtant la syntaxe de déclaration de l'itérateur itn est bonne!!!!

Faux !

Code :

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

map<string,mapstrvect>::iterator itn=Nom_Notes_mat.begin();

Nom_Notes_mat est un type, et pas une variable.
begin est une fonction sur un objet map.

**Davidbrcz** · 12/11/2011, 23h31

Code :

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

map< string, map<string, vector<float> > >

Smell code !!!!!!

Il faut comprendre que lorsqu'on voit ca, il faut tiquer et se dire que quelque chose ne va pas.

Il manque dans ton programme des abstractions nécéssaires pour rendre le tout plus lisible et manipulable. Ton programme est sensé faire quoi ?

**dauphin11** · 14/11/2011, 20h20

merci !!

maintenant j'ai un autre problème...

Le code suivant doit lire un fichier texte donné contenant sur chaque ligne une matière, un nom d'élève, et une note
et remplir une map de map à partir de celui-ci, sauf que l'affichage provoque une segfault dont je ne vois pas l'origine!!

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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
#include <fstream>
 
#include <string> 
 
#include <iostream>
 
#include <map>
 
#include <vector>
 
#include <stdio.h>
 
#include <algorithm>
 
#include <iterator>
 
#include <cstring>
 
using namespace std;
 
 
 
 
 
bool test_lecture()
 
{
 
    ifstream file( "notes100.txt" );
 
    if ( !file )
 
    {
 
        cerr << "Erreur d'ouverture\n";
 
        return false;
 
    }
 
    else return true;
 
    string line;
 
    if ( ! ( file >> line ) )
 
    {
 
        cerr << "Erreur de lecture\n";
 
        return false;
 
    }
 
    else return true;
 
}
 
 
 
 
 
int main(){
 
 
 
 
 
vector<float> notes;
 
vector<string> noms;
 
vector<string> matieres;
 
map < string, vector<float> >  mapstrvect;
 
 map < string, vector<float> > Mat_Notes;
 
 map < string, vector<float> > Nom_Notes;
 
map < string, map < string, vector<float> > > Nom_Notes_mat;
 
string nom;
 
string matiere;
 
float note;
 
 
 
 
 
int s = sizeof(matieres);
 
    int t = sizeof(noms);
 
    vector< vector<float> > synthese((s+1)*(t+1));
 
 
 
 
 
ifstream fichier( "elevesNotes.txt"); 
 
 if (!test_lecture()) cout<<"pb"<<endl;
 
 else{
 
   while (!fichier.eof( ))   {
 
 
 
     fichier>>nom;
 
     fichier>>matiere;
 
     fichier>>note;
 
 
 
     matieres.push_back(matiere);
 
     notes.push_back(note);
 
     noms.push_back(nom);
 
 
 
     sort (noms.begin(), noms.end());
 
     Nom_Notes[nom].push_back(note);
 
     Mat_Notes[matiere].push_back(note);
 
     ((Nom_Notes_mat[matiere])[nom]).push_back(note);
 
   }
 
 
 
map< string, map < string, vector <float> > >::iterator itn=Nom_Notes_mat.begin();
 
map< string, vector <float> >::iterator it=(itn->second).begin(); 
 
 
 
for(;itn!= Nom_Notes_mat.end();++itn){
 
   for(;it!= (itn->second).end();++it){
 
     //for(int k=0;k<((*it).second).size();++k){
 
     cout << (it->first) << endl;
 
       //cout << (it->second) [k] <<endl;
 
       // cout << (*itn).first << endl;
 
   }
 
	 }
 
 
 
vector<string>::iterator itv;
 
itv=noms.begin();
 
for (;itv< noms.end();itv++){
 
  /*if ( itv++ != noms.end() )
 
    {cout << *itv << *(itv++) << endl;}
 
    else cout << *itv << endl;*/
 
    const char* c = (itv->c_str());
 
    const char* cc = ( (itv++)->c_str());
 
   if ( strcmp( c,cc ) == 0)
 
	 {  
 
         vector<string>::iterator it=itv;
 
         noms.erase(it);}
 
 
 
	}
 
 
}
}

Le message donné par valgrind ne m'inspire pas..
vous arrivez à voir où est le problème????

merciiiiiiiiiiiiiiiiiiiiii

**dauphin11** · 14/11/2011, 20h23

j'oubliais: le but est d'afficher un tableau répertoriant toutes les matières, tous les élèves et leurs notes respectives avec la moyenne s'ils ont plusieurs notes...

la suite de mon prog s'en occupe mais pour l'instant je n'arrive meme pas à afficher le contenu de ma map histoire de voir ce qu'elle contient!!!

**regis.portalez** · 16/11/2011, 16h37

(*itn).first : itn->first
C'est plus lisible et ça fait moins peur

sizeof(matieres) - > matieres.size()
tu fais du C++

Nom_Notes_mat.begin()
comme dit l'autre, le Nom_Notes_mat est un type et pas une instance...

Dans la suite, faire une boucle sur une map dans laquelle on erase certains iterators est dangereux...

Sinon t'es sur que t'as besoin de map de map pour faire ça?
Ya pas plus simple? (toujours se poser cette question...)

**therwald** · 16/11/2011, 19h16

Envoyé par regis.portalez

Sinon t'es sur que t'as besoin de map de map pour faire ça?
Ya pas plus simple? (toujours se poser cette question...)

Comme le faisait remarquer Davidbrcz, ça sent le manque de modélisation à 100 années lumières!

Pour le rendre lisible, à mon avis il faudrait créer des classes => élève, matière

clarifier les relations entre ces niveaux => plus lisible, plus facile à écrire, à tester et à débugger.

**koala01** · 17/11/2011, 12h47

Salut,

J'en rajoute une couche à ce qu'on dit david et therwald, mais, de toute évidence, une approche OO ne ferait pas de mal

...

Réfléchissons donc un tout petit peu au besoins que nous avons à rencontrer :

Nous avons un certain nombre d'élèves (peut on considérer qu'il s'agit d'une classe (au sens scolaire du terme)

) qui ont un certain nombre de notes dans un certain nombre de matière...

L'idée est de pouvoir donner une (ou plusieurs

) note(s) à un élève donné dans une matière donnée, et de pouvoir manipuler les données de manière à :

récupérer toutes les notes qu'un élève donné a obtenu pour un cours particulier
récupérer toutes les notes qu'un élève donné a obtenu, tous cours confondus
récupérer les notes obtenues par tous les élèves pour un cours particulier
récupérer l'ensemble des notes obtenues par tous les élèves dans tous les cours
pourquoi pas, calculer des moyennes par cours
pourquoi pas, vérifier la réussite d'un élève pour ses cours
pourquoi pas, vérifier la réussite "globale" d'un élève (tous cours confondus)
j'en oublie peut etre

Dans un premier temps, je vais juste essayer de faire quelque chose qui marche, sans *trop* m'inquiéter des performances...

Je sais que la comparaison de chaines de caractères prend énormément de temps, et qu'il faudra donc essayer d'améliorer les choses par la suite, mais il y a parfaitement moyen de s'en sortir avec elles, nous allons donc en profiter

La première chose dont on se rend compte, c'est qu'il y a une relation forte entre le cours et un résultat : c'est la note.

Nous pouvons donc créer une classe (qui a sémantique de valeur

) proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Note
{
    public:
        Note(std::string const & cours, float resultat = 0.0): 
            cours_(cours),resultat_(resultat){}
        std::string const & cours() const{return cours_;}
        float resultat() const{return resultat_;}
    private:
        std::string cours_;
        float resultat_;
};

petite astuce : j'ai donné une valeur par défaut au résultat pour permettre la création d'une note au départ du premier paramètre uniquement...

Cela permet d'utiliser le constructeur comme opérateur de conversion implicite d'une chaine de caractère en Note

Comme on va rechercher essentiellement la note par rapport au cours auquel elle se rapporte, donnons nous la possibilité de trier et de trouver une note donnée.

Pour pouvoir trier des éléments, il nous faut l'opérateur <.

Pour l'instant, nous avons la chance qu'un même élève n'aie jamais deux notes pour un même cours, autrement il faudrait trouver un élément discriminant supplémentaire (la date à laquelle il obtient la note, peut etre, à rajouter dans le fichier

)

Nous aurions tout à fait pu définir cet opérateur comme fonction membre de Note, mais, comme je n'ai pas envie de recopier la classe, et qu'il peut au demeurant etre une fonction libre, profitons en

Code :

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

1
2
3
4
bool operator<(Note const & n1, Note const & n2)
{
    return n1.cours() < n2.cours;
}

Il serait aussi pas mal de disposer de l'opérateur d'égalité == (pour pouvoir écrire un test proche de if(note1 == note2).

Les memes remarque que celles que j'ai faites au sujet de l'opérateur < sont d'application

Code :

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

1
2
3
4
bool operator==(Note const & n1, Note const & n2)
{
    return n1.cours() == n2.cours;
}

Maintenant, créer des notes seules n'a aucun intérêt...

Par contre, si on crée une classe Student (élève

) et que l'on demande à l'élève de garder la trace de toutes les notes qu'il a reçues, ca devient franchement pas mal

Un élève est identifié par son prénom (sur base des données que l'on devra lire

) et a donc la responsabilité de maintenir l'ensemble des notes qu'il a reçues.

Nous attendrons donc d'un élève qu'il puisse prendre en compte une nouvelle note, qu'il puisse donner accès à l'ensemble des notes qu'il a reçue, qu'il puisse nous renvoyer la note qu'il a recue pour un cours particulier et qu'il puisse nous dire le nombre de notes qu'il a reçues (pour faire sa moyenne

) .

Une fois qu'il a reçu une note, celle-ci n'est plus modifiable, mais nous souhaitons faciliter la recherche des éléments, et donc pouvoir les maintenir sous forme triées...

Comme enfin nous pouvons identifier de manière unique les notes par le cours auquel elles se rapportent, nous pouvons gérer en interne les note sous la forme d'un set (il s'agit d'une collection triée, dont la clé de tri est la valeur elle-même

)

Notre classe Student pourrait donc ressembler à quelque chose comme

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
 
class Student
{
    friend class ScoolClass;
public:
    typedef std::set<Note>::const_iterator const_iterator;
    Student(std::string const & name):name_(name){}
    std::string const & name() const{return name_;}
    void add(std::string cours, float result)
    {
        notes_.insert(Note(cours,result));
    }
    const_iterator begin() const{return notes_.begin();}
    const_iterator end() const{return notes_.end();}
    const_iterator find(std::string const & cours) const
    {
        return notes_.find(cours);
    }
    size_t count() const{return notes_.size();}
private:
    std::string name_;
    std::set<Note> notes_;
};

Comme il faut pouvoir trier les élèves par nom, il nous faut de nouveau les opérateur < et == (même remarques que pour les opérateur pour Note

)

Code :

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

1
2
3
4
5
6
7
8
bool operator<(Student const & st1, Student const & st2)
{
    return st1.name() < st2.name();
}
bool operator==(Student const & st1, Student const & st2)
{
    return st1.name() == st2.name();
}

Tiens, si tu veux disposer de la moyenne qu'un élève a obtenu tous cours confondus, tu peux créer une fonction (qui pourrait etre une fonction membre

) proche de

Code :

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

1
2
3
4
5
6
7
8
9
double average(Student const & st)
{
    float ret(0.0);
    for(Student::const_iterator it=st.begin();it!=st.end();++it)
    {
        ret+=it->resultat();
    }
    return ret / float(st.count());
}

Bien!!! j'ai maintenant la possibilité de créer des élèves...

Mais je dois pouvoir les gérer

Hé bien, je vais créer une nouvelle classe (au sens objet du terme

) qui représentera... une classe (au sens scolaire du terme

): SchoolClass.

Sa responsabilité sera de... gérer les élèves qui se trouvent dans une classe (au sens scolaire du terme

)

J'en attendrai donc

de pouvoir rajouter un élève
de pouvoir accéder à un élève particulier en écriture (pour pouvoir lui demander de prendre une nouvelle note en compte)... Il devra être créé si l'élève en question n'existe pas
de pouvoir accéder à un élève particulier en lecture seule
de pouvoir accéder à l'ensemble des élèves
de savoir combien d'élèves il y a dans la classe

Mais la gestion des élèves sera un peu particulière : en effet, ce n'est pas parce que l'on rajoute une note à un élève que nous aurons affaire à un autre élève... l'élève a sémantique d'entité

En plus, nous allons rechercher un élève donné par son prénom, mais nous allons utiliser tout le reste (le prénom inclus

) quand il s'agira d'afficher le résultat. Nous allons donc devoir recourir à une "pair clé / valeur", que nous trierons par clé et dont nous utiliserons la valeur

Comme nous voulons que nos élèves soient triés, nous allons gérer, en interne, nos élèves sous la forme d'une std::map<std::string, Student>.

La std::string qui servira de clé ne sera autre que... le prénom de l'élève

La class ScoolClass ressemblera donc à

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
class ScoolClass
{
public:
    typedef std::map<std::string,Student>::const_iterator const_iterator;
    const_iterator begin()const{return students_.begin();}
    const_iterator end() const{return students_.end();}
    const_iterator find(std::string const & name) const{return students_.find(name);}
    size_t count() const{return students_.size();}
    void insert(Student const & s)
    {
        students_.insert(std::make_pair(s.name(),s));
    }
    Student & operator[](std::string const & name)
    {
        if(students_.find(name)==students_.end())
            insert(name);
        return students_.find(name)->second;
    }
private:
    std::map<std::string, Student> students_;
 
};

La fonction membre insert permet (pourquoi pas

) de rajouter un élève qui aurait déjà été manipulé à la classe...

Elle nous permet, le cas échéant, d'écrire un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Student st1("Henry");
st1.add("Francais",10);
st1.add("Math",9);
st1.add("Anglais",7);
ScoolClass cl;
cl.insert(st1);
/* voir */
cl.insert("Patrick"); /* le constructeur de Student sert d'opérateur
                       * de conversion de std::string vers Student ;)
                       */

Quand à l'opérateur [], il va nous faciliter énormément l'écriture du code qui nous manque encore...

En effet, lorsque nous lirons le fichier, nous allons fatalement tomber sur des élèves que nous n'avons pas encore créés

Si, lors de la lecture, nous devons essayer de récupérer une première fois l'élève pour nous rendre compte qu'il n'existe pas, et donc décider de le créer avant de le récupérer une seconde fois, nous donnons à la fonction de lecture une responsabilité qu'elle ne devrait pas avoir : celle de décider de demander la création d'un nouvel élève.

De plus, cela nous obligerait à fournir une verison non constante pour begin(), end() et find(), qui renverrait des itérateur non constant, et donc, à définir un typedef en plus...

Enfin, il faut avouer que le code à écrire deviendrait vachement plus compliqué car il ressemblerait à laclasse.find(name)->second.add("Francais",10); (dans le cas le plus simple) alors que, grace à l'opérateur [] que j'ai défini, non seulement c'est cet opérateur qui décide de créer un étudiant s'il n'existe pas (et non la fonction de lecture), mais, en plus, le code peut devenir aussi simple que laclasse[nom].add(cours,resultat);En parlant de la fonction de lecture, il est peut etre temps de s'y attaquer

Elle devra ouvrir en lecture un fichier dont le nom lui sera donné en paramètre ( on ne sait jamais que elevesNotes.txt soit renommé ou qu'il faille utiliser un autre fichier

), lire l'ensemble de lignes, et... ajouter les notes de chaque ligne à l'élève adéquat.

Ben, c'est pas si compliqué que cela en fait, voici à quoi elle ressemblerait

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
 
void readFile(ScoolClass & scoolclass, std::string const & filename)
{
    std::ifstream ifs(filename.c_str());
    std::string temp;
    if(! ifs)
        throw std::invalid_argument("bad filename");
    while(ifs>>temp)
    {
        std::stringstream ss;
        ss<<temp;
        std::string name;
        std::string cours;
        float result;
        ss>>name>>cours>>result;
        scoolclass[name].add(cours,result);
    }
}

On as maintenant tout ce qu'il nous faut pour travailler...
alors, que veux tu comme tableaux ?
Toutes les notes d'un élève

Allez, une petite fonction supplémentaire

Code :

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

1
2
3
4
5
6
7
8
9
 
void printStudentNotes(Student const & st)
{
    std::cout<<st.name()<<std::endl;
    for(Student::const_iterator it=st.begin();it!=st.end();++it)
    {
        std::cout<<"\t"<<it->name()<<"\t"<<it->resultat() << std::endl;
    }
}

Ouppss... tu le veux sans doute pour toute la classe

Pas de problème:

Code :

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

1
2
3
4
5
void printAllStudentNotes(ScoolClass const & sc)
{
    for(ScoolClass::const_iterator it=sc.begin();it!=sc.end();++it)
        printStudentNote(it->second);
}

Tu veux peut etre la note d'un élève pour un cours particulier ?

Code :

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

1
2
3
4
5
6
7
8
void printNoteByCursus(Student const & st, std::string const & cursus)
{
    Student::const_iterator it=st.find(cursus);
    if(it!=st.end())
        std::cout<<st.name()<<"\t"<<it->resultat()<<std::endl;
    else
        std::cout<<st.name()<<"\t non noté"<<std::endl;
}

Ah, mais, bien sur, tu le veux pour toute la classe, encore une fois

Code :

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

1
2
3
4
5
6
 
void printAllStudentByCursus(ScoolClass const & sc, std::string const & cursus)
{
    for(ScoolClass::const_iterator it=sc.begin();it!=sc.end();++it)
        printNoteByCursus(it->second,cursus);
}