【求助C++问题】有关虚拟析构函数的问题

运动补偿

一个特简单的程序，增加基类的虚拟析构函数，则程序输出不一致。请哪位懂C++解释一下其中的道道？

#include <iostream>
#include <string>
using namespace std;
class base
{
        public:
                virtual void print(){cout<<"base::print()"<<endl;}
                //virtual ~base(){}//增加虚析构函数，将导致输出不一致。
};
class derived :public base
{
        public:
                virtual void print(){cout<<"devrived::print()"<<endl;}
};
int main(int argc, char *argv[])
{
        base* p1=&derived();
        p1->print();

        derived d;
        base* p2=&d;
        p2->print();

        return 0;
}

加入虚拟析构函数后，输出为：
base::print()
devrived::print()
不加入虚拟析构函数，输出则为：
devrived::print()
devrived::print()

[ 本帖最后由 运动补偿 于 2006-2-16 22:57 编辑 ]

mik

base* p1=&derived();
有这样的语法,不会报错?

什么不同?

converse

谈谈我的看法,不一定对,大家指教~~

实际上,第一个赋值指向的是一个临时对象,加入与没有加入虚拟析构函数的区别在于:加入之后,在derived类中会合成一个析构函数以便调用base的虚拟析构函数,如果没有加入的话那么就不会合成这个析构函数,所有的资源在main函数结束之后才回收.

因此,对于代码: base* p1=&derived();
没有加入虚拟析构函数的时候因为derived()函数生成的临时对象没有被销毁,因此对它的调用是对derived的调用;当加入虚拟析构函数之后,derived()函数生成的临时对象在以上的赋值完成之后就会调用析构函数进行析构,这个时候再次对p1调用print函数时,因为临时对象已经析构,那么这个调用就是对base的调用了.

我做了一个实验的代码,加了一些东西,大家看看~~

1. #include <iostream>
   
2. #include <string>
   
3. using namespace std;
   
4. class base
   
5. {
   
6.         public:
   
7.                 virtual void print(){cout<<"base::print()"<<endl;}
   
8.                 virtual ~base(){cout << "~base()\n";}//增加虚析构函数，将导致输出不一致。
   
9. };
   
10. class derived :public base
    
11. {
    
12.         public:
    
13.                 virtual void print(){cout<<"devrived::print()"<<endl;}
    
14.                 //virtual ~derived(){cout << "~derived()\n";}//增加虚析构函数，将导致输出不一致。
    
15. };
    
16. 
    
17. int main(int argc, char *argv[])
    
18. {
    
19.         derived *t = &derived();
    
20.         base* p1 = t;
    
21.         p1->print();
    
22. 
    
23.         derived d;
    
24.         base* p2=&d;
    
25.         p2->print();
    
26. 
    
27.         // 第一部分相当于以下的代码
    
28.         // 用temp模拟临时对象
    
29.         derived temp;
    
30.         derived *s = &temp;
    
31.         base *p3 = s;
    
32.         // 这次调用是对derived的函数调用
    
33.         p3->print();
    
34.         // 显式地对temp进行析构
    
35.         temp.base::~base();
    
36.         // 析构完后,同样的一个内存,却是用base指针去解释,
    
37.         // 因此调用的是base的函数
    
38.         p3->print();
    
39. 
    
40.         return 0;
    
41. }

复制代码

nuclearweapon

楼上的大哥,您的大意我是明白了.
但是有一个细节我不明白:
"当加入虚拟析构函数之后,derived()函数生成的临时对象在以上的赋值完成之后就会调用析构函数进行析构,这个时候再次对p1调用print函数时,因为临时对象已经析构,那么这个调用就是对base的调用了."
我的疑问是:
p1所指的对象被析构的时候,析构函数对此对象做了什么导致------析构后还能够用p1调用基类的成员函数.?

刚开始学c++ .多指教.
3x

converse

这个问题就好像用不同的指针去解释同一块内存,会有不同的结果一样的道理,你先想想看,我回头再仔细说~~

nuclearweapon

我是这样想的:

通过一个 _对象指针_ 访问 _虚函数_ , 要根据 _对象指针_  所指的对象类型来动态的决定调用哪一个函数.
既然一个 _对象指针_  所指的 _对象_ 已经不存在了,为什么还可以调用对象的成员函数.?
而且调用对象的成员函数是基类的成员函数?