2024年C C++最新c++ 内存管理一：初识内存分配工具_c++ 内存分配器，熬夜整理最新大厂C C++高频面试题-CSDN博客

本文链接：https://blog.csdn.net/2401_84976655/article/details/138778933

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

3 pStr->string::string(“123”);//ctor


出于好奇，我们能否直接使用第三步呢？

class A
{
public:
int id;

A() : id(0) { cout << “default ctor. this=” << this << " id=" << id << endl; }
A(int i) : id(i) { cout << “ctor. this=” << this << " id=" << id << endl; }
~A() { cout << “dtor. this=” << this << " id=" << id << endl; }
};

void test_call_ctor_directly()
{

string\* pstr = new string;
cout << "str= " << \*pstr << endl;

//! pstr->string::string(“jjhou”);
//[Error] ‘class std::basic_string’ has no member named ‘string’
//! pstr->~string(); //crash – crash正确, crash 只因上一行被注释
cout << "str= " << *pstr << endl;

//------------

A\* pA = new A(1);         	//ctor. this=000307A8 id=1
cout << pA->id << endl;   	//1

//! pA->A::A(3); //in VC6 : ctor. this=000307A8 id=3
//in GCC : [Error] cannot call constructor ‘A::A’ directly

//! A::A(5); //in VC6 : ctor. this=0013FF60 id=5
// dtor. this=0013FF60
//in GCC : [Error] cannot call constructor ‘A::A’ directly
// [Note] for a function-style cast, remove the redundant ‘::A’

cout << pA->id << endl;   	//in VC6 : 3
							//in GCC : 1 

delete pA;                	//dtor. this=000307A8

}


从测试用例来看，直接使用第三步这种方式调用构造，在某些编译器标准中是可行的。


#### 2 new[]和delete[]


`new[]`和`delete[]`：与new和delete类似，new[]操作符用于在堆上分配数组的内存，delete[]操作符用于释放先前分配的数组内存。


例如，使用new[]操作符分配一个整型数组的内存：

int* arr = new int[10];


使用delete[]操作符释放数组内存：

delete[] arr;


当然这里需要注意的是**析构的顺序和构造是相反**的，构造是从从下标0 1 2开始, 而析构则是从下标2 1 0开始。


#### 3 operator new


`operator new` 是 C++ 中的一个操作符和函数，用于在堆上分配内存。它是一个全局的分配函数，可以根据需要进行重载和自定义。


`operator new` 的基本语法如下：

void* operator new (std::size_t size);


这会分配 `size` 字节大小的内存，并返回指向分配内存的指针。如果分配失败，`operator new` 会抛出一个 `std::bad_alloc` 异常。


以下是一些常见用法：

int* num = new int; // 使用 new 运算符分配一个整数对象的内存


上述代码等效于以下使用 `operator new` 的操作：

int* num = static_cast<int*>(operator new(sizeof(int))); // 手动调用 operator new 分配内存


需要注意的是，使用 `operator new` 进行内存分配后，必须手动调用相应的析构函数来销毁对象，并使用 `operator delete` 进行内存释放。

delete num; // 释放之前由 new 运算符分配的整数对象的内存


对于数组的分配和释放，可以使用 `operator new[]` 和 `operator delete[]`。

int* arr = new int[10]; // 使用 new 运算符分配一个包含 10 个整数的数组的内存

delete[] arr; // 释放之前由 new 运算符分配的整数数组的内存


同样，上述代码等效于以下使用 `operator new[]` 和 `operator delete[]` 的操作：

int* arr = static_cast<int*>(operator new[](10 * sizeof(int))); // 手动调用 operator new[] 分配内存

operator delete; // 手动调用 operator delete[] 释放内存


需要注意的是，`operator new` 和 `operator new[]` 通常在内部被 `new` 和 `new[]` 运算符隐式调用，我们可以通过重载它们来实现自定义的内存分配行为或内存池的使用。


**这里补充一个问题：**


operator new源码

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
static const std::bad_alloc nomem;
_RAISE(nomem);
}

    return (p);
    }


`operator new`函数来分配内存。当`operator new`函数无法分配足够的内存时，会抛出一个`std::bad_alloc`异常。如果你希望接管这个异常并进行自定义的处理，可以使用`std::set_new_handler`函数来注册一个自定义的`new-handler`。


下面是一个示例，展示了如何使用`std::set_new_handler`来接管`new`操作符的异常处理：

