目录
内存分布
在我们讲解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);
}
对于上述代码，回答下列两个题组：
| 题组1一 | 选项: A.栈 B.堆 C.数据段 D.代码段 |
|---|---|
| globalVar在哪里？____ | staticGlobalVar在哪里？____ |
| staticVar在哪里？____ | localVar在哪里？____ |
| num1 在哪里？____ |
| 题组二 | 选项: A.栈 B.堆 C.数据段 D.代码段 |
|---|---|
| char2在哪里？____ | *char2在哪里？___ |
| pChar3在哪里____？ | *pChar3在哪里？____ |
| ptr1在哪里？____ | *ptr1在哪里？____ |
这里先不展示答案，我会在文章末尾给出答案与解析。
C++内存管理方式
对于C语言中的内存管理方式，比如malloc/calloc/realloc等，在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
new 与delete的使用
new 与delete的使用十分简单：
当我们申请和释放单个元素的空间，使用new和delete操作符
当我们申请和释放连续的空间，使用new[]和delete[]
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}
当然，new/delete可以操作内置数据类型，也可以操作自定义数据类型：
class Test
{
public:
Test()
: _data(0)
{
cout<<"Test():"<<this<<endl;
}
~Test()
{
cout<<"~Test():"<<this<<endl;
}
private:
int _data;
};
void Test2()
{
// 申请单个Test类型的对象
Test* p1 = new Test;
delete p1;
// 申请10个Test类型的对象
Test* p2 = new Test[10];
delete[] p2;
}
new/delete 和 malloc/free 的差别
虽然new/delete相较于malloc/free来说确实简化了写法，但两者的区别仅限于此吗？
显然不是：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new可以初始化
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
- malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
- malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
- 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间
后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
这里需要注意：
- 如果申请的对象是内置类型，两者是没有差别的、
- 如果动态申请的是自定义类型，则会有差别，此时new会调用构造函数，delete会调用析构函数，而malloc与free不会
比如：对于下面一段程序：
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A()" << endl;
}
~A()
{
}
private:
int _a;
};
struct ListNode
{
int _val;
ListNode* _next;
ListNode(int val)
:_val(val),_next(nullptr){}
};
int main()
{
A* p3 = (A*)malloc(sizeof(A));
A* p4 = new A;
free(p3);
delete(p4);
可以看到，p4中的内置类型被初始化了。
同时还有一点值得注意：
在我们开辟空间失败的时候：
- malloc失败，返回NULL
- new和malloc不一样，申请空间失败，抛异常
int main()
{
//malloc失败 返回NULL
char* p1 = (char*)malloc((size_t)2*1024*1024*1024);
if (p1 == NULL)
{
printf("malloc fail");
}
//new和malloc不一样，申请空间失败，抛异常
try
{
char* p2 = new char[0xfffffff];
}
catch (const exception& e)
{
cout << e.what() << endl;
}
new和delete的底层原理
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间
我们来看一下operator和operator到底是怎样实现的？
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
void operator delete(void *pUserData)
{
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg( pUserData, pHead->nBlockUse );
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
我们大致阅读可以发现：
- operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常
- operator delete: 该函数最终是通过free来释放空间的
所以简单来说：operator new 就是一个具有抛异常功能的malloc函数
由此我们可以总结出new和free的运作流程：
- new
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数，完成对象的构造
- delete
- 在空间上执行析构函数，完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
- new T[N]
- 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申
请 - 在申请的空间上执行N次构造函数
- delete[]
- 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
- 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
operator new与operator delete的类专属重载（了解）
其实，针对某些自定义类型，我们是可以对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;
}
这一部分不要求理解，感兴趣的同学可以自行学习
题目讲解
首先我们将文章开头抛出的文章解决：
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);
}
答案如下：
| 题组1一 | 选项: A.栈 B.堆 C.数据段 D.代码段 |
|---|---|
| globalVar在哪里？ C | staticGlobalVar在哪里？C |
| staticVar在哪里？C | localVar在哪里？A |
| num1 在哪里？ A |
对于第一题组，十分简单：
静态变量和全局变量存储在 数据段
局部变量存储在栈中
| 题组二 | 选项: A.栈 B.堆 C.数据段 D.代码段 |
|---|---|
| char2在哪里？ A | *char2在哪里？ D |
| pChar3在哪里？ B | *pChar3在哪里？D |
| ptr1在哪里？ B | *ptr1在哪里？ B |
对于第二组，我们直接看图：
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
