Je cherche à trier un vector avec la fonction sort de la stl.
J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante
------A.h------
bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des
instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Patrick Mézard
LaFleche wrote:
Bonjour,
Je cherche à trier un vector avec la fonction sort de la stl. J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante ------A.h------ bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Merci
Oui, créer un prédicat de comparaison du genre :
struct CompareA { inline bool operator()(const A* a1, const A* a2) const { //Gèrer le cas s'ils peuvent être NULLs assert(a1!=0 && a2!=0); return (*a1)<(*a2); } };
L'intérêt principal de cette méthode (qui marche aussi dans le cas où le conteneur contient des instances et non des pointeurs) est qu'elle permet de définir différents critères de tris, au lieu d'un seul basé sur l'operateur < du type en question.
Patrick Mézard
LaFleche wrote:
Bonjour,
Je cherche à trier un vector avec la fonction sort de la stl.
J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante
------A.h------
bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des
instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Merci
Oui, créer un prédicat de comparaison du genre :
struct CompareA
{
inline bool operator()(const A* a1, const A* a2) const
{
//Gèrer le cas s'ils peuvent être NULLs
assert(a1!=0 && a2!=0);
return (*a1)<(*a2);
}
};
L'intérêt principal de cette méthode (qui marche aussi dans le cas où le
conteneur contient des instances et non des pointeurs) est qu'elle
permet de définir différents critères de tris, au lieu d'un seul basé
sur l'operateur < du type en question.
Je cherche à trier un vector avec la fonction sort de la stl. J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante ------A.h------ bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Merci
Oui, créer un prédicat de comparaison du genre :
struct CompareA { inline bool operator()(const A* a1, const A* a2) const { //Gèrer le cas s'ils peuvent être NULLs assert(a1!=0 && a2!=0); return (*a1)<(*a2); } };
L'intérêt principal de cette méthode (qui marche aussi dans le cas où le conteneur contient des instances et non des pointeurs) est qu'elle permet de définir différents critères de tris, au lieu d'un seul basé sur l'operateur < du type en question.
Patrick Mézard
LaFleche
Patrick Mézard wrote:
LaFleche wrote:
Bonjour,
Je cherche à trier un vector avec la fonction sort de la stl. J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante ------A.h------ bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Merci
Oui, créer un prédicat de comparaison du genre :
struct CompareA { inline bool operator()(const A* a1, const A* a2) const { //Gèrer le cas s'ils peuvent être NULLs assert(a1!=0 && a2!=0); return (*a1)<(*a2); } };
L'intérêt principal de cette méthode (qui marche aussi dans le cas où le conteneur contient des instances et non des pointeurs) est qu'elle permet de définir différents critères de tris, au lieu d'un seul basé sur l'operateur < du type en question.
Patrick Mézard
Parfait et je viens de voir que ca marche aussi avec un set<A*,CompareA>,
Merci beaucoup pour ta réponse.
Patrick Mézard wrote:
LaFleche wrote:
Bonjour,
Je cherche à trier un vector avec la fonction sort de la stl.
J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante
------A.h------
bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des
instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Merci
Oui, créer un prédicat de comparaison du genre :
struct CompareA
{
inline bool operator()(const A* a1, const A* a2) const
{
//Gèrer le cas s'ils peuvent être NULLs
assert(a1!=0 && a2!=0);
return (*a1)<(*a2);
}
};
L'intérêt principal de cette méthode (qui marche aussi dans le cas où le
conteneur contient des instances et non des pointeurs) est qu'elle
permet de définir différents critères de tris, au lieu d'un seul basé
sur l'operateur < du type en question.
Patrick Mézard
Parfait et je viens de voir que ca marche aussi avec un set<A*,CompareA>,
Je cherche à trier un vector avec la fonction sort de la stl. J'ai donc redéfini l'opérateur < dans ma classe A de la manière suivante ------A.h------ bool operator<(const A& a)const
Le problème c'est que le sort fonctionne si mon vector contient des instances de A (vector<A>) mais pas avec des pointeurs (vector<A*>).
Existe-il un moyen (propre si possible) de contourner le problème?
Merci
Oui, créer un prédicat de comparaison du genre :
struct CompareA { inline bool operator()(const A* a1, const A* a2) const { //Gèrer le cas s'ils peuvent être NULLs assert(a1!=0 && a2!=0); return (*a1)<(*a2); } };
L'intérêt principal de cette méthode (qui marche aussi dans le cas où le conteneur contient des instances et non des pointeurs) est qu'elle permet de définir différents critères de tris, au lieu d'un seul basé sur l'operateur < du type en question.
Patrick Mézard
Parfait et je viens de voir que ca marche aussi avec un set<A*,CompareA>,