C++显示调用析构函数_显式调用析构函数

C++中new的用法及显示调用析构函数

最近被问到了C++内存池的问题，其中不免涉及到在指定内存地址调用对象构造函数以及显示调用对象析构函数的情况。

C++中new的用法

new是C++中用于动态内存分配的运算符，在C语言中一般使用malloc函数。

（1）plain new顾名思义就是普通的new，就是我们惯常使用的new。分配内存，调用构造函数，在C++中是这样定义的：

1 void* operator new(std::size_t) throw(std::bad_alloc);
2 void operator delete(void *) throw();

plain new在分配失败的情况下，抛出异常std::bad_alloc而不是返回NULL，因此通过判断返回值是否为NULL是徒劳的。

 1 #include "stdafx.h"
 2 #include <iostream>
 3 using namespace std;
 4 char *GetMemory(unsigned long size)
 5 {
 6     char *p=new char[size];//分配失败，不是返回NULL
 7     return p;
 8 }
 9 
10 int main()
11 {
12     try
13     {
14           char *p=GetMemory(10e11);// 分配失败抛出异常std::bad_alloc
15           //...........
16           if(!p)//徒劳
17            cout<<"failure"<<endl;
18           delete [] p;
19     }
20     catch(const std::bad_alloc &ex)
21     {
22           cout<<ex.what()<<endl;
23     }
24 
25     return 0;
26 }

 

（2）nothrow new是不抛出异常的运算符new的形式。nothrow new在失败时，返回NULL。定义如下：

1 void * operator new(std::size_t,const std::nothrow_t&) throw();
2 void operator delete(void*) throw();　

 1 #include "stdafx.h"
 2 #include <iostream>
 3 #include <new>
 4 using namespace std;
 5 char *GetMemory(unsigned long size)
 6 {
 7     char *p=new(nothrow) char[size];//分配失败，是返回NULL
 8     if(NULL==p)
 9           cout<<"alloc failure!"<<endl;
10     return p;
11 }
12 
13 int main()
14 {
15     try
16     {
17           char *p=GetMemory(10e11);
18           //...........
19           if(p==NULL)
20                cout<<"failure"<<endl;
21           delete [] p;
22     }
23     catch(const std::bad_alloc &ex)
24     {
25           cout<<ex.what()<<endl;
26     }
27     return 0;
28 }

 

（3）placement new意即“放置”，这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：

1 void* operator new(size_t,void*);
2 void operator delete(void*,void*);

palcement new的主要用途就是反复使用一块较大的动态分配的内存来构造不同类型的对象或者他们的数组。placement new构造起来的对象或其数组，要显示的调用他们的析构函数来销毁，千万不要使用delete。

 1 #include "stdafx.h"
 2 #include <iostream>
 3 #include <new>
 4 using namespace std;
 5 class ADT
 6 {
 7     int i;
 8     int j;
 9 public:
10     ADT()
11     {
12     }
13     ~ADT()
14     {
15     }
16 };
17 
18 int main()
19 {
20     char *p=new(nothrow) char[sizeof(ADT)+2];
21     if(p==NULL)
22           cout<<"failure"<<endl;
23     ADT *q=new(p) ADT;  //placement new:不必担心失败
24     // delete q;//错误!不能在此处调用delete q;
25     q->ADT::~ADT();//显示调用析构函数
26     delete []p;
27     return 0;
28 }

使用placement new构造起来的对象或数组，要显式调用它们的析构函数来销毁（析构函数并不释放对象的内存），千万不要使用delete.这是因为placement new构造起来的对象或数组大小并不一定等于原来分配的内存大小，

使用delete会造成内存泄漏或者之后释放内存时出现运行时错误。

 

另：

当使用new运算符定义一个多维数组变量或数组对象时，它产生一个指向数组第一个元素的指针，返回的类型保持了除最左边维数外的所有维数。例如：  

 int *p1 = new int[10];   

返回的是一个指向int的指针int*  

int (*p2)[10] = new int[2][10]; 

new了一个二维数组, 去掉最左边那一维[2], 剩下int[10], 所以返回的是一个指向int[10]这种一维数组的指针int (*)[10].  

int (*p3)[2][10] = new int[5][2][10];  new了一个三维数组, 去掉最左边那一维[5], 还有int[2][10], 所以返回的是一个指向二维数组int[2][10]这种类型的指针int (*)[2][10].     

#include<iostream>

#include <typeinfo> 

using namespace std;

 int main() { 

int *a = new int[34]; 

int *b = new int[]; 

int (*c)[2] = new 

int[34][2]; 

int (*d)[2] = new int[][2]; 

int (*e)[2][3] = new int[34][2][3];

 int (*f)[2][3] = new int[][2][3];

 a[0] = 1; 

 b[0] = 1; //运行时错误,无分配的内存,b只起指针的作用,用来指向相应的数据

 c[0][0] = 1;

d[0][0] = 1;//运行时错误,无分配的内存,d只起指针的作用,用来指向相应的数据 

e[0][0][0] = 1; 

f[0][0][0] = 1;//运行时错误,无分配的内存,f只起指针的作用,用来指向相应的数据 

cout<<typeid(a).name()<<endl;

 cout<<typeid(b).name()<<endl;

 cout<<typeid(c).name()<<endl; 

cout<<typeid(d).name()<<endl; 

cout<<typeid(e).name()<<endl;

 cout<<typeid(f).name()<<endl; 

delete[] a; delete[] b; delete[] c; 

delete[] d; delete[] e; delete[] f; 

}   

