文章目录
C/C++内存管理
C/C++内存分布
我们先来看下面的一段代码：
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof (int)* 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int)* 4);
free(ptr1);
free(ptr3);
}
你知道上面这些变量，指针，数组名等等是分别存储存在内存的哪一个区域吗？
知道的话证明你很不错，不知道也没关系，接下来就由我来告诉你。
【说明】
**顺便再来说一下：**为什么说栈是向下增长的，堆是向上增长的？
简单来说，在栈区开辟空间，先使用的是高地址的空间，一般情况在堆区开辟空间，会先使用低地址的空间。
接下来我们通过一段代码来看一下栈是向下增长的
void f2()
{
int b = 0;
cout << "b:" << &b << endl;
}
void f1()
{
int a = 0;
cout << "a:" << &a << endl;
f2();
}
int main()
{
f1();
return 0;
}
在栈区开辟空间，先开辟的空间地址较高，因此打印出来a的地址大于b的地址。
我们再来通过一段代码看一下堆是向上增长的
int main()
{
//堆向上生长
int* p1 = (int*)malloc(4);
int* p2 = (int*)malloc(4);
cout << "p1:"<< p1 << endl;
cout << "p2:"<< p2 << endl;
return 0;
}
那为什么又说一般情况下在堆区开辟空间是先使用低地址呢？
因为在堆区开辟空间，后开辟的空间不一定比先开辟的空间地址高，假如你开辟了两块空间，然后你释放第一块空间，又再去开一块空间，这个时候你开的空间有可能用的是你上次释放的那块空间，我们通过一段代码来看一下吧。
int main()
{
//一般情况下后申请的比先申请的大，但是也不一定
for (int i = 0; i < 3; i++)
{
int* p1 = (int*)malloc(4);
int* p2 = (int*)malloc(4);
cout << "p1:"<< p1 << endl;
cout << "p2:"<< p2 << endl;
free(p1);
}
return 0;
}
C语言中动态内存管理方式
malloc/calloc/realloc和free
void Test ()
{
int* p1 = (int*) malloc(sizeof(int)); free(p1);
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？
free(p3 );
}
面试题
malloc/calloc/realoc的区别？
如果想具体了解它们的使用以及区别请去看博主的这篇博客：(174条消息) C语言进阶——动态内存管理_Ustinian%的博客-CSDN博客
C++内存管理方式
new/delete操作内置类型
1.动态申请单个类型的空间
int main()
{
//申请单个类型的空间
int* p1 = new int;
delete p1;
}
它的作用等价于：
int main()
{
//动态申请单个int类型的空间
int* p2 = (int*)malloc(sizeof(int));
free(p2);
}
2.动态申请多个某类型空间
int main()
{
//动态申请10个int类型的空间
int* p3 = new int[10];
delete[] p3;
}
它的作用等价于：
int main()
{
//动态申请10个int类型的空间
int* p4 = (int*)malloc(sizeof(int)* 10);
free(p1);
}
3.动态申请单个类型的空间并进行初始化
int main()
{
//动态申请单个int类型的空间并初始化
int* p5 = new int(3);
free(p5);
}
它的作用等价于：
int main()
{
//动态申请单个int类型的空间
int* p6 = (int*)malloc(sizeof(int));
*p6 = 3;
free(p6);
}
4.动态申请多个某类型空间并初始化
int main()
{
//动态申请4个int类型的空间
int* p7 = new int[4]{0,1,2,3};
delete[] p7;
}
它的作用等价于：
int main()
{
//动态申请4个int类型的空间
int* p8 = (int*)malloc(sizeof(int)* 4);
for(int i = 0;i<4;i++)
{
*(p8+i) = i;
}
free(p8);
}
new/delete和malloc/free针对内置类型没有任何差别，只是用法不一样。
但是需要注意的是：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。new/delete new[]/delete[]一定要匹配，否则可能会出错。
new/delete操作自定义类型
我们通过代码来看一下new和delete操作自定义类型
struct ListNode
{
//struct ListNode* _next;//C
ListNode* _next;
ListNode* _prev;
int _val;
ListNode(int val = 0)
:_next(nullptr)
, _prev(nullptr)
, _val(val)
{
cout << "ListNode(int val = 0)" << endl;
}
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
int main()
{
//C malloc只是开空间，free释放空间
struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
free(n1);
//CPP new针对自定义类型，开空间 + 构造函数初始化
// delete针对自定义类型，析构函数清理 + 释放空间
ListNode* n2 = new ListNode(5); //相当于C语言中BuyListNode(5)
delete n2;
struct ListNode* arr3 = (struct ListNode*)malloc(sizeof(struct ListNode)*4);
free(arr3);
ListNode* arr4 = new ListNode[4]{1, 2, 3, 4};
delete[] arr4;
delete arr4;//不匹配会崩溃
return 0;
}
通过调试我们可以看到对于自定义类型malloc只是开辟了空间，free释放空间。但是new不仅开辟了空间还调用了构造函数初始化，并且delete调用析构函数清理和释放空间。
总结
operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层调用operator delete全局函数来释放空间。
operator new和operator delete全局函数他们的用法跟malloc和free是完全一样的，功能都是在堆上申请和释放空间。但是区别是失败了处理方式不一样，malloc失败会返回NULL，oeprator new失败以后会抛异常。
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int _val;
ListNode(int val)
:_next(nullptr)
, _prev(nullptr)
, _val(val)
{}
};
void f()
{
ListNode* p1 = (ListNode*)malloc(sizeof(ListNode));
free(p1);
//等价于上面两行代码
ListNode* p2 = (ListNode*)operator new(sizeof(ListNode));
operator delete(p2);
}
void test()
{
//他的用法跟malloc和free是完全一样的，功能都是在堆上申请释放空间
//失败了处理方式不一样，malloc失败返回NULL，operator new失败以后抛异常
void* p3 = malloc(0x7fffffff);
if (p3 == NULL)
{
cout << "malloc fail" << endl;
}
char* p5 = new char[0x7fffffff];
cout << "继续" << endl;
}
int main()
{
try
{
f();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
实际上，operator new函数实际是通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，则尝试空间不足应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。同时operator delete最终是通过free来释放空间的。
operator new与operator delete的类专属重载
下面代码演示了，针对链表的节点ListNode通过重载类专属 operator new/ operator delete，实现链表节点使用内存池申请和释放内存，提高效率。
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int _data;
void* operator new(size_t n)
{
void* p = nullptr;
p = allocator<ListNode>().allocate(1);
cout<<"memory pool allocate"<<endl;
return p;
}
void operator delete(void* p)
{
allocator<ListNode>().deallocate((ListNode*)p,1);
cout<<"memory pool deallocate"<<endl;
}
};
class List
{
public:
List()
{
_head = new ListNode;
_head->_next = _head;
_head->_prev = _head;
}
~List()
{
ListNode* cur = _head->_next;
while (cur != _head)
{
ListNode* next = cur->_next;
delete cur; cur = next;
}
delete _head;
_head = nullptr;
}
private:
ListNode* _head;
};
int main()
{
List l;
return 0;
}
new和delete的实现原理
内置类型
自定义类型
- new的原理
1.调用operator new函数申请空间
2.在申请的空间调用构造函数，完成对象的构造。
- delete的原理
1.在空间上执行析构函数，完成对象中资源的清理工作
2.调用operator delete函数释放对象的空间
- new T[N]的原理
1.调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2.在申请的空间上执行N次构造函数
- delete[]的原理
1.在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2.调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
定位new表达式(placement-new)
常见面试题
malloc/free/和new/delete的区别
内存泄漏
什么是内存泄漏，内存泄漏的危害
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题 int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}
这里还需要强调一下：
内存泄漏是指针丢了还是内存丢了呢？
答案是指针丢了。
内存泄漏分类
C/C++程序中一般我们关心两种方面的内存泄漏：
- 堆内存泄漏
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统内存泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
如何避免内存泄漏
如何一次在堆上申请4G的内存
int main()
{
//1byte == 8bit
//1KB = 1024byte
//1MB = 1024KB
//1GB = 1024MB
//1TB = 1024GB
//1G
//void* p1 = malloc(1024 * 1024 * 1024);
//1.8G
//void* p1 = malloc(1024 * 1024 * 1024 * 1.8);
//要想malloc出4G的空间，就得切换成64位
//因为32位下最多只能申请2G空间，申请连续的空间大概1.8G左右
//0xffffffff转换为十进制就是4G
void* p1 = malloc(0xffffffff);
cout << p1 << endl;
return 0;
}
在32位下我们最多只能申请2G的空间，申请连续的空间大概1.8G左右，因此我们要想申请4G的空间，就得切换成64位平台才可以。
若下图操作所示：
