如何在 C++ 中声明接口？

Question

如何设置代表接口的类？ 这只是一个抽象基类吗？

Answer 1

使用纯虚方法创建一个类。 通过创建另一个重写这些虚拟方法的类来使用该接口。

纯虚方法是定义为虚方法并赋值为 0 的类方法。

class IDemo
{
    public:
        virtual ~IDemo() {}
        virtual void OverrideMe() = 0;
};

class Child : public IDemo
{
    public:
        virtual void OverrideMe()
        {
            // do stuff
        }
};

Answer 2

要扩展 bradtgmurray 的答案，您可以想要通过添加虚拟析构函数来对接口的纯虚拟方法列表做出一个例外。 这允许您将指针所有权传递给另一方，而无需公开具体的派生类。 析构函数不必执行任何操作，因为该接口没有任何具体成员。 将函数定义为虚拟函数和内联函数似乎是矛盾的，但相信我 - 事实并非如此。

class IDemo
{
    public:
        virtual ~IDemo() {}
        virtual void OverrideMe() = 0;
};

class Parent
{
    public:
        virtual ~Parent();
};

class Child : public Parent, public IDemo
{
    public:
        virtual void OverrideMe()
        {
            //do stuff
        }
};

您不必包含虚拟析构函数的主体 - 事实证明，某些编译器在优化空析构函数时遇到困难，您最好使用默认值。

Answer 3

除了 C#/ 中的抽象基类之外，您还拥有特殊的 Interface 类型类别的全部原因Java是因为C#/Java不支持多重继承。

C++ 支持多重继承，因此不需要特殊类型。 没有非抽象（纯虚拟）方法的抽象基类在功能上等同于 C#/Java 接口。

Answer 4

C++ 本身没有“接口”的概念。 AFAIK，接口首先在 Java 中引入是为了解决多重继承的缺乏。 事实证明这个概念非常有用，在 C++ 中通过使用抽象基类也可以达到相同的效果。

抽象基类是这样一种类，其中至少有一个成员函数（Java 术语中的方法）是使用以下语法声明的纯虚函数：

class A
{
  virtual void foo() = 0;
};

抽象基类无法实例化，即不能声明类 A 的对象。只能从 A 派生类，但任何不提供 foo() 实现的派生类也将是抽象类。 为了不再是抽象的，派生类必须为其继承的所有纯虚函数提供实现。

请注意，抽象基类可以不仅仅是一个接口，因为它可以包含非纯虚的数据成员和成员函数。 接口的等效项是没有任何数据成员且仅包含纯虚函数的抽象基类。

而且，正如 Mark Ransom 指出的那样，抽象基类应该提供一个虚拟析构函数，就像任何基类一样。

考虑这个问题的一个好方法是继承接口与继承实现。 在 C++ 中，您可以同时继承接口和实现（公共继承），也可以仅继承实现（私有继承）。 在 Java 中，您可以选择仅继承接口，而不继承实现。

Answer 5

据我测试，添加虚拟析构函数非常重要。 我使用的是用 new 创建并用 delete 销毁的对象。

如果接口中没有添加虚析构函数，那么继承类的析构函数就不会被调用。

class IBase {
public:
    virtual ~IBase() {}; // destructor, use it to call destructor of the inherit classes
    virtual void Describe() = 0; // pure virtual method
};

class Tester : public IBase {
public:
    Tester(std::string name);
    virtual ~Tester();
    virtual void Describe();
private:
    std::string privatename;
};

Tester::Tester(std::string name) {
    std::cout << "Tester constructor" << std::endl;
    this->privatename = name;
}

Tester::~Tester() {
    std::cout << "Tester destructor" << std::endl;
}

void Tester::Describe() {
    std::cout << "I'm Tester [" << this->privatename << "]" << std::endl;
}


void descriptor(IBase * obj) {
    obj->Describe();
}

