目录
4.operator new与operator delete函数
1.C/C++内存分布
我们先来看下面一段代码和问题
#include<iostream>
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);
}
首先我们来了解一下这几个区域
-
栈（Stack）：存放函数的局部变量和临时数据。栈采用后进先出（LIFO）的方式管理数据，每当进入一个新的函数，都会在栈上分配一个新的栈帧，函数返回时栈帧会被释放。栈的大小是固定的，由系统预先分配。
-
堆（Heap）：存放程序运行时动态分配的内存。在C/C++中，通过调用malloc、calloc、realloc等函数分配的内存都位于堆中。堆的大小是动态变化的，需要手动分配和释放。
-
数据区（Data Segment）：也称为静态区，存放全局变量和静态变量，以及常量数据。数据区分为初始化的数据区（Initialized Data Segment）和未初始化的数据区（Uninitialized Data Segment）。
-
代码区（Code Segment）：也称为文本区，存放程序的机器指令。该区域通常是只读的，且是共享的，多个进程可以共享同一段代码区。
说明:
1. 栈又叫堆栈--非静态局部变量 / 函数参数 / 返回值等等，栈是向下增长的。
2. 内存映射段是高效的I / O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。
5. 代码段--可执行的代码 / 只读常量。
2.C语言中的内存管理方式
void Test()
{
int* p1 = (int*)malloc(sizeof(int) * 10);
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
free(p1);
free(p3);
}总共有四种方式：malloc / calloc /realloc /free四个操作。
1.malloc,calloc,realloc这三个到底有啥区别？
2.上面的程序需要free(p2)吗？
这个两个问题的答案可以参考：malloc - C++ Reference
或者我之前的文章。
3.C++的内存管理方式
由于C++是兼容C语言的，所以C语言的内存管理方式在C语言中任然可以使用，但是有些地方比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete这两个操作符来进行动态的内存管理。
1.动态的申请一个int 类型的空间
int*p1 = new int;2.动态的申请一个int类的空间，并初始化为10；
int*p2 = new int(10);3.动态申请10个int类型的空间
int *p3 = new int[10];相应地释放这些空间的操作如下：
delete p1;
delete p2;
delete[] p3;注意：申请和释放单个的元素空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[];要匹配使用。
提问：
1.使用 char* p = new char[100]申请一段内存，然后使用delete p释放，有什么问题？( )
对于内置类型来说 此时的delete就相当于free，程序并不会崩溃，也不会内存泄漏，编译不会报错，建议针对数组释放使用delete[],如果是自定义类型，不使用方括号就会运行时错误.
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
}对于自定义类型来说，new/delete和malloc/free区别就是，new和delete对于自定义类型会自动调用构造和析构函数，而malloc和free并不会。 这一点可以通过调试进行观察.
4.operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
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);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果
malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施
就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
5.new和delete的原理
5.1内置类型
如果申请的是内置类型的空间,new和malloc,delete和free基本相似,不同的地方是new和delete申请和释放的是单个的空间,而new[]和delete[]申请和释放的多个连续的空间,而malloc在申请失败的时候会返回null,但是new会直接抛出异常,这也是为什么malloc需要检查返回值是否为null的情况,但是new不需要.
5.2自定义类型
new的原理
1.调用operator new函数申请空间.
2.在申请的空间上执行构造函数,完成对象的构造
delete的原理
1.在空间上执行析构函数,完成对象中资源的清理
2.调用operator delete释放对象的空间
new T[N]的原理
1.调用operator new[]函数,在operator new[]中实际调用operator new函数中完成N个对象空间的申请
2.在申请的空间上执行N此构造函数
delete[] T的原理
1.在释放的对象空间上执行N次析构函数,完成N个对象中的资源清理
2.调用operator delete[]释放空间,实际在operator delete[]中执行了operator delet来释放空间.
6.定位new表达式(placement-new)
定位new表达式是在已经分配的原始空间中调用构造函数初始化一个对象
使用格式： new (place_address) type或者new (place_address) type(initializer-list).place_address必须是一个指针，initializer-list是类型的初始化列表 使用场景： 定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如 果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
#include<iostream>
using namespace std;
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);
//虽然这个p1指向的空间存放的是一个A类类型的对象,但是这个对象并不会自动调用其构造函数和析构函数
//需要手动调用
//即使手动调用了,这个p1指向的空间仍然存在,并没有消失
//因为析构是对对象中的资源清理,其销毁需要我们free这个空间
A* p2 = (A*)operator new(sizeof(A));
//operator new在底层会调用malloc函数所以不会像new那样进行构造函数
//仍然需要我们手动进行
new(p2)A(10);//定位new对其初始化,也就是构造函数
p2->~A();
operator delete(p2);
//更上面同理需要手动调用析构和delete
//operator delete底层就是使用free进行空间释放.
return 0;
}7.malloc/free和new/delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：
1. malloc和free是函数，new和delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，[]中指定对象个数即可
4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需 要捕获异常
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new 在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成 空间中资源的清理释放
总结:在C++中，`operator new`和`operator delete`是用于动态内存分配和释放的全局函数。它们与`new`和`delete`操作符紧密相关，但并不相同。下面是对这两个函数的详细解释：
1. `operator new`函数：
- 当使用`new`操作符分配内存时，实际上是在调用`operator new`函数来执行内存分配任务。
- `operator new`的基本形式是`void* operator new(size_t size) throw(bad_alloc);`，它接受一个`size_t`类型的参数，表示需要分配的内存大小。
- 如果内存分配成功，`operator new`返回指向分配内存的指针；如果分配失败，它会抛出`bad_alloc`异常。
- `operator new`可以重载，允许用户自定义内存分配行为。例如，可以编写自己的`operator new`函数来使用不同的内存分配策略或记录分配信息。
2. `operator delete`函数：
- 当使用`delete`操作符释放内存时，`operator delete`函数被调用。
- `operator delete`的基本形式是`void operator delete(void* ptr) throw();`，它接受一个指针参数，指向要释放的内存块。
- `operator delete`负责释放由`operator new`分配的内存。如果传递给`operator delete`的指针为`NULL`，函数将不执行任何操作。
- 与`operator new`类似，`operator delete`也可以重载，以提供不同的内存释放行为。
除了基本的`operator new`和`operator delete`，C++还提供了`new[]`和`delete[]`操作符用于数组的动态内存分配和释放，以及对应的`operator new[]`和`operator delete[]`函数。这些函数用于处理数组类型的内存分配和释放。
在实际编程中，通常不需要直接调用`operator new`和`operator delete`，因为`new`和`delete`操作符会自动调用它们。然而，了解这些底层函数的工作原理对于理解内存管理和优化程序性能非常重要。
此外，C++标准库提供了`std::nothrow`常量，可以传递给`operator new`的`nothrow`版本，以防止在内存分配失败时抛出异常，而是返回`nullptr`。还有`placement new`，它是一种特殊的`operator new`形式，允许在指定的内存位置上进行对象构造，而不是分配新的内存。
总之，`operator new`和`operator delete`是C++中用于动态内存管理的关键函数，它们与`new`和`delete`操作符协同工作，提供灵活的内存分配和释放机制。正确理解和使用这些函数对于编写高效和健壮的C++程序至关重要。
扫一扫
2307
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
