Шаблонный класс, специализация функции

Question

Я хочу иметь шаблонный класс, который будет выглядеть примерно так, как у меня ниже. Затем мне нужна функция со специализацией шаблона в зависимости от параметра шаблона CLASS. Как мне сделать эту работу? Я понимаю, что приведенный мною код неверен на многих уровнях, но это просто для иллюстрации концепции.

template <typename _T, size_t num>
class Foo
{
    // If num == 1, I want to call this function...
    void Func<_T, 1>()
    {
        printf("Hi!");
    }

    // Otherwise, I want to call this version.
    void Func<_T, num>()
    {
        printf("Hello world!");
    }
};

Answer 1

struct Otherwise { };
template<size_t> struct C : Otherwise { };

// don't use _Uppercase - those names are reserved for the implementation
// (i removed the '_' char)
template <typename T, size_t num>
class Foo
{
public:
    void Func() { Func(C<num>()); }

private:
    // If num == 1, I want to call this function...
    void Func(C<1>)
    {
        printf("Hi 1!");
    }

    // If num == 2, I want to call this function...
    void Func(C<2>)
    {
        printf("Hi 2!");
    }

    // Otherwise, I want to call this version.
    void Func(Otherwise)
    {
        printf("Hello world!");
    }

    //// alternative otherwise solution:
    // template<size_t I>
    // void Func(C<I>) { .. }
};

Answer 2

Частичных специализаций функции нет шаблоны, и для частичной специализации члена необходимо сначала частично специализирую шаблон класса.

template< typename _T, size_t num >
struct Foo {
    void Func() {
        printf("Hello world!");
    }
};

template< typename _T >
struct Foo< _T, 1 > {
    void Func() {
        printf("Hi!");
    }
};

Теперь, если Foo также содержит методы, отличные от Func, реализация которых не зависит от значения num, и вы не хотите дублировать их реализацию в специализации Foo, вы можете применить следующий шаблон:

template< typename _T, size_t num >
struct FooFuncBase {
    void Func() {
        printf("Hello world!");
    }
};

template< typename _T >
struct FooFuncBase< _T, 1 > {
    void Func() {
        printf("Hi!");
    }
};

template< typename _T, size_t num >
struct Foo : public FooFuncBase< _T, num > {
  void OtherFuncWhoseImplementationDoesNotDependOnNum() {
    ...
  }
};

Или, используя CRTP :

template< typename _Derived, typename _T, size_t num >
struct FooFuncBase {
    void Func() {
        static_cast< _Derived* >(this)->OtherFuncWhoseImplementationDoesNotDependOnNum();
        printf("Hello world!");
    }
};

template< typename _Derived, typename _T >
struct FooFuncBase< _Derived, _T, 1 > {
    void Func() {
        static_cast< _Derived* >(this)->OtherFuncWhoseImplementationDoesNotDependOnNum();
        printf("Hi!");
    }
};

template< typename _T, size_t num >
struct Foo : public FooFuncBase< Foo< _T, num >, _T, num > {
  void OtherFuncWhoseImplementationDoesNotDependOnNum() {
    printf("Other");
  }
};

Answer 3

Это называется частичной специализацией шаблона. Это выглядит так:

template<typename _T, size_t num>
class FooBase
{
};

template <typename _T, size_t num>
class Foo : public FooBase<_T,num>
{
    void Func()
    {
        printf("Hello world!");
    }
};


template <typename _T>
class Foo<_T,1> : public FooBase<_T,num>
{
    void Func()
    {
        printf("Hi!");
    }
}