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

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

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

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

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

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

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

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

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

提示：

您可以将其作为基类继承（允许虚拟和非虚拟），并在后代的构造函数中填充单击。您可以将函数指针作为受保护的成员，并具有公共引用和/或getter。如上所述，这允许您在运行时切换实现。因此，这也是一种管理状态的方法。根据代码中ifs与状态变化的数量，这可能比switch（）es或ifs更快（预计周转时间在3-4个ifs左右，但始终要先测量。如果在函数指针上选择std:：function<>，则可能能够管理IBase中的所有对象数据。从这一点开始，您可以获得IBase的值示意图（例如，std:：vector＜IBase＞将起作用）。注意，根据编译器和STL代码的不同，这可能会更慢；此外，与函数指针甚至虚拟函数相比，std:：function<>的当前实现往往会有开销（这在将来可能会改变）。

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

如果有人试图删除IDemo类型的对象，请在接口中声明一个虚拟析构函数或创建一个受保护的非虚拟析构器，以避免未定义的行为。使用虚拟继承来避免多重继承的问题。（当我们使用接口时，通常会有多重继承。）

和其他答案一样：

使用纯虚拟方法创建类。通过创建另一个重写这些虚拟方法的类来使用该接口。类IDemo{公众：虚空OverrideMe（）=0；virtual~IDemo（）｛｝}或类IDemo{公众：虚空OverrideMe（）=0；受保护的：~IDemo（）｛｝}和class Child:虚拟公共IDemo{公众：虚拟空OverrideMe（）{//做一些事情}}

以上都是好答案。还有一件事你应该记住——你也可以有一个纯粹的虚拟析构函数。唯一的区别是你仍然需要实现它。

困惑的

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

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

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

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

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

在派生类中重新实现析构函数根本没什么大不了的——我总是在派生类里重新实现一个析构函数，不管是虚拟的还是非虚拟的。

在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++博客-类型Erasure第i、ii、iii和iv部分。ConceptC中混合对象和概念的运行时多态泛型编程++Boost.TypeErasure文档Adobe Poly文档Boost.Any，std:：任何提案（修订版3），Boost.Spirit:：hold_Any。

您还可以考虑使用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.
};