#include
#include

// 自定义的new-handler函数
void customNewHandler()
{
std::cout << “Allocation failed! Custom new-handler called.” << std::endl;
// 这里可以进行一些处理，如释放一些内存资源或者记录日志等
throw std::bad_alloc(); // 抛出std::bad_alloc异常
}

int main()
{
std::set_new_handler(customNewHandler); // 注册自定义的new-handler

try
{
    int\* ptr = operator new int[1000000000000]; // 尝试分配一个非常大的内存块
    // 在正常情况下，当内存分配成功时，这里将会执行
    operator delete[] ptr;
}
catch (const std::bad_alloc& e)
{
    std::cerr << "Caught exception: " << e.what() << std::endl;
    // 这里可以进行进一步的处理，如恢复内存状态或者终止程序等
}

return 0;

}


在上述示例中，我们定义了一个名为`customNewHandler`的自定义`new-handler`函数。我们通过调用`std::set_new_handler`将其注册为全局的`new-handler`。当`new`操作无法分配内存时，会自动调用该函数。


请注意，这种接管`new-handler`的方式只会在使用`new`操作符分配内存时生效，对于直接使用`malloc`之类的函数是不起作用的。此外，应当谨慎使用自定义的`new-handler`，确保它能够正确处理内存分配失败的情况，并适当进行异常处理。


#### 4 placement new


`“placement new”` 是 C++ 中的一个特殊用法，它允许你在提供的内存地址上构造一个对象，通常情况下，使用 `“new”` 运算符会在堆上分配内存，并在分配的内存上构造对象。而 `“placement new”` 则允许你在给定的内存地址上进行对象的构造，而无需分配额外的内存。


下面是 `“placement new”` 的使用方式示例：

#include

class MyClass {
public:
MyClass(int val) : value(val) {
std::cout << "Constructor called for value: " << value << std::endl;
}

~MyClass() {
std::cout << "Destructor called for value: " << value << std::endl;
}

private:
int value;
};

int main() {
// 分配一块内存
void* memory = operator new(sizeof(MyClass));

// 使用 placement new 在给定的内存地址上构造对象
MyClass* obj = new (memory) MyClass(42);

// 使用对象
std::cout << "Value of the object: " << obj->getValue() << std::endl;

// 销毁对象，但不会释放内存
obj->~MyClass();

// 释放内存
operator delete(memory);

return 0;
}


在上述代码中，我们首先通过 `operator new` 分配了一块内存，然后使用 `“placement new”` 在该内存上构造了一个 MyClass 对象，并进行使用。最后，通过显式调用析构函数 `obj->~MyClass()` 销毁对象，然后用 `operator delete` 释放内存。


从源码中去看这句代码

// 分配一块内存
void* buf = operator new(sizeof(MyClass));
// 使用 placement new 在给定的内存地址上构造对象
MyClass* obj = new (buf) MyClass(42);


`MyClass* obj = new (buf) MyClass(42);`可以转换为

void* mem = operator new(sizeof(MyClass),buf);
obj = static_cast<MyClass*>(mem);
obj->MyClass::MyClass(42);


这里发现operator new(与前面相比多了buf这个参数，这个函数的定义`operator new(size_t,void * loc){return loc;}`也能找得到。这里`operator new直接return loc是合理的，没有分配内存，因为loc是已经分配好的。


所以不存在placement delete，因为placement new 没有分配内存。当然，有时候我们又想把`placement new` 对应的`operator delete`称为placement delete，这都是自己对术语的理解。


这里补充下这**两个operator new区别**：  
 在 C++ 标准中，`operator new` 是负责动态分配内存的函数，其函数签名为 `void* operator new(std::size_t)`, 在分配内存时会调用这个函数。而 `operator new(size_t, void* loc)` 的函数签名是用于 `placement new` 的，它用于在指定的内存位置构造对象，而不是进行内存分配。所以，这两个函数具有不同的功能和用途，并且无法直接对 `operator new(size_t, void* loc)` 进行重载。



![img](https://img-blog.csdnimg.cn/img_convert/a084fc5f1f0f3dc3806fe3b34608ea5c.png)
![img](https://img-blog.csdnimg.cn/img_convert/821cf13491965be03848aca0cd072169.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

外链图片转存中...(img-sUypxHfk-1715545677420)]
[外链图片转存中...(img-29wRnsAS-1715545677420)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**