stl : tri d'élément selon un membre.

On 7 Jul 2006 07:29:11 -0700, "ALB" <lebatteux@crans.org>:

s'il existe une ligne de code permettant de trier une liste selon un
membre donné, sans utiliser de foncteur.

Certes : tu peux utiliser une fonction à la place du foncteur.

Certes : tu peux utiliser une fonction à la place du foncteur.

C'est vrai. Mais, je ne souhaite pas faire ça non plus.

En fait, utiliser des foncteurs et des fonctions obligent à les
définir avant de les utiliser, ce qui, je trouve encombre le code
inutilement dans la mesure où je ne les utilise généralement qu'une
seule fois.

Et puis, je suis assez convaincu qu'on doit pouvoir se débrouiller en
composant les bind, les mem_fun et un greater<>. Mais, je ne réussis
pas à le faire sans erreur (et ça commence à n'enerver... )

ALB

On 7 Jul 2006 08:54:00 -0700, "ALB" <lebatteux@crans.org>:

Et puis, je suis assez convaincu qu'on doit pouvoir se débrouiller en
composant les bind, les mem_fun et un greater<>.

C'est possible. Par contre, je ne suis pas convaincu que le résultat
soit lisible.

C'est possible. Par contre, je ne suis pas convaincu que le résultat
soit lisible.

j'aimerais bien voir, histoire de me faire mon idée...

Je suis en train d'éclaircir/nettoyer mon code et j'aimerais savoir
s'il existe une ligne de code permettant de trier une liste selon un
membre donné, sans utiliser de foncteur.
Exemple :
struct foo {
int ID;
int taille;
float poids;
};

list<foo> malist;
// on remplit malist.

comment la trier par taille ? Avec foncteur, je sais faire. Mais avec
des bind, des mem_fun_ref et du greater, je ne vois pas comment faire.

Je me pose la même question pour une recherche de maximum par exemple
(quel est l'ID ayant la plus grande taille ?)

J'ai jeté un coup d'oeil à la faq, j'ai (beaucoup) cherché avec
google... sans succès.
Alors, je m'en remets à une âme charitable.

Avec boost::bind, ça marche relativement bien, si je ne me trompe pas:

maliste.sort(boost::bind(std::less<int>(),
boost::bind(&foo::ID, _1),
boost::bind(&foo::ID, _2)));

maliste.sort(boost::bind(std::less<float>(),
boost::bind(&foo::poids, _1),
boost::bind(&foo::poids, _2)));

list<foo>::iterator le_plus_grand std::max_element(maliste.begin(), maliste.end(),
boost::bind(std::less<int>(),
boost::bind(&foo::taille, _1),
boost::bind(&foo::taille, _2)));

Par contre, je ne sais pas comment enlever la répétition de la référence
du membre.

--
C'est ma signature qu'elle est la mieux. Pas la vôtre.

"ALB" <lebatteux@crans.org> a écrit dans le message de news:
1152282551.846929.73180@m73g2000cwd.googlegroups.com...

struct foo {
int ID;
int taille;
float poids;
};

list<foo> malist;
// on remplit malist.

comment la trier par taille ? Avec foncteur, je sais faire. Mais avec
des bind, des mem_fun_ref et du greater, je ne vois pas comment faire.

Avec la librairie standard, ca risque d'être assez illisible, mieux vaut
utiliser un foncteur classique. Par contre, avec boost::bind (qu'on peut
espérer voir intégrer dans la prochaine mouture de la norme), ca devient
simplissime :

#include <boost/bind.hpp>
using namespace boost;

list<foo> malist;
// on remplit malist.

malist.sort( bind(&foo::poids, _1) < bind (&foo::poids, _2));
//liste triée par taille

malist.sort( bind(&foo::taille, _1) < bind (&foo::taille, _2));
//liste triée par poids

Un autre approche qui pourrait t'intéresser (selon tes besoins) serait
d'utiliser boost::multi_index à la place de std::list pour avoir en
permanence plusieurs indexs sur ta collection.

Arnaud

c'est vrai que boost (que j'ai croisé ça et là, sans trop m'y
arreter pour l'instant) a l'air de permettre d'écrire les choses
clairement. C'est assez séduisant.
J'ai effectivement lu que cette librairie était sur le bon chemin pour
être intégrée au standard, mais un peu buté (enfin, je préfère
dire puriste), je voulais me limiter à l'utilisation de la stl. Je
souhaite que mon code soit portable et léger (bon avec la stl, il y a
déjà un premier serieux boulet).

Je vous remercie pour vos réponses.
ALB

On 8 Jul 2006 04:45:57 -0700, "ALB" <lebatteux@crans.org>:

Je souhaite que mon code soit portable

Qu'entends-tu par "portable" exactement ?
Boost fonctionne sur la plupart des compilos récents.

Si tu veux porter ton code sur un compilo ancien et/ou pourri, tu
auras effectivement des problèmes -- mais pas seulement avec Boost.

et léger

Qu'entends-tu par "léger" ?

"ALB" <lebatteux@crans.org> a écrit dans le message de news:
1152359157.507478.8260@p79g2000cwp.googlegroups.com...
c'est vrai que boost (que j'ai croisé ça et là, sans trop m'y
arreter pour l'instant) a l'air de permettre d'écrire les choses
clairement. C'est assez séduisant.
J'ai effectivement lu que cette librairie était sur le bon chemin pour
être intégrée au standard, mais un peu buté (enfin, je préfère
dire puriste), je voulais me limiter à l'utilisation de la stl.

A mon avis, ce n'est pas faisable avec les binders de la STL, parce que les
classes mem_fun_t, mem_fun_ref_t, etc.... ansi que binder1st et binder2nd ne
fonctionnent qu'avec des fonctions membres, pas avec des données membres :
je ne vois donc pas comment référencer &foo::taille dans une expression qui
utiliserait ces classes (Ah là là, les pointeurs vers *données* membres!
J'avais oublié que ca existait ;-).

Arnaud

A mon avis, ce n'est pas faisable avec les binders de la STL, parce que l es
classes mem_fun_t, mem_fun_ref_t, etc.... ansi que binder1st et binder2nd ne
fonctionnent qu'avec des fonctions membres, pas avec des données membre s :
je ne vois donc pas comment référencer &foo::taille dans une expressi on qui
utiliserait ces classes (Ah là là, les pointeurs vers *données* mem bres!
J'avais oublié que ca existait ;-).

Arnaud

avec un
int foo::Gettaille() { return taille;};