W jaki sposób dozwolony zakres liczby całkowitej może być ograniczony przez błędy czasu kompilacji?

Question

Chciałbym utworzyć typ, który jest liczbą całkowitą, ale z ograniczonym zakresem. Próba utworzenia wystąpienia tego typu o wartości spoza dozwolonego zakresu powinna spowodować błąd czasu kompilacji.

Znalazłem przykłady, które pozwalają na kompilowanie błędów czasu, które mają być wyzwalane, gdy enumeration value outside those specified is used, ale żadne nie pozwalają na ograniczony zakres liczb całkowitych (bez nazw).

Czy to możliwe?

Answer 1

Tak, ale to niezgrabne:

// 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) {} 
    int value_; 
public: 
    template <int Val> // This needs to be a template for compile time errors 
    static limited_int make_limited() { 
     static_assert(Val >= Min && Val <= Max, "Bad! Bad value."); 
     // If you don't have static_assert upgrade your compiler or use: 
     //typedef char assert_in_range[Val >= Min && Val <= Max]; 
     return Val; 
    } 

    int value() const { return 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>(); 
} 

Co będzie znacznie łatwiejsze, gdy C++0x jest obecnie z constexpr, static_assert i user defined literals.

Answer 2

To, o co prosisz, to funkcja Ada, ale nie C++. Nie wierzę, że możesz ograniczyć zakres liczby całkowitej podczas kompilacji.

Answer 3

Może być w stanie zrobić coś podobnego poprzez połączenie makr i statycznego assert C++ 0x.

#define SET_CHECK(a,b) { static_assert(b>3 && b<7); a=b; } 

Answer 4

Wartość całkowita środowiska wykonawczego może być sprawdzana tylko w środowisku wykonawczym, ponieważ istnieje tylko w środowisku wykonawczym, ale jeśli sprawdzisz wszystkie metody zapisu w czasie wykonywania, możesz zagwarantować jej zawartość. Możesz zbudować klasyczną, zastępczą klasę zastępczą z określonymi ograniczeniami.

Dla stałych całkowitych można użyć szablonu do wymuszenia takiej rzeczy.

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); 
    } 
}; 

Próba utworzenia tej klasy z wartością szablonu, która nie mieści się w zakresie, spowoduje niepowodzenie zastąpienia i błąd kompilacji. Oczywiście nadal będzie wymagać ozdoby z operatorami i innymi, aby zastąpić int, a jeśli chcesz, aby czas kompilacji gwarantował inne operacje, będziesz musiał zapewnić im funkcje statyczne (są prostsze sposoby na zapewnienie arytmetycznej kompilacji).

Answer 5

Cóż, jak zauważyłeś, istnieje już pewna forma diagnostyki dla wyliczeń.

Generalnie jest to surowe: oznacza to, że sprawdzenie jest "luźne", ale może również zapewnić prostą formę kontroli.

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

Zazwyczaj można przypisać (bez reklamacji) dowolne wartości między zdefiniowanymi minimalnymi i maksymalnymi wartościami.

Często można przypisać nieco więcej (myślę, że gcc działa z uprawnieniami 2).