解决 C++ 中不明确的 this 指针

Question

我正在尝试从旧类中派生出一个新类。基类声明如下所示：

class Driver : public Plugin, public CmdObject
{
protected:
    Driver();

public:
    static Driver* GetInstance();
    virtual Engine& GetEngine();
public:
    // Plugin methods...
    virtual bool InitPlugin (Mgr* pMgr);
    virtual bool Open();
    virtual bool Close();

    // CmdObject
    virtual bool ExecObjCmd(uint16 cmdID, uint16 nbParams, CommandParam *pParams, CmdChannelError& error);

    Mgr *m_pMgr;

protected:
    Services *m_pServices;
    Engine m_Engine;
};

它的构造函数如下所示：

Driver::Driver() : 
    YCmdObject("Driver", (CmdObjectType)100, true),
    m_Engine("MyEngine")
{
    Services *m_pServices = NULL;
    Mgr *m_pMgr = NULL;
}

因此，当我创建派生类时，我首先尝试简单地从基类继承：

class NewDriver : public Driver

并复制构造函数：

NewDriver::NewDriver() : 
    CmdObject("NewDriver", (EYCmdObjectType)100, true),
    m_Engine("MyNewEngine")
{
    Services *m_pServices = NULL;
    Mgr *m_pMgr = NULL;
}

编译器（来自 Analog Devices 的 VisualDSP++ 5.0）没有像这样：

".\NewDriver.cpp", line 10: cc0293:  error: indirect nonvirtual base
      class is not allowed
 CmdObject("NewDriver", (EYCmdObjectType)100, true),

这是有道理的，所以我决定直接继承自Plugin和CmdObject。为了避免多重继承歧义问题（我是这么想的），我使用了虚拟继承：

class NewDriver : public Driver, public virtual Plugin, public virtual CmdObject

但是，在 NewDriver 中实现虚拟方法时，我尝试调用带有 Plugin* 的 Mgr::RegisterPlugin 方法，然后我得到了这个：

".\NewDriver.cpp", line 89: cc0286:  error: base class "Plugin" is
      ambiguous
 if (!m_pMgr->RegisterPlugin(this))

this 指针如何不明确，如何解决？

谢谢，

--保罗

Answer 1

如果您从 Driver 派生，则不必显式调用 Driver 基类的构造函数：

class NewDriver : public Driver { /* ... */ };
NewDriver::NewDriver() : Driver() {}

Driver 的构造函数然后初始化其自己的构造函数基地，你不必也不应该直接这样做。
如果它的行为不同，请让它接受参数：

class Driver : /* ... */ {
public:
    Driver(const std::string& name /* , ... */)
      : CmdObject(name /* , ... */)
    {}
    // ...
};

NewDriver::NewDriver() : Driver("NewDriver" /* , ... */) {}

Answer 2

多重继承的黄金法则——所有类的所有公共基必须是虚拟的。只要遵循该规则，多重继承就能正常工作。在您的情况下，您会收到不明确的基类错误，因为 Plugin 未在 Driver 中声明 virtual

Answer 3

Georg 的答案是正确的，在这种情况下绝对没有必要搞乱多重继承。

使用多重继承，尤其是创建可怕的钻石是强烈< /strong> 气馁，并且会给绝大多数 C++ 程序员带来很大的困惑和沮丧。

Answer 4

如果您创建层次结构：

class A {public:  a(int i){} };
class B : public A {public:  b(){} };
class C : public B {public:  c(); };

您不能直接从 C 的构造函数将参数传递给 A 的构造函数，

C::C() : A(5) {} // illegal

除非 A 是 B 的虚拟基类，这是一种特殊情况，在这种情况下它很有用。请检查蒂姆·西尔维斯特提供的链接。

编译器提到这种情况并不意味着它是适合您的解决方案。

如果您创建像代码中那样的层次结构，则 NewDriver 对象中有 2 个 Plugin 类型的子对象和 2 个 CmdObject 类型的子对象。在这种情况下，如果您尝试将 NewDriver* 类型的 this 指针向下转换为 Plugin* 类型，编译器将不知道如何调整地址，因为它不知道指针应该指向 NewDriver 对象中存在的 2 个子对象中的哪一个。这就是错误消息中提到的歧义所在。有一种方法可以告诉编译器，但我认为我所描述的混乱应该已经让你相信这不是方法。

Answer 5

我不确定引入虚拟继承是您想要的方式。您收到的初始错误是有效的 - 您试图从 Driver 类的“上方”调用 CmdObject() ctor。您可以在 Driver 类中添加另一个 ctor 吗？

Answer 6

如果您出于某种原因想要再次从这些类继承，那么您不应该使用虚拟继承。如果要使用虚拟继承，则需要在更基类上指定。但是，您不想在这里使用虚拟继承。只需省略基类的初始化程序，因为 Driver 已经这样做了。在您的示例中，您根本不需要 NewDriver 构造函数，并且如果您的实现确实需要一个构造函数，那么它应该仅用于初始化 NewDriver 的成员变量，并且应该期望 Driver做正确的事。如果 Driver 没有做正确的事情，只需给它一个带有适当参数的构造函数，并让该构造函数做正确的事情。例如

class Driver : public Stuff
{
public:
    Driver(const char* enginename) : Stuff(99), m_Engine(enginename) { }

private:
   Engine m_Engine;
};

class NewDriver : public Driver
{
public:
   NewDriver() : Driver("New Driver!") { } // yes, Stuff gets initialized with 99 automatically!
};

Answer 7

Driver 中的 CmdObject 应该足够了。调整 Driver 以拥有一个 protected 构造函数，该构造函数可以在指定限制内​​自定义 CmdObject。

class Driver ...
protected:
    Driver( std::string driverName, std::string engineName );

……

Driver::Driver( std::string driverName, std::string engineName ) :
    YCmdObject(driverName, (CmdObjectType)100, true),
    m_Engine(engineName) {

​

NewDriver::NewDriver() : 
    Driver( "NewDriver", "MyNewEngine" ) {
    ...
}