Discussion :

[r0d]

Bonjour tout le monde,

je suis confronté à un problème qui parait simple de prime abord, mais qui s'est avéré plus ardu que prévu (à moins que ce soit moi qui, à force de me triturer les méninges, cherche trop la complication). Je m'explique:

J'ai des événements à traiter. Pour ce post, nous pouvons considérer ces événements comme une structure qui comprend un poids et un pointeur de fonction.

J'ai plusieurs type d'événements. J'ai donc une classe mere Event, et plusieurs classes fille.

Je dois stocker mes événements dans un conteneur. Ils doivent être triés selon leur poids. J'ai donc opté pour un std::set.

Problème: étant donné que mon set va contenir differents type d'evenements, je suis contraint de n'y stocker que des pointeurs: std::set<Event*>.

=> Du coup, je ne peux pas implémenter mon opérateur < pour m'assurer de la façon dont vont être triés mes événements dans le set.

Question: y a-t-il quelque chose qui cloche dans mon raisonnement? Si non, quelle est la solution? (créer une classe Bidon qui va contenir un Event* et faire un set de cette classe Bidon ne me plait guère...)

[JolyLoic]

set prend un paramètre template optionnel permettant de spécifier un comparateur pour tes objets.

[r0d]

merci JolyLoic,

mais en fait, maintenant que j'y repense, je ne peux pas utiliser un set car je dois pouvoir stocker des événements qui ont le même poids

Du coup je ne sais pas trop quel conteneur utiliser. Une list (ou une queue) serait pas mal mais ça m'obligerait à implémenter une fonction d'insertion moi-même puisque je veux que le conteneur reste trié.

[JolyLoic]

J'ai oublié que je voulais ajouter un autre commentaire :
Set ne me semble pas adapté à ce genre de choses, car il peut y avoir des égalités

Pour ça, deux possibilités :
- Un multiset (mais l'interface n'est pas forcément formidable pour ça).
- Une priority_queue, qui est fait pour ce genre de chose, tant que le seul traitement que tu veux faire sur un élément inséré est de le retirer quand il est en première position...

[r0d]

Vi. En fait, ce que je veux faire c'est une sorte de séquenceur "général". Général dans le sens où les événements sont de nature vraiment différente.

Je viens de voir qu'en effet, une solution est possible avec un multiset, je vais voir maintenant ce que ça donne avec une priority queue.

[corrector]

je ne peux pas utiliser un set car je dois pouvoir stocker des événements qui ont le même poids

Dans quel ordre doivent être les éléments de même poids?

[r0d]

Le plus faible en tête.

Aujourd'hui j'ai un algo qui fonctionne, mais je pense que je peux faire mieux. Pour l'instant, j'utilise un multiset. L'algorithme que j'ai mis en place est le suivant:
-> Le séquenceur possède le multiset d'événements. J'en ai fais un singleton de façon à ce que des événements puissent être ajoutés facilement par tous les objets de l'appli.
-> Mon appli fonctionne en frame constante, c'est à dire que chaque boucle du "mainframe" dure le même nombre de millisecondes
-> A chaque boucle, l'execution des événements se passe en 3 phases:
1/ je décrémente le poids de tous les événements de mon multiset de 1
2/ j'execute tous les événements dont le poids est négatif
3/ je supprime tous les evenement dont le poids est négatif (en faisant un find_first_of puis un swap ).

edit: pour l'instant, le nombre d'événements présents dans mon multiset ne dépasse pas 20.

edit2: oops, j'avais mal compris ta question
Donc en fait, l'ordre des événements de même poids n'a aucune importance.

[Emmanuel Deloget]

Dans quel ordre doivent être les éléments de même poids?

Le plus faible en tête.

J'allais répondre:

On a enfin trouvé une notion d'ordre qui permet de répondre à la question "quel est le plus lours entre 1kg de plomb et 1kg de plume ?" et personne ne m'a prévenu ?

[corrector]

1/ je décrémente le poids de tous les évènements de mon multiset de 1

Concrètement, comment fais-tu?

[r0d]

avec un foncteur et un for_each. Pourquoi?

[corrector]

avec un foncteur et un for_each. Pourquoi?

Primo, parce que la clef est constante : map<K,E>::element_type est pair<const K, E> !

(Le principe de tous les conteneurs associatifs standard est que la clef est déclarée const.)

[r0d]

C'est vrai ça... ça ne devrait pas marcher normalement

Et puis ce que tu dis là met à jour une contradiction dans mon algo: je modifie la clé des éléments de mon conteneur associatif.

ps: je n'ai pas le code (celui dont je parle dans ce topic) sous les yeux, je vérifierai ça demain.