如何设置表示接口的类？这只是一个抽象基类吗？
使用纯虚拟方法创建类。通过创建另一个重写这些虚拟方法的类来使用该接口。
纯虚拟方法是定义为虚拟并分配给0的类方法。
class IDemo
{
public:
virtual ~IDemo() {}
virtual void OverrideMe() = 0;
};
class Child : public IDemo
{
public:
virtual void OverrideMe()
{
// do stuff
}
};
除了C#/Java中的抽象基类之外，您还有一个特殊的接口类型类别，这是因为C#/Java不支持多重继承。
C++支持多重继承，因此不需要特殊类型。没有非抽象（纯虚拟）方法的抽象基类在功能上等同于C#/Java接口。
为了扩展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
}
};
您不必为虚拟析构函数包含一个主体——事实证明，某些编译器在优化空析构函数时遇到了问题，最好使用默认值。
C++中没有“接口”本身的概念。AFAIK，接口首先在Java中引入，以解决缺少多重继承的问题。事实证明，这个概念非常有用，在C++中使用抽象基类也可以达到同样的效果。
抽象基类是一个类，其中至少一个成员函数（Java语言中的方法）是使用以下语法声明的纯虚拟函数：
class A
{
virtual void foo() = 0;
};
抽象基类不能实例化，即不能声明类A的对象。只能从A派生类，但任何不提供foo（）实现的派生类也将是抽象的。为了停止抽象，派生类必须为其继承的所有纯虚拟函数提供实现。
请注意，抽象基类可以不仅仅是一个接口，因为它可以包含非纯虚拟的数据成员和成员函数。接口的等价物是一个抽象基类，没有任何数据成员，只包含纯虚拟函数。
而且，正如MarkRansom所指出的，抽象基类应该像任何基类一样提供虚拟析构函数。
考虑这一点的一个好方法是继承接口而不是继承实现。在C++中，您可以同时继承接口和实现（公共继承），也可以只继承实现（私有继承）。在Java中，您可以选择只继承接口，而不继承实现。
您还可以考虑使用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.
};
我的答案与其他人基本相同，但我认为还有两件重要的事情要做：
如果有人试图删除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()
{
}
你想这样做的主要原因是，如果你想提供接口方法，就像我所说的那样，但让重写它们成为可选的。
要使类成为接口类，需要一个纯虚方法，但所有的虚方法都有默认实现，因此唯一剩下的方法就是析构函数。
在派生类中重新实现析构函数根本没什么大不了的——我总是在派生类里重新实现一个析构函数，不管是虚拟的还是非虚拟的。
如果您使用的是Microsoft的C++编译器，则可以执行以下操作：
struct __declspec(novtable) IFoo
{
virtual void Bar() = 0;
};
class Child : public IFoo
{
public:
virtual void Bar() override { /* Do Something */ }
}
我喜欢这种方法，因为它会产生更小的接口代码，生成的代码大小也会明显更小。novtable的使用删除了该类中对vtable指针的所有引用，因此您永远不能直接实例化它。请参阅此处的文档-novtable。
就我所能测试的而言，添加虚拟析构函数非常重要。我使用的是用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（）。
在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。
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++开发的新手。我从Visual Studio（VS）开始。
然而，似乎没有人提到VS（.NET）中的__interface。我不太确定这是否是声明接口的好方法。但它似乎提供了额外的强制执行（文件中提到）。这样就不必显式指定虚拟TYPE Method（）=0；，因为它将被自动转换。
__interface IMyInterface {
HRESULT CommitX();
HRESULT get_X(BSTR* pbstrName);
};
然而，我不使用它，因为我担心跨平台编译兼容性，因为它只在.NET下可用。
如果有人对此感兴趣，请分享。：-）
谢谢
虽然虚拟是定义接口的事实标准，但我们不要忘记经典的类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++标准中抽象类的定义
第4687页
13.4.2
抽象类是只能用作其他类的基类的类；没有抽象对象类只能作为派生类的子对象来创建。如果类至少具有一个纯虚拟函数。
在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);
限制是不能在容器中使用它。
如果您只需要接口的静态绑定（没有虚拟的，没有接口类型本身的实例，接口仅作为指南）：
#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();
}
