Remonter le temps : classes et interfaces

Bonjour à toutes et à tous ! :D

On a besoin d'itérer sur un historique dans un algorithme extérieur à la classe History

En pseudo code ça donne :
1- On remonte le temps d'un pas de temps t
2- On chope une info sur l'histoire au temps t et si une certaine condition A est remplie on s'arrête
3- Si on ne peut plus remonter le temps on s'arrête
4- Sinon on retourne à 1)

Le "truc" c'est que les temps viennent d'un objet history ayant une certaine étendue temporelle. L'étendue temporelle de l'objet peut être bornée (2014-2064) ou infinie (2014 - ...).

• Si l'histoire est bornée, l'algorithme parcourt l'histoire jusqu'à la fin, mais s'arrête avant si une certaine condition A est remplie.
• Si l'histoire est infinie, l'algorithme parcourt le temps indéfiniment jusqu'à ce que la condition A soit remplie

Du coup je me posais plusieurs questions sur le fait de généraliser l'algorithme pour les deux types d'histoires...

Dans le cas borné, Hisotry prend grosso modo l'implémentation d'une map<time_type, info_type>. J'ai filé un itérateur sur le temps pour récupérer les infos nécessaires.
Dans le cas infini, on pourrait avoir l'info donnée par une formule de récursion ou une constante. Mais y a t'il encore un sens à lui fournir des itérateurs ?

J'ai (encore et toujours) du mal à imaginer la généralité, et notamment la forme que doivent ces deux cas de "history". Comment départager entre :
- est ce une même classe avec deux implémentations,
- deux classes différentes avec une même interface publique est un algo template,
- un héritage (je commence à me méfier de ce dernier... :? ) et un algo sur le type ancestral ?

Je me débats toujours sur ces questions, même si je penche pour la deuxième solution. :(

Désoléééééé pour les questions bêtes !!! :oops:
Merci d'avance de vos réponses ! :D

Le truc c'est que l'infini n'existe pas en informatique. Donc comment est gérée le [2014-...] ?
Si c'est via une fonction du genre isEnded() { return false; }, va falloir faire avec.
Si c'est juste une valeur très grande [2014-999999], alors tu as belle et bien une fin et tu itères jusque là. Dans ce cas, ça revient au même que d'itérer sur [2014-2014], tu parcours tes itérateurs jusqu'à ce qu'ils soient ko.

Regarde comment sont construits les algorithmes standards: ils sont templatés sur le type des itérateurs, et parcourent simplement de début jusqu'à ce que fin s'en suivent.

Je t'invite à regarder copy_if, qui a une signature assez proche de ce dont tu semble avoir besoin.
L'idée des itérateurs est de séparer l'accès à la donnée (vector, list ou que sais-je encore) de son usage.

Nous avons sur le site un tuto (traduit) sur le sujet: comment écrire un algorithme standard

Coucou ! Merci de vos réponses !
Mille excuses pour ma réponse tardive, j'ai essayé de me documenter sur tout ça avant ! :)

Citation:

---

Envoyé par Bousk

Le truc c'est que l'infini n'existe pas en informatique. Donc comment est gérée le [2014-...] ?
Si c'est via une fonction du genre isEnded() { return false; }, va falloir faire avec.
Si c'est juste une valeur très grande [2014-999999], alors tu as belle et bien une fin et tu itères jusque là. Dans ce cas, ça revient au même que d'itérer sur [2014-2014], tu parcours tes itérateurs jusqu'à ce qu'ils soient ko.

---

Citation:

---

Envoyé par leternel

Je t'invite à regarder copy_if, qui a une signature assez proche de ce dont tu semble avoir besoin.
L'idée des itérateurs est de séparer l'accès à la donnée (vector, list ou que sais-je encore) de son usage.

---

Ok, je note les idées, merci beaucoup (j'ai relu le tuto sur les algo, il est vraiment cool :D ). En fait je pensais vouloir écrire quelquechose comme :

Code:

---

1 2 3 4 5 6

time = demo.begin_time() while( someCondition != true || time != demo.end_time() ){ // ....   ++time }

---

Du coup comme les cas finis de démographie sont implémentés avec des collections classiques, je n'ai qu'à renvoyer les itérateurs des collections.
Mais par exemple pour le cas temps infini et valeur constante, je me demandais si il était débile de fournir un itérateur begin() "pointant" sur une constante, un itérateur end() qui n'est jamais atteint, et d'avoir un ++it qui n'incrémente rien (puisque c'est constant). Sauf que je ne sais pas comment faire...
Je ne sais pas à quel point ça paraît bizarre de faire passer un simple entier pour un truc assez complexe... La vérité est que bien que l'objet d'étude soit une démographie très compliquée, on essaie de tester un algorithme un peu général dans des cas simplistes (infini et constant) pour lesquels il y a des attendus théoriques.

Qu'en pensez-vous ?

J'en dis qu'en général, c'est while (a && b), pas while (a || b).

Pour ton problème d'itérateur, c'est que ce n'est pas un véritable itérateur, sauf si démo peut-être vu comme une collection temporelle (complete).
Auquel cas, il te faut un end qui soit toujours différent des valeurs parcourues.