tags:

views:

135

answers:

5

I would like to create a type that is an integer value, but with a restricted range. Attempting to create an instance of this type with a value outside the allowable range should cause a compile time error.

I have found examples that allow compile time errors to be triggered when an enumeration value outside those specified is used, but none that allow a restricted range of integers (without names).

Is this possible?

A: 

What you are asking for is a feature of Ada, but not C++. I don't believe you can restrict a range of an integer during compile time.

Starkey
+3  A: 

Might be able to do something similar by combining macros and C++0x's static assert.

#define SET_CHECK(a,b) { static_assert(b>3 && b<7); a=b; }
softwarebug2.0
Now that's horrid :/ Please refrain from defining macros when the situation certainly doesn't call for it, a template function would be much better.
Matthieu M.
+4  A: 

Yes but it's clunky:

// Defining as template but the main class can have the range hard-coded
template <int Min, int Max>
class limited_int {
private:
    limited_int(int i) : value(i) {}
public:
    template <int Val> // This needs to be a template for compile time errors
    static limited_int make_limited() { 
        typedef char assert_in_range[Val >= Min && Val <= Max];
        return Val;
    }
    int value;
};

typedef limited_int<0, 9> digit ;
int main(int argc, const char**) 
{

    // Error can't create directly (ctor is private)
    //digit d0 = 5; 

    // OK
    digit d1 = digit::make_limited<5>(); 

    // Compilation error, out of range (can't create zero sized array)
    //digit d2 = digit::make_limited<10>(); 

    // Error, can't determine at compile time if argc is in range
    //digit d3 = digit::make_limited<argc>(); 
}

Things will be much easier when C++0x is out with constexpr, static_assert and user defined literals.

Motti
Nice idea with the array 0 or 1 sized. I used the regular enable_if technique.
DeadMG
This is great - To prevent a compiler warning over unused assert_in_range variable I have added " = {}" to that line.
Andrew Cecil
@DeadMG, this is the traditional way to do it, I used to use `enable_if` for its template coolness but came to realise it's overkill (`static_assert` is a welcome addition to the language)
Motti
@Andrew, actually it's better to just use a typedef (I was lazy when writing the answer) I'll update my answer.
Motti
@Motti, even better, thanks.
Andrew Cecil
+1  A: 

A runtime integer's value can only be checked at runtime, since it only exists at runtime, but if you make a runtime check on all writing methods, you can guarantee it's contents. You can build a regular integral replacement class with given restrictions for that.

For constant integers, you could use a template to enforce such a thing.

template<bool cond, typename truetype> struct enable_if {
};
template<typename truetype> struct enable_if<true, truetype> {
    typedef truetype type;
};
class RestrictedInt {
    int value;
    RestrictedInt(int N)
        : value(N) {
    }
public:
    template<int N> static typename enable_if< (N > lowerbound) && (N < upperbound), RestrictedInt>::type Create() {
        return RestrictedInt(N);
    }
};

Attempting to create this class with a template value that isn't within the range will cause a substitution failure and a compile-time error. Of course, it will still require adornment with operators et al to replace int, and if you want to compile-time guarantee other operations, you will have to provide static functions for them (there are easier ways to guarantee compile-time arithmetic).

DeadMG
A: 

Well, as you noticed, there is already a form of diagnostic for enumerations.

It's generally crude: ie the checking is "loose", but could provide a crude form of check as well.

enum Range { Min = 0, Max = 31 };

You can generally assign (without complaint) any values between the minimal and maximal values defined.

You can in fact often assign a bit more (I think gcc works with powers of 2).

Matthieu M.