相关文章
C++智能指针
文章目录
- 相关文章
- 前言
- 一、new 运算符
- 1. operator new 函数的范围
- 2. 在类中重载new运算符
- 3. 分配失败
- 二、delete 运算符
- 1. 内存泄露统计示例
- 2. 在类中重载delete运算符
- 总结
前言
在C++中，new和delete是用于动态内存管理的运算符，它们允许程序在运行时动态地分配和释放内存，而不需要在编译时知道确切的内存需求。动态内存分配是指在程序运行时根据需要分配内存空间，而静态内存分配是指在编译时分配内存空间。new和delete是C++中实现动态内存分配和释放的关键工具。
new运算符用于在堆上动态分配内存。它可以用于分配单个对象或数组。当使用new来分配单个对象时，它会返回一个指向所分配内存空间的指针，并自动调用对象的构造函数来初始化对象。当使用new来分配数组时，它会分配足够的内存来存储整个数组，并返回指向数组第一个元素的指针。这样，程序可以根据需要动态地创建数组，而不需要在编译时知道数组的大小。
delete运算符用于释放由new分配的内存。对于单个对象，使用delete；对于数组，使用delete[]。当不再需要动态分配的内存时，应该使用delete来释放内存，以防止内存泄漏。delete会调用对象的析构函数来清理对象，并释放所分配的内存。这样，程序可以在不需要内存时及时释放它，以避免内存资源的浪费。
new和delete提供了灵活的内存管理机制，使程序能够根据需要动态地分配和释放内存。然而，它们需要谨慎使用，因为错误的使用可能导致内存泄漏、悬空指针等问题。例如，在使用new分配内存后，如果忘记使用delete释放内存，就会导致内存泄漏；而在使用delete释放内存后，如果继续使用指向已释放内存的指针，就会导致悬空指针问题。因此，在使用new和delete时，需要确保正确地匹配内存的分配和释放，并避免出现悬空指针的情况。
C++ 支持使用 new 和 delete 运算符动态分配和解除分配对象。 这些运算符为来自称为“自由存储”（也称为“堆”）的池中的对象分配内存。 new 运算符调用特殊函数 operator new，delete 运算符调用特殊函数 operator delete。
一、new 运算符
operator new的第一个参数必须为 size_t 类型，且返回类型始终为 void*，编译器将如下语句转换为对函数 operator new 的调用：
char *p = new char[64];
重复调用 operator new 会返回不同的地址（指针）。
如果要申请的的存储空间为零字节，operator new 将返回指向不同对象的指针：
#include <iostream>
using namespace std;
int main()
{
char *p1 = new char[0];
char *p2 = new char[0];
char *p3 = new char[0];
cout << "p1=0x" << (int*)p1 << endl;
cout << "p2=0x" << (int*)p2 << endl;
cout << "p3=0x" << (int*)p3 << endl;
return 0;
}
如果分配请求的内存不足，operator new 会引发 std::bad_alloc 异常。 或者，如果使用了 placement 形式 new(std::nothrow)，或者链接在非引发的 operator new 支持中，它将返回 nullptr。
1. operator new 函数的范围
| 运算符 | 范围 |
|---|---|
| ::operator new | 全局 |
| class-name::operator new | 类 |
在使用 new 运算符分配内置类型的对象、不包含用户定义的 operator new 函数的类类型的对象和任何类型的数组时，将调用全局 operator new 函数。 在使用 new 运算符分配类类型的对象时（其中定义了 operator new），将调用该类的 operator new。
2. 在类中重载new运算符
示例：
#include <memory.h>
#include <iostream>
using namespace std;
class Test
{
public:
Test() {
cout << "Test()" << endl;
}
void *operator new(size_t size)
{
//可以自定义空间申请规则
cout << "operator new" << endl;
return malloc(size);
}
};
int main()
{
Test *p = new Test;
return 0;
}
执行结果：
执行流程：
在类声明中支持数组的 new 运算符。 例如：
#include <memory.h>
#include <iostream>
using namespace std;
class Test
{
public:
Test() {
cout << "Test()" << endl;
}
void *operator new[](size_t size)
{
cout << "operator new[]" << endl;
return malloc(size);
}
};
int main()
{
Test *p = new Test[5];
return 0;
}
执行结果：
3. 分配失败
C++ 标准库中的 new 函数支持自 C++98 以来在 C++ 标准中指定的行为。 如果分配请求的内存不足，operator new 会引发 std::bad_alloc 异常。标准 C++ 要求分配器引发 std::bad_alloc 或派生自 std::bad_alloc 的类。 可以处理此类异常，如以下示例所示：
#include <iostream>
using namespace std;
int main()
{
size_t n = 20000000000L;
try {
int *p = new int[n];
cout << p << endl;
}
catch (bad_alloc& ex) {
cout << "申请内存失败: " << ex.what() << endl;
}
return 0;
}
执行结果：
二、delete 运算符
可使用 delete 运算符释放使用 new 运算符动态分配的内存。 delete 运算符调用 operator delete 函数，该函数将内存释放回可用池。 使用 delete 运算符也会导致调用类析构函数（如果存在）。
1. 内存泄露统计示例
能过自定义 operator new 和 operator delete 函数，来记录申请内存和释放的次数，判断是否存在内存泄露，示例如下：
#include <iostream>
using namespace std;
bool bLog = 0;
int nAllocated = 0;
void *operator new(size_t size) {
++nAllocated;
cout << "申请内存 " << nAllocated
<< " 大小 " << size
<< "\n";
return malloc(size);
}
void operator delete(void *p) {
--nAllocated;
clog << "释放内存 " << nAllocated
<< "\n";
free(p);
}
int main() {
for (int i = 0; i < 10; ++i) {
char *p = new char[10];
delete[] p;
}
cout << nAllocated << endl;
return 0;
}
2. 在类中重载delete运算符
示例如下：
#include <iostream>
using namespace std;
class Test {
public:
Test() {
cout << "Test()" << endl;
}
~Test() {
cout << "~Test()" << endl;
}
void *operator new(size_t size)
{
cout << "operator new" << endl;
return malloc(size);
}
void *operator new[](size_t size)
{
cout << "operator new[]" << endl;
return malloc(size);
}
void operator delete (void* p) {
cout << "operator delete(void*)" << endl;
free(p);
}
void operator delete[](void* p) {
cout << "operator delete[](void*)" << endl;
free(p);
}
};
int main() {
Test *p1 = new Test;
delete p1;
cout << "------------------\n";
Test *p2 = new Test[5];
delete[] p2;
return 0;
}
执行结果:
执行过程：
总结
new和delete是C++中用于动态内存管理的运算符，它们提供了灵活的内存分配和释放机制，但需要谨慎使用以避免内存泄漏和悬空指针等问题。随着智能指针的引入，程序员可以更安全地进行动态内存管理，减少了对new和delete的直接使用，提高了程序的可靠性和可维护性。
✍结尾 ❤️ 感谢您的支持和鼓励，关注不迷路✍
