La limitation de la gamme de types de valeur en C++

OK, c'est le C++11 avec pas de Boost dépendances.

Tout garanti par le système de type est vérifiée au moment de la compilation, et rien d'autre, déclenche une exception.

J'ai ajouté unsafe_bounded_cast pour les conversions que peut jeter, et safe_bounded_cast pour les conversions explicites qui sont statiquement correcte (ce qui est superflu, puisque le constructeur de copie qu'il gère, mais à condition de symétrie et d'expressivité).

Exemple D'Utilisation

#include "bounded.hpp"

int main()
{
    BoundedValue<int, 0, 5> inner(1);
    BoundedValue<double, 0, 4> outer(2.3);
    BoundedValue<double, -1, +1> overlap(0.0);

    inner = outer; //ok: [0,4] contained in [0,5]

    //overlap = inner;
    //^ error: static assertion failed: "conversion disallowed from BoundedValue with higher max"

    //overlap = safe_bounded_cast<double, -1, +1>(inner);
    //^ error: static assertion failed: "conversion disallowed from BoundedValue with higher max"

    overlap = unsafe_bounded_cast<double, -1, +1>(inner);
    //^ compiles but throws:
    //terminate called after throwing an instance of 'BoundedValueException<int>'
    //  what():  BoundedValueException: !(-1<=2<=1) - BOUNDED_VALUE_ASSERT at bounded.hpp:56
    //Aborted

    inner = 0;
    overlap = unsafe_bounded_cast<double, -1, +1>(inner);
    //^ ok

    inner = 7;
    //terminate called after throwing an instance of 'BoundedValueException<int>'
    //  what():  BoundedValueException: !(0<=7<=5) - BOUNDED_VALUE_ASSERT at bounded.hpp:75
    //Aborted
}

Exception De Soutien

