如何在 C++ 中模拟接口？

Question

由于 C++ 缺乏 Java 和 C# 的接口功能，那么在 C++ 类中模拟接口的首选方法是什么？ 我的猜测是抽象类的多重继承。 对内存开销/性能有何影响？ 此类模拟接口是否有任何命名约定，例如 SerializedInterface？

Answer 1

由于与 C# 和 Java 不同，C++ 具有多重继承，因此您可以创建一系列抽象类。

至于约定，就看你自己了； 不过，我喜欢在类名前加上 I。

class IStringNotifier
{
public:
  virtual void sendMessage(std::string &strMessage) = 0;
  virtual ~IStringNotifier() { }
};

与 C# 和 Java 相比，性能无需担心。 基本上，您将只需要为您的函数或 vtable 提供一个查找表的开销，就像任何带有虚拟方法的继承所给出的那样。

Answer 2

实际上没有必要“模拟”任何东西，因为 C++ 并没有缺少 Java 可以用接口做的任何事情。

从 C++ 指针的角度来看，Java 在接口 和类 之间进行了“人为”区分。 接口只是一个类，其所有方法都是抽象的，并且不能包含任何数据成员。

Java 做出此限制是因为它不允许不受约束的多重继承，但它确实允许类实现多个接口。

在 C++ 中，类 是一个类，接口 是一个类。 extends 是通过公共继承实现的，implements 也是通过公共继承实现的。

从多个非接口类继承可能会导致额外的复杂性，但在某些情况下可能很有用。 如果您限制自己只能从最多一个非接口类和任意数量的完全抽象类继承类，那么您将不会遇到 Java 中遇到的任何其他困难（其他 C++/Java 差异除外）。

就内存和开销成本而言，如果您要重新创建 Java 样式的类层次结构，那么无论如何您可能已经为类支付了虚拟函数成本。 鉴于您无论如何都使用不同的运行时环境，就不同继承模型的成本而言，两者之间的开销不会有任何根本差异。

Answer 3

“对内存开销/性能有什么影响？”

尽管标准在性能方面没有提供太多保证，但通常除了使用虚拟调用之外，没有任何其他方法。

在内存开销方面，“空基类”优化显式允许编译器布局结构，以便添加没有数据成员的基类不会增加对象的大小。 我认为您不太可能需要处理不执行此操作的编译器，但我可能是错的。

与没有虚拟成员函数的情况相比，向类添加第一个虚拟成员函数通常会增加对象的指针大小。 添加更多虚拟成员函数不会产生额外的差异。 添加虚拟基类可能会产生进一步的影响，但对于您所讨论的内容，您不需要这样做。

添加具有虚拟成员函数的多个基类可能意味着实际上您只能获得一次空基类优化，因为在典型的实现中，该对象将需要多个 vtable 指针。 因此，如果每个类需要多个接口，则可能会增加对象的大小。

在性能方面，虚拟函数调用比非虚拟函数调用有一点点额外的开销，更重要的是，您可以假设它通常（总是？）不会被内联。 添加空基类通常不会向构造或析构添加任何代码，因为空基类构造函数和析构函数可以内联到派生类构造函数/析构函数代码中。

如果您想要显式接口，但不需要动态多态性，可以使用一些技巧来避免虚拟函数。 但是，如果您尝试模拟 Java，那么我认为情况并非如此。

示例代码：

#include <iostream>

// A is an interface
struct A {
    virtual ~A() {};
    virtual int a(int) = 0;
};

// B is an interface
struct B {
    virtual ~B() {};
    virtual int b(int) = 0;
};

// C has no interfaces, but does have a virtual member function
struct C {
    ~C() {}
    int c;
    virtual int getc(int) { return c; }
};

// D has one interface
struct D : public A {
    ~D() {}
    int d;
    int a(int) { return d; }
};

// E has two interfaces
struct E : public A, public B{
    ~E() {}
    int e;
    int a(int) { return e; }
    int b(int) { return e; }
};

int main() {
    E e; D d; C c;
    std::cout << "A : " << sizeof(A) << "\n";
    std::cout << "B : " << sizeof(B) << "\n";
    std::cout << "C : " << sizeof(C) << "\n";
    std::cout << "D : " << sizeof(D) << "\n";
    std::cout << "E : " << sizeof(E) << "\n";
}

