文章目录
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);
}
你知道上面这些变量，指针，数组名等等是分别存储存在内存的哪一个区域吗？
知道的话证明你很不错，不知道也没关系，接下来就由我来告诉你。
【说明】
- 栈又叫堆栈，主要存储非静态局部变量/函数参数/返回值等等，栈是向下增长的。
- 内存映射段是搞笑的I/O映射方式，用于装载一共共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
- 堆用于程序运行时动态内存分配，堆是向上增长的。
- 数据段又叫做静态区，用于存储全局数据和静态数据。
- 代码段又叫常量区，用于存储可执行的代码和只读常量。
顺便再来说一下： 为什么说栈是向下增长的，堆是向上增长的？
简单来说，在栈区开辟空间，先使用的是高地址的空间，一般情况在堆区开辟空间，会先使用低地址的空间。
接下来我们通过一段代码来看一下栈是向下增长的
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的区别？
简单来说：
1.malloc在堆上动态开空间
2.calloc在堆上动态开空间+初始化成0.等价于malloc+memset
3.realloc针对在已有的空间进行扩容
扩容分为：原地扩容和异地扩容
原地扩容：后面有足够的空间，直接扩容。
异地扩容：后面没有足够的空间，重新区找一块空间，把旧空间的内容拷贝到新空间上，然后再释放旧空间。
如果想具体了解它们的使用以及区别请去看博主的这篇博客：(174条消息) C语言进阶——动态内存管理_Ustinian%的博客-CSDN博客
C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方旧无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
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调用析构函数清理和释放空间。
总结
- C++中如果是申请内置类型对象或者数组，malloc和new没什么区别
- 如果是自定义类型，区别很大，new和delete是开空间+初始化，析构清理+释放空间，而malloc和free仅仅是开空间+释放空间
- 建议在C++中，无论是内置类型还是自定义类型的申请释放，尽量使用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和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请释放的是连续空间，并且new在申请空间失败时会抛异常，malloc会返回NULL。
自定义类型
- 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)
定位new表达式表示在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new(place_address)type或者new(place_address)type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般时配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
class A { public: A(int a = 0) :_a(a) { cout << "A()" << this << endl; } ~A() { cout << "~A()" << endl; } private: int _a; }; int main() { A* p = (A*)malloc(sizeof(A)); //等价于直接用A* p = new A A* p1 = (A*)operator new(sizeof(A)); //new(p1)A; new(p1)A(3); //定位new，placement-new，显式调用构造函数 //定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象 p->~A();//析构函数可以显示调用 //等于delete p operator delete(p); return 0; }注意：
在使用定位new表达式之前，p现在指向的只不过是与A对象相同大小的一块空间，还不能算是一个对象，因为构造函数还没有执行。
常见面试题
malloc/free/和new/delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。
不同的地方是：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new可以初始化
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果时多个对象，[]中指定对象个数即可。
- malloc的返回值为void*，在使用时必须强转，new不需要，因为new后跟的是空间的类型
- malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是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;
}
这里还需要强调一下：
内存泄漏是指针丢了还是内存丢了呢？
答案是指针丢了。
malloc，new申请空间的本质是把一块内存的使用权给你。不使用空了，free、delete释放内存空间的本质，是交换使用权给系统，那么系统就可以把这块内存再分配给别人。
如果申请了一块空间，但是不使用这块空间了但是又不释放，就会造成内存泄漏。这就有点像我们所说的——占着茅坑不拉屎。
内存泄漏分类
C/C++程序中一般我们关心两种方面的内存泄漏：
- 堆内存泄漏
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统内存泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
如何避免内存泄漏
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
内存泄漏非常常见，解决方案分为两种：
1.事前预防型。如智能指针等。
2.事后查错型。如泄漏检测工具。
如何一次在堆上申请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位平台才可以。
若下图操作所示：
3202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
