More Effective C++

多态指的是可以通过基类类型的指针或引用, 来 *** 作派生类的对象. 然而通过基类类型的指针或引用,来 *** 作派生类的对象数组, 则没有任何保证如预期般运作.

有一个class BST以及继承自BST的class BalancedBST:

class BST
{
public:
    BST():bst1(-1),bst2(-2){}
    virtual ~BST(){cout << "BST::~BST" << endl;}
    virtual ostream& operator<<(ostream& os) const
    {
        os << "BST::operator<<:" << bst1 << "," << bst2 << endl;
        return os;
    }
private:
    int bst1;
    int bst2;
};

class BalancedBST: public BST
{
public:
    BalancedBST():bbst1(1), bbst2(2){}
    virtual ~BalancedBST(){cout << "BalancedBST::~BalancedBST" << endl;}
    virtual ostream& operator<<(ostream& os) const
    {
        os << "BalancedBST::operator<<:" << bbst1 << "," << bbst2 << endl;
        return os;
    }
private:
    int bbst1;
    int bbst2;
};

为了让输出BST类族, 惯用 cout<

ostream& operator<<(ostream& os, const BST& bst)
{
    bst << os;
    return os;
}

然后通过遍历指向基类的指针或引用(数组名作为函数参数会被退化为基类对象数组首地址):

void printBSTArray1(ostream& s, const BST array[], int numEles)
{
    cout << "printBSTArray1:" << endl;
    for (int i = 0; i < numEles; ++i) {
        array[i]<

BST BSTArray[10];
BalancedBST BalancedBSTArray[10];

printBSTArray1(cout, BSTArray, 10);           //ok
printBSTArray1(cout, BalancedBSTArray, 10);   //crash

void deleteArray(ostream& logstream, BST array[])
{
    logstream << "deleting array at address " << static_cast(array) << endl;
    delete [] array;
}

BST* balTree = new BalancedBST;
delete balTree;

cout << "===============" << endl;

BalancedBST* balTreeArray = new BalancedBST[4];
deleteArray(cout, balTreeArray);

BalancedBST::~BalancedBST
BST::~BST
===============
deleting array at address 0x100705688
BST::~BST
BST::~BST
BST::~BST
BST::~BST