C++ operator new重载

2021-04-22

cpp中operator new或者placement new是内存管理的中间层，直接关系到allocator和new的具体实现，因此，实现operator new或者placement new的重载是实现内存接管的方法。

对于operator new的重载，包含全局重载和在类中进行重载，其中全局重载的影响是全局的，一般不推荐，主要使用第二种类内重载。

全局重载

void* myAlloc(size_t size){
    return malloc(size);
}

void* myFree(void* ptr){
    return free(ptr);
}

inline void* operator new(size_t size){
    cout << "global new() \n";
    return myAlloc(size);
}

inline void* operator new[](size_t size){
    cout << "global new[]()\n";
    return myAlloc(size);
}

inline void operator delete(void* ptr){
    cout << "global delete() \n";
    myFree(ptr);
}

inline void operator delete[](void* ptr){
    cout << "global delete[]()\n";
    myFree(ptr);
}

类内重载

class Foo{
public:
    void* operator new(size_t);
    void operator delete(void*, size_t); // size_t可选
    
    void* operator new[](size_t);
    void* operator delete[](void*, size_t); // size_t可选
}

按道理上述的重载函数需要是static，因为operator new的对象还没创建完成，没办法通过对象来进行函数调用，因此需要是static来实现通过类调用函数。不过cpp考虑到了这个问题，没有把上述写法当作一种错误。

// 如果要调用自己的内存管理工具
Foo* pf = new Foo;
delete pf;

// 如果使用下面的方式，会强制调用全局版本，上述的重载失效
Foo* pf = ::new Foo;
::delete pf;

placement new的各种重载

class Foo {
public:
    Foo() {cout<<"Foo::Foo()";}
    Foo(int) {cout<<"Foo::Foo(int)"<<endl; throw Bad();}

// 重载版本第一个元素类型必须要是size_t
    
// 一般的operator new重载
void* operator new(size_t size){
    return malloc(size);
}

// placement new的重载
void* operator new(size_t size, void* start){
    return start;
}

// 新的placement new
void* operator new(size_t size, long extra){
    return malloc(size+extra);
}

// 新的placement new
void* operator new(size_t size, long extra, char init){
    return malloc(size+extra);
}

// 对应的placement delete版本，逐条对应上述的placement new
void operator delete(void*, size_t){ // size_t可缺省
    cout<<"operator delete(void*, size_t)"<<endl;
}
void operator delete(void*, void*){
    cout<<"operator delete(void*, void*)"<<endl;
}
void operator delete(void*, long){
    cout<<"operator delete(void*, long)"<<endl;
}
void operator delete(void*, long, char){
    cout<<"operator delete(void*, long, char)"<<endl;
}

private:
    int m_i;
};

上述的placement delete一般不会被调用，只有当我们的placement new出现异常时才会调用我们自己的placement delete，这实际上类似一种异常处理的handler。因此，也不需要全部写好对应的placement delete，没写的代表放弃了异常处理。