《Effective C++》第8章 定制new和delete-读书笔记

章节回顾：

《Effective C++》第1章 让自己习惯C++-读书笔记

《Effective C++》第2章 构造/析构/赋值运算（1）-读书笔记

《Effective C++》第2章 构造/析构/赋值运算（2）-读书笔记

《Effective C++》第3章 资源管理（1）-读书笔记

《Effective C++》第3章 资源管理（2）-读书笔记

《Effective C++》第4章 设计与声明（1）-读书笔记

《Effective C++》第4章 设计与声明（2）-读书笔记

《Effective C++》第5章 实现-读书笔记

《Effective C++》第8章 定制new和delete-读书笔记

---

条款49：了解new-handler的行为

当operator new无法满足某一内存分配需求时，它会抛出异常，当其抛出异常以反应一个未获满足的内存需求之前，会先调用一个客户指定的错误处理函数，一个所谓的new-handler。为了指定这个“用以处理内存不足”的函数，客户必须调用set_new_handler。

namespace std
{
    typedef void (*new_handler)();
    new_handler set_new_handler(new_handler p) throw();
}

说明：

（1）set_new_handler是声明于<new>的一个标准库函数。

（2）throw()是一份异常明细，表示该函数不抛出任何异常。

（3）形参p指向operator new无法分配足够内存时该被调用的函数，返回指针指向set_new_handler被调用前正在执行（但马上就要被替换）的那个new-handler函数。

（4）set_new_handler的例子：

void OutOfMem()
{
    cerr << "Unable to satisfy request for memory" << endl;
    abort();
}
int main()
{
    set_new_handler(OutOfMem);
    int *ptr = new int[100000000L];

    return ;
}

（5）当operator new无法满足内存申请时，它会不断调用new-handler函数，直到找到足够内存。

1、一个设计良好的new-handler函数必须做以下事情：

（1）让更多内存被使用。

这可能使得operator new中下一次内存分配的尝试成功。实现这一策略的一个方法是在程序启动时分配一大块内存，然后在new-handler第一次被调用时释放它供程序使用。

（2）安装另一个new-handler。

如果当前的new-handler不能做到使更多的内存可用，或许它知道有一个不同的 new-handler 可以做到。

（3）卸载new-handler。

即将空指针传给set_new_handler，当内存分配不成功时，operator new将抛出一个异常。

（4）抛出bad_alloc（或派生自bad_alloc）的异常。

这样的异常不会被operator new捕获，因此会被传播到内存请求的地方。

（5）不返回。

通常调用abort或exit。

2、以不同方式处理分配内存失败

只要让每一个class提供set_new_handler和operator new的自己的版本即可。operator new无法分配足够内存时应抛出bad_alloc异常，但也可能返回null（传统形式仍然保留），这种传统形式称为“nothrow”。

class Widget { ... };
Widget *pw1 = new Widget;            // throws bad_alloc if allocation fails
if (pw1 == ) ...                    // this test must fail
Widget *pw2 =new (std::nothrow)  Widget;    // returns 0 if allocation for the Widget fails
if (pw2 == ) ...                            // this test may succeed

请记住：

（1）set_new_handler允许客户指定一个函数，在内存分配无法获得满足时被调用。

（2）nothrow new是一个局限的工具，因为它只适用于内存分配，后继的构造函数调用还是可能抛出异常。

———————————————————————————————————————————————————————

条款50：了解new和delete的合理替换时机

为什么有些人想要替换编译器提供的operator new或operator delete 版本呢？原因有：

（1）为了检测运用错误；（2）为了收集动态分配内存之使用统计信息；（3）为了增加分配和归还的速度；（4）为了降低缺省内存管理器带来的空间额外开销；（5）为了弥补缺省分配器中的非最佳对齐；（6）为了将相关对象成簇集中；（7）为了获得非传统的行为。

———————————————————————————————————————————————————————

条款51：编写new和delete时需固守常规

1、operator new

实现一致性operator new需要考虑：

（1）必须返回正确的值，内存不足时调用new-handling函数。

（2）必须有对付0内存需求的准备。

（3）避免不慎掩盖正常形式的new。

下面分别说明：

（1）如果operator new有能力供应客户申请的内存，就返回一个指针指向那块内存，如果没有就抛出一个bad_alloc异常。

