Sorry to come late to this discussion, busy, busy... In the date_time library there is a class called constrained_value that does something very similar to what you are attempting. It uses a policy to define the error handling -- so you throw an exception or whatever. In the case of date_time it is used exclusively during construction to do range checking of input. So the class doesn't support arithmetic operators. By creating a bunch of these small utitlity classes almost all user input checking is performed transparently by simple construction. That is: //actually constructs 3 objects to check range of year, month, day date d(2004, 4, 1); So I think you can argue that there is some use to the subrange idea. Here's the details on how it gets used: //from boost/date_time/greg_month.hpp //! Exception thrown if a greg_month is constructed with a value out of range struct bad_month : public std::out_of_range { bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {} }; //! Build a policy class for the greg_month_rep typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies; //! A constrained range that implements the gregorian_month rules typedef CV::constrained_value<greg_month_policies> greg_month_rep; And here's the code that implements it. //from boost/date_time/constrained_value.hpp namespace boost { //! Namespace containing constrained_value template and types namespace CV { //! Represent a min or max violation type enum violation_enum {min_violation, max_violation}; //! A template to specify a constrained basic value type /*! This template provides a quick way to generate * an integer type with a constrained range. The type * provides for the ability to specify the min, max, and * and error handling policy. * * <b>value policies</b> * A class that provides the range limits via the min and * max functions as well as a function on_error that * determines how errors are handled. A common strategy * would be to assert or throw and exception. The on_error * is passed both the current value and the new value that * is in error. * */ template<class value_policies> class constrained_value { public: typedef typename value_policies::value_type value_type; // typedef except_type exception_type; constrained_value(value_type value) { assign(value); }; constrained_value& operator=(value_type v) { assign(v); return *this; } //! Return the max allowed value (traits method) static value_type max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();}; //! Return the min allowed value (traits method) static value_type min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();}; //! Coerce into the representation type operator value_type() const {return value_;}; protected: value_type value_; private: void assign(value_type value) { //adding 1 below gets rid of a compiler warning which occurs when the //min_value is 0 and the type is unsigned.... if (value+1 < (min)()+1) { value_policies::on_error(value_, value, min_violation); return; } if (value > (max)()) { value_policies::on_error(value_, value, max_violation); return; } value_ = value; } }; //! Template to shortcut the constrained_value policy creation process template<typename rep_type, rep_type min_value, rep_type max_value, class exception_type> class simple_exception_policy { public: typedef rep_type value_type; static rep_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; }; static rep_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value;}; static void on_error(rep_type, rep_type, violation_enum) { throw exception_type(); } }; } } //namespace CV