铸造 Derived** → Base** 错了吗？有什么选择？

Question

上下文

我的目标是拥有一个包含和操作多个基类对象的基容器类，然后是一个包含和操作多个派生类对象的派生容器类。在this answer 的建议下，我尝试通过让每个指针都包含一个指针数组（Base** 和Derived**）来做到这一点，并在初始化基本容器类时从Derived** 转换为Base**。

然而，我遇到了一个问题——尽管编译得很好，但在操作包含的对象时，我会遇到段错误，或者会调用 错误的方法。

---

问题

我将问题归结为以下最小情况：

#include <iostream>

class Base1 {
public:
    virtual void doThing1() {std::cout << "Called Base1::doThing1" << std::endl;}
};

class Base2 {
public:
    virtual void doThing2() {std::cout << "Called Base2::doThing2" << std::endl;}
};

// Whether this inherits "virtual public" or just "public" makes no difference.
class Derived : virtual public Base1, virtual public Base2 {};

int main() {
    Derived derived;
    Derived* derivedPtrs[] = {&derived};
    ((Base2**) derivedPtrs)[0]->doThing2();
}

您可能希望这会打印“Called Base2::doThing2”，但是……

$ g++ -Wall -Werror main.cpp -o test && ./test
Called Base1::doThing1

确实——代码调用Base2::doThing2，但Base1::doThing1最终被调用。我在更复杂的类中也遇到了这个段错误，所以我认为它是与地址相关的 hijink（可能与 vtable 相关——如果没有 virtual 方法，错误似乎不会发生）。你可以run it here和see the assembly it compiles to here。

You can see my actual structure here – 它更复杂，但它与上下文相关联并解释了为什么我需要类似的东西。

为什么Derived**→Base** 转换在Derived*→Base* 可以正常工作，更重要的是，处理数组的正确方法是什么将派生对象作为基对象数组（或者，如果做不到这一点，另一种方法可以创建可以包含多个派生对象的容器类）？

恐怕我无法在向上转换 (((Base2*) derivedPtrs[0])->doThing2()) 之前建立索引，因为在完整代码中，数组是类成员 - 我不确定转换是否是个好主意（甚至可能）手动在容器类中使用包含的每个位置的对象。不过，如果 是 处理这个问题的方法，请纠正我。

（我认为在这种情况下不会有什么不同，但我处于std::vector 不可用的环境中。）

---

编辑：解决方案

许多答案表明，单独强制转换每个指针是拥有一个可以包含派生对象的数组的唯一方法——而且似乎确实如此。不过，对于我的特定用例，我设法使用 templates 解决了这个问题！通过为容器类应该包含的内容提供类型参数，而不是必须包含派生对象的数组，可以在编译时将数组的类型设置为派生类型（例如BaseContainer<Derived> container(length, arrayOfDerivedPtrs);)。

Here's a version of the broken "actual structure" code above, fixed with templates.

Answer 1

有很多因素使这段代码非常糟糕并导致了这个问题：

1. 为什么我们首先要处理两星类型？如果std::vector 不存在，为什么不自己写呢？

2. 不要使用 C 风格的强制转换。您可以将指向完全不相关类型的指针相互转换，并且不允许编译器阻止您（巧合的是，这正是这里发生的事情）。请改用static_cast/dynamic_cast。

3. 让我们假设我们有std::vector，以便于表示。您正在尝试将 std::vector<Derived*> 转换为 std::vector<Base*>。这些是不相关的类型（Derived** 和 Base** 也是如此），将一个类型转换为另一个类型在任何情况下都是不合法的。

4. 从/到派生的指针转换不一定是微不足道的。如果您有struct X : A, B {}，那么指向B 基址的指针将不同于指向A 基址^† 的指针（并且在使用vtable 时，也可能与指针不同到X)。它们必须是，因为（子）对象不能驻留在相同的内存地址。当您转换指针时，编译器将调整指针值。如果您（尝试）转换一个指针数组，这当然不会/不可能发生在每个单独的指针上。

如果您有一个指向Derived 的指针数组，并且想要获得一个指向Base 的指针数组，那么您必须手动转换每个指针。由于两个数组中的指针值通常不同，因此无法“重用”同一个数组。

