CODEWITHSUNDEEP
c++templatestemplate-specializationfunction-templates
Skeen
Skeen

Reputation: 4722

C++ template specialization on functions

I'm playing around with template specialization, and I've found an issue I can't seem to solve; this is my code:

template<int length, typename T>
void test(T* array)
{
    ...
    test<length-1>(array);
}

template<typename T>
void test<0>(T* array)
{
    return;
}

So what I'm trying to do, is to pass the length, of what's to be processed in the template.

The problem is, that the compilation of this, well outputs forever:

a.cpp:83:43: error: template-id 'test<0>' in declaration of primary template
a.cpp: In function 'void test(T*) [with int length= -0x000000081, T = int]':
a.cpp:77:9:   instantiated from 'void test(T*) [with int length= -0x000000080, T = int]'
a.cpp:77:9:   instantiated from 'void test(T*) [with int length= -0x00000007f, T = int]'
a.cpp:77:9:   [ skipping 151 instantiation contexts ]
a.cpp:77:9:   instantiated from 'void test(T*) [with int length= 28, T = int]'
a.cpp:77:9:   instantiated from 'void test(T*) [with int length= 29, T = int]'
...
a.cpp: In function 'void test(T*) [with int length= -0x000000082, T = int]':
a.cpp:77:9:   instantiated from 'void test(T*) [with int length= -0x000000081, T = int]'
a.cpp:77:9:   instantiated from 'void test(T*) [with int length= -0x000000080, T = int]'

Last two lines, is pretty much the same as the first ones.

To me it would seem, its not catching the specialization, hence: 

a.cpp:83:43: error: template-id 'test<0>' in declaration of primary template

Am I correct?

And if I'm correct, I'm guessing it's the issue that partial template specialisation is not allowed for function templates, so what would be the solution then, making a struct, and using specialisation on that?

Upvotes: 20

Views: 23273

Answers (4)

R. Martinho Fernandes
R. Martinho Fernandes

Reputation: 234354

Partial specialization of function templates is not allowed. Herb Sutter explains why in his article "Why Not Specialize Function Templates?".

To work around this limitation you need to use class templates instead. You can then write a regular function template that uses that class template.

That specific error you're getting is because you forgot the second parameter in your specialization. If you this instead:

template<int length, typename T>
void test(T* array)
{
    //...
    test<length-1,T>(array);
}


template<typename T>
void test<0,T>(T* array)
{
    return;
}

GCC complains with the following:

error: function template partial specialization 'test<0, T>' is not allowed

Upvotes: 23

Sebastian Mach
Sebastian Mach

Reputation: 39089

You can workaround with a helper class. For illustrational purposes:

template<typename T, typename U> struct helper_t {
    static int foo () { return 0; }
};

template<typename T> struct helper_t<T,T> {
    static int foo () { return 1; }
};

template <typename T, typename U>
int frob () {
    return helper_t<T,U>::foo();
}

Upvotes: 2

Dark Falcon
Dark Falcon

Reputation: 44181

Functions cannot be partially specialized. To work around this, have your template function call a function in a class:

template<int length, typename T>
struct helper
{
    static void go(T* array)
    {
        ...
        helper<length-1, T>::go(array);
    }
};

template<typename T>
struct helper<0, T>
{
    static void go(T* array)
    {
        ...
    }
};

template<int length, typename T>
void test(T* array)
{
    ...
    helper<length, T>::go(array);
}

Upvotes: 9

NPE
NPE

Reputation: 500167

Partial specialization of function templates is not allowed.

To work around that, you could make test a static member of a class template, and partially specialize the class.

Upvotes: 3

Related Questions