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

假设我有一些类型

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()。

最佳答案

也许您可以使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 ... ;
 };

关于c++ - 方法重载的接口(interface)类？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/50380730/