int main(int argc, char** argv) {

    std::cout << std::endl << "Tester Testing..." << std::endl;
    Tester * obj1 = new Tester("Declared with Tester");
    descriptor(obj1);
    delete obj1;

    std::cout << std::endl << "IBase Testing..." << std::endl;
    IBase * obj2 = new Tester("Declared with IBase");
    descriptor(obj2);
    delete obj2;

    // this is a bad usage of the object since it is created with "new" but there are no "delete"
    std::cout << std::endl << "Tester not defined..." << std::endl;
    descriptor(new Tester("Not defined"));


    return 0;
}

如果您在没有 virtual ~IBase() {}; 的情况下运行前面的代码，您将看到析构函数 Tester::~Tester() 从未被调用。

Answer 6

我的答案基本上与其他人相同，但我认为还有另外两件重要的事情要做：

1. 在界面中声明一个虚拟析构函数或创建一个受保护的非虚拟析构函数，以避免在有人尝试删除对象时出现未定义的行为IDemo 类型。

2. 使用虚拟继承来避免多重继承的问题。 （当我们使用接口时，更常见的是多重继承。）

并且像其他答案一样：

• 使用纯虚方法创建一个类。

• 通过创建另一个覆盖这些虚拟方法的类来使用该接口。

  类 IDemo 
    { 
        民众： 
            虚拟无效 OverrideMe() = 0; 
            虚拟 ~IDemo() {} 
    } 
    

  或者

  类 IDemo 
    { 
        民众： 
            虚拟无效 OverrideMe() = 0; 
        受保护： 
            ~IDemo() {} 
    } 
    

  和

  class Child : virtual public IDemo 
    { 
        民众： 
            虚拟无效 OverrideMe() 
            { 
                //做东西 
            } 
    } 
    

Answer 7

在 C++11 中，您可以轻松地完全避免继承：

struct Interface {
  explicit Interface(SomeType& other)
  : foo([=](){ return other.my_foo(); }), 
    bar([=](){ return other.my_bar(); }), /*...*/ {}
  explicit Interface(SomeOtherType& other)
  : foo([=](){ return other.some_foo(); }), 
    bar([=](){ return other.some_bar(); }), /*...*/ {}
  // you can add more types here...

  // or use a generic constructor:
  template<class T>
  explicit Interface(T& other)
  : foo([=](){ return other.foo(); }), 
    bar([=](){ return other.bar(); }), /*...*/ {}

  const std::function<void(std::string)> foo;
  const std::function<void(std::string)> bar;
  // ...
};

在这种情况下，接口具有引用语义，即您必须确保对象比接口寿命更长（也可以创建具有值语义的接口）。

这些类型的接口各有优缺点：

• 它们需要更多内存 比基于继承的多态性。
• 它们通常比基于继承的多态性更快。
• 在您知道最终类型的情况下，它们要快得多！（一些编译器，如 gcc 和 clang，在没有虚拟函数的类型/从具有虚拟函数的类型继承的类型中执行更多优化）。

最后，继承是复杂软件设计中的万恶之源。 在 Sean Parent 的价值语义和基于概念的多态性（强烈推荐，该技术的更好版本）在那里进行了解释）研究了以下案例：

假设我有一个应用程序，其中我使用 MyShape 接口以多态方式处理我的形状：

struct MyShape { virtual void my_draw() = 0; };
struct Circle : MyShape { void my_draw() { /* ... */ } };
// more shapes: e.g. triangle

在您的应用程序中，您使用 对不同的形状执行相同的操作>YourShape 界面：

struct YourShape { virtual void your_draw() = 0; };
struct Square : YourShape { void your_draw() { /* ... */ } };
/// some more shapes here...

现在假设您想使用我在您的应用程序中开发的一些形状。 从概念上讲，我们的形状具有相同的界面，但为了使我的形状在您的应用程序中工作，您需要按如下方式扩展我的形状：

struct Circle : MyShape, YourShape { 
  void my_draw() { /*stays the same*/ };
  void your_draw() { my_draw(); }
};

首先，修改我的形状可能根本不可能。 此外，多重继承导致了意大利面条式代码的发展（想象一下第三个项目使用 TheirShape 接口......如果他们也调用其绘制函数 my_draw 会发生什么？）。

更新：有一些关于基于非继承的多态性的新参考文献：

