在 C++11 中声明接口的最佳方法

Question

众所周知，有些语言有接口的概念。这是Java：

public interface Testable {
  void test();
}

如何在 C++（或 C++11）中以最紧凑的方式实现这一点，并且代码噪音很小？我很欣赏不需要单独定义的解决方案（让标题就足够了）。这是一种非常简单的方法，即使我也觉得有问题 ;-)

class Testable {
public:
  virtual void test() = 0;
protected:
  Testable();
  Testable(const Testable& that);
  Testable& operator= (const Testable& that);
  virtual ~Testable();
}

这只是一个开始……而且已经比我想要的更长了。如何改进它？也许在 std 命名空间中的某个地方有一个专门为此而制作的基类？

Answer 1

对于动态（运行时）多态性，我建议使用 Non-Virtual-Interface (NVI) 习惯用法。这种模式保持接口非虚拟和公共，析构函数虚拟和公共，实现纯虚拟和私有

class DynamicInterface
{
public:
    // non-virtual interface
    void fun() { do_fun(); } // equivalent to "this->do_fun()"

    // enable deletion of a Derived* through a Base*
    virtual ~DynamicInterface() = default;    
private:
    // pure virtual implementation
    virtual void do_fun() = 0; 
};

class DynamicImplementation
:
    public DynamicInterface
{
private:
    virtual void do_fun() { /* implementation here */ }
};

动态多态性的好处在于，您可以在运行时传递任何派生类，其中需要指向接口基类的指针或引用。运行时系统会自动将this 指针从其静态基类型向下转换为其动态派生类型并调用相应的实现（通常通过带有指向虚函数的指针的表发生）。

对于静态（编译时多态性），我建议使用 Curiously Recurring Template Pattern (CRTP)。这是相当复杂的，因为动态多态的从基础到派生的自动向下转换必须使用static_cast 完成。这种静态转换可以在每个静态接口派生自的帮助类中定义

template<typename Derived>
class enable_down_cast
{
private:  
        typedef enable_down_cast Base;    
public:
        Derived const* self() const
        {
                // casting "down" the inheritance hierarchy
                return static_cast<Derived const*>(this);
        }

        Derived* self()
        {
                return static_cast<Derived*>(this);
        }    
protected:
        // disable deletion of Derived* through Base*
        // enable deletion of Base* through Derived*
        ~enable_down_cast() = default; // C++11 only, use ~enable_down_cast() {} in C++98
};

然后你像这样定义一个静态接口：

template<typename Impl>
class StaticInterface
:
    // enable static polymorphism
    public enable_down_cast< Impl >
{
private:
    // dependent name now in scope
    using enable_down_cast< Impl >::self;    
public:
    // interface
    void fun() { self()->do_fun(); }    
protected:
    // disable deletion of Derived* through Base*
    // enable deletion of Base* through Derived*
    ~StaticInterface() = default; // C++11 only, use ~IFooInterface() {} in C++98/03
};

最后你制作了一个从接口派生的实现，本身作为参数

class StaticImplementation
:
    public StaticInterface< StaticImplementation > 
{
private:
    // implementation
    friend class StaticInterface< StaticImplementation > ;
    void do_fun() { /* your implementation here */ }
};

这仍然允许您拥有同一接口的多个实现，但您需要在编译时知道您正在调用哪个实现。

那么什么时候使用哪个表单呢？这两种表单都可以让你重用一个通用接口，并在接口类中注入前置/后置条件测试。动态多态性的优点是您具有运行时灵活性，但您在虚函数调用中为此付出代价（通常通过函数指针进行调用，几乎没有内联的机会）。静态多态是它的镜像：没有虚函数调用开销，但缺点是您需要更多样板代码，并且您需要知道在编译时调用的是什么。基本上是效率/灵活性的权衡。

注意： 对于编译时多态性，您也可以使用模板参数。通过 CRTP 成语静态接口与普通模板参数的区别在于 CRTP 类型接口是显式的（基于成员函数），而模板接口是隐式的（基于有效表达式）

Answer 2

怎么样：

class Testable
{
public:
    virtual ~Testable() { }
    virtual void test() = 0;
}

在 C++ 中，这对子类的可复制性没有任何影响。所有这一切都是说孩子必须实现test（这正是您想要的接口）。你不能实例化这个类，所以你不必担心任何隐式构造函数，因为它们不能直接作为父接口类型调用。

如果您希望强制子类实现析构函数，您也可以将其设为纯（但您仍然必须在接口中实现它）。

另外请注意，如果您不需要多态破坏，您可以选择将您的析构函数设置为非虚拟的。

Answer 3

根据 Scott Meyers（有效的现代 C++）：在声明接口（或多态基类）时，您需要虚拟析构函数，以便在通过基类访问的派生类对象上获得正确的操作结果，例如 delete 或 typeid指针或引用。

virtual ~Testable() = default;

但是，用户声明的析构函数会禁止生成 移动操作，因此要支持移动操作，您需要添加：

Testable(Testable&&) = default; 
Testable& operator=(Testable&&) = default;

声明移动操作会禁用复制操作，您还需要：

Testable(const Testable&) = default;
Testable& operator=(const Testable&) = default;

最后的结果是：

class Testable 
{
public:
    virtual ~Testable() = default; // make dtor virtual
    Testable(Testable&&) = default;  // support moving
    Testable& operator=(Testable&&) = default;
    Testable(const Testable&) = default; // support copying
    Testable& operator=(const Testable&) = default;

    virtual void test() = 0;

};

这里还有一篇有趣的文章：The Rule of Zero in C++

Answer 4

将class替换成struct，默认所有方法都是公开的，可以省一行。

没有必要对构造函数进行保护，因为无论如何你都不能用纯虚方法实例化一个类。这也适用于复制构造函数。编译器生成的默认构造函数将是空的，因为您没有任何数据成员，并且对于您的派生类来说完全足够了。

您担心= 运算符是对的，因为编译器生成的运算符肯定会做错事。实际上，没有人会担心它，因为将一个接口对象复制到另一个是没有意义的。这不是经常发生的错误。

可继承类的析构函数应该始终是公共的和虚拟的，或者受保护的和非虚拟的。在这种情况下，我更喜欢 public 和 virtual。

最终结果只比 Java 等价的多一行：

struct Testable {
    virtual void test() = 0;
    virtual ~Testable();
};

Answer 5

请记住，如果您不管理指针、句柄和/或类的所有数据成员都有自己的析构函数来管理任何清理，那么“三法则”是不必要的。同样在虚拟基类的情况下，因为基类永远不能直接实例化，所以如果你想要做的只是定义一个没有数据成员的接口，则不需要声明构造函数......编译器默认值就好了。如果您计划在接口类型的指针上调用delete，您需要保留的唯一项目是虚拟析构函数。所以实际上你的界面可以很简单：

class Testable 
{
    public:
        virtual void test() = 0;  
        virtual ~Testable();
}