c++ 内存管理二：重载（接管内存管理工具）
文章目录
-
-
- 前言
- 1 重载全局的 ::operator new 运算符
- 2 重载类的 operator new 运算符
- 3 重载类的带有额外参数的 operator new 运算符
- 4 单类重载new的优化示例
- 5 总结
-
前言
重载 operator new 运算符来自定义内存分配的行为。重载 operator new 运算符允许我们使用自定义的内存分配逻辑，例如使用池分配、内存池等。
以下是重载 operator new 运算符的几种方式：
1 重载全局的 ::operator new 运算符
void* operator new(std::size_t size) {
// 自定义内存分配逻辑
void* ptr = /* 自定义逻辑 */;
return ptr;
}
通过重载全局的 operator new，我们可以自定义所有类的内存分配行为，注意这里一般不会这样做，因为影响太深远，涉及面广，因为程序中可能大多数类的new都是使用默认的，没有重载自身类的operator new，可能都是使用全局的 ::operator new。
2 重载类的 operator new 运算符
class MyClass {
public:
static void* operator new(std::size_t size) {
// 自定义内存分配逻辑
void* ptr = /* 自定义逻辑 */;
return ptr;
}
};
在类中重载 operator new 运算符，可以针对该类自定义内存分配的行为。
因为new往往是在创建对象的时候，所以不是对象的方法，应该是static。
示例代码
class Foo
{
public:
int _id;
long _data;
string _str;
public:
static void* operator new(size_t size);
static void operator delete(void* deadObject, size_t size);
static void* operator new[](size_t size);
static void operator delete[](void* deadObject, size_t size);
Foo() : _id(0) { cout << "default ctor. this=" << this << " id=" << _id << endl; }
Foo(int i) : _id(i) { cout << "ctor. this=" << this << " id=" << _id << endl; }
~Foo() { cout << "dtor. this=" << this << " id=" << _id << endl; }
};
void* Foo::operator new(size_t size)
{
Foo* p = (Foo*)malloc(size);
cout << "Foo::operator new(), size=" << size << "\t return: " << p << endl;
return p;
}
void Foo::operator delete(void* pdead, size_t size)
{
cout << "Foo::operator delete(), pdead= " << pdead << " size= " << size << endl;
free(pdead);
}
void* Foo::operator new[](size_t size)
{
Foo* p = (Foo*)malloc(size); //crash, 問題可能出在這兒
cout << "Foo::operator new[](), size=" << size << "\t return: " << p << endl;
return p;
}
void Foo::operator delete[](void* pdead, size_t size)
{
cout << "Foo::operator delete[](), pdead= " << pdead << " size= " << size << endl;
free(pdead);
}
void test_overload_operator_new_and_array_new()
{
cout << "\ntest_overload_operator_new_and_array_new().......... \n";
cout << "sizeof(Foo)= " << sizeof(Foo) << endl;
{
Foo* p = new Foo(7);
delete p;
Foo* pArray = new Foo[5]; //無法給 array elements 以 initializer
delete [] pArray;
}
{
cout << "testing global expression ::new and ::new[] \n";
// 直接调用全局的 ::new 这会绕过 overloaded new(), delete(), new[](), delete[]()
// 但 ctor, dtor 都会被正常调用.
Foo* p = ::new Foo(7);
::delete p;
Foo* pArray = ::new Foo[5];
::delete [] pArray;
}
}
3 重载类的带有额外参数的 operator new 运算符
void* operator new(std::size_t size, AdditionalArgs args) {
// 自定义内存分配逻辑，可以使用额外的参数
void* ptr = /* 自定义逻辑 */;
return ptr;
}
通过重载带有额外参数的 operator new，我们可以在内存分配过程中传递额外的参数，以便进行更复杂的内存管理。
在重载 operator new 运算符时，注意以下几点：
- 返回值类型必须为
void*，表示分配的内存地址。 - 第一个参数是
std::size_t size，表示要分配的内存大小。 - 可以有额外的参数，以满足特定需求。
- 可以使用任何自定义的内存分配逻辑，例如使用
malloc、内存池等。 - 注意处理错误和异常情况，确保内存分配成功。
示例代码
class Foo
{
public:
Foo() { cout << "Foo::Foo()" << endl; }
Foo(int) {
cout << "Foo::Foo(int)" << endl;
}
//(1) 这个就是一般的 operator new() 的重载
void* operator new(size_t size) {
cout << "operator new(size_t size), size= " << size << endl;
return malloc(size);
}
//(2) 这个就是标准库已经提供的 placement new() 的重载 (形式)
void* operator new(size_t size, void* start) {
cout << "operator new(size_t size, void* start), size= " << size << " start= " << start << endl;
return start;
}
void* operator new(size_t size, long extra) {
cout << "operator new(size_t size, long extra) " << size << ' ' << extra << endl;
return malloc(size+extra);
}
void* operator new(size_t size, long extra, char init) {
cout << "operator new(size_t size, long extra, char init) " << size << ' ' << extra << ' ' << init << endl;
return malloc(size+extra);
}
//(1) 这是对应一般的 operator delete() 的重載
void operator delete(void*,size_t)
{ cout << "operator delete(void*,size_t) " << endl; }
//(2) 这是对应上述的 (2)
void operator delete(void*,void*)
{ cout << "operator delete(void*,void*) " << endl; }
//(3) 这是对应上述的 (3)
void operator delete(void*,long)
{ cout << "operator delete(void*,long) " << endl; }
//(4) 这是对应上述的 (4)
//如果沒有一一对应, 也不会有任何编译错误
void operator delete(void*,long,char)
{ cout << "operator delete(void*,long,char) " << endl; }
private:
int m_i;
};
void test_overload_placement_new()
{
cout << "\n\n\ntest_overload_placement_new().......... \n";
Foo start; //Foo::Foo
Foo* p1 = new Foo; //op-new(size_t)
Foo* p2 = new (&start) Foo; //op-new(size_t,void*)
Foo* p3 = new (100) Foo; //op-new(size_t,long)
Foo* p4 = new (100,'a') Foo; //op-new(size_t,long,char)
Foo* p5 = new (100) Foo(1); //op-new(size_t,long) op-del(void*,long)
Foo* p6 = new (100,'a') Foo(1); //
Foo* p7 = new (&start) Foo(1); //
Foo* p8 = new Foo(1); //
}
//VC6 warning C4291: ‘void *__cdecl Foo::operator new(unsigned int)’
//no matching operator delete found; memory will not be freed if
//initialization throws an exception
这表示对对应的new调用的构造函数的异常不做处理。所以这里delete参数实际上是对应异常的类型。
将构造函数抛出异常，然后打印。这里要注意将调用的代码即test_overload_placement_new使用try catch包含，否则无法捕获异常。
Foo(int) {
cout << "Foo::Foo(int)" << endl;
throw 1;
}
可以看到，operator delete(void*,long)是执行了。
当然异常抛出以后后面的自然也就不执行了。
4 单类重载new的优化示例
版本1：
需要指针指向下一个快的空间，因此并没有减少占用的内存
版本2：
内存管理一般是一个链表，对于每一个内存节点，必然需要一个next指针，但是这就算额外损耗了。Rep是我们需要存放的数据。
刚开始，内存块未被使用，因此该obj所占内存全被next指针拿去用了；但是当内存块被使用的时候（分配给Rep了），此时next所占空间可以看为0，所有内存空间都给data使用了，这就没有任何损耗。
版本3：
如果每个类都要重写一个new的方法，那么太过繁琐，因此需要将重复动作抽取出来放到一个class里面
抽取出来形成一个方法 。最终将每个类的动作封装成宏，使用更加方便。
5 总结
本章内存管理的关键：
1. 减少malloc调用次数，节约了cookie
2. 使用链表来链接内存块
3. 使用union嵌入式指针避免指针浪费