cs_LordBob
Messages postés2865Date d'inscriptionsamedi 2 novembre 2002StatutMembreDernière intervention11 mai 2009
-
7 mars 2004 à 19:41
cs_Kirua
Messages postés3006Date d'inscriptiondimanche 14 avril 2002StatutMembreDernière intervention31 décembre 2008
-
10 mars 2004 à 14:00
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
cs_Kirua
Messages postés3006Date d'inscriptiondimanche 14 avril 2002StatutMembreDernière intervention31 décembre 2008 10 mars 2004 à 14:00
okok, j'ajoute ça à ma liste de TO DO, thx.
Hylvenir
Messages postés364Date d'inscriptionmercredi 11 février 2004StatutMembreDernière intervention 5 octobre 20062 10 mars 2004 à 12:14
So... pour la relation d'équivalence.
si tu as regardé (la class pair, et/ou l'inversion des arguments )
la fonction est équivalene à la tienne.
bool Comparer( const CPerso& lhs, const CPerso& rhs )
{
return (lhs.TileY < rhs.TileY)
|| !(rhs.TileY < lhs.TileY) && ( lhs.dY < rhs.dX );
}
voilà, tu n'as besoin de ne définir que l'opérateur < sur
CPerso ( grâce au ! et l'inversion des arguments )
sinon c'est partial_sort_copy qui n'utilise qu'un InputIteractor
(honnêtement je ne l'utilise jamais) et non partial_sort
Hylvenir
Messages postés364Date d'inscriptionmercredi 11 février 2004StatutMembreDernière intervention 5 octobre 20062 9 mars 2004 à 23:45
Pour l'accès aléatoire, c'est lié à la manière de trier du sort.
Je crois que partial_sort permet de faire quelque chose.
Pour les références automatiques, rien à faire.
Pour la relation d'équivalence, j'suis trop fatigué pour relire. demain.
mais dans le include il faut regarder l'opérateur < pour
les paires par exemple.
(sinon dans la pratique, je la code comme toi à quelques détails près).
cs_Kirua
Messages postés3006Date d'inscriptiondimanche 14 avril 2002StatutMembreDernière intervention31 décembre 2008 9 mars 2004 à 23:08
Hylvenair, en rapport à ta 3ème remarque, ta solution n'est pas acceptable.
regarde bien, mes deux premiers tests passés, il n'y a plus qu'une possibilité: a.TileY == b.TileY
du coup je vérifie la sous position (en fait, dY est une variable qui "affine" la position du perso à l'intérieur d'une grande case nommée Tile). utiliser !(...<...) ne produirait pas l'effet voulu, puisqu'en cas de TileY équivalents, dY ne serait pas utilisé pour déterminer plus précisément l'ordre des persos.
je ne savais pas que sort ne pouvais pas traiter les list, pq on a besoin d'un itérateur aléatoire? je trouve ça étonnant...
pr les référence je suis d'accord, mais comment je suis sensé faire comprendre ça à sort? les conteneurs contiennent des objets, pas des pointeurs (ni des références).
Hylvenir
Messages postés364Date d'inscriptionmercredi 11 février 2004StatutMembreDernière intervention 5 octobre 20062 9 mars 2004 à 22:25
Salut,
Kirua >
1. sort() ne permet pas de trier les lists ( pas d'itérateur à
accès aléatoire )
2. beaucoup mieux de passer une référence constante pour Comparer
bool Comparer( const CPerso& lhs, const CPerso& rhs )
3. Les puristes préférent utiliser uniquement < dans le compare
du style x<y puis !(y<x )
sauf erreur de ma part of course ;-)
cs_cppman
Messages postés2Date d'inscriptionjeudi 19 juin 2003StatutMembreDernière intervention 9 mars 2004 9 mars 2004 à 00:27
Merci Kirua
cs_Kirua
Messages postés3006Date d'inscriptiondimanche 14 avril 2002StatutMembreDernière intervention31 décembre 2008 8 mars 2004 à 22:04
Hmm, je vais te dire dans quel cadre j'ai utilisé cet en-tête. J'avais une liste (assez variable) d'objets de ma création (CPerso, une class) stockés dans un vector (STL). Tu vois à quel point les algos de l'en-tête sont flexibles: ça marche avec n'importe quel type d'objet!
j'ai utilisé la fonction "sort()" qui trie (on s'en doute) ton vector, ta liste, ton tableau dynamique/statique, ton stack... (peu importe, ça marche avec tout ça!) par ordre CROISSANT en utilisant l'opérateur d'infériorité de l'objet utilisé (dans mon cas (CPerso), comme je voulais dessiner les personnages dans un certain ordre, j'ai juste définis l'opérateur < en fonction de la position verticale))
Note que tu n'es pas obligé de définir l'opérateur "<" pour tes types d'objets. Tu peux aussi fournir à la fonction sort une fonction de tri. Ce foncteur (comparateur) doit retourner true si son premier paramètre est "inférieur" au second.
Pour des types intégrés comme int, float, double, char (bool je sais pas) et leurs dérivés (unsigned, long ...) tu ne dois évidemment pas redéclarer les foncteurs ou les opérateurs!
Tiens, pour que tu vois à quoi ça ressemble, moi j'ai utilisé un comparateur que j'ai définit comme membre static de CPerso:
avec en premier paramètre un itérateur qui pointe sur le premier élément de la séquence à trier et en deuxième paramètre un itérateur qui pointe sur le dernier élément de la séquence à trier (ça te permet de ne trier qu'une sous partie d'un tableau).
Le troisième paramètre est facultatif, c'est un pointeur (je pense) sur la fonction de comparaison.
Bon amusement ;-)
cs_cppman
Messages postés2Date d'inscriptionjeudi 19 juin 2003StatutMembreDernière intervention 9 mars 2004 8 mars 2004 à 21:52
Salut Kiria ! Pourrais-tu me donner un peu plus de détails sur . Je suis en train de simplifier l'exemple qui s'intitulera strategy2 et qui fait intervenir des itérateurs et de le commenter.
cs_Kirua
Messages postés3006Date d'inscriptiondimanche 14 avril 2002StatutMembreDernière intervention31 décembre 2008 8 mars 2004 à 16:39
c'est bien d'avoir créé ton propre système d'algo. mtnt pr les amoureux de la STD/STL (comme moi ^^), il y a l'en-tête qui gère tt ça comme un chef :-)
cs_LordBob
Messages postés2865Date d'inscriptionsamedi 2 novembre 2002StatutMembreDernière intervention11 mai 20099 7 mars 2004 à 19:41
je trouve qu'il y a beaucoup de fichier pour pas grand chose... tout ce n'est pas clair, ca manque un peu de commentaire je trouve !!!
10 mars 2004 à 14:00
10 mars 2004 à 12:14
si tu as regardé (la class pair, et/ou l'inversion des arguments )
la fonction est équivalene à la tienne.
bool Comparer( const CPerso& lhs, const CPerso& rhs )
{
return (lhs.TileY < rhs.TileY)
|| !(rhs.TileY < lhs.TileY) && ( lhs.dY < rhs.dX );
}
voilà, tu n'as besoin de ne définir que l'opérateur < sur
CPerso ( grâce au ! et l'inversion des arguments )
sinon c'est partial_sort_copy qui n'utilise qu'un InputIteractor
(honnêtement je ne l'utilise jamais) et non partial_sort
9 mars 2004 à 23:45
Je crois que partial_sort permet de faire quelque chose.
Pour les références automatiques, rien à faire.
Pour la relation d'équivalence, j'suis trop fatigué pour relire. demain.
mais dans le include il faut regarder l'opérateur < pour
les paires par exemple.
(sinon dans la pratique, je la code comme toi à quelques détails près).
9 mars 2004 à 23:08
regarde bien, mes deux premiers tests passés, il n'y a plus qu'une possibilité: a.TileY == b.TileY
du coup je vérifie la sous position (en fait, dY est une variable qui "affine" la position du perso à l'intérieur d'une grande case nommée Tile). utiliser !(...<...) ne produirait pas l'effet voulu, puisqu'en cas de TileY équivalents, dY ne serait pas utilisé pour déterminer plus précisément l'ordre des persos.
je ne savais pas que sort ne pouvais pas traiter les list, pq on a besoin d'un itérateur aléatoire? je trouve ça étonnant...
pr les référence je suis d'accord, mais comment je suis sensé faire comprendre ça à sort? les conteneurs contiennent des objets, pas des pointeurs (ni des références).
9 mars 2004 à 22:25
Kirua >
1. sort() ne permet pas de trier les lists ( pas d'itérateur à
accès aléatoire )
2. beaucoup mieux de passer une référence constante pour Comparer
bool Comparer( const CPerso& lhs, const CPerso& rhs )
3. Les puristes préférent utiliser uniquement < dans le compare
du style x<y puis !(y<x )
sauf erreur de ma part of course ;-)
9 mars 2004 à 00:27
8 mars 2004 à 22:04
j'ai utilisé la fonction "sort()" qui trie (on s'en doute) ton vector, ta liste, ton tableau dynamique/statique, ton stack... (peu importe, ça marche avec tout ça!) par ordre CROISSANT en utilisant l'opérateur d'infériorité de l'objet utilisé (dans mon cas (CPerso), comme je voulais dessiner les personnages dans un certain ordre, j'ai juste définis l'opérateur < en fonction de la position verticale))
Note que tu n'es pas obligé de définir l'opérateur "<" pour tes types d'objets. Tu peux aussi fournir à la fonction sort une fonction de tri. Ce foncteur (comparateur) doit retourner true si son premier paramètre est "inférieur" au second.
Pour des types intégrés comme int, float, double, char (bool je sais pas) et leurs dérivés (unsigned, long ...) tu ne dois évidemment pas redéclarer les foncteurs ou les opérateurs!
Tiens, pour que tu vois à quoi ça ressemble, moi j'ai utilisé un comparateur que j'ai définit comme membre static de CPerso:
static bool Comparer(CPerso a, CPerso b)
{
if(a.TileY < b.TileY) return true;
if(a.TileY > b.TileY) return false;
return (a.dY < b.dY);
}
(l'intérieur, ça dépend de ton type bien sûr)
et j'appelle sort comme ça:
sort(PNJ.begin(), PNJ.end(), CPerso::Comparer);
avec en premier paramètre un itérateur qui pointe sur le premier élément de la séquence à trier et en deuxième paramètre un itérateur qui pointe sur le dernier élément de la séquence à trier (ça te permet de ne trier qu'une sous partie d'un tableau).
Le troisième paramètre est facultatif, c'est un pointeur (je pense) sur la fonction de comparaison.
Bon amusement ;-)
8 mars 2004 à 21:52
8 mars 2004 à 16:39
7 mars 2004 à 19:41