Les ensembles en C++

Bonjour,

Je viens de tester les ensembles en C++.
Mon exemple [1] porte sur un ensemble de personnes.
Ce qui m'intéresse avec les ensembles, c'est la propriété "chaque élément de l'ensemble est unique" (c'est à dire qu'il ne peut pas y avoir deux membres identiques).
J'ai été obligé de surcharger l'opérateur "inférieur à" (operator<) pour pouvoir insérer des éléments dans mon ensemble. Sinon, j'ai une erreur à la compilation me disant que l'opérateur manque.
Je ne suis pas très satisfait de ma surcharge d'opérateur car à l'intérieur, je compare le nom des personnes. Il se pourrait que deux personnes aient le même nom. Le mieux serait de se baser sur l'adresse des objets (avec &). Mais quand je remplace le code, j'ai 5 personnes dans mon ensemble au lieu de 3. C'est le même résultat que si j'écris de renvoyer vrai.

Est-ce que vous avez une solution satisfaisante pour la surcharge de mon opérateur ?

Merci.

[1]

Code:

---

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

#include <string> #include <iostream> #include <set> #include <vector> using namespace std; class Person { private: string name; public: Person(string name); virtual string getName()const; }; Person::Person(string name) { this->name = name; } string Person::getName()const { return this->name; } bool operator<(const Person& person1, const Person& person2) { return person1.getName() < person2.getName(); } ostream& operator<<(ostream& os, const Person& person) { os << person.getName(); return os; } int main() { Person p1("Toto"); Person p2("Tata"); Person p3("Tutu"); set<Person> persons; persons.insert(p1); persons.insert(p1); persons.insert(p1); persons.insert(p2); persons.insert(p3); set<Person>::iterator it; /* vector<Person> persons; persons.push_back(p1); persons.push_back(p1); persons.push_back(p1); persons.push_back(p2); persons.push_back(p3); vector<Person>::iterator it; */ for(it = persons.begin(); it != persons.end(); it++) { cout << *it << endl; } }

---

Bonjour,

Tu va stocker des Person, donc tu vas effectuer une copie pour insérer tes éléments, il est donc normal que les adresses ne soient plus les même.

Donc soit tu dois stocker un pointeur sur un Person soit tu dois intégrer un identifiant dans chaque Person.

Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class Person { Person(void); static TypeId compteur; TypeId id; };   Person::compteur = 0;   Person::Person(void) : id(compteur++) { }

---

Bonjour

Si on utilise des pointeurs, on peut pas définir un opérateur < (Person*, Person*)
Mais d'un autre côté, avoir un opérateur < pour Person n'a pas de sens (voir la sémantique d'entité)
Il faut utiliser des pointeurs en donner un operateur Less<Key> spécifique dans le set

Si 2 personnes ont le même nom, comment distingues tu ces 2 personnes ? (prénom ? date de naissance ? numéro de sécu ?) Il suffit que l'opérateur Less prenne plusieurs paramètres

gbdivers>C'est clair que si je complète ma classe Person avec un attribut numéro de sécurité sociale, le problème est résolu car j'aurai un identifiant unique pour comparer mes personnes. Mais j'essaie de voir si je peux m'en sortir sans modifier les propriétés de ma classe Person et de travailler plutôt avec l'adresse en mémoire des objets.

Neckara>Ah oui d'accord je travaille avec des copies... Je préfère ne pas ajouter de propriétés à ma classe pour gérer ça. Je vais essayer avec l'adresse en mémoire des objets. Dans ce cas il me suffit de faire un set de Person* au lieu de faire un set de Person. C'est bien ça ?

La solution qui me semble appropriée est bien le set<Person*>. Tu devrais d'ailleurs interdire la copie de Person, ça t'éviterait quelques bugs incompréhensibles ;)

@gbdivers: s'il utilise un set de pointeurs, il n'y a aucun intérêt à spécialiser Less...

@germinolegrand
Je pensais à un Less pour comparer en fonction des propriétés des objets et non de leurs adresses

Je pense que le but recherché ici est seulement de garantir l'unicité des entités... Par conséquent la comparaison de propriétés me parait superflue...

Je viens de tester [1] et effectivement ça fonctionne avec un set<Person*>...
Par contre, je suis assez étonné de ne plus avoir besoin de surcharger l'opérateur inférieur (operator<).
Je pensais le surcharger en faisant la comparaison des adresses... Mais ça le fait tout seul pour moi j'ai l'impression.

Vous savez pourquoi ?

[1]

Code:

---

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

#include <string> #include <iostream> #include <set> #include <vector> using namespace std; class Person { private: string name; public: Person(string name); virtual string getName()const; }; Person::Person(string name) { this->name = name; } string Person::getName()const { return this->name; } /* bool operator<(const Person& person1, const Person& person2) { return person1.getName() < person2.getName(); } */ ostream& operator<<(ostream& os, const Person& person) { os << person.getName(); return os; } int main() { Person p1("Toto"); Person p2("Tata"); Person p3("Tutu"); set<Person*> persons; persons.insert(&p1); persons.insert(&p1); persons.insert(&p1); persons.insert(&p2); persons.insert(&p3); set<Person*>::iterator it; /* vector<Person> persons; persons.push_back(p1); persons.push_back(p1); persons.push_back(p1); persons.push_back(p2); persons.push_back(p3); vector<Person>::iterator it; */ for(it = persons.begin(); it != persons.end(); it++) { cout << **it << endl; } }

---

Les opérateurs sont déjà défini pour tous les pointeurs (et ne sont pas ailleurs pas surchargeables si on ne prend que des pointeurs).

Merci à vous tous pour ces explications claires.
Problème résolu.