Partial specialising function template with templated argument

Question

I've got a template function (for the sake of simplification, let's call it "add")

template<typename T>
inline T add(const T a, const T b)
{
    return a+b;
}

I can specialise it for certain types, but what I'd like to do is specialise it for a templated type.

In my case, my templated type is called Vec2<T>. It's a 2-dimensional trigonometric vector (as in x & y, rather than c++ vector!)

What I'd like to do is specialise my add function for the generic case of Vec2<T>, rather than have to specialise for each type that Vec2 may be used with.

The library that Vec2<T> comes from has typedefs for V2d (double), V2f (float) and V2i (int).

I can specialise for each of these using something like:

template<>
inline V2f add<V2f>(const V2f a, const V2f b)
{
    return V2f(a.x + b.x, a.y + b.y);
}

However, what I'd like to be able to do, and this is where I've found myself stuck, is something like:

template<typename S>
inline Vec2<S> add<Vec2<S> >(const Vec2<S> a, const Vec2<S> b)
{
    return Vec2<S>(a.x + b.x, a.y + b.y);
}

I feel like there must be a way of doing this, but I'm struggling to find the right syntax for it.

The accepted answer may be of interest to you http://stackoverflow.com/questions/39250545/sfinae-to-make-base-template-always-result-in-error — StoryTeller - Unslander Monica, Nov 14 '16 at 10:10

songyuanyao · Accepted Answer · 2016-11-14T10:33:54.410

Partial template specialization is not allowed for function templates (it only works with class templates). You could use function template overloading instead:

template<typename S>
inline Vec2<S> add(const Vec2<S>& a, const Vec2<S>& b)
{
    return Vec2<S>(a.x + b.x, a.y + b.y);
}

It'll be selected when you call add with all the instantiations of Vec2 as arguments.

It would be better to change the parameters to pass-by-const-reference to avoid copy.

StoryTeller - Unslander Monica · Answer 2 · 2016-11-14T10:19:41.763

You can't partially specialize function templates. But you can do it for class templates, so all your function needs to do is forward to one:

template<typename> struct add_impl;

template<typename T>
T add(const T a, const T b)
{
    return add_impl<T>::do_it(a, b);
}

template<typename T>
struct add_impl {
  static T do_it(const T a, const T b) { return a + b; }
};

template<typename S>
struct add_impl<Vec2<S> > {
  static Vec2<S> do_it(const Vec2<S> a, const Vec2<S> b) { 
    return Vec2<S>(a.x + b.x, a.y + b.y);
  }
};

Partial specialising function template with templated argument

2 Answers2