Template Function Specialisation C++

Question

I need to implement algorithm, that recursively calculates the scalar product of two vectors using templates.

There is my code:

#include <iostream>
#include <vector>

template<typename T, int Size>
T scalar_product(const std::vector<T> &a, const std::vector<T> &b)
{
    return a[Size - 1]*b[Size - 1] + (scalar_product<T, Size - 1>(a, b));
}

template<typename T>
T scalar_product<T, 0>(const std::vector<T> &a, const std::vector<T> &b) // error!
{
    return a[0] * b[0];
}

int main()
{
    std::vector<int> a(3, 1);
    std::vector<int> b(3, 3);

    std::cout << scalar_product<int, 3>(a, b);
    return 0;
}

If I use this specialisation T scalar_product<T, 0>(...), I get error "'scalar_product' : illegal use of explicit template arguments". But if I remove it like this T scalar_product(...) compiler report that recursion is going to be infinite (because there is no specialisation, as I understand).

There are a lot of questions of this type here, but I wasn't able to find useful answer. How can I specialize this function without using classes? Thank you beforehand!

Not related to your question but you can have a base case in your main recursive function that checks if size == 1, do this, else that. — Abhishek Bansal, Dec 10 '13 at 10:02
I guess you are using Visual Studio. GCC/Clang error message is clearer: "**function template partial specialization is not allowed**" — gx_, Dec 10 '13 at 10:04
Why function templates cannot be partially specialized: http://stackoverflow.com/questions/5101516/why-function-template-cannot-be-partially-specialized — Peter, Dec 10 '13 at 10:07
Btw your base case is wrong: it should be `` not ``, or `` should `return 0;` — gx_, Dec 10 '13 at 10:16
FYI, there is a standard library algorithm [`std::inner_product`](http://en.cppreference.com/w/cpp/algorithm/inner_product) that will perform this task. — Blastfurnace, Dec 10 '13 at 11:08

score 4 · Accepted Answer · edited May 23 '17 at 11:57

4

There is no partial function template specialization. You can either use a functor, which can be partially specialized:

template<typename T, int Size>
struct myFunctor
{
    T scalar_product(const std::vector<T> &a, const std::vector<T> &b)
    {
        static_assert(Size > 0,"Size must be positive!")
        return a[Size - 1]*b[Size - 1] + (myFunctor<typename T, Size - 1>::scalar_product(a, b));
    }
};
template<typename T>
struct myFunctor<T,1>
{
    T scalar_product(const std::vector<T> &a, const std::vector<T> &b)
    {
        return a[0] * b[0];
    }
};

Or you can achieve something like partial function specialization by using std::enable_if.

template<typename T, int Size>
typename std::enable_if<(Size>1), T>::type scalar_product(const std::vector<T> &a, const std::vector<T> &b)
{
    return a[Size - 1]*b[Size - 1] + (scalar_product<T, Size - 1>(a, b));
}
template<typename T, int Size>
T scalar_product(const std::vector<T> &a, const std::vector<T> &b, typename std::enable_if<(Size == 1), void*>::type x = nullptr)
{
    return a[0] * b[0];
}

Notice that I used 2 different ways to use std::enable_if in the 2 functions only to show that both are possible. Both functions can use enable_if on the return type like the first function does, and both of them could use them on an argument like the second function does. For additional reading see SFINAE.

Or as a third option you can handle the specialization inside the function like this:

template<typename T, int Size>
T scalar_product(const std::vector<T> &a, const std::vector<T> &b)
{
    static_assert(Size > 0,"Size must be positive!")
    if (Size==1)
        return a[0] * b[0];
    return a[Size - 1]*b[Size - 1] + (scalar_product<T, (Size==1) ? Size : Size - 1>(a, b));
}

Note that without (Size==0) ? Size : Size - 1, the compiler will create a function for all values of int, or die trying.

edited May 23 '17 at 11:57

Community

1
1

answered Dec 10 '13 at 10:12

Peter

5,608
1
24
43

Have you tried to compile this? http://ideone.com/nlxF0G – n. m. could be an AI Dec 10 '13 at 10:17
It should be `template` in `myFunctor` specialization. – Evgeny Timoshenko Dec 10 '13 at 10:20
When I use the second variant I get "fatal error C1202: recursive type or function dependency context too complex", which says that compiler needs specialisation, but if can't find it inside function. – Ann Orlova Dec 10 '13 at 10:45
Sorry for that. I added the explanation for this issue, and a workaround (use char instead of int). – Peter Dec 10 '13 at 10:47
3

@Peter “use char instead of int” is a _terrible_ workaround. Better “guard” the recursive instantiation with `scalar_product`: http://ideone.com/n5ZvKD (_edit:_ or use your `Max::value` alternative indeed) – gx_ Dec 10 '13 at 10:55
@ideone.com/n5ZvKD I forgot that that works. Thanks. I changed the answer accordingly. – Peter Dec 10 '13 at 11:00
2

I think it should rather be `Size==1` instead of `Size==0`, and protect against `Size<=0` via a `static_assert`. – dyp Dec 10 '13 at 11:01
Thank you for explanation! The second variant is working now. – Ann Orlova Dec 10 '13 at 11:04
Yes, it should be (Size == 1) – Ann Orlova Dec 10 '13 at 11:04
AFAIK the string-literal in a `static_assert(constant-expression, string-literal);` is not optional. – dyp Dec 10 '13 at 11:05
It's been too long since I did C++. Thanks for the help guys! Anything else? – Peter Dec 10 '13 at 11:06

Template Function Specialisation C++

1 Answers1