• Sean Parent 的 继承是邪恶的基类谈话。
• Sean Parent 的价值语义和基于概念的多态性演讲。
• Pyry Jahkola 的无继承多态性演讲和poly 库文档。
• Zach Laine 的实用类型擦除：用优雅的设计模式解决 OOP 问题演讲。
• Andrzej 的 C++ 博客 - 类型擦除部分 i, < a href="http://akrzemi1.wordpress.com/2013/12/06/type-erasure-part-ii/" rel="noreferrer">ii, iii 和 iv。
• 运行时多态泛型编程 - 在 ConceptC++ 中混合对象和概念
• Boost.TypeErasure 文档
• Adobe Poly 文档
• Boost.Any, std::任何提案（修订版 3）、Boost.Spirit::hold_any。

Answer 8

对上面写的内容进行一点补充：

首先，确保您的析构函数也是纯虚拟的

。其次，您可能希望在实现时虚拟继承（而不是正常继承），只是为了采取良好的措施。

Answer 9

在 C++20 中，您可以使用概念而不是类。
它比继承更有效率。

template <class T>
concept MyInterface = requires (T t) {
    { t.interfaceMethod() };
};

class Implementation {
public:
    void interfaceMethod();
};
static_assert(MyInterface<Implementation>);

然后你可以在函数中使用它：

void myFunction(MyInterface auto& arg);

限制是你不能在容器中使用它。

Answer 10

虽然 virtual 确实是定义接口的事实上的标准，但我们不要忘记经典的类似 C 的模式，它带有 C++ 中的构造函数：

struct IButton
{
    void (*click)(); // might be std::function(void()) if you prefer

    IButton( void (*click_)() )
    : click(click_)
    {
    }
};

// call as:
// (button.*click)();

这样做的优点是您可以重新- 运行时绑定事件，无需再次构造类（因为 C++ 没有用于更改多态类型的语法，这是变色龙类的解决方法）。

提示：

• 您可以从该类继承作为基类（允许虚拟和非虚拟）并在后代的构造函数中填充click。
• 您可能将函数指针作为 protected 成员，并具有 public 引用和/或 getter。
• 如上所述，这允许您在运行时切换实现。 因此，它也是一种管理状态的方法。 根据代码中 if 的数量与状态更改的数量，此可能比 switch()es 或 if 更快s（预计周转时间约为 3-4 个 ifs，但始终先进行测量。
• 如果您选择 std::function<> 而不是函数指针，则可能能够管理IBase中的所有对象数据。从这一点开始，您就可以获得IBase的值示意图（例如，）。 std::vector 可以工作）。 ; 与函数指针甚至虚函数相比，往往会产生开销（这在将来可能会改变）。

Answer 11

上面都是很好的答案。
您应该记住的另一件事 - 您还可以拥有纯虚拟析构函数。 唯一的区别是您仍然需要实现它。

使困惑？

    --- header file ----
    class foo {
    public:
      foo() {;}
      virtual ~foo() = 0;

      virtual bool overrideMe() {return false;}
    };

    ---- source ----
    foo::~foo()
    {
    }

您想要这样做的主要原因是，如果您想提供接口方法，就像我一样，但使重写它们成为可选的。

要使该类成为接口类，需要一个纯虚方法，但所有虚方法都有默认实现，因此剩下的唯一使纯虚方法是析构函数。

在派生类中重新实现析构函数根本不是什么大问题 - 我总是在派生类中重新实现析构函数，无论是否是虚拟的。

Answer 12

您还可以考虑使用 NVI（非虚拟接口模式）实现的合约类。 例如：

struct Contract1 : boost::noncopyable
{
    virtual ~Contract1() = default;
    void f(Parameters p) {
        assert(checkFPreconditions(p)&&"Contract1::f, pre-condition failure");
        // + class invariants.
        do_f(p);
        // Check post-conditions + class invariants.
    }
private:
    virtual void do_f(Parameters p) = 0;
};
...
class Concrete : public Contract1, public Contract2
{
private:
    void do_f(Parameters p) override; // From contract 1.
    void do_g(Parameters p) override; // From contract 2.
};

