1

代码：

class B {
public:
    B () : b(++bCounter) {}
    int b;
    static int bCounter;
};

int B::bCounter = 0;

class D : public B {
public:
    D () : d(0) {}
    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;
}

问题：

这些返回什么：

1）sum1(arrB)=？

2）sum1(arrD)=？

3）sum2(arrD)=？

当我编译并运行这些时，我得到 55、65 和 155，但不知道为什么。我收集到在 arrB 中的变量是 b=1,2,3,...,10，而在 arrD b=11,12,...,20 中，我会回答 sum1(arrB)=55 和sum1(arrD)=155 等于 11+12+..+20 的和，而 sum2(arrD)=155，因为处处 d=0。

我究竟做错了什么？

4

2 回答 2

4

您正在进行对象切片。您正在将一个D*数组传递给一个接受数组的函数B*。D最初大于B。

每次您这样做时，s+=arr[i].b;您都将指针移动B 的大小，而您需要将其移动D 的大小，因此每次迭代后指针不会向前移动一项。

[TheBPart|TheDPart][TheBPart|TheDPart][TheBPart|TheDPart]
^
|
iteration 0

[TheBPart|TheDPart][TheBPart|TheDPart][TheBPart|TheDPart]
         ^
         |
      iteration 1

[TheBPart|TheDPart][TheBPart|TheDPart][TheBPart|TheDPart]
                   ^
                   |
             iteration 2

[TheBPart|TheDPart][TheBPart|TheDPart][TheBPart|TheDPart]
                            ^
                            |
                          iteration 3

在您的特定情况下发生的情况是，在每次奇数迭代之后，它都指向类对象中间D的某个位置。之所以发生这种情况，是因为D恰好是 的两倍B，否则行为会有所不同。

于 2012-09-04T08:50:07.387 回答
2

问题在于转换arrD为arrB. B 的大小为 4 个字节，而 D 的大小为 8 个字节。

当您将 D* 转换为 B* 时，实际上每次迭代会在内存中跳转 4 个字节，而不是 8 个字节。如果我们一次取 4 个字节，arrD 将在内存中保存以下值

11   // arrD[0].b
0    // arrD[0].d
12   // arrD[1].b
0    // arrD[1].d
13   // arrD[2].b
0    // arrD[2].d
14   // arrD[3].b
0    // arrD[3].d
15   // arrD[4].b
0    // arrD[4].d
16   // arrD[5].b
0    // arrD[5].d
17   // arrD[6].b
0    // arrD[6].d
18   // arrD[7].b
0    // arrD[7].d
19   // arrD[8].b
0    // arrD[8].d
20   // arrD[9].b
0    // arrD[9].d

现在，当你总结一次取 4 个字节时，你取它的前 10 个值。因此你的结果是：11+0+12+0+13+0+14+0+15+0 = 65

从类似的推理中，您可以知道结果的原因sum2。

于 2012-09-04T08:52:41.457 回答