^†（除非满足empty base optimization 的条件，而你的情况并非如此）。

Answer 2

就像其他人说的那样，问题在于您没有让编译器完成调整索引的工作，假设内存中的派生布局类似于（标准不保证，只是一种可能的实现）：

| vtable_Base1 | Base1 | vtable_Base2 | Base2 | vtable_Derived | Derived |

然后&derived 指向对象的开头，当你通常这样做时

Base2* base = static_cast<Derived*>(&derived)

编译器知道Base2结构在Derived类型中的偏移量，并调整地址指向它的开始。

如果您直接转换一个指针数组，编译器会强制转换该类型，假设您的数组已经存储了指向 Base2 的指针，但没有对其进行调整。

在您的情况下可能有效或无效的肮脏黑客方法是有一个返回指向自身的指针的方法，例如：

class Base2 {
public:
  Base2* base2() { return this; }
}

这样你就可以derivedPtrs[0]->base2()->doThing2()。

Answer 3

它不起作用的原因与它不起作用的原因相同：

struct Base {};

struct Derived : Base { int i; };

int main() {
    Derived d[6];
    Derived* d2 = d;
    Base** b = &d2; // ERROR!
}

您的 c 样式转换是一种不好的做法，因为它没有警告您错误。只是不要对您的代码这样做。您的 c 风格演员实际上是伪装的 reinterpret_cast，这在这种情况下是完全错误的。

但是为什么你不能将一个数组转换成一个数组到基数呢？很简单：它们有不同的布局。

你看，当你迭代一个类型的数组时，数组中的每个元素在内存中都是连续的。 Derived 类的大小可能是 24 字节，Base 的大小是 8：

Derived d[4];
------------------------------------------------------
|     D1     |     D2     |     D3     |      D4     |
------------------------------------------------------

Base b[4];
---------------------
| B1 | B2 | B3 | B4 |
---------------------

如您所见，Derived[4] 和 Base[4] 是不同的类型，具有不同的布局。

---

那你能做什么呢？

其实有很多解决方案。最简单的方法是创建一个指向基的新指针数组，并将每个派生的指针转换为基指针。无论如何，您必须调整每个对象的指针。

看起来像这样：

std::vector<Base*> bases;
bases.reserve(std::size(derived_arr))

std::transform(
    std::begin(derived_arr), std::end(derived_arr),
    std::back_inserter(bases), 
    [](Dervied* d) {
        // You must use dynamic cast because the 
        // pointer offset in only known at runtime
        // when using virtual inheritance
        return dynamic_cast<Base*>(d); 
    }
);

内存中的另一个解决方案是创建您自己的迭代器类型，在调用operator* 和operator-> 时执行强制转换。这有点难做，但可以通过使迭代变慢一些来节省分配。

---

最重要的是，这可能无关紧要，但我建议不要使用虚拟继承。这不是一个好的做法，根据我的经验，这比任何事情都更痛苦。我建议使用适配器模式并包装非多态类型。

Answer 4

当您从Derived* 转换为Base* 时，编译器将调整该值。当您将 Derived** 转换为 Base** 时，您就打败了它。

这是始终使用static_cast 的好理由。更改代码的示例错误：

test.cpp:19:5: error: static_cast from 'Derived **' to 'Base2 **' is not
      allowed
    static_cast<Base2**>(derivedPtrs)[0]->doThing2();

Answer 5

(Base2 **) 实际上是reinterpret_cast（您可以通过尝试所有四个转换来确认这一点）并且该表达式会导致 UB。您可以将指向派生的指针隐式转换为指向基址的指针这一事实并不意味着它们是相同的，例如int 和 float。在这里，您通过它不是的类型来引用对象，在这种情况下，会导致 UB。

以这种方式调用虚函数会导致调用该对象的最终覆盖器。这如何实现取决于编译器。

假设编译器使用“vtable”，从Derived 的内存地址找到Base2 的vtable（可能是向内存添加偏移量。assembly）并非易事。

基本上，您必须对每个指针执行动态转换，将它们存储在某处或在需要时动态转换它。