Is there an elegant way to declare a set of functions with the same template parameters?

Question

For instance, let's say I have a simple 2D vector templated structure:

template <typename T>
struct Vec { T x, y; };

And a generic way to do summation:

template <typename T, typename U>
constexpr auto operator+(const Vec<T>& u, const Vec<U>& v) {
    return Vec<decltype(u.x + v.x)>{u.x + v.x, u.y + v.y};
}

But I have to rewrite template <typename T, typename U> for all the other basic operations (-, *, / etc.). I wish I could do something like:

template <typename T, typename U>
{
    constexpr auto operator+(const Vec<T>& u, const Vec<U>& v) { /* ... */ };
    constexpr auto operator-(const Vec<T>& u, const Vec<U>& v) { /* ... */ };
    /* ... */
}

Also, as said in this thread, auto is not permitted when nested within a decl-specifier, which means that the below solution isn't valid (even if it compiles somehow):

constexpr auto operator+(const Vec<auto>& u, const Vec<auto>& v) { /* ... */ }

I was thinking about that, but aren't macros considered as evil and a bad practice? — Arthur R., Aug 01 '20 at 15:05
Should I say evil is subjective? :P What you wish to do can only be done through macros in C++, if at all. — Tanveer Badar, Aug 01 '20 at 15:06
Is it really that onerous to repeat `template ` line for each operator? C++ template metaprogramming is verbose; we all have to live with that. — Igor Tandetnik, Aug 01 '20 at 15:06
1. macros are evil. 2. your code should clearly state what it is doing and be easy to read. So, just use the full invocation for each operator. — rsjaffe, Aug 01 '20 at 15:18

score 0 · Answer 1 · answered Aug 01 '20 at 15:10

You can save one template parameter, by defining the operators inline:

template <typename T>
struct Vec {
    T x, y; 
    template<class U> auto operator+(Vec<U> const& v)
    { return Vec<decltype(x + v.x)>{x + v.x, y + v.y};}
    template<class U> auto operator-(Vec<U> const& v)
    { return Vec<decltype(x - v.x)>{x - v.x, y - v.y};}
};

If you completely want to avoid writing repetitive code, macros would be a way to avoid that (whether that is good practice, and whether it helps or disturbs understanding the code, is probably a question of taste and context)

Is there an elegant way to declare a set of functions with the same template parameters?

1 Answers1