Метод класса с количеством аргументов, заданным целочисленным параметром шаблона

В C++0x наконец-то доступно template typedef!

Отказ от ответственности: ничего не скомпилировано...

Из статьи Википедии:

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

что в вашем случае даст

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

Я не могу передать вам, как сильно я жаждал этого ;)

Однако это не решает проблему параметров. Как уже упоминалось, вы можете попробовать использовать вариативные шаблоны здесь, однако я не уверен в их применении в этом случае. Нормальное использование - с рекурсивными методами, и вам нужно будет бросить static_assert посредине.

Отредактировано с учетом комментариев.

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

Еще одна возможность, которая уже доступна, — объединить генерацию препроцессора с 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);
  // ...
};

Использование Boost.Preprocessor для генерации упрощает эту задачу.

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

Реализация конструктора оставлена ​​читателю в качестве упражнения. Это еще один звонок BOOST_PP_REPEAT.

Как видите, вскоре это становится уродливым, поэтому вам будет лучше, если вы сможете использовать версию шаблона с переменным числом аргументов.

Есть еще одно решение вашей проблемы: использование вариативных параметров шаблона в списке инициализаторов.

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

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

Однако количество аргументов должно быть меньше или равно N, а их типы должны быть преобразованы только в T.

Можно ли заменить конструктор, который принимает количество аргументов Size в специализациях шаблона, подобных этому

Не обошлось и без тонны повторяющегося механического кода, а максимальный размер будет ограничен количеством повторений. Показательный пример: boost::tuple (который может иметь именно ту функциональность, которую вы хотите).

В C++0x это не будет проблемой благодаря вариативным шаблонам.

Сначала вы должны рассмотреть возможность использования std::array. Он не отвечает всем вашим требованиям, но достаточно близок, чтобы, если различия не имеют значения, вы могли сэкономить себе много работы. Проблема в том, что эта дешевая версия будет иметь конструкцию, которая принимает 2 аргумента, а не 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.

В противном случае вы можете создать собственный класс, который во многом похож на std::array, за исключением более привередливого конструктора.

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.