Answer 13

如果您使用 Microsoft 的 C++ 编译器，那么您可以执行以下操作：

struct __declspec(novtable) IFoo
{
    virtual void Bar() = 0;
};

class Child : public IFoo
{
public:
    virtual void Bar() override { /* Do Something */ }
}

我喜欢这种方法，因为它会产生更小的接口代码，并且生成的代码大小可以明显更小。 使用 novtable 会删除对该类中 vtable 指针的所有引用，因此您永远无法直接实例化它。 请参阅此处的文档 - novtable。

Answer 14

我对 C++ 开发还是个新手。 我从 Visual Studio (VS) 开始。

然而，似乎没有人提到 VS (.NET) 中的 __interface。 我不太非常确定这是否是声明接口的好方法。 但它似乎提供了额外的强制（在文档）。 这样您就不必显式指定virtual TYPE Method() = 0;，因为它会自动转换。

__interface IMyInterface {
   HRESULT CommitX();
   HRESULT get_X(BSTR* pbstrName);
};

但是，我不使用它，因为我担心跨平台编译兼容性，因为它仅在.NET下可用。

如果有人对此有什么有趣的事情，请分享。 ：-）

谢谢。

Answer 15

中抽象类的定义

这是c++标准n4687

13.4.2

抽象类是只能用作其他类的基类的类； 没有抽象的对象
类可以被创建，但作为派生类的子对象除外。 一个类是抽象的，如果它至少有
一个纯虚函数。

Answer 16

如果您只需要接口的静态绑定（没有虚拟，没有接口类型本身的实例，接口仅充当指南）：

#include <iostream>
#include <string>

// Static binding interface
// Notice: instantiation of this interface should be usefuless and forbidden.
class IBase {
 protected:
  IBase() = default;
  ~IBase() = default;

 public:
  // Methods that must be implemented by the derived class
  void behaviorA();
  void behaviorB();

  void behaviorC() {
    std::cout << "This is an interface default implementation of bC().\n";
  };
};

class CCom : public IBase {
  std::string name_;

 public:
  void behaviorA() { std::cout << "CCom bA called.\n"; };
};

class CDept : public IBase {
  int ele_;

 public:
  void behaviorB() { std::cout << "CDept bB called.\n"; };
  void behaviorC() {
    // Overwrite the interface default implementation
    std::cout << "CDept bC called.\n";
    IBase::behaviorC();
  };
};

int main(void) {
  // Forbid the instantiation of the interface type itself.
  // GCC error: ‘constexpr IBase::IBase()’ is protected within this context
  // IBase o;

  CCom acom;
  // If you want to use these interface methods, you need to implement them in
  // your derived class. This is controled by the interface definition.
  acom.behaviorA();
  // ld: undefined reference to `IBase::behaviorB()'
  // acom.behaviorB();
  acom.behaviorC();

  CDept adept;
  // adept.behaviorA();
  adept.behaviorB();
  adept.behaviorC();
  // adept.IBase::behaviorC();
}

Answer 17

class Shape 
{
public:
   // pure virtual function providing interface framework.
   virtual int getArea() = 0;
   void setWidth(int w)
   {
      width = w;
   }
   void setHeight(int h)
   {
      height = h;
   }
protected:
    int width;
    int height;
};

class Rectangle: public Shape
{
public:
    int getArea()
    { 
        return (width * height); 
    }
};
class Triangle: public Shape
{
public:
    int getArea()
    { 
        return (width * height)/2; 
    }
};

int main(void)
{
     Rectangle Rect;
     Triangle  Tri;

     Rect.setWidth(5);
     Rect.setHeight(7);

     cout << "Rectangle area: " << Rect.getArea() << endl;

     Tri.setWidth(5);
     Tri.setHeight(7);

     cout << "Triangle area: " << Tri.getArea() << endl; 

     return 0;
}

结果：
矩形面积：35
三角形面积：17

我们已经看到抽象类如何根据 getArea() 定义接口，另外两个类实现相同的功能但使用不同的算法来计算特定于形状的面积。