C++ 内存管理之重载operator new 和operator delete

当我们在C++中使用new 和delete时，其实执行的是全局的::operator new和::operator delete。首先我们来看一个简单的例子。

class Foo{...}
Foo* pf = new Foo;
delete pf

上面的代码底层执行的是什么呢？

首先new包含两阶段的操作。
（1）首先调用：：operator new分配内存 （2）调用Foo::Foo() 构造对象内容
然后是delete也分两部分的操作。
（1）首先调用Foo::~Foo()将对象析构 （2）调用::operator delete释放内存
那么可以对::operator new和::operator delete进行重载么，当然是肯定的
见代码：

#include<iostream>
using namespace std;

class Foo
{
    public:
        int _id;
        long _data;
        string _str;
    public:
        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;}
        static void* operator new(size_t size);
        static void operator delete(void* pdead,size_t size);
        static void* operator new[](size_t size);
        static void operator delete[](void* pdead,size_t size);
};

void* Foo::operator new(size_t size)
{
    Foo* p = (Foo *)malloc(size);
    cout<<"调用了Foo::operator new"<<endl;
    return p;
}

void Foo::operator delete(void *pdead,size_t size)
{
    cout<<"调用了Foo::operator delete"<<endl;
    free(pdead);
}
void* Foo::operator new[](size_t size)
{
    Foo* p  = (Foo*)malloc(size);
    cout<<"调用了Foo::operator new[]"<<endl;
    return p;
}

void Foo::operator delete[](void *pdead, size_t size)
{
    cout<<"调用了Foo::operator delete[]"<<endl;
    free(pdead);
}

int main()
{
    Foo* pf = new Foo(7);
    Foo* pf1 = new Foo[10];
    delete pf;
    delete[] pf1;
}

最后的运行结果是：

最后看结果和我们预想的一样，::operator new 和::operator delete都被重载了，并且执行顺序也是我们预想的

但是如果使用全局的::operator new和::operator delete会怎么样呢？？

int main()
{
    Foo* pf = ::new Foo(7);
    Foo* pf1 = ::new Foo[10];
    ::delete pf;
    ::delete[] pf1;
}

运行结果：

看到我们重载的函数被屏蔽了，因为使用的是全局的operator new 和operator delete