关于析构函数~

lolikon

本来以为类的析构函数就是释放掉某个对象,释放完了该内存应该也释放了,就像通过指针delete一样,但是做了个小测试发现有点问题:

1. 
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. class  base
   
6. {
   
7. public:
   
8.         base(int a)
   
9.         {cout<<a<<" "<<"base con"<<endl;}
   
10.         virtual ~base()
    
11.         {cout<<a<<" "<<this<<" "<<"base ~con"<<endl;}
    
12. private:
    
13.         int a;
    
14.         base &operator=(const base &a);
    
15. };
    
16. 
    
17. class derived:public base
    
18. {
    
19. public:
    
20.         derived(int a):base(a)
    
21.         {cout<<"d1 con"<<endl;}
    
22.         ~derived()
    
23.         {cout<<"d1 ~con"<<endl;}
    
24. private:
    
25.         derived &operator=(const derived &d);
    
26. };
    
27. 
    
28. void main()
    
29. {
    
30.         //base *b=new derived(2);
    
31.         //delete b;
    
32.         derived d(2);
    
33.         d.~derived();
    
34. }
    

复制代码

假如采用new和delete方式,结果和我想象的一样,输出构造和析构函数各一次,然后如果采用创建对象然后调用其析构函数的方式则会输出两遍析构函数,求解

jiangcaiyang

动态开辟的空间可以调用delete函数自动析构，但是静态开辟的（也就是在类的后面定义对象的），不能手动使用delete析构，只能属于哪个括号的析构就在哪里。另外《数据结构（严蔚敏版）》中，大量使用了指针作为类的元素。因为指针的作用可以使用malloc()函数或new语句来动态开辟空间，有了这些就可以动态释放的，如果你在一个大括号中无法析构这个对象的话，之多它包含的是几个指针的值，而指针所指向的空间已经被释放了。另外，可以看看我的代码。这是我自己定义的一个类：JStack。
#ifndef _J_DEFINE_H_
#define _J_DEFINE_H_
//Using C++ style
template<typename CustomType>//可将任意类型应用于此
struct CustomStruct
{
        CustomType elem;
        CustomStruct* link;
};
template<typename CustomType>
class JStack
{
public:
        JStack():base(NULL),top(NULL),JStackSize(NULL){}//默认构造函数
        ~JStack(){}//默认析构函数
        bool IsEmpty( void );//判断是否为空栈
        CustomType GetTop( void );//取出栈顶的元素
        CustomType Pop( void );//将元素从栈中弹出
        bool Push(CustomType e);//将元素压入栈顶
private:
        CustomStruct<CustomType>* base;//栈底
        CustomStruct<CustomType>* top;//栈顶
        int JStackSize;//栈的元素个数
};//栈结构的定义
#endif






#include "JStackDefine.h"

template<typename CustomType>
bool JStack<CustomType>::IsEmpty( void )//判断是否为空栈
{
        if ( top == base )
                return true;
        return false;
}

template<typename CustomType>
bool JStack<CustomType>:ush(CustomType e)//将元素压入栈顶
{
        CustomStruct<CustomType>* temp;
        temp = top;
        top = new CustomStruct<CustomType>;
        if ( !top )
                return false;
        top->elem = e;
        top->link = temp;
        JStackSize++;
        return true;
}//此方法相当于头插法

template<typename CustomType>
CustomType JStack<CustomType>::Pop( void )//将元素从栈中弹出
{
        CustomStruct<CustomType> temp;
        temp.elem = top->elem;
        temp.link = top->link;
        delete top;
        top = temp.link;
        JStackSize--;
        return temp.elem;
}

template<typename CustomType>
CustomType JStack<CustomType>::GetTop( void )//取出栈顶的元素
{
        return top->elem;
}

??b我心

delete是delete,释放是释放,对象不同...

lolikon

终于搞清楚了  
事实上这个代码漏写了一句话,导致自己被搞糊涂了
那也就是说一个对象被创建后不遇到右括号是不会消失的, 手动调用其析构函数是无效的.
看来只有用指针来创建释放了  
彩阳多谢...