虽然虚拟是定义接口的事实标准，但我们不要忘记经典的类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<>的当前实现往往会有开销（这在将来可能会改变）。

在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。

虽然虚拟是定义接口的事实标准，但我们不要忘记经典的类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<>的当前实现往往会有开销（这在将来可能会改变）。

就我所能测试的而言，添加虚拟析构函数非常重要。我使用的是用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（）。

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（）定义接口的，另外两个类实现了相同的函数，但使用了不同的算法来计算特定于形状的面积。

除了C#/Java中的抽象基类之外，您还有一个特殊的接口类型类别，这是因为C#/Java不支持多重继承。

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