Interface class with method overloads? - c++

Question

Suppose I have some types
class A {…};
class B {…};
class C {…};
...
And I have some other classes that does various things on objects of these types
class process1
{
public:
void do_stuff(std::vector<A>& …);
};
class process2
{
public:
void do_stuff(std::vector<B>& …);
void do_stuff(std::vector<C>& …);
};
...
These "process" classes share some common interface (do_stuff()), so naturally I want to make an class/template to "regulate" how these classes should be written. I want to have something like
template <class T>
class process_interface
{
public:
virtual void do_stuff(std::vector<T>& …)
{
// Default implementation.
}
// I might also want this.
// virtual void do_other_stuff(std::vector<T>& …) = 0;
};
and let process1 and process2 derive from it. In this way I'm saying that all "process" classes should have a do_stuff(), and that one doesn't necessarily need to write it explicitly because there a default version.
But of course this doesn't work, because process2 has 2 versions of do_stuff(). (Some other "process" classes may have more.) So is there a way to achieve what I want to with this "interface" class/template? I was thinking using a variadic template but I suppose that won't work either.
For now what I have is this:
class process_interface
{
public:
template <class T>
void do_stuff(std::vector<T>& …)
{
// Default implementation.
}
// template <class T>
// void do_other_stuff(std::vector<T>& …)
// {
// throw std::runtime_error("Nope.");
// }
};
But it has problems. For one, do_stuff() cannot be virtual/pure virtual. And if I have other methods that need the same treatment, like the do_other_stuff() there, there's no way to force the subclasses to have a do_other_stuff() for each type that one can do_stuff() on.

Answer 1

Maybe you can make process2 (and all classes with need of more do_stuff() a sort of variadic self inheriting class.
Something as
template <typename...>
struct process2;
template <typename T>
struct process2<T> : public process_interface<T>
{ };
template <typename T0, typename ... Ts>
struct process2<T0, Ts...> : public process_interface<T0>,
public process2<Ts...>
{
using process_interface<T0>::do_stuff;
using process2<Ts...>::do_stuff;
};
The following is a full working example
#include <vector>
class A {};
class B {};
class C {};
class D {};
template <typename T>
struct process_interface
{
virtual void do_stuff (std::vector<T> const &)
{ }
};
struct process1 : public process_interface<A>
{ };
template <typename...>
struct process2;
template <typename T>
struct process2<T> : public process_interface<T>
{ };
template <typename T0, typename ... Ts>
struct process2<T0, Ts...> : public process_interface<T0>,
public process2<Ts...>
{
using process_interface<T0>::do_stuff;
using process2<Ts...>::do_stuff;
};
int main ()
{
process1 p1;
process2<B, C, D> p2;
p1.do_stuff(std::vector<A>{});
p2.do_stuff(std::vector<B>{});
p2.do_stuff(std::vector<C>{});
p2.do_stuff(std::vector<D>{});
}
Starting from C++17, there is no needs of a self-recursive process2: you can use unpacking using and process2 simply become
template <typename ... Ts>
struct process2 : public process_interface<Ts>...
{
using process_interface<Ts>::do_stuff ... ;
};

Answer 2

Use your first version and use multiple inheritance:
class process2 : process_interface<B>, process_interface<C> {
public:
using process_interface<B>::do_stuff;
using process_interface<C>::do_stuff;
};
Note the using declarations bring do_stuff in the base classes to process2 itself, so both can be found by name lookup, then participate in overload resolution.
A Complete Example

Answer 3

This is a great case to illustrate why common functionallity sharing is better handled through composition than inheritance.
Here's a super simple way of getting what you want without any inheritance whatsoever:
class common_interface {
template <class T>
void do_stuff(std::vector<T>& …)
{
//...
}
};
class process_1 {
common_interface common_;
public:
void do_stuff(std::vector<A>& v) {
common_.do_stuff(v);
//...
}
};
class process_2 {
common_interface common_;
public:
void do_stuff(std::vector<B>& v) {
common_.do_stuff(v);
//...
}
void do_stuff(std::vector<C>& v) {
common_.do_stuff(v);
//...
}
};