c++ - 将派生类数组分配给基类指针

Question

#include <iostream> 
class B { 
public: 
 B () : b(bCounter++) {} 
int b; 
static int bCounter;  
}; 
int B::bCounter = 0; 
class D : public B { 
public: 
D () : d(bCounter) {} 
int d; 
}; 
const int N = 10; 
B arrB[N]; 
D arrD[N]; 
int sum1 (B* arr) { 
    int s = 0; 
    for (int i=0; i<N; i++) 
         s+=arr[i].b; 
    return s; 
} 
int sum2 (D* arr) { 
     int s = 0; 
     for (int i=0; i<N; i++) s+=arr[i].b+arr[i].d; 
     return s; 
} 
int main() { 
    std::cout << sum1(arrB) << std::endl; 
    std::cout << sum1(arrD) << std::endl; 
    std::cout << sum2(arrD) << std::endl; 
    return 0; 
}

问题出在 main 函数的第 2 行。我预计当使用参数 arrD(它是派生类对象的数组)调用 sum1() 函数时，它会简单地“切断”D::d，但在这种情况下它会重新排列 arrD 中的顺序，并且总结是这样的: 10+11+11+12+12+13+13+14+14+15 它似乎在 arrD[i] 的 b 和 d 字段之间交替，它应该只对 b 字段求和。 有人可以解释为什么吗？ 提前致谢。

Answer 1

您很不幸遇到了允许编译完全无效代码的类型系统的最佳位置之一。

函数int sum1 (B* arr)接受一个指向 B 的指针根据签名将对象作为参数，但从语义上讲，它实际上需要一个指向 B 的数组 的指针。对象。当您调用 sum1(arrD)您传递的不是 B 的数组 违反了契约(Contract)对象，而是 D 的数组对象。它们有何不同？指针运算是根据指针类型的大小来完成的，一个B对象和一个 D对象有不同的大小。

一组 D不是 B 的数组

一般来说，派生类型的容器不是基类型的容器。仔细想想，一个容器的合约D是它持有，嗯，D对象，但如果 D 的容器是 B 的容器, 那么你就可以添加 B对象(如果参数是扩展的，你甚至可以考虑添加 D1 对象——也是从 B 派生的!)。

如果您使用高阶构造而不是原始数组，例如 std::vector编译器会阻止您传递 std::vector<D>代替 std::vector<B> ，但是为什么在数组的情况下它没有阻止你呢？

如果 D 的数组不是 B 的数组，为什么程序可以编译？

这个问题的答案早于 C++。在 C 中，函数的所有参数都是按值传递的。有些人认为您也可以按指针传递，但那只是按值传递指针。但是数组很大，按值传递数组的开销会很大。同时，当您动态分配内存时，您使用指针，尽管从概念上讲，当您 malloc 10 int如果您正在分配 int 的数组 . C 语函数存在规则，您不能复制一个函数，因此传递一个函数会隐式获得一个指向该函数的指针并传递它)。从一开始，C++ 中就有相同的规则。

现在，下一个问题是类型系统不区分指向元素的指针和指向作为数组一部分的元素的指针。这会产生后果。指向 D 的指针object 可以隐式转换为指向 B 的指针, 自 B是 D 的基础，并且 OO 编程的整个对象能够使用派生类型代替基础对象(好吧，为了多态性的目的)。

现在回到您的原始代码，当您编写 sum1( arrD ) 时, arrD用作右值，这意味着数组衰减为指向第一个元素的指针，因此它有效地转换为 sum1( &arrD[0] ) .子表达式 &arrD[0]是指针，指针只是指针... sum1接受一个指向 B 的指针, 和指向 D 的指针可隐式转换为指向 B 的指针，因此编译器很乐意为您进行转换:sum1( static_cast<B*>(&arrD[0]) ) .如果该函数只是获取指针并将其用作单个元素，那会很好，因为您可以传递一个 D。代替 B ，而是一组 D不是 B 的数组...即使编译器允许您这样传递它。