CODEWITHSUNDEEP
c++templatesc++17
no one special
no one special

Reputation: 1764

template function for complex types

Is there any way in C++17 or older to use single template implementation of function compute in the code below?

template <typename T>
class C
{
    public:

        T x, y;

        C() = default;
        C(T x, T y) : x(x), y(y) {}

        operator T() const { return x; }
        C operator +(const C<T> &c) const { return C(x + c.x, y + c.y); }
        C operator +(const T &t) const { return C(x + t, y); }
};

template <typename T>
void compute(C<T> *a, T *b, size_t size)
{
    while (size--)
        a[size] = a[size] + b[size];
}

template <typename T>
void compute(T *a, C<T> *b, size_t size)
{
    while (size--)
        a[size] = a[size] + b[size];
}

template <typename T>
void compute(C<T> *a, C<T> *b, size_t size)
{
    while (size--)
        a[size] = a[size] + b[size];
}

int main()
{
    const size_t size = 4;
    C<float> a[size];
    float b[size];
    compute(a, b, size);
    compute(b, a, size);
    compute(a, a, size);
}

Upvotes: 0

Views: 340

Answers (1)

n. m. could be an AI
n. m. could be an AI

Reputation: 120049

Yes, if you are willing to tolerate a little boilerplate (I imagine you have many, many functions just like compute).

template <typename A, typename B>
struct is_cable_t : std::false_type {};

template <typename A>
struct is_cable_t<A, C<A>> : std::true_type {};

template <typename A>
struct is_cable_t<C<A>, A> : std::true_type {};

template <typename A>
struct is_cable_t<C<A>, C<A>> : std::true_type {};

template <typename A, typename B>
constexpr bool is_cable_v = is_cable_t<A,B>::value;

template <typename K, typename S, 
          typename R = typename std::enable_if<is_cable_v<K,S>>::type>
void compute(K *a, S *b, size_t size)
{
    while (size--)
        a[size] = a[size] + b[size];
}

Upvotes: 3

Related Questions