Discussion :

[Jéjé34]

Bonjour,

Le but de mon exercice est de réécrire le conteneur 'map' à l'aide d'une classe Dictionnaire qui contient un tableau dynamique d'Associations.
Oui cela n'a pas de sens, mais ça permet de s'initier aux vectors et aux templates.

J'ai donc une classe Assoc, que voici...

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
template<typename TypeCle, typename TypeValeur>
class Assoc{
    private:
    TypeCle cle; TypeValeur valeur;
 
    public:
    Assoc();
    Assoc(TypeCle, TypeValeur);
    virtual ~Assoc ();
    virtual TypeCle getCle()const;
    virtual void setCle(TypeCle);
    virtual TypeValeur getValeur()const;
    virtual void setValeur(TypeValeur);
    virtual void affiche(ostream&)const;
};
 
template<typename TypeCle, typename TypeValeur>
ostream& operator<<(ostream&, const Assoc<TypeCle,TypeValeur>&);

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
template<typename TypeCle, typename TypeValeur>
Assoc<TypeCle,TypeValeur>::Assoc() {}
 
template<typename TypeCle, typename TypeValeur>
Assoc<TypeCle,TypeValeur>::Assoc(TypeCle c, TypeValeur v)
:cle(c), valeur(v) {}
 
template<typename TypeCle, typename TypeValeur>
Assoc<TypeCle,TypeValeur>::~Assoc () {}
 
template<typename TypeCle, typename TypeValeur>
TypeCle Assoc<TypeCle,TypeValeur>::getCle() const {
    return cle;
}
 
template<typename TypeCle, typename TypeValeur>
void Assoc<TypeCle,TypeValeur>::setCle(TypeCle c) {
    cle=c;
}
 
template<typename TypeCle, typename TypeValeur>
TypeValeur Assoc<TypeCle,TypeValeur>::getValeur() const {
    return valeur;
}
 
template<typename TypeCle, typename TypeValeur>
void Assoc<TypeCle,TypeValeur>::setValeur(TypeValeur v){
    valeur=v;
}
 
template<typename TypeCle, typename TypeValeur>
void Assoc<TypeCle,TypeValeur>::affiche(ostream &os) const {
    os <<getCle() << ", " <<getValeur();
}
 
template<typename TypeCle, typename TypeValeur>
ostream& operator<<(ostream& os, const Assoc<TypeCle,TypeValeur>& a){
    a.affiche(os); 
    return os;
}

...et ma classe Dictionnaire qui doit contenir un tableau dynamique d'associations.

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
 
template<typename TypeCle, typename TypeValeur>
class Dictionnaire {
 
    private :
    vector < Assoc<TypeCle, TypeValeur> > associations;
 
    public :
    Dictionnaire();
    ~Dictionnaire();
    void put(TypeCle, TypeValeur);
    TypeValeur get(TypeCle) const;
    bool estVide() const;
    int taille() const;
    bool contient(TypeCle) const;
    ostream& affiche(ostream&) const;
    Dictionnaire& operator=(const Dictionnaire&);
 
};
 
template<typename TypeCle, typename TypeValeur>
ostream& operator<< (ostream& os, const Dictionnaire<TypeCle, TypeValeur>&);

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template<typename TypeCle, typename TypeValeur>
Dictionnaire<TypeCle, TypeValeur>::Dictionnaire(): associations(10) { }
 
template<typename TypeCle, typename TypeValeur>
Dictionnaire<TypeCle, TypeValeur>::~Dictionnaire() { }
 
template<typename TypeCle, typename TypeValeur>
void Dictionnaire<TypeCle, TypeValeur>::put(TypeCle cle, TypeValeur valeur) {
    Assoc<TypeCle, TypeValeur> a(cle, valeur);
    associations.push_back(a);
}

J'ai essayé des tester mon constructeur et ma méthode 'put' comme ceci :

Code :

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

1
2
3
4
5
int main() {
    Dictionnaire<string, int> dico;
    dico.put("abricot", 235);
    return 0;
}

Mais j'ai les erreurs suivantes, et je ne comprend pas pourquoi.

main.cpp:(.text+0x12): undefined reference to `Dictionnaire<std::string, int>::Dictionnaire()'
main.cpp:(.text+0x23): undefined reference to `Dictionnaire<std::string, int>::~Dictionnaire()'
collect2: error: ld returned 1 exit status

Merci à vous.

[Iradrille]

Hello,

Oui cela n'a pas de sens, mais ça permet de s'initier aux vectors et aux templates.

Au contraire, c'est généralement comme ça qu'est implémentée la classe map : à partir de std::pair (-> ta class Assoc), et d'un set (tu utilise un vector ici, un set est plus adapté car il possède les mêmes caractéristiques qu'une map).

Pour ta classe Assoc, ça n'a pas de sens d'avoir des fonctions virtuelles : cette classe n'est pas destinée à être héritée. Elle doit par contre pouvoir être copiable et assignable (sémantique de valeur)
Quand on fourni getter et setter publiquement, autant ne pas les fournir et simplement mettre les attributs publiques.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <class K, class V>
struct Assoc {
    K key;
    V value;
    Assoc() { }
    Assoc(K k, V v) : key(k), value(v) { }
    // constructeur par copie, et operator= peuvent être template pour autoriser d'autres types, par exemple
    // Assoc<int, int> ai(1, 1);
    // Assoc<long, long> al = ai;
    Assoc(const Assoc& other) : key(other.key), value(other.value) { }
    Assoc& operator=(const Assoc& other) { key = other.key; value = other.value; return *this; }
};

Comme avec tout template, l'implémentation ne va pas dans un .cpp, mais directement dans le .h (-> d'où tes erreurs de link)