#include<iostream.h>
class baseone
{
public:
baseone(){cout<<"baseone() called!\n";}
~baseone(){cout<<"~baseone() called!\n";}
};
class basetwo
{
public:
basetwo(){cout<<"basetwo() called!\n";}
~basetwo(){cout<<"~basetwo() called!\n";}
};
class derive
{
public:
derive(){cout<<"derive() called!\n";}
~derive(){cout<<"~derive() called!\n";one.~baseone();two.~basetwo();} //虽然显式调用基类析构函数，系统还是会再一次调用基类析构函数
baseone one;/////////
basetwo two;//改变 one 与two 的声明先后会导致系统自动调用 baseone 与 basetwo的析构函数顺序不同
};
void main()
{
derive der;
}
最终~basetwo()与~baseone()都调用了两次

谢谢6楼和song4！经过这两天的讨论，我对析构函数又有了更进一步认识。

创建实例时,程序首先初始化对象的数据成员: A construction
调用构造函数: B construction
C++在释放对象前调用析构函数:B destruction
删除对象的一切数据: A destruction
通常对数据成员的处理(初始化或者删除)是在构造和析构函数里执行
但A是一个类成员,在B的构造函数调用前被自动调用,B在没有调用析构
函数前,B的数据成员都是有效的,B调用析构函数后 A的生命周期也随之
结束,因此A自动调用其自身的析构函数.

这两天，又仔细琢磨了下。觉得问题关键应该是和栈有关。一个最简单的例子：
class CA
{ public:
CA(){cout<<"CA construction"<<endl;}
~CA(){cout<<"CA destruction"<<endl;}
};
class CB
{ public:
CB(){cout<<"CB construction"<<endl;}
~CB(){cout<<"CB destruction"<<endl;}
};
void main()
{
CA a;
CB b;
}
结果还是：CA construction
CB construction
CB destrutcion
CA destruction
在这里没有包含或者被包含的关系，或者是继承与被继承的关系，可是输出结果仍旧是先前我们说的那样。可见，析构函数的处理过程和栈有关系--先进后出。至于在一个类中声明另外类的对象，或者一个类继承另外一个类，都只不过是析构函数的一个特殊应用而已。我想最终还是需要从析构函数的实现原理上去考虑这个问题。呵呵

呵呵
我们说的也是栈的原理啊
但是我说的是原理
为什么呢
因为这样做最安全
怎么样做？？
按构造相反的顺序析构
为什么这样最安全呢？？？
因为在不知道基类里面是否有与子类有关的东西
的情况下，只有与其相反的顺序返回才不会
涉及到析构基类影响子类的情况

晕，刚才写的那么多东西，提交时出现错误，文字全没了！
谢谢楼上的几位，经过几天来的讨论，我想是不是这样认识这个问题：首先，需要澄清一个错误的认识：调用了子类的析构函数，就释放了占用的所用资源。根据“类与类之间，你做你的，我做我的，以接口作沟通。即使基类与子类也不例外”（引自：钱能 《C++程序设计教程》）的原则，子类的析构函数只是释放自己做申请的那部分资源；基类的资源的释放还是需要调用基类的析构函数。这样以来，基类和子类的的析构函数是各司其职。
总体来说：构造函数是一个入栈过程，而析构函数则是一个出栈的过程。