C++ 中的编译时接口实现检查

Question

我在 C++ 中使用伪接口，即纯抽象类。假设我有三个接口，IFoo、IBar 和 IQuux。我还有一个 Fred 类，它实现了这三个类：

interface IFoo
{
    void foo (void);
}   

interface IBar
{
    void bar (void);
}

interface IQuux
{
    void quux (void);
}   

class Fred : implements IFoo, IBar, IQuux
{
}

我想声明一个方法，该方法接受任何实现 IFoo 和 IBar 的对象 - 例如，Fred 就可以工作。我能想到的唯一编译时方法是定义第三个接口 IFooAndBar 来实现这两个接口，并重新声明 Fred：

interface IFooAndBar : extends IFoo, IBar
{   
}

class Fred : implements IFooAndBar, IQuux
{
}

现在我可以将我的方法声明为接收 IFooAndBar*。到目前为止，一切都很好。

---

但是，如果我还想要一种接受 IBar 和 IQuux 的不同方法，会发生什么情况？我尝试声明一个新接口 IBarAndQuux 并将 Fred 声明为继承两者：

class IFooAndBar : IFoo, IBar
{
};


class IBarAndQuux : IBar, IQuux
{
};


class Fred : IFooAndBar, IBarAndQuux
{
};

当我将 Fred 作为 IFooAndBar 传递给方法时，这会起作用；然而，当我尝试直接调用 Fred::bar() 时，gcc 抱怨：

error: request for member ‘bar’ is ambiguous
error: candidates are: void IBar::bar()
error:                 void IBar::bar()

这使得这个解决方案或多或少毫无用处。

---

我的下一次尝试是将 Fred 声明为从三个单独的接口继承，并使该方法接受混合接口之一作为参数：

class Fred : public IFoo, public IBar, public IBaz
{

};

void doTest (IBarAndBaz* pObj)
{
    pObj->bar();
    pObj->baz();
}

当我尝试将 Fred 作为 IBarAndBaz* 参数传递时，我收到一个错误，如预期的那样：

error: cannot convert ‘Fred*’ to ‘IBarAndBaz*’ for argument ‘1’ to ‘void doTest(IBarAndBaz*)’

dynamic_cast< ;>也会产生一个错误（我不明白）

error: cannot dynamic_cast ‘pFred’ (of type ‘class Fred*’) to type ‘class IBarAndBaz*’ (source type is not polymorphic)

强制转换确实工作，但是：

doTest((IBarAndBaz*)pFred);

但我想知道这有多安全和可移植（我为Linux，Mac和Windows开发），以及它是否在现实世界中工作。

---

最后，我意识到我的方法可以接受指向其中一个接口的指针，并动态转换到其他接口，以在运行时强制执行正确的参数类型，但我更喜欢编译时解决方案。

Answer 1

首先考虑使用经过测试的解决方案 - Boost.TypeTraits 救援：

template<class T>
void takeFooAndBar(const T& t) {
    BOOST_STATIC_ASSERT(
           boost::is_base_of<IFoo, T>::value 
        && boost::is_base_of<IBar, T>::value);
    /* ... */
}

Answer 2

要以 OO 风格执行此操作，您需要虚拟继承来确保 Fred 仅最终得到 IBar 的一份副本：

class IFooAndBar : public IFoo, public virtual IBar {};
class IBarAndQuux : public virtual IBar, public IQuux {};

class Fred : public IFooAndBar, public IBarAndQuux {};

Fred fred;
fred.bar(); // unambiguous due to virtual inheritence

正如其他人所说，您可以执行类似于您的操作第二次尝试使用模板来获得静态多态性。

您尝试的转换是不可能的，因为 Fred 的实例不是 IBarAndBaz 的实例。强制转换会编译，因为无论转换是否安全，大多数强制转换都会编译，但在这种情况下，它将给出未定义的行为。

编辑：或者，如果您不想使用模板，也不喜欢定义所有可能的接口组的组合爆炸，您可以定义函数以将每个接口作为单独的参数：

void doTest(IBar *bar, IBaz *baz)
{
    bar->bar();
    baz->baz();
}

class Fred : public IBar, public IBaz {};

Fred fred;
doTest(&fred,&fred);

Answer 3

您可以使用模板元编程来实现此效果：

tempate<class C>
void doTest( C* pObj )
{
  pObj->bar();
  pObj->baz();
}

对于提供 bar() 和 baz() 的类将正确运行，而对于任何其他类则无法编译。

Answer 4

您可以做的是创建一个带有模板化构造函数的类，该构造函数接受任意指针，使用隐式向下转换来获取所需的两个接口，然后实现组合接口。

struct IFoo 
{
    virtual void foo() = 0;
};

struct IBar 
{
    virtual void bar() = 0;
};

struct IFooAndBar : public IFoo, public IBar {};

class FooAndBarCompositor : public IFooAndBar
{
public:
    template <class T>
    FooAndBarCompositor(T* pImpl) : m_pFoo(pImpl), m_pBar(pImpl) {}

    void foo() {m_pFoo->foo();}
    void bar() {m_pBar->bar();}

private:
    IFoo* m_pFoo;
    IBar* m_pBar;
};

然后，如果需要两个接口，则编写一个接受 IFooAndBar* 的函数，并且调用者可以在堆栈上构造一个 FooAndBarCompositor ，分派到他们选择的对象。它看起来像：

void testFooAndBar(IFooAndBar* pI) {}

void baz(Fred* pFred)
{
    FooAndBarCompositor fb(pFred);
    testFooAndBar(&fb);
}

这不是很通用，并且迫使您在合成器中编写调度函数。另一种方法是使用通用接口合成器模板：

template <class IA, class IB>
class InterfaceCompositor
{
public:
    template <class T>
    InterfaceCompositor(T* pObj) : m_pIA(pObj), m_pIB(pObj) {}

    IA* AsA() const {return m_pIA;}
    operator IA* () const {return AsA();}
    IB* AsB() cosnt {return m_pIB;}
    operator IB* () const {return AsB();}

private:
    IA* m_pIA;
    IB* m_pIB;
};

然后函数如下所示：

void testFooAndBar(InterfaceCompositor<IFoo, IBar> pI)
{
    IFoo* pFoo = pI; // Or pI.AsA();
    IBar* pBar = pI; // Of pI.AsB();
}

这需要想要强制多个接口的函数使用需要 A* 或 B* 的合成器（例如赋值或函数参数）或显式调用适当的 AsX() 方法。具体来说，要使用的接口不能从 -> 的使用推断出来。运算符和 * 运算符对组合没有任何意义。

如果您使用通用代码，则可以使用相同的模板来强制对象也支持 IBar 和 IBaz。

C++0x 将引入可变参数模板，允许将此概念扩展到任意数量的接口类。