c++ - 具有方法重载的接口(interface)类？

Question

假设我有一些类型

class A {…};
class B {…};
class C {…};
...

我还有一些其他类可以对这些类型的对象执行各种操作

class process1
{
public:
    void do_stuff(std::vector<A>& …);
};

class process2
{
public:
    void do_stuff(std::vector<B>& …);
    void do_stuff(std::vector<C>& …);
};

...

这些“进程”类共享一些公共(public)接口(interface) (do_stuff())，所以我自然想制作一个类/模板来“规范”这些类的编写方式。我想要类似的东西

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;
};

并让 process1 和 process2 从它派生。通过这种方式，我是说所有“进程”类都应该有一个 do_stuff()，并且不一定需要显式编写它，因为有一个默认版本。

但这当然行不通，因为 process2 有 2 个版本的 do_stuff()。 (其他一些“过程”类可能有更多。)那么有没有办法用这个“接口(interface)”类/模板实现我想要的？我在考虑使用可变参数模板，但我想这也行不通。

目前我所拥有的是:

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.");
    // }
};

但是它有问题。其一，do_stuff() 不能是虚拟的/纯虚拟的。如果我有其他需要相同处理的方法，比如那里的 do_other_stuff()，就没有办法强制子类对每个类型都有一个 do_other_stuff()可以 do_stuff() on.

Answer 1

也许您可以使 process2(以及所有需要更多 do_stuff() 的类成为一种可变自继承类。

作为

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;
 };

下面是一个完整的工作示例

#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>{});
 }

从C++17开始，不再需要自递归process2:你可以简单地使用解包using和process2成为

template <typename ... Ts>
struct process2 : public process_interface<Ts>...
 {
   using process_interface<Ts>::do_stuff ... ; 
 };