文章目录
new和delete
new和malloc的区别&delete和free的区别
new动态开辟空间还可以调用其构造函数对其初始化，可以对于之定义类型进行初始化，
malloc只会动态开辟空间，不会初始化
但是对于内置类型没有区别
delete可以完成资源的清理和空间的销毁，对于自定义类型可以调用其析构函数完成其资源的清理
free只会完成空间的销毁
用法：
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
| class A
{
int _a;
int _b;
public:
A()
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
};
int main()
{
int* ptr1 = (int *)malloc(sizeof(int));
int* ptr2 = (int*)malloc(sizeof(int) * 5);
int* p3 = new int;
int* p4 = new int[5];
int* p5 = new int(5);
int* p6 = new int[5]{ 1,2 };
free(ptr1);
free(ptr2);
ptr1 = nullptr;
ptr2 = nullptr;
delete p3;
delete[] p4;
p3 = nullptr;
p4 = nullptr;
A* pa = (A*)malloc(sizeof(A));
A* pa2 = new A;
A* pa3 = (A*)malloc(sizeof(A) * 5);
A* pa4 = new A[5];
delete pa3;
delete[] pa4;
return 0;
}
|
需要注意的是new要和delete配对
new[]要和delete[]配对
new和delete的应用
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
| class Stack
{
private:
int _top;
int _capacity;
int* _a;
public:
Stack(int capacity = 4)
:_top(0)
,_capacity(4)
{
_a = new int[capacity];
}
~Stack()
{
delete[] _a;
_a = nullptr;
}
};
int main()
{
Stack* s1 = new Stack;
delete s1;
return 0;
}
```cpp
struct ListNode
{
ListNode* prev;
ListNode* next;
int _val;
ListNode(int val)
:prev(nullptr)
,next(nullptr)
,_val(val)
{}
};
class List
{
public:
List()
{
_head = new ListNode(-1);
_head->next = _head;
_head->prev = _head;
}
void pushback(int val)
{
ListNode* newnode = new ListNode(val);
ListNode* tail = _head->prev;
tail->next = newnode;
newnode->prev = tail;
_head->prev = newnode;
newnode->next = _head;
}
private:
ListNode* _head;
};
int main()
{
struct ListNode* n1 = (struct ListNode*)malloc(sizeof(ListNode));
n1->prev = nullptr;
n1->next = nullptr;
n1->_val = 0;
ListNode* n2 = new ListNode(0);
return 0;
}
|
new和delete的底层
operator new和operator delete
operator new中调用malloc申请内存，但是malloc失败之后返回null，而operator new失败以后，改为抛异常处理错误，这样符合c++面向对象语言处理错误的方式
这个operator new是给new用的一般不是给我们用的
new就是使用operator new（申请空间）+调用构造函数（初始化）
1
| Stack* ps1 = (Stack*)operator new(sizeof(Stack));
|
同理operator delete就是只会申请空间，不会调用析构函数，也是给delete所使用的
定位new
定位new对已经分配的原始内存空间中调用构造函数初始化一个对象
用法：
new(地址)类型（值）
定位new表达式在实际中一般时配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| class A
{
public:
A(int a)
:_a(a)
{}
~A()
{
}
private:
int _a;
};
int main()
{
A* p = (A*)malloc(sizeof(A));
new(p)A(1);
p->~A();
operator delete(p);
return 0;
}
|
内存泄漏
1–动态申请的内存，不使用了，又没有主动释放，就存在内存泄漏了
2–内存泄露的危害：
a，出现内存泄露的进程会正常结束，进程结束时这些内存会还给系统，不会又危害
b，出现内存泄露的进程非正常结束，比如僵尸内存，系统用的内存越来越少
c。需要长期运行的程序出现内存泄露，危害很大，系统会越来越满，甚至卡死宕机 —服务器程序，