C'est un peu passe-partout-y, mais ne donne assez lisible à l'exception des messages comme ci-dessus (le min/max/valeur sont exposées ainsi, si vous choisissez d'attraper la dérivée type d'exception et peut faire quelque chose d'utile avec elle).

#include <stdexcept>
#include <sstream>
#define STRINGIZE(x) #x
#define STRINGIFY(x) STRINGIZE( x )
//handling for runtime value errors
#define BOUNDED_VALUE_ASSERT(MIN, MAX, VAL) \
if ((VAL) < (MIN) || (VAL) > (MAX)) { \
bounded_value_assert_helper(MIN, MAX, VAL, \
"BOUNDED_VALUE_ASSERT at " \
__FILE__ ":" STRINGIFY(__LINE__)); \
}
template <typename T>
struct BoundedValueException: public std::range_error
{
virtual ~BoundedValueException() throw() {}
BoundedValueException() = delete;
BoundedValueException(BoundedValueException const &other) = default;
BoundedValueException(BoundedValueException &&source) = default;
BoundedValueException(int min, int max, T val, std::string const& message)
: std::range_error(message), minval_(min), maxval_(max), val_(val)
{
}
int const minval_;
int const maxval_;
T const val_;
};
template <typename T> void bounded_value_assert_helper(int min, int max, T val,
char const *message = NULL)
{
std::ostringstream oss;
oss << "BoundedValueException: !("
<< min << "<="
<< val << "<="
<< max << ")";
if (message) {
oss << " - " << message;
}
throw BoundedValueException<T>(min, max, val, oss.str());
}

Valeur Classe

template <typename T, int Tmin, int Tmax> class BoundedValue
{
public:
typedef T value_type;
enum { min_value=Tmin, max_value=Tmax };
typedef BoundedValue<value_type, min_value, max_value> SelfType;
//runtime checking constructor:
explicit BoundedValue(T runtime_value) : val_(runtime_value) {
BOUNDED_VALUE_ASSERT(min_value, max_value, runtime_value);
}
//compile-time checked constructors:
BoundedValue(SelfType const& other) : val_(other) {}
BoundedValue(SelfType &&other) : val_(other) {}
template <typename otherT, int otherTmin, int otherTmax>
BoundedValue(BoundedValue<otherT, otherTmin, otherTmax> const &other)
: val_(other) //will just fail if T, otherT not convertible
{
static_assert(otherTmin >= Tmin,
"conversion disallowed from BoundedValue with lower min");
static_assert(otherTmax <= Tmax,
"conversion disallowed from BoundedValue with higher max");
}
//compile-time checked assignments:
BoundedValue& operator= (SelfType const& other) { val_ = other.val_; return *this; }
template <typename otherT, int otherTmin, int otherTmax>
BoundedValue& operator= (BoundedValue<otherT, otherTmin, otherTmax> const &other) {
static_assert(otherTmin >= Tmin,
"conversion disallowed from BoundedValue with lower min");
static_assert(otherTmax <= Tmax,
"conversion disallowed from BoundedValue with higher max");
val_ = other; //will just fail if T, otherT not convertible
return *this;
}
//run-time checked assignment:
BoundedValue& operator= (T const& val) {
BOUNDED_VALUE_ASSERT(min_value, max_value, val);
val_ = val;
return *this;
}
operator T const& () const { return val_; }
private:
value_type val_;
};

Cast Soutien

template <typename dstT, int dstMin, int dstMax>
struct BoundedCastHelper
{
typedef BoundedValue<dstT, dstMin, dstMax> return_type;
//conversion is checked statically, and always succeeds
template <typename srcT, int srcMin, int srcMax>
static return_type convert(BoundedValue<srcT, srcMin, srcMax> const& source)
{
return return_type(source);
}
//conversion is checked dynamically, and could throw
template <typename srcT, int srcMin, int srcMax>
static return_type coerce(BoundedValue<srcT, srcMin, srcMax> const& source)
{
return return_type(static_cast<srcT>(source));
}
};
template <typename dstT, int dstMin, int dstMax,
typename srcT, int srcMin, int srcMax>
auto safe_bounded_cast(BoundedValue<srcT, srcMin, srcMax> const& source)
-> BoundedValue<dstT, dstMin, dstMax>
{
return BoundedCastHelper<dstT, dstMin, dstMax>::convert(source);
}
template <typename dstT, int dstMin, int dstMax,
typename srcT, int srcMin, int srcMax>
auto unsafe_bounded_cast(BoundedValue<srcT, srcMin, srcMax> const& source)
-> BoundedValue<dstT, dstMin, dstMax>
{
return BoundedCastHelper<dstT, dstMin, dstMax>::coerce(source);
}

La délimité::integer bibliothèque fait ce que vous voulez (pour les types d'entiers seulement). http://doublewise.net/c++/borné/

(Dans l'intérêt de la divulgation complète, je suis l'auteur de cette bibliothèque)

Il diffère des autres bibliothèques qui tentent de fournir des "safe entiers" de manière significative: elle suit l'entier de limites. Je pense que cela est mieux illustré par l'exemple:

auto x = bounded::checked_integer<0, 7>(f());
auto y = 7_bi;
auto z = x + y;
//decltype(z) == bounded::checked_integer<7, 14>
static_assert(z >= 7_bi);
static_assert(z <= 14_bi);

x est un entier de type qui est entre 0 et 7. y est un entier de type entre le 7 et le 7. z est un entier de type entre 7 et 14. Toutes ces informations sont connues au moment de la compilation, c'est pourquoi nous sommes en mesure de static_assert sur elle, même si la valeur de z n'est pas une constante de compilation.

z = 10_bi;
z = x;
static_assert(!std::is_assignable<decltype((z)), decltype(0_bi)>::value);

La première affectation, z = 10_bi, n'est pas cochée. C'est parce que le compilateur ne peut pas prouver que 10 se situe dans la plage de z.

La deuxième cession, z = x, vérifie que la valeur de x est dans la gamme de z. Si non, il déclenche une exception (le comportement exact dépend du type d'entier que vous utilisez, il existe de nombreuses stratégies de quoi faire).

La troisième ligne, le static_assert, montre que c'est une erreur de compilation à assigner à partir d'un type qui n'a pas de chevauchement à tous. Le compilateur sait déjà c'est une erreur et ne vous arrête.

La bibliothèque n'est pas de convertir implicitement le type sous-jacent, ce qui peut causer beaucoup de situations où vous essayez de l'empêcher quelque chose, mais il se produit en raison de conversions. Il ne permet pas de conversion explicite.

Pour le moment, ce qui est impossible dans une manière portable en raison du C++ règles sur la façon de méthodes (et, par extension, les constructeurs) sont appelées, même avec les querelles constantes.

Dans le C++0x standard, vous pourriez avoir un const-expr qui permettrait une telle erreur peut être produit si.

(C'est en supposant que vous voulez qu'il lève une erreur si la valeur réelle est illégal. Si les plages ne correspondent pas, vous pouvez atteindre cet objectif)

Je voudrais offrir une autre version pour Kasprzol la solution: L'approche proposée utilise toujours les limites de type int. Vous pouvez obtenir un peu plus de souplesse et de sécurité de type avec une mise en œuvre telles que:

template<typename T, T min, T max>
class Bounded {
private:
T _value;
public:
Bounded(T value) : _value(min) {
if (value <= max && value >= min) {
_value = value;
} else {
//XXX throw your runtime error/exception...
}
}
Bounded(const Bounded<T, min, max>& b)
: _value(b._value){ }
};

Cela va permettre au vérificateur de types d'attraper évident miss affectations telles que:

Bounded<int, 1, 5> b1(1);
Bounded<int, 1, 4> b2(b1); //<-- won't compile: type mismatch

Cependant, le plus avancé de relations où vous voulez vérifier si la gamme d'un modèle, s'il est inclus dans la gamme d'une autre instance ne peut pas être exprimée dans le C++ mécanisme de template.

Tous les Borné cahier des charges devient un nouveau type. Ainsi, le compilateur peut vérifier les incompatibilités de type. Il ne peut pas vérifier pour les plus avancés des relations qui peuvent exister pour ces types de.