Class method with number of arguments specified by integer template parameter

Question

Was not exactly sure how to phrase this question or what to search on so if this is the same as another question please close and redirect to the appropriate question.

Suppose

template<typename Type, int Size> class vector
{
  Type data[Size];
}

Is it possible to replace a constructor which takes Size number of arguments in template specializations like this

template<typename Type> class vector3<Type,3>
{
  Type data[3];
  public:
    vector3( Type, Type, Type );
}

with something in the non-specialized template class? Like a "varargs constructor" that produces a constructor with Size number of arguments of type Type?

A solution involving C++0x features is fine.

Answer 1

Is it possible to replace a constructor which takes Size number of arguments in template specializations like this

Not without a ton of repetitive, mechanical code, and the maximum size will be limited by the number of times you repeat yourself. Case in point: boost::tuple (which might have exactly the functionality what you want).

In C++0x this won't be a problem thanks to variadic templates.

Answer 2

In C++0x you have template typedef finally available!

Disclaimer: nothing has been compiled...

From Wikipedia's article:

template< typename second>
using TypedefName = SomeType<OtherType, second, 5>;

which in your case would yield

template <class Type>
using vector3 = vector<Type, 3>;

I can't tell you how much I craved for this ;)

However it doesn't solve the parameters issue. As mentioned, you could try and use variadic templates here, however I am unsure as to their application in this case. The normal use is with recursive methods and you would need to throw a static_assert in the midst.

Edited to take the comments into account.

template <class Type, size_t Size>
class vector
{
public:
  template <class... Args>
  vector(Args... args): data({args...})
  {
    // Necessary only if you wish to ensure that the exact number of args
    // is passed, otherwise there could be less than requested
    BOOST_MPL_ASSERT_RELATION(sizeof...(Args), ==, Size);
  }

private:
  T data[Size];
};

Another possibility that is already available is to combine Preprocessor generation with boost::enable_if.

template <class Type, size_t Size>
class vector
{
public:
  vector(Type a0, typename boost::enable_if_c< Size == 1 >::type* = 0);
  vector(Type a0, Type a1, typename boost::enable_if_c< Size == 2 >::type* = 0);
  // ...
};

Using Boost.Preprocessor for the generation makes this easier.

BOOST_PP_REPEAT(MAX_COUNT, CONSTRUCTOR_MACRO, ~);

// where MAX_COUNT is defined to the maximum size you wish
// and CONSTRUCTOR_MACRO actually generates the constructor

#define CONSTRUCTOR_MACRO(z, n, data)                              \
  vector(                                                          \
    BOOST_PP_ENUM_PARAMS(n, Type a),                               \
    typename boost::enable_if_c< Size == n >::type* = 0            \
  );

The implementation of the constructor is left as an exercise for the reader. It's another call to BOOST_PP_REPEAT.

As you can see, it soon gets ugly, so you'll be better off if you can use the variadic template version.

Answer 3

There's a further solution to your problem: Using variadic template parameters in the initializer list

template<typename T, unsigned int N>
struct vector {
    T data[N];

    template<typename... Args>
    vector(Args... args) : data({args...}) { }
};

However the number of arguments only needs to be less or equal than N and their types only needs to be convertible to T.

Answer 4

First you should consider using std::array. It doesn't meet all your requirements but it's close enough that if the differences don't matter you can save yourself a lot of work. The problem is this cheap version will have construct that accepts 2 arguments as well as 3.

template< typename T>
using Vector3 = std::array<T,3>;

Vector3 v1{1,2,3};
Vector3 v2{1,2}; // it sounds like you want to disallow this case.

Otherwise you can create a custom class that acts a lot like std::array, except with a more picky constructor.

template<typename T, std::size_t SIZE>
class Vector
{
public:
   template< typename ... Args >
   Vector( Args ... args ) :
      data({args...})
   {
      static_assert( sizeof...(Args) == SIZE,
                     "Incorrect number of arguments passed to Vector constructor");
   }
   /* lots of extra code here to add std::array -like methods */
private:
   // could use std::array here as well.
   T data[3];
};

template< typename T >
using Vector3 = Vector<T,3>;

Vector3 v1(1,2,3);
Vector3 v2(1,2); // error at compile time.