输出结果：

 int *

int *

int (*)[2]

int (*)[2]

int (*)[2][3]

int (*)[2][3]

 

一、文章来由

现在在写一个项目，需要用到多叉树存储结构，但是在某个时候，我需要销毁这棵树，这意味着如果我新建了一个树对象，我很可能在某处希望将这个对象的声明周期终结，自然会想到显示调用析构函数，但是就扯出来这么大个陷阱。

二、原因

在了解为什么不要轻易显示调用析构函数之前，先来看看预备知识。 
为了理解这个问题，我们必须首先弄明白“堆”和“栈”的概念。

1）堆区（heap） —— 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

2）栈区（stack） —— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

我们构造对象，往往都是在一段语句体中，比如函数，判断，循环，还有就直接被一对“{}”包含的语句体。这个对象在语句体中被创建，在语句体结束的时候被销毁。问题就在于，这样的对象在生命周期中是存在于栈上的。也就是说，如何管理，是系统完成而程序员不能控制的。所以，即使我们调用了析构，在对象生命周期结束后，系统仍然会再调用一次析构函数，将其在栈上销毁，实现真正的析构。

所以，如果我们在析构函数中有清除堆数据的语句，调用两次意味着第二次会试图清理已经被清理过了的，根本不再存在的数据！这是件会导致运行时错误的问题，并且在编译的时候不会告诉你！

三、显示调用带来的后果

如果硬要显示调用析构函数，不是不可以，但是会有如下3条后果：

1）显式调用的时候，析构函数相当于的一个普通的成员函数；

2）编译器隐式调用析构函数，如分配了对内存，显式调用析构的话引起重复释放堆内存的异常；

3）把一个对象看作占用了部分栈内存，占用了部分堆内存（如果申请了的话），这样便于理解这个问题，系统隐式调用析构函数的时候，会加入释放栈内存的动作（而堆内存则由用户手工的释放）；用户显式调用析构函数的时候，只是单纯执行析构函数内的语句，不会释放栈内存，也不会摧毁对象。

用如下代码表示：

例1：

class aaa
{
public:
    aaa(){}
    ~aaa(){cout<<"deconstructor"<<endl; } //析构函数
    void disp(){cout<<"disp"<<endl;}
private:
    char *p;
};
 
void main()
{
aaa a;
a.~aaa();
a.disp();
}

 

分析：

这样的话，显式两次destructor，第一次析构相当于调用一个普通的成员函数，执行函数内语句，显示第二次析构是编译器隐式的调用，增加了释放栈内存的动作，这个类未申请堆内存，所以对象干净地摧毁了，显式＋对象摧毁

例2：

class aaa
{
public:
    aaa(){p = new char[1024];} //申请堆内存
    ~aaa(){cout<<"deconstructor"<<endl; delete []p;}
    void disp(){cout<<"disp"<<endl;}
private:
    char *p;
};
 
void main()
{
aaa a;
a.~aaa();
a.disp();
} 

分析：

这样的话，第一次显式调用析构函数，相当于调用一个普通成员函数，执行函数语句，释放了堆内存，但是并未释放栈内存，对象还存在（但已残缺，存在不安全因素）；第二次调用析构函数，再次释放堆内存（此时报异常），然后释放栈内存，对象销毁

四、奇葩的错误

系统在什么情况下不会自动调用析构函数呢？显然，如果对象被建立在堆上，系统就不会自动调用。一个常见的例子是new…delete组合。但是好在调用delete的时候，析构函数还是被自动调用了。很罕见的例外在于使用布局new的时候，在delete设置的缓存之前，需要显式调用的析构函数，这实在是很少见的情况。

我在栈上建树之后，显示调用析构函数，对象地址任然存在，甚至还可以往里面插入节点。。。

其实析构之前最好先看看堆上的数据是不是已经被释放过了。

a.hpp
#ifndef A_HPP
#define A_HPP
 
#include <iostream>
using namespace std;
 
class A
{
private:
    int a;
    int* temp;
    bool heap_deleted;
public:
    A(int _a);
    A(const A& _a);
    ~A();
    void change(int x);
    void show() const;
};
 
#endif
 
a.cpp
 
#include "a.hpp"
A::A(int _a): heap_deleted(false)
{
    temp = new int;
    *temp = _a;
    a = *temp;
    cout<< "A Constructor!" << endl; 
}
 
A::A(const A& _a): heap_deleted(false)
{
    temp = new int;
    *temp = _a.a;
    a = *temp;
    cout << "A Copy Constructor" << endl;
}
 
A::~A()
{
    if ( heap_deleted == false){
        cout << "temp at: " << temp << endl;
        delete temp;
        heap_deleted = true;
        cout << "Heap Deleted!\n";
    }
    else {
        cout << "Heap  already Deleted!\n";
    }
 
    cout << "A Destroyed!" << endl; 
}
 
void A::change(int x)
{
    a = x;
}
 
void A::show() const
{
    cout << "a = " << a << endl;
}
 
 
//main.cpp
 
#include "a.hpp"
int main(int argc, char* argv[])
{
 
    A a(1);
    a.~A();
    a.show();
    cout << "main() end\n";
    a.change(2);
    a.show();
 
    return 0;
}

五、小结

所以，一般不要自作聪明的去显示调用析构函数。