比较显式调用构造函数和析构函数

最新推荐文章于 2024-03-27 17:20:04 发布

五山小新新

最新推荐文章于 2024-03-27 17:20:04 发布

阅读量616

点赞数

分类专栏：深度探索C++对象模型

本文链接：https://blog.csdn.net/Al_xin/article/details/38581643

版权

深度探索C++对象模型专栏收录该内容

14 篇文章 3 订阅

订阅专栏

1.首先看如下的代码，显式调用析构函数：

    C++ Code  
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
using namespace std;

class MyClass
{
public:
    MyClass()
    {
        n_ = 1;
        cout << "Constructors" << endl;
    }
    ~MyClass()
    {
        cout << "Destructors" << endl;
    }
     void display()
    {
        cout << n_ << endl;
    }
private:
     int n_;
};

int main ( void)
{
    MyClass *pMyClass = new MyClass;
    pMyClass->~MyClass();
     delete pMyClass;
     return 0;
}

输出为：

Constructors

Destructors

证实了一些说法：

new的时候，其实做了两件事，

一是：调用malloc分配所需内存（实际上是调用operator new），二是：调用构造函数。

delete的时候，也是做了两件事，

一是：调用析造函数，二是：调用free释放内存（实际上是调用operator delete）。

这里只是为了演示，正常情况下析构函数只会被调用一次，如果被调用两次，而析构函数内有delete的操作，会导致内存释放两次的错误。

2. 接着再看：显式调用构造函数（第一种方式）：

    C++ Code  
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <iostream>

using namespace std;

class MyClass
{

public:

    MyClass()
    {
        n_ = 1;

        cout << "Constructors" << endl;
    }

    ~MyClass()
    {
        cout << "Destructors" << endl;
    }

     void display()
    {
        cout << "n=" << n_ << endl;
    }

private:

     int n_;

};

int main ( void)
{

    MyClass *pMyClass = (MyClass *)malloc( sizeof(MyClass));

    pMyClass->MyClass::MyClass(); //第一种方式

    pMyClass->display();

    free(pMyClass); // 不能用delete，对应malloc，不会调用析构函数

     return 0;
}

输出为：

Constructors

n=1

3.显示调用构造函数（第二种方式）：placement new

    C++ Code  
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <iostream>

using namespace std;

class MyClass
{
public:
     MyClass()
    {
        n_ = 1;
        cout << "Constructors" << endl;
    }

    ~MyClass()
    {
        cout << "Destructors" << endl;
    }

     void display()
    {
        cout << "n=" << n_ << endl;
    }

private:

     int n_;
};

int main ( void)
{
     char tmp[ 10];
    MyClass *pMyClass = new (tmp) MyClass; // placement new 用法
    pMyClass->display();
    pMyClass->~MyClass(); // 不是堆上的内存，不能用delete
     return 0;
}

Constructors

n=1

Destructors

placement new的作用就是：创建对象(调用该类的构造函数)但是不分配内存，而是在已有的内存块上面创建对象。用于需要反复创建并删除的对象上，可以降低分配释放内存的性能消耗。