输出（32 位平台上的 GCC）：

A : 4
B : 4
C : 8
D : 8
E : 12

Answer 4

C++ 中的接口是仅具有纯虚函数的类。 例如：

class ISerializable
{
public:
    virtual ~ISerializable() = 0;
    virtual void  serialize( stream& target ) = 0;
};

这不是一个模拟接口，它是一个类似于Java中的接口，但没有缺点。

例如，您可以添加方法和成员，而不会产生负面后果：

class ISerializable
{
public:
    virtual ~ISerializable() = 0;
    virtual void  serialize( stream& target ) = 0;
protected:
    void  serialize_atomic( int i, stream& t );
    bool  serialized;
};

对于命名约定... C++ 语言中没有定义真正的命名约定。 因此，请选择适合您环境的一个。

开销是 1 个静态表，并且在尚未具有虚函数的派生类中，有一个指向静态表的指针。

Answer 5

在 C++ 中，我们可以比 Java 和 Java 的简单无行为接口走得更远。 公司
我们可以使用 NVI 模式添加显式契约（如Design by Contract）。

struct Contract1 : noncopyable
{
    virtual ~Contract1();
    Res f(Param p) {
        assert(f_precondition(p) && "C1::f precondition failed");
        const Res r = do_f(p);
        assert(f_postcondition(p,r) && "C1::f postcondition failed");
        return r;
    }
private:
    virtual Res do_f(Param p) = 0;
};

struct Concrete : virtual Contract1, virtual Contract2
{
    ...
};

Answer 6

通过记录模板类型参数的要求，C++ 中的接口也可以静态出现。

模板模式匹配语法，因此您不必预先指定特定类型实现特定接口，只要它具有正确的成员即可。 这与 Java 的 或 C# 的 where T : IInterface 样式约束，要求替换类型了解 (I)Interface。

一个很好的例子是 Iterator 系列，它们是通过指针等实现的。

Answer 7

如果不使用虚拟继承，那么开销应该不会比具有至少一个虚拟函数的常规继承差。 继承的每个抽象类都会添加一个指向每个对象的指针。

但是，如果您执行空基类优化之类的操作，则可以将其最小化：

struct A
{
    void func1() = 0;
};

struct B: A
{
    void func2() = 0;
};

struct C: B
{
    int i;
};

C 的大小将是两个单词。

Answer 8

顺便说一句，MSVC 2008 有 __interface 关键字。

A Visual C++ interface can be defined as follows: 

 - Can inherit from zero or more base
   interfaces.
 - Cannot inherit from a base class.
 - Can only contain public, pure virtual
   methods.
 - Cannot contain constructors,
   destructors, or operators.
 - Cannot contain static methods.
 - Cannot contain data members;
   properties are allowed.

此功能是 Microsoft 特有的。 注意：__interface 没有虚拟析构函数如果通过接口指针删除对象，则需要。

Answer 9

没有好的方法可以按照您要求的方式实现接口。 诸如完全抽象 ISerialized 基类之类的方法的问题在于 C++ 实现多重继承的方式。 请考虑以下情况：

class Base
{
};
class ISerializable
{
  public:
    virtual string toSerial() = 0;
    virtual void fromSerial(const string& s) = 0;
};

class Subclass : public Base, public ISerializable
{
};

void someFunc(fstream& out, const ISerializable& o)
{
    out << o.toSerial();
}

显然，函数 toSerial() 的目的是序列化 Subclass 的所有成员，包括它从 Base 类继承的成员。 问题是没有从 ISerialized 到 Base 的路径。 如果执行以下命令，您可以以图形方式看到这一点：

void fn(Base& b)
{
    cout << (void*)&b << endl;
}
void fn(ISerializable& i)
{
    cout << (void*)&i << endl;
}

void someFunc(Subclass& s)
{
    fn(s);
    fn(s);
}

第一次调用输出的值与第二次调用输出的值不同。 即使在这两种情况下都会传递对 s 的引用，编译器也会调整传递的地址以匹配正确的基类类型。