1. C/C++内存分布模式
相信你们会想知道在内存的地址是怎样分布的
先给你们看图然会带你们去看验证过程
#include<iostream> using namespace std; int global = 1; //全局变量 数据段区 static int static_global = 1;// 静态全局变量 数据段区 void test() { static int static_val = 0;// 数据段区 int val = 0;// 栈 int arr[] = { 1, 2, 3, 4 };// 栈 int* ptr = (int*)malloc(sizeof(int) * 4);// 堆区 char str[] = "abcdef";// 代码段 const char* pstr = "abcdef";// 代码段 printf("val: %p\n", &val); printf("arr: %p\n", arr); printf("&ptr: %p\n", &ptr);//栈 printf("---------------\n"); printf("ptr: %p\n", ptr);//堆 printf("---------------\n"); printf("static_global: %p\n", &static_global); printf("global: %p\n", &global); printf("static_val: %p\n", &static_val);// 数据段 printf("---------------\n"); printf("str:%p\n", reinterpret_cast<void*>(*str));//这里reinterpret_cast就是一个强制类型转换,转成void* printf("str:%p\n", reinterpret_cast<void*>(*pstr));//常量区 free(ptr); } int main() { test(); return 0; }
栈又叫堆栈–非静态局部变量/函数参数/返回值等等,栈是向下增长的。
共享区是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存,做进程间通信。堆用于程序运行时动态内存分配,堆是可以上增长的。
数据段–存储全局数据和静态数据。
代码段–可执行的代码/只读常量
2. C++内存管理
c语言内存管理在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因
此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。
2.1 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操作符,申请和释放连续的空间,使用
new[]和delete[],注意:匹配起来使用
2.2 new和delete操作自定义类型
class A { public: A(int a = 1) { cout << "A()" << endl; } ~A() { cout << "~A" << endl; } }; int main() { A* ptr1 = new A; A* ptr2 = new A(10); A* ptr3 = new A[3]; delete ptr1; delete ptr2; delete[] ptr3; printf("------------------\n"); A* ptr4 = (A*)malloc(sizeof(A)); free(ptr4); return 0; }
特点:
- new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
还会调用构造函数和析构函数- 内置类型几乎是一样的
注意:在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc与free不会
3. operator new与operator delete函数
3.1 operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符,operator new 和operator delete是
系统提供的全局函数,new在底层调用operator new全局函数来申请空间,delete在底层通过
operator delete全局函数来释放空间。operator new 实际也是通过malloc来申请空间,如果malloc申请空间成功就直接返回,否则执行用户提供的空间不足应对措施,如果用户提供该措施就继续申请,否则就抛异常。operator delete 最终是通过free来释放空间的。
3.2 重载operator new与operator delete
注意:一般情况下不需要对 operator new 和 operator delete进行重载,除非在申请和释放空间
时候有某些特殊的需求。比如:在使用new和delete申请和释放空间时,打印一些日志信息,可
以简单帮助用户来检测是否存在内存泄漏
// 重载operator delete,在申请空间时:打印在哪个文件、哪个函数、第多少行,申请了多少个字节
void* operator new(size_t size, const char* fileName, const char* funcName,
size_t lineNo)
{
void* p = ::operator new(size);
cout << fileName << "-" << funcName << "-" << lineNo << "-" << p << "-"
<< size << endl;
return p;
}
// 重载operator delete,在释放空间时:打印再那个文件、哪个函数、第多少行释放
void operator delete(void* p, const char* fileName, const char* funcName,
size_t lineNo)
{
cout << fileName << "-" << funcName << "-" << lineNo << "-" << p <<
endl;
::operator delete(p);
}
int main()
{
// 对重载的operator new 和 operator delete进行调用
int* p = new(__FILE__, __FUNCTION__, __LINE__) int;
operator delete(p, __FILE__, __FUNCTION__, __LINE__);
return 0;
}
// 上述调用显然太麻烦了,可以使用宏对调用进行简化
// 只有在Debug方式下,才调用用户重载的 operator new 和 operator delete
#ifdef _DEBUG
#define new new(__FILE__, __FUNCTION__, __LINE__)
#define delete(p) operator delete(p, __FILE__, __FUNCTION__, __LINE__)
#endif
int main()
{
int* p = new int;
delete(p);
return 0;
}
4. new和delete的实现原理
4.1 内置类型
如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是: new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申
请空间失败时会抛异常,malloc会返回NULL。
4.2 自定义类型
- 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来释
放空间
5. 定位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():" << this << endl; } private: int _a; }; // 定位new/replacement new int main() { // p1现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行 A* p1 = (A*)malloc(sizeof(A)); new(p1)A; // 注意:如果A类的构造函数有参数时,此处需要传参 p1->~A(); free(p1); A* p2 = (A*)operator new(sizeof(A)); new(p2)A(10); p2->~A(); operator delete(p2); return 0; }