C++ template range

Question

From a previous question I got an answer that included some template magic (that to be blunt was mind-boggling (as I could not understand it)).

So I have been trying to achieve the same results (because trying helps me learn).
To make sure I have learn correctly I am putting it here for comment. Hopefully it will also help somebody else (and you never know it may encourage me to write a blog post about it).

Template based ranges (I am sure it has been done to death).

The idea you provide a range that expanded by the template to make writing code easier. So the code I use to test it is working correctly.

template<typename>
struct printNumberRange;

// Only a specialization for my range is implemented.
template<int... N>
struct printNumberRange<Sizes<N...>>
{
    static void call()
    {
        std::vector<int> v {N...};
        std::copy(std::begin(v), std::end(v), std::ostream_iterator<int>(std::cout, "\n"));
    }
};

// Function to deduce the arguments and
// Call the print correctly.
template<int S, int E>
void printRange()
{
    print<typename Range<S,E>::type>::call();
}

int main()
{
    // Print the range using a template
    printRange<3,8>();
}

Version 1

The template code I started with:

template<int... N>
struct Sizes
{
    typedef Sizes<N...>       type;
};

template<int C, int P, int... N>
struct GetRange
{
    typedef typename GetRange<C-1, P+1, N..., P>::type      type;
};
template<int P, int... N>
struct GetRange<0, P, N...>
{
    typedef typename Sizes<N..., P>::type                   type;
};

template<int S, int E>
struct Range
{
    typedef typename GetRange<E-S, S>::type       type;
};

But it seems the trend nowadays is to use inheritance to get rid of the ugly typedef typename .... at each level:

Version 2

This should be exactly the same.
But we use inheritance to get the type of the terminal class in the recursion. Personally I find this much harder to read than the previous version. But it is more compact.

template<int... N>
struct Sizes
{
    typedef Sizes<N...>       type;
};

template<int C, int P, int... N>
struct GetRange: GetRange<C-1, P+1, N..., P>
{};
template<int P, int... N>
struct GetRange<0, P, N...>: Sizes<N...>
{};

template<int S, int E>
struct Range: GetRange<E-S+1, S>
{};

I can specialize printNumberRange to take a range directly.

template<int S, int E>
struct printNumberRange<Range<S, E>>:
     printNumberRange<typename Range<S,E>::type>  // Inherits from the version
{};                                               // That takes a Sizes<int...>

Then the print becomes:

int main()
{
   printNumberRange<Range<4,18>>::call();
}

Any comments on the Range stuff or the test harness welcome.

Answer 1

Generally speaking, it's good and works great (version 2 seems better). There are some things that could be changed/added though:

• In C++, ranges tend to be [begin, end) ranges. Your compile-time integer ranges are actually [begin, end] ranges. The last element should not be included in the range. Therefore, you change this code:

  template<int S, int E>
  struct Range: GetRange<E-S+1, S>
  {};
  

  By this one:

  template<int S, int E>
  struct Range: GetRange<E-S, S>
  {};
  

  I tried it and it even works for Range<8,8> by producing an empty range.

• Currently, your Range only works for increasing ranges of values (and empty ones). You could modify your code so that it also works with decreasing ranges of values. What I did is probably not really clean, but it works (take it as a proof of concept). I replaced Range and GetRange by the following classes:

  template<int C, int P, int... N>
  struct GetIncreasingRange:
      GetIncreasingRange<C-1, P+1, N..., P>
  {};
  
  template<int C, int P, int... N>
  struct GetDecreasingRange:
      GetDecreasingRange<C+1, P-1, N..., P>
  {};
  
  template<int P, int... N>
  struct GetIncreasingRange<0, P, N...>:
      Sizes<N...>
  {};
  
  template<int P, int... N>
  struct GetDecreasingRange<0, P, N...>:
      Sizes<N...>
  {};
  
  template<int S, int E, bool Increasing=(S<E)>
  struct Range;
  
  template<int S, int E>
  struct Range<S, E, true>:
      GetIncreasingRange<E-S, S>
  {};
  
  template<int S, int E>
  struct Range<S, E, false>:
      GetDecreasingRange<E-S, S>
  {};
  

  These ranges are [begin, end) ranges and also work for empty ranges.

• Another possible improvement would be to let the user choose the integer type he wants to use for his range. That is actually what is done in the C++14 class std::integer_sequence, provided along with std::index_sequence which is its specialization for a range of std::size_t values. Here is a possible implementation.

• Also, in your function call, you can drop the std::vector and replace it by std::array. The number of values is known at compile time (thanks to the operator sizeof...), so there's no need to use a dynamic storage container.

  static void call()
  {
      std::array<int, sizeof...(N)> v { N... };
      std::copy(std::begin(v), std::end(v), std::ostream_iterator<int>(std::cout, "\n"));
  }