Effective C++ 第二版 8) 写operator new 和operator delete 9) 避免隐藏标准形式的new

条款8 写operator new 和operator delete 时要遵循常规

重写operator new时, 函数提供的行为要和系统缺省的operator new一致:

1)正确的返回值; 2)可用内存不够时调用出错处理函数; 3)处理0字节内存请求的情况; 避免隐藏标准形式的new;

1)如果内存分配请求成功, 返回指向内存的指针, 失败抛出std::bad_alloc异常; 
operator new实际上不止一次尝试分配内存, 每次失败会调用出错处理函数(期望释放别处的内存), 只有在出错处理函数的指针为空的情况下才抛出异常.

Note 按C++标准要求, 在请求分配0字节的内存时, operator new也要返回一个合法指针.

非类成员形式的operator new伪代码:

void  * operator  new ( size_t  size)  // operator new 还可能有其它参数
{
    if  (size == 0) {  // 处理0 字节请求时，
        size = 1;  // 把它当作1 个字节请求来处理
    }
    while  (1) {
        "分配 size 字节内存;"
        if  (分配成功)
            return  (指向内存的指针);
        // 分配不成功，找出当前出错处理函数
        new_handler globalHandler = set_new_handler(0);
        set_new_handler(globalHandler);
        if  (globalHandler) (*globalHandler)();
        else  throw  std::bad_alloc();
    }
}

>处理零字节的请求的技巧是把他作为请求一个字节来处理;

>把handler置为0然后再恢复是因为没法直接得到handler的指针, 必须调用set_new_handler;

>operator new包含一个无限循环: while(1), 跳出循环的条件是内存分配成功或出错处理函数完成事件中的一种: 
得到可用内存; 安装了新的new-handler; 卸除了new-handler; 抛出bad_alloc类型的异常; 返回失败; 所以new-hander必须做到其中一件事, 否则循环无法结束;

operator new经常会被子类继承, 引出复杂度; 大多数指针对类所写的operator new只为特定的类设计的, 不是为其他类或子类设计的;
对于一个类X的operator new来说, 函数内部的行为在涉及到对象的大小时, 都是sizeof(X). 但由于存在继承, 基类中的operator new可能被调用给子类对象分配内存;

class  Base {
    public :
    static  void  * operator  new ( size_t  size);
...
};
class  Derived:  public  Base  // Derived 类没有声明operator new
{ ... };  //
Derived *p =  new  Derived;  // 调用Base::operator new

>如果Base类的operator new不想处理这种情况, 简单的方法是把内存分配请求转给标准operator new来处理:

void  * Base::operator  new ( size_t  size)
{
    if  (size !=  sizeof (Base))  // 如果数量“错误”，让标准operator new
        return  ::operator  new (size);  // 去处理这个请求
//
...  // 否则处理这个请求
}

>size != sizeof(Base)处理了size等于零的情况: C++标准规定独立的freestanding类的大小都是非零值; 即使Base没有成员, sizeof(Base)也总是非0; (非独立的类sizeof可能为零) [嵌套类??] size为零时, 请求就会转到::operator new来处理;

如果想控制基于类的数组的内存分配, 必须实现operator new的数组形式: operator new[]("数组new");
写operator new[]时, 面对的是"原始"内存, 不能对数组里还不存在的对象进行操作; 还不知道数组对象的个数和大小;
基类的operator new[]会通过继承的方式被用来为子类对象的数组分配内存, 但子类对象一般比基类的大;
Base::operator new平[]里的每个对象大小不一定都是sizeof(Base), 数组对象的数量不一定就是 (请求字节数)/sizeof(Base);

对于operator delete和operator delete[], 要记住C++保证删除空指针总是安全的;

void  operator  delete ( void  *rawMemory)
{
    if  (rawMemory == 0)
        return ; file: //如果指针为空，返回
    //释放 rawMemory指向的内存;
    return ;
}

假设类的operator new将"错误"大小分配请求转给::operator new, 那么必须将"错误"大小的删除请求转给::operator delete;

class  Base {  // 和前面一样，只是这里声明了operator delete
public :
    static  void  * operator  new ( size_t  size);
    static  void  operator  delete ( void  *rawMemory,  size_t  size);
...
};
void  Base::operator  delete ( void  *rawMemory,  size_t  size)
{
    if  (rawMemory == 0)  // 检查空指针
        return ;
    if  (size !=  sizeof (Base))
    {  // 如果size"错误"，让标准operator 来处理请求
        ::operator  delete (rawMemory);
        return ;
    }
    "释放指向 rawMemory的内存;"
    return ;
}

必须遵守operator new和operator delete的规定; 需要内存分配程序支持new-handler函数, 并正确处理零内存请求; 

条款9 避免隐藏标准形式的new

内部范围声明的名称会隐藏掉外部范围的相同名称, 所以对于在类的内部和全局声明的同名函数f来说, 类成员函数会隐藏掉全局函数;

void  f();  // 全局函数
class  X {
public :
    void  f();  // 成员函数
};
X x;
f();  // 调用 f
x.f();  // 调用 X::f

>调用全局函数和成员函数时采用的是不同的语法形式;

但是如果在类里增加一个带多个参数的operator new函数:

class  X {
public :
    void  f();
// operator new 的参数指定一个 new-hander(new 的出错处理)函数
    static  void  * operator  new ( size_t  size, new_handler p);
};
void  specialErrorHandler();  // 定义在别的地方

X *px1 =  new  (specialErrorHandler) X;  // 调用X::operator new
X *px2 =  new  X;  //错误

>类里定义了"operator new"函数后, 会阻止对标准new的访问;

Solution 1)在类里写一个支持标准new调用方式的operator new, 和标准new做同样的事情;

class  X {
public :
    void  f();
    static  void  * operator  new ( size_t  size, new_handler p);
    static  void  * operator  new ( size_t  size) {  return  ::operator  new (size); }
};

X *px1 =  new  (specialErrorHandler) X;  // 调用 X::operator new(size_t, new_handler)
X* px2 =  new  X;  // 调用 X::operator new(size_t)

>使用内联实现;

Solution 2)为每一增加到operator new的参数提供缺省值;

class  X {
public :
    void  f();
    static  void  * operator  new ( size_t  size, new_handler p = 0);  // p 缺省值为0
};
X *px1 =  new  (specialErrorHandler) X;  // 正确
X* px2 =  new  X;  // 也正确

>以后想对"标准"形式的new定制新的功能, 只需重写这函数;