注意：只有当指向new-handling函数的指针是null，operator new才会抛出异常。

（2）即使客户要求0bytes，operator new也要返回一个合法指针，这种行为是为了简化语言其他部分。下面是个operator new伪码：

void * operator new(std::size_t size) throw(std::bad_alloc)
{                                            // your operator new might
    using namespace std;                    // take additional params
    if (size == ) {                        // handle 0-byte requests
        size = ;                            // by treating them as 1-byte requests
    }
    while (true) {
        attempt to allocate size bytes;
        if (the allocation was successful)
            return (a pointer to the memory);
        // allocation was unsuccessful; find out what the
        // current new-handling function is (see below)
        new_handler globalHandler = set_new_handler();
        set_new_handler(globalHandler);
        if (globalHandler) (*globalHandler)();
        else throw std::bad_alloc();
    }
}

说明：

1）把0bytes申请量视为1byte申请量，毕竟客户多久才会发出一个0bytes申请。

2）将new-handling函数指针设为null而后又立即恢复原样，是因为没有办法可以直接取得new-handling函数指针，所以必须调用set_new_handler找出它来。这种做法在单线程环境下有效，多线程环境下或许需要某种锁以便安全处置new-handling函数背后的数据结构。

下面考虑operator new成员函数被继承会发生什么情况：

如果Base class专属的operator new并非被设计用来处理上述情况。最佳做法是采用标准operator new：

void * Base::operator new(std::size_t size) throw(std::bad_alloc)
{
    if (size != sizeof(Base))  // if size is "wrong,"
        return ::operator new(size) ; // have standard operator
    // new handle the request
    ... // otherwise handle
        // the request here
}

2、operator delete

C++保证“删除null指针永远安全”，所以你必须兑现这项保证。

class Base { // same as before, but now
public: // operator delete is declared
    static void * operator new(std::size_t size) throw(std::bad_alloc);
    static void operator delete(void *rawMemory, std::size_t size) throw();
    ...
};
void Base::operator delete(void *rawMemory, std::size_t size) throw()
{
    if (rawMemory == ) return; // check for null pointer
    if (size != sizeof(Base)) {  // if size is "wrong,"
        ::operator delete(rawMemory);  // have standard operator
        return;  // delete handle the request
    }
    deallocate the memory pointed to by rawMemory;
    return;
}

请记住：

（1）operator new应该内含一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就该调用new-handler。它也应该有能力处理0bytes申请。class专属版本还应该处理“比正确大小更大的（错误）申请”。

（2）operator delete应该在收到null指针时不做任何事。class专属版本还应该处理“比正确大小更大的（错误）申请”。

———————————————————————————————————————————————————————

条款52：写了placement new也要写placement delete

当你写一个new表达式：

Widget *pw = new Widget;

共有两个函数被调用：第一个是operator new用于分配内存，第二个是Widget的default 构造函数。

假设第一个调用成功，第二个调用导致抛出一个异常。那么在第1步中完成的内存分配必须被撤销，否则内存泄漏。但客户不可能回收这些内存，因为如果Widget的构造函数抛出一个异常，pw根本就没有被赋值。对于客户来说无法得到指向应该被回收的内存指针。所以撤销第1步的职责必然落在了C++ 运行时系统身上。C++ 运行时系统会调用第1步operator new相应的operator delete，但只有在它知道哪一个operator delete（可能有许多个）该被调用。

（1）对于正常的operator new，运行时系统可以找到对应的operator delete。常规的operator new

void* operator new(std::size_t) throw(std::bad_alloc);

对应常规的operator delete：

void operator delete(void *rawMemory) throw();                        // normal signature at global scope
void operator delete(void *rawMemory, std::size_t size) throw();    // typical normal signature at class scope 

（2）当声明operator new的非常规形式（带有额外参数）的时候，问题就出现了。假设编写了一个类专用的operator new，但编写了一个常规的operator delete：

class Widget {
public:
    ...
        static void* operator new(std::size_t size, // non-normal
        std::ostream& logStream)                    // form of new
        throw(std::bad_alloc);
    static void operator delete(void *pMemory    // normal class-
        std::size_t size) throw();                // specific form
                                                // of delete
    ...
};

说明：如果operator new接受的参数除了size_t之外还有其他，称为placement new。比较有用的一个placement new版本是“接受一个指针指向对象该被构造之处”。

