这段禁止继承的代码是如何工作的？

Question

我发现了一些相当奇怪的代码：

class Base {
public:
    virtual bool IsDerived() const { return false; }
};

class Derived : public Base {
public:
    bool IsDerived() const { return true; }
};

Derived* CastToDerived( Base* base )
{
    // private and protected inheritance from Derived is prohibited
    Derived* derived = dynamic_cast<Derived*>(base);
    if( derived == 0 ) {
       assert( !base->IsDerived() );
    }
    return derived;
}

我没有得到有关私有和受保护继承的段落。

假设我使用 protected 修饰符从 Derived 继承：

class FurtherDerived : protected Derived {
};

会发生什么？该断言将如何被触发？

Answer 1

如果您有 Protected 或 Private 继承，您不能这样做：

Base *ptr = new Derived();

您也不能这样做，

Derived *ptr1 = new Derived();
Base *ptr = ptr1;

这是因为，Base 是 Base 的不可访问的基础code>Derived

由于您不能让 Base 类指针指向 Derived 类对象，因此该检查看起来是多余的。

---

编辑：
即使您无法直接将 Derived 类对象分配给 Base 类指针，也可能以其他方式发生这种情况，例如：如果 Derived 的函数code> 类返回一个 Base 类指针。

简而言之，即使派生是受保护的或私有的，Base 类指针也可能指向Derived 类对象。

鉴于上述情况，

根据 C++ 标准：
5.2.7.8：

运行时检查逻辑上执行如下：
— 如果在 v 所指向（引用）的最底层派生对象中，v 指向（引用）T 对象的公共基类子对象，并且如果只有一个类型 T 的对象是从所指向的子对象派生的(引用) v ，结果是指向该 T 对象的指针（引用左值）。
— 否则，如果 v 指向（引用）最派生对象的公共基类子对象，并且最派生对象的类型具有类型为 T 的基类，那么这是明确的并且public，结果是指向最派生对象的 T 子对象的指针（左值引用）。
— 否则，运行时检查失败。

请注意，该标准明确要求推导必须公开。
因此，如果派生是受保护的或私有的，则dynamic_cast将检测到将转换视为不正确的转换，并返回NULL （因为您使用的是指针）并且将调用 assert 。

所以是的，该代码非常有效。它确实做到了评论所说的

---

这个示例，演示了它按照评论工作：

#include<iostream>
class Base 
{
    public:
        virtual bool IsDerived() const { return false; }
};

class Derived : protected Base 
{
    public:
        bool IsDerived() const { return true; }
        Base* getBase() { return this; }
};

Derived* CastToDerived( Base* base )
{
     // private and protected inheritance from Derived is prohibited
     Derived* derived = dynamic_cast<Derived*>(base);
     if( derived == 0 ) 
     {
         std::cout<< "!base->IsDerived()";
     }
     return derived;
}


int main()
{
    Derived *ptr3 = new Derived();
    Base *ptr = ptr3->getBase();
    Derived *ptr2 = CastToDerived(ptr);
    return 0;
}

Answer 2

IsDerived 是在基类中定义的虚拟函数，函数根据调用该函数所使用的对象的静态类型进行解析。这意味着，这不是问题。它会起作用的。 （或者也许，我错过了你问题中的一些内容）。

Answer 3

dynamic_cast 执行运行时检查 (5.2.7/8)。

如果 Base 被 Derived 继承为受保护或私有，则运行时检查将失败。

转换为指针时失败的运行时检查值为 NULL 指针 (5.2.7/9)。

因此，该代码是私有和受保护后代的解决方法：如果您使用 protected 或 private 继承 Derived，则 dynamic_cast 将返回 NULL 并且将执行自定义检查。

Answer 4

我不明白有关私有继承和受保护继承的段落。

答案很简单。与许多其他注释一样，此注释不以任何方式、形状或形式描述代码。

示例：

class PrivateDerived : private Derived {
public:
   Base* cast_to_base () {
      return dynamic_cast<Base*>(this);
   }   
};  

void check_base (const char * id, Base* pbase) {
   if (pbase == 0) {
      std::cout << id << " conversion yields a null pointer.\n";
   }
   else {
      std::cout << id << "->IsDerived() = "
                << pbase->IsDerived() << "\n";
      Derived* pderived = CastToDerived (pbase);
      std::cout << "CastToDerived yields "
                << (pderived ? "non-null" : "null") << " pointer.\n";
      std::cout << "pderived->IsDerived() = "
                << pderived->IsDerived() << "\n\n";
   }
}

int main () {
   PrivateDerived private_derived;

   // Good old c-style cast can convert anything to anything.
   // Maybe a bit disfunctional, but it works in this case.
   check_base ("c_style_cast", (Base*)&private_derived);

   // The cast_to_base method can see the private inheritance,
   // and does so without invoking undefined behavior.
   check_base ("cast_method", private_derived.cast_to_base());

   return 0;
}

使用多个版本的 gcc 和 clang 进行测试；他们都没有提出 assert 语句。

附录
我怀疑发生的事情是，在具有特定编译器的特定机器上，相关代码确实以某种方式设法完成了作者认为它应该做的事情。我怀疑作者从未测试过这个所谓的检查，看看它是否真的像广告中那样有效。