Multiple Integer-type classes in C++

Question

I often find myself using Integers to represent values in different "spaces". For example...

int arrayIndex;
int usersAge;
int daysToChristmas;

Ideally, I'd like to have separate classes for each of these types "Index","Years" and "Days", which should prevent me accidentally mixing them up. Typedefs are a help from a documnentation perspective, but aren't type-safe enough.

I've tried wrapper classes, but end up with too much boilerplate for my liking. Is there a straightforward template-based solution, or maybe something ready-to-go in Boost?

EDIT: Several people have talked about bounds-checking in their answers. That maybe a handy side-effect, but is NOT a key requirement. In particular, I don't just want to prevent out-of-bound assignments, but assignments between "inappropriate" types.

Answer 1

One funky "hack" you could use is a template non-type parameter to create wrapper types. This doesn't add any bounds but it does allow to treat them as different types with only one set of boilerplate template code. I.e.

template<unsigned i>
class t_integer_wrapper
  {
  private:
    int m_value;
  public:
     // Constructors, accessors, operators, etc.
  };

typedef t_integer_wrapper<1> ArrayIndex;
typedef t_integer_wrapper<2> UsersAge;

Extend the template with lower and upper bounds or other validation as you like. Not pretty by a long shot though.

Answer 2

I remember solving a similar problem with a simple template where you would specify the allowed range, i.e.

Int<0, 365> daysToChristmas;
Int<0, 150> usersAge;
Int<0, 6> dayOfWeek;

You get the point. Now you could just derive from such a template type, like

class DayOfYear: public Int<0, 365> {}

and you could no longer pass a user age to a function expecting a DayOfYear, and you wouldn't have to use the angled brackets.

Answer 3

Adding in the operator int () will allow you to use the object where a normal int is required. You can also add in a operator = () to set it within range.

class DayType 
  {
  public:
    static int const low = 1;
    static int const high = 365;
  };

template<class TYPE>
class Int
  {
  private:
    int m_value;
  public:
     operator int () { return m_value; }
     operator = ( int i ) { /* check and set*/ }
  };

  Int<DayType> day;
  int d = day;
  day = 23;

I hope this helps.

Answer 4

int arrayIndex;

This is what std::size_t is for.

int usersAge;

People can't have negative ages and it is not useful/easy to set a fixed upper bound for ages. So here you should just use unsigned int.

int daysToChristmas;

Days to Christmas requires special attention. The number of days until Christamas can range from 0-366. The simple solution is to write the following wherever needed:

assert( 0 < daysToChristmas && daysToChristmas < 366 )

If you feel you're going to duplicate that assert in too many places, then David Allan Finch proposes a neat solution for this case. Though I am partial to using the assert.

Answer 5

This is a generic "StrongType" template that we use to wrap different types and contexts. The only significant difference to this answer is that we prefer to use a tag-type that gives a meaningful name to each specialized wrapper type:

template <typename ValueType, class Tag> class StrongType {
public:
  inline StrongType() : m_value(){}
  inline explicit StrongType(ValueType const &val) : m_value(val) {}
  inline operator ValueType () const {return m_value; }
  inline StrongType & operator=(StrongType const &newVal) {
    m_value = newVal.m_value;
    return *this;
  }
private:
  //
  // data
  ValueType m_value;
};

And a use of the template as follows:

class ArrayIndexTag;
typedef StringType<int, ArrayIndexTag> StrongArrayIndex;
StringArrayIndex arrayIndex;

Notice too, that all of the functions are 'inline', the intention being that the compiler can do its best to generate exactly the same code it would generated had the template not been used at all!

Answer 6

Boost does in fact have a library specifically for this type of thing! Check out the Boost.Units library.

Answer 7

For an array index I'd use size_t provided I didn't need negative values, because that's what it's there for. Of course that frequently is unsigned int, so won't give you any type safety at all. However, anything that did give you type safety (i.e. that stopped you assigning an unsigned int to an array index) would also stop you returning a size_t value into your type. That might be too much type safety anyway.

You could probably use an enum for bounded ranges:

enum YearDay {
    FirstJan = 0,
    LastDecInLeapYear = 365
};

You can assign YearDay to int, but you can't assign an int (or another enum type) to YearDay without an explicit cast. Any value between the least and greatest named value in an enum is a valid value for the enum. Assigning a value outside the range [0,365] results in undefined behaviour. Or possibly an unspecified or implementation-defined result, I can't remember.

Age is tricky, because it's almost bounded, but not quite. You could use 969 (age of Methuselah) in an enum, or a class wrapping an int with explicit conversions as described by others.

Answer 8

In addition to the Boost Units library mentioned by Ryan Fox, there will be also the Boost Constrained Value library, which is currently under review.

Who knows when or if it will hit an official Boost release, but you can probably try it out anyway.

Answer 9

You could try BOOST_STRONG_TYPEDEF. From boost/strong_typedef.hpp:

// macro used to implement a strong typedef.  strong typedef
// guarentees that two types are distinguised even though the
// share the same underlying implementation.  typedef does not create
// a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
// that operates as a type T.

Answer 10

Check out this old CUJ article on this subject. IIRC the technique desribes how to make it work with all the fundamental operators