void* operator new(std::size_t, void *pMemory) throw();

考虑以下代码：

Widget *pw = new (std::cerr) Widget; // call operator new, passing cerr as
                                    // the ostream; this leaks memory
                                    // if the Widget constructor throws

如果内存分配成功，构造函数抛出异常。运行时系统寻找“参数个数和类型都与operator new相同”的某个operator delete，如果找到则调用。显然，这里没有找到，所以运行时系统无法取消分配的内存。对应于placement new的placement delete版本类似于：

void operator delete(void *, std::ostream&) throw();

然而如果构造函数没有抛出异常，客户代码为delete pw，调用的是正常形式的operator delete，而非placement版本。

注意：只有在调用一个与placement new相关联的构造函数抛出异常，placement delete才会被调用。所以如果要处理所有与placement new相关的内存泄露，必须同时提供正常的operator delete和placement版本。

另外需要注意的是，成员函数名称会掩盖其外围作用域中的相同名称，所以要避免让class专属的news遮盖客户期望的其他news（包括正常版本）。

class Base {
public:
    ...
        static void* operator new(std::size_t size, // this new hides the normal global forms
        std::ostream& logStream)
        throw(std::bad_alloc);
    ...
};
Base *pb = new Base;                // error! the normal form of
                                    // operator new is hidden
Base *pb = new (std::cerr) Base;    // fine, calls Base's
                                    // placement new

同样道理，derived classes中的operator news会遮盖globle版本和继承而得到的operator new。

class Derived: public Base {                        // inherits from Base above
public:
    ...
        static void* operator new(std::size_t size) // redeclares the normal
        throw(std::bad_alloc);                        // form of new
    ...
};
Derived *pd = new (std::clog) Derived;    // error! Base's placement
                                        // new is hidden
Derived *pd = new Derived;                // fine, calls Derived's
                                        // operator new

对于撰写内存分配函数，需要注意的是，缺省情况下C++在globle作用域内提供的operator news形式：

void* operator new(std::size_t) throw(std::bad_alloc); // normal new
void* operator new(std::size_t, void*) throw(); // placement new
void* operator new(std::size_t,                // nothrow new — see Item 49
    const std::nothrow_t&) throw();            

如果你在class内声明任何operator news都会遮掩上述标准形式，除非你就是故意阻止客户使用这些形式。如果你希望这些函数可用，只要令你的class专属版本调用globle版本即可。

class StandardNewDeleteForms {
public:
    // normal new/delete
    static void* operator new(std::size_t size) throw(std::bad_alloc)
    { return ::operator new(size); }
    static void operator delete(void *pMemory) throw()
    { ::operator delete(pMemory); }
    // placement new/delete
    static void* operator new(std::size_t size, void *ptr) throw()
    { return ::operator new(size, ptr); }
    static void operator delete(void *pMemory, void *ptr) throw()
    { return ::operator delete(pMemory, ptr); }
    // nothrow new/delete
    static void* operator new(std::size_t size, const std::nothrow_t& nt) throw()
    { return ::operator new(size, nt); }
    static void operator delete(void *pMemory, const std::nothrow_t&) throw()
    { ::operator delete(pMemory); }
};

class Widget: public StandardNewDeleteForms {            // inherit std forms
public:
    using StandardNewDeleteForms::operator new;            // make those
    using StandardNewDeleteForms::operator delete;        // forms visible
    static void* operator new(std::size_t size,             // add a custom
        std::ostream& logStream)                        // placement new
        throw(std::bad_alloc);
    static void operator delete(void *pMemory,            // add the corresponding placement delete
        std::ostream& logStream)
        throw();
    ...
};

请记住：

（1）当你写operator new的placement版本时，确保同时编写operator delete相应的placement版本。否则，你的程序可能会发生微妙的，断续的内存泄漏。

（2）当你声明new和delete的placement版本时，确保不会无意中覆盖这些函数的常规版本。

———————————————————————————————————————————————————————

我感觉写的有点流水账。但其实每次拜读这本书感受都有点不同，比如有的问题，自己知道这样做肯定行，但是就是想不明白为什么这么麻烦着做。可能是没有经验吧。这篇总结，先记录到这里，我还要回顾修改的。看起来有点乱糟糟的。