1、  关于主动调用析构函数；

C++编程规范中都不支持显示的调用析构函数，部分文章中甚至说明析构函数是不能显示调用的，然而执行如下类似的操作编译器并不会报错，而且会调用成功。

pa->~A();

我们先来看看这样的操作会有哪些副作用，然后再讨论存在的意义；

1.       如果在析构函数中显示地释放了堆上的内存，显示调用析构函数会存在重复释放内存错误，例子如下：

class A

{

        char *a;

public:

        A(){a =(char *)malloc(4);}

        ~A()

        {

               free(a);

               printf(“Adeconstructor\n”);

        }

};

int main()

{

        A a;

        a.~A();

        return0;

}

2.       显示的调用析构函数相当于执行了析构函数内容（包括子类析构函数），但是并没有释放内存，也没有摧毁对象；上述的例子可以理解为a对象占用了char *大小的栈内存，占用了4个字节的堆内存，堆内存通过构造函数申请，通过析构函数释放；显示的调用析构函数执行了析构函数，释放掉了堆上的内存，但是并不会释放栈上内存。

3.       使用new操作符的情况有写不同，new操作符可以考虑为两个阶段。

a．  在堆上申请对象本身成员所占内存；

b．  执行构造函数。

考虑如下例子：

class A

{

        char *a;

public:

        A(){a =(char *)malloc(4);}

        ~A()

        {

               free(a);

               printf(“Adeconstructor\n”);

        }

};

int main()

{

        A *a =new A();

        a->~A();

        return0;

}

显然此时编译器不会隐式调用析构函数，所以不会出现重复释放的问题，但是由于a->~A()只会执行析构函数，a指针本身所占的内存不会被释放掉，所以会造成内存泄漏。

 

由以上的分析可知，显示调用析构函数不但不会带来任何好处，还会造成很多奇怪、难以分析的问题，这也是不推荐使用的原因，为什么C++标准不禁止呢？来看一下关于placementnew的用法。

placement new是operator new的一个重载版本；所谓placement new就是在用户指定的内存位置上构建新的对象，这个构建过程不需要额外分配内存，只需要调用对象的构造函数即可。

例子如下：

struct A {…};

struct B {…};

 

A* pa = new A;

pa->~A();

B* pb = new (pa) B;//placement new

以上例子必须要求sizeof(A)>=sizeof(B)。B* pb = new (pa) B并不会申请内存，只是在原来A对象的位置上生成B的对象。

 

更普遍的使用方法如下：

class A{

       …

public:

       show();

};

1）分配内存

char* buff = new char[ sizeof(A) *N+sizeof(int)) ];

memset( buff, 0, sizeof(A)*N +sizeof(int));

 

2）构建对象

A* pa = new (buff)A;

 

3）使用对象

pa->show();

 

4）析构对象，显式的调用类的析构函数。

pa->~A();

 

5）销毁内存

delete [] buff;

 

对于buff这块内存可以反复使用，只要重复2）、3）、4）步骤即可。在C++标准中，对于placementoperator new []有如下的说明：placementoperator new[] needs implementation-defined amount of additional storage tosave a size of array. 所以我们必须申请比原始对象大小多出sizeof(int)个字节来存放对象的个数，或者说数组的大小。

对于效率和容错要求比较高的程序来说placement new是很有用的：

1）  placement new能够有效的解决内存碎片的问题；

2）  malloc、new等申请内存有失败的可能，对有些程序来说是不允许的，而placementnew可以做到；

3）  placement new不需要执行申请内存的过程，速度更快；

 

C++标准STL就有使用placement new的情况，不过不是在特殊情况下比如自己编写高效率库、需要自己管理内存池时不推荐使用placement new。

析构函数是当对象要被释放掉时才会被调用，所以常被用来处理数据，例如释放堆区空间。

由此，可以得出析构函数释放时的三种情况：

1.正常情况

例：

#include <iostream>
using namespace std;

class Cstu
{
    int a;
    Cstu():a(22)
    {
        cout << a << endl;
        a = 23;
    }
    ~Cstu()
    {
        cout << a << endl;
    }
};

int main()
{
    {
        Cstu stu;
    }    

    system("pause");
    return 0;
}

对象stu处于一个局部域内，当执行到22行的花括号时，执行析构函数，可用断点和控制台上输出的数值来验证。

2.处于带返回值函数的内

"return"相当于宣告函数已经执行结束，当执行到这一语句时，便会调用析构函数。

可用上述例子，减去"Cstu stu"两侧的花括号去做实验。

3.指针对象/堆区对象

即：

Cstu *p = new Cstu;
delete p;

因为delete的作用便是释放堆区空间，所以执行到delete时执行析构函数。

4.临时对象

Cstu();

因为临时对象的作用域只是其所在的这条语句，所以当语句执行完毕前会调用析构函数。

 

另：1.只有new 和 delete 会分别触发构造函数和析构函数，malloc 和 free无法触发。

       2.析构函数的形式只能是"~Cstu()"，不能有参数，所以也无法构成重载函数。

       3.当没有写析构函数时，系统会执行默认的析构函数，其内容为空。

今天用C++改写jept_json的时候遇到了一个问题。
首先，在lept_json中，在lept_value中定义了一个联合

struct lept_value {
    union {
        struct { char* s; size_t len; }s;                   /* string: null-terminated string, string length */
        double n;                                           /* number */
    }u;
    lept_type type;
};

一开始C++中也想这么写，想想不用自己建栈了美滋滋啊

union {
	std::string s;
	double n;
};

还顺便用了下匿名union，以后访问再也不用v->u.n了。
然后编译器就报错啦！

构造函数是已删除的函数？
回忆了一下C++ Primer里讲的，这里也没有成员没有默认构造函数呀？
想了下，这个问题也只可能是union引起的。查了查果然是，由于union里有类类型，因此编译器就懵逼了，不知道调用谁的构造函数。
自己手动添加构造函数和析构函数吧。
构造函数容易解决，在构造阶段，直接吧type置为TYPE_NULL就可以了。
略麻烦的是析构函数。以前从来没有自己手动调用过析构函数，这里明显是要根据类型来调用析构函数啊。
踩个坑，可能理解的也没有很透彻

手动调用析构函数的小例子

参考别人的，写了个测试类。

class testDes {
public:
	testDes() {
		//pi = new int(42);
		cout << "cons" << endl;
	}
	~testDes() {
		//delete pi;
		cout << "des" << endl;
	}
	string s = "sssssss";
	vector<int> ivec{ 1,2,3 };
	int i = 0;
	//int *pi;
};

	//main.cpp
	testDes t;
	cout << t.s << endl;
	cout << t.i << endl;
	for (auto i : t.ivec)
		cout << i << " ";
	cout << endl;
	//cout << *t.pi << endl;
	t.~testDes();
	cout << t.s << endl;
	cout << t.i << endl;
	for (auto i : t.ivec)
		cout << i << " ";
	cout << endl;
	cout << t.ivec.size() << endl;

运行结果：

在上面的代码状态下，当类内没有int* pi，也就是没有堆区数据的时候，尽管析构函数被调用了两次，但是没有什么问题。类内的string和vector在第一次调用析构函数后数据就被清理了，但是还在栈区占有空间。int没有收到影响，可以第二次调用。
但是如果去掉注释，第二次delete pi肯定就会报错了，因为不能把一块空间释放两次。（其实可以delete完了pi=nullptr）。

所以，可以根据类型判断，调用union的对应类型的析构函数。