template<class T>
inline void _deallocate(T* buffer) {::operator delete(buffer);//operator delete可以被重载
//    operator delete(buffer);
}

class A {
public:void TT() {cout << "A" << endl;}
};
inline void TT() {cout<<"G"<<endl;
}
class B: public A {
public:void TT() {cout << "B" << endl;::TT();}
};int main(int argc, char **argv) {
//  new Allocator();(new B())->TT();return 0;
}

B
G

#include <iostream>#include <vector>#include "2jjalloca.h"#include <new>

using namespace std;

//inline void *operator new(size_t n) {//    cout << "global new" << endl;//    return ::operator new(n);//}////inline void *operator new(size_t n, const std::nothrow_t& nt) {//    cout << "global new nothrow" << endl;//    return ::operator new(n, nt);//}

class Allocator {public:    void *operator new(size_t n) {        cout << "allocator new" << endl;        return ::operator new(n);    }    //作用域覆盖原则，即在里向外寻找operator new的重载时，    //只要找到operator new()函数就不再向外查找，如果参数符合则通过，    //如果参数不符合则报错，而不管全局是否还有相匹配的函数原型。    //所以的调用new(std::nothrow) Allocator;注释这个函数是报错    void* operator new(size_t n, const std::nothrow_t& nt) {        cout << "allocator new nothrow" << endl;        return ::operator new(n, nt);    }

    void* operator new(size_t n, void *p) {        cout << "allocator placement new" << endl;        return p;    }

    void operator delete(void *p) {        cout << "allocator delete" << endl;        return ::operator delete(p);    }    void operator delete(void*, void*) {        cout << "allocator placement delete" << endl;    }

    void* operator new[](size_t n) {        cout << "allocator new[]" << endl;        return ::operator new[](n);    }};

int main(int argc, char **argv) {//    Allocator *a = new Allocator;//    delete a;//    ::new Allcator;

    Allocator *a=new Allocator[10];    return 0;}