Discussion :

[arthurG]

Bonjour,

J'ai deux questions :

- Quel est le meilleur moyen de borner un type ?

Par exemple un int compris dans l'intervalle [a,b], y a-t-il une meilleure solution que quelque chose du genre std::max(a,std::min(i,b)) ?

- Comment éviter de "dépasser" un type ?

Ex :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
typedef unsigned char byte;
byte a = 128;
a += 128;  //a=0;

Faut-il créer un wrapper qui redéfinisse les opérateurs avec des tests du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
//addition
T& operator +=(const T& other) {
  T d = std::numeric_limits<T>::max() - *this;  //espace restant
  if (other>=d)
    *this = std::numeric_limits<T>::max();
  else
    *this += other;
  return *this;
}

Est-ce une solution portable pour tous les types ? Y a-t-il une solution moins gourmande ?
Existe-t-il une implémentation performante pour ce genre de problèmes dans une librairie ?

Merci !

[Melem]

- Je n'ai pas compris la première question.
- Dans l'exemple de la deuxième question je pense que tu voulais mettre 255 et non 128, mais ta fonction est correcte et je ne vois pas d'autre manière portable de le faire.

[arthurG]

Bonjour, merci pour la réponse.

La première question est assez proche de la seconde. Je cherche une solution pour borner un type mais ne tient pas compte d'un éventuel dépassement de capacité lors d'une opération :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int i = ...;
 
//borne i entre a et b
i = std::max(a,std::min(i,b));

Y a-t-il une meilleure solution ?

Mais en fait le vrai problème concerne le deuxième point. Dans mon exemple je voulais bien mettre 128 pour illustrer le problème : Arrivé à sa limite un type est cyclique.
Alors j'aimerais trouver le meilleur moyen (générique, portable et rapide) pour bloquer le type à une limite. On fixe un intervalle et on est sur que la variable n'en sortira pas. Par contre ça pose d'autres problèmes, plus aucune opération n'est commutative...

ex :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
//soit a borné entre 0 et 10
a = 5;
//a = a-8+4 :
a -= 8; //a=0
a += 4;
 
//a = 4
//alors que a devrait être égal à 1 et 1 est compris dans l'intervalle.
 
//si on faisait a = a+4-8 l'opération donnerait le bon résultat

Donc un wrapper qui borne un type n'est pas une solution viable non plus.

[Melem]

Bon, tu veux forcer un nombre i quelconque à être compris entre a et b ? Dans ce cas ton code est bon, on ne peut pas faire mieux non plus. Sinon si tu veux gagner des nanosecondes à la compilation tu peux toujours la remplacer par i = (i < a ? a : (i > b ? b : i)).

Dans mon exemple je voulais bien mettre 128 pour illustrer le problème

Oui j'ai compris mais je croyais avoir vu a++ en dessous en fait . J'ai du être faigué .

A part ça franchement, tes codes sont déjà tous très bons, je ne vois rien que l'on puisse encore ajouter.

[Klaim]

Il y a une bibliothèque proposée dans boost (et il me semble acceptée sous conditions mais c'est à vérifier) : Boost Constrained value http://student.agh.edu.pl/~kawulak/constrained_value/


Peut -être que ça serait une bonne idée de la tenter.


edit> Elle a bien été acceptée : http://www.boost.org/community/review_schedule.html

Le resultat de la review (2008 2010) : http://lists.boost.org/boost-announce/2010/09/0265.php

Encore une bibliothèque qui prends trop de temps à être incluse dans le package :/

Rectification : la review date de septembre 2010, donc certainement que ça arrivera dans pas trop longtemps. Dans l'idéal, dans moins de 2 releases.

[Melem]

On fixe un intervalle et on est sur que la variable n'en sortira pas. Par contre ça pose d'autres problèmes, plus aucune opération n'est commutative...

En fait, le mieux c'est de lancer une exception lorsque une tentative de dépassement de borne a été détecté.

[arthurG]

Boost Constrained Value a l'air de correspondre à ce que je cherchais, je vais voir de ce côté. Et comme le propose Melem j'ai l'impression qu'ils ont choisi de lever des exceptions quand on sort de l'intervalle.

Par contre traiter chaque dépassement dans un catch risque d'être un peu lourd. Peut-être que la librairie de boost est une garantie sur les valeurs d'un type comme une sorte d'assert, mais que ce n'est pas vraiment fait pour des calculs où on ne controle pas les résultats.

En fait je pense à une image, si on traite les points par des bytes. Avec certaines opérations on peut très vite dépasser la limite des bytes. Alors faut-il travailler avec des types plus larges, convertir et recopier les valeurs dans l'image, ce qui est la solution la plus facile mais pas la plus économe. Ou alors faut-il utiliser des wrapper ce qui en définitive est peut-être un peu plus joli mais revient à peu près au même...

[Goten]

Boost Constrained Value a l'air de correspondre à ce que je cherchais, je vais voir de ce côté. Et comme le propose Melem j'ai l'impression qu'ils ont choisi de lever des exceptions quand on sort de l'intervalle.

Non, y'a plusieurs comportement. Notamment (surement plus intéressant dans ton cas) un wrapping (ie si supérieur à la limite on revient à l'opposé) ou clipping qui fait que tu restes à la valeur maximum / minimum possible. (et donc pas d'exception bien entendu).

[arthurG]

Non, y'a plusieurs comportement. Notamment (surement plus intéressant dans ton cas) un wrapping (ie si supérieur à la limite on revient à l'opposé) ou clipping qui fait que tu restes à la valeur maximum / minimum possible. (et donc pas d'exception bien entendu).

Ca c'est pas mal du tout, ça devrait être effectivement la meilleure solution dans mon cas !

Merci.