java - 在 C++ 中，我们能否向上转换一个数组，然后尝试将另一个子类型放入其中(受 Java ArrayStoreException 启发)？

Question

我试过看看如果我们尝试以与 Java 中类似的方式“破坏”一个对象数组，在 C++ 中会发生什么。

在 Java 中我们可以有一个 Double[] 类型的数组，例如，将其向上转换为 Number[](因为 Double 是 Number 的子类)，并尝试将 Number 的另一个子类添加到数组中，例如，一个整数。代码可以编译，但我们会在运行时得到 ArrayStoreException，因为 Integer 类型会在运行时根据数组的实际类型(碰巧是 Double)进行检查，当然会出现不匹配。代码可能如下所示:

Double[] ds = new Double[12];
Number[] ns = ds;
ns[0] = 2.3;              // OK
ns[1] = new Integer(1);   // compiles, but we have ArrayStoreException in runtime

所以我想——C++ 怎么样？我们可以尝试执行相同的技巧吗？运行时会发生什么？

这是我试过的代码和输出。

#include <iostream>

class A
{
public:
    A(int v = 0): val(v) {}
    virtual void g() {std::cout << val << " in A\n";}
    void setVal(int v) {val = v;}
protected:
    int val;
};

class B : public A
{
public:
    virtual void g() {std::cout << val << " in B\n";}
};

class C : public A
{
public:
    C(int v = 0): A(v) {}
    virtual void g() {std::cout << val << " in C\n";}
private:
    int stuff[10];
};


void f(A* as)
{
    as[1] = *(new A(12));
}

void f2(A* as)
{
    as[1] = *(new C(22));
}

int main()
{
    A* bs = new B[5];
    for (int i=0 ; i<5; ++i)
    {
        bs[i].setVal(i);
        bs[i].g();
    }

    std::cout << std::endl;

    f(bs);
    for (int i=0 ; i<5; ++i)
    {
        bs[i].g();
    }

    std::cout << std::endl;

    f2(bs);
    for (int i=0 ; i<5; ++i)
    {
        bs[i].g();
    }
}

输出:

0 in B
1 in B
2 in B
3 in B
4 in B

0 in B
12 in B
2 in B
3 in B
4 in B

0 in B
22 in B
2 in B
3 in B
4 in B

看到创建 A 或 C 然后将其复制到 B 的数组中确实复制了数据(并且，正如预期的那样，在 C 的情况下，仅复制了 A 的一部分数据 - 复制元素后没有内存损坏), 但是选择了B的方法，也就是说vptr一定没有被复制。

所以我的问题是:

• 我猜 vptr 没有被复制到默认赋值运算符中。是这样吗？这是我们调用 B 的方法但调用 C 对象的数据的唯一可能原因吗？

• 我们真的可以想出一个例子来让一些不好的或意想不到的事情发生，一些运行时失败吗？我想我所说的坏的意思是有一个B 数组，但其中有一个 A 或 C 的对象(不是 B 或 B 的子类型)，一个对 B 来说是“外星人”的对象？

• 或者也许 C++ 语言确实通过其特性的某些组合明确或隐含地保证这种情况不会发生(就像 Java 明确引发 ArrayStoreException)？

更新:

A* bs = new B[5];

我实际上是在最后一刻更改了这一行，以强调 B 方法的运行时选择(不应该这样做，因为该方法是虚拟的，所以很明显)。我最初有 B* bs = new B[5]; 并且输出是相同的。

Answer 1

实际上，当您编写 A* bs = new B[5] 时，您做错了什么。如果 B 元素的大小与 B 元素不同，则会导致问题。因为您可以将 B* 向上转换为 A*，所以转换是安全的……如果只有一个元素。

假设 A 的长度为 32 位，B 的长度为 64 位。然后，当您浏览 bs 数组时，会发生奇怪的事情。 (bs[1] 将是第一个 B 元素的结尾)。

如果你有多个虚拟继承并且编译器需要改变指向的地址，那么它只会对第一个元素完成。

所以:

1. 无需复制任何内容，如果需要，只需更改第一个元素的指针地址。

2. 是的，只需向 B 添加一些元素，使 B 大于 A，您就可以在未定义行为的精彩世界中。您也可以这样做，将 C 对象的 A 部分复制到 B 对象中。

Nb :如果你想在同一个数组中管理一些 B 和 C，你可以使用 A** (或 std::whatever)，这样就安全了。 (但您可能已经知道了)。