CODEWITHSUNDEEP
c++templates
Clark Gaebel
Clark Gaebel

Reputation: 17948

Template class, function specialization

I want to have a template class that looks something like what I have down below. Then, I want a function in it with a template specialization depending on a CLASS template parameter. How do I make this work? I realize the code I provided is wrong on many levels, but it's just to illustrate the concept.

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!");
    }
};

Upvotes: 7

Views: 1568

Answers (3)

Michael Anderson
Michael Anderson

Reputation: 73480

This is called partial template specialisation. It looks like this:

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!");
    }
}

Upvotes: 1

vladr
vladr

Reputation: 66671

There are no partial specialisations of function templates, and to partially specialise a member you need to first partially specialise the class template.

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

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

Now, if Foo also contains methods other than Func whose implementation is independent of the value for num, and you don't want to duplicate their implementation in the specialization of Foo, you can apply the following pattern:

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() {
    ...
  }
};

Or, using 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");
  }
};

Upvotes: 2

Johannes Schaub - litb
Johannes Schaub - litb

Reputation: 506975

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>) { .. }
};

Upvotes: 10

Related Questions