不要以多态方式处理数组

类继承的最重要的特性是你可以通过基类指针或引用来操作派生类。这样的指针或引用具有行为的多态性，就好像它们同时具有多种形态。C++允许你通过基类指针和引用来操作派生类数组。不过这根本就不是一个特性，因为这样的代码几乎从不如你所愿地那样运行。

假设你有一个类 BST(比如是搜索树对象)和继承自 BST 类的派生类 BalancedBST:

class BST { ... };
class BalancedBST: public BST { ... };

我们假设 BST 和 BalancedBST 只包含 int 类型数据。有这样一个函数，它能打印出 BST 类数组中每一个 BST 对象的内容:

void printBSTArray(ostream& s,
                   const BST array[],
                   int numElements)
{
	for (int i = 0; i < numElements; ) {
	s << array[i]; //假设 BST 类
	} //重载了操作符<< 
}

当你传递给该函数一个含有 BST 对象的数组变量时，它能够正常运行:

BST BSTArray[10];
...
printBSTArray(cout, BSTArray, 10); // 运行正常

然而，请考虑一下，当你把含有 BalancedBST 对象的数组变量传递给 printBSTArray 函数时，会产生什么样的后果:

BalancedBST bBSTArray[10];
...
printBSTArray(cout, bBSTArray, 10); // 还会运行正常么?

你的编译器将会毫无警告地编译这个函数，但是再看一下这个函数的循环代码:

for (int i = 0; i < numElements; ) {
  s << array[i];
}

这里的 array[i]只是一个指针算法的缩写:它所代表的是*(array+i)。我们知道 array 是一个指向数组起始地址的指针，但是 array 中各元素内存地址与数组的起始地址的间隔究竟有多大呢?它们的间隔是 i*sizeof(数组里的对象)，因为在 array 数组[0]到[i] 间有 i 个对象。编译器为了建立正确遍历数组的执行代码，它必须能够确定数组中对象的大小，这对编译器来说是很容易做到的。参数 array 被声明为 BST 类型，所以 array 数组中每一个元素都是 BST 类型，因此每个元素与数组起始地址的间隔是i*sizeof(BST)。

但是如果你把一个含有 BalancedBST 对象的数组变量传递给 printBSTArray 函数，你的编译器就会犯错误。在这种情况下，编译器原先已经假设数组中元素与 BST 对象的大小一致，但是现在数组中每一个对象大小却与BalancedBST 一致。派生类的长度通常都比基类要长。我们料想 BalancedBST 对象长度的比 BST 长。如果如此的话，printBSTArray 函数生成的指针算法将是错误的，没有人知道如果用 BalancedBST 数组来执行 printBSTArray 函数将会发生什么样的后果。不论是什么后果都是令人不愉快的。

如果你试图删除一个含有派生类对象的数组，将会发生各种各样的问题。以下是一种你可能采用的但不正确的做法。

//删除一个数组, 但是首先记录一个删除信息
void deleteArray(ostream& logStream, BST array[]) {
	logStream << "Deleting array at address "
				<< static_cast<void*>(array) << '\n';
	delete [] array;
}
BalancedBST *balTreeArray =
      new BalancedBST[50];
    ...

当编译器遇到这样的代码: delete [] array;它肯定象这样生成代码:

// 以与构造顺序相反的顺序来
// 解构 array 数组里的对象
for ( int i = 数组元素的个数 1; i >= 0;--i)
{
	deleteArray(cout, balTreeArray);
	array[i].BST::~BST();

因为你所编写的循环语句根本不能正确运行，所以当编译成可执行代码后，也不可能正常运行。语言规范中说通过一个基类指针来删除一个含有派生类对象的数组，结果将是不确定的。这实际意味着执行这样的代码肯定不会有什么好结果。多态和指针算法不能混合在一起来用，所以数组与多态也不能用在一起。

文章目录