在第一部分中，我们介绍了new / delete的具体用法和背后的实现细节，这次我们将构建我们自己的小型工具集，可以使用我们自定义的allocator类来创建任意类型的实例（或者实例数组），我们需要做好准备，因为这里面涉及到了函数模板，type-based dispatching，模板黑魔法，以及一些巧妙的宏定义。
理想中，我们准备做的自定义内存系统需要创建实例的语法大概像下面这样：
假如我们定义了一个负责内存分配的类Arena
Arena arena; // one of many memory arenas
// ...
Test* test = new (arena, additionalInfo) Test(0, 1, 2);
delete(test, arena); // no placement-syntax of delete
// ...
Test* test = new (arena, additionalInfo) Test[10];
delete[] (test, arena); // no placement-syntax of delete[]
我们可以让new operator像这样去工作，只需要重载operator new，然后使用placement new syntax即可。但是delete却不能如上一样，因为delete operator没有placement-syntax，也就是说它只能接收一个参数，如果直接调用operator delete，我们就会遇到上节我们提到的operator delete[]的析构问题，我们无法写出编译器无关的，跨平台的析构调用方法。
另外，我们想要在new的时候传递一些额外的信息，像文件名、行号、类名、内存标签等等，同时还x想尽量保留C++原始的new operator调用语法，所以，我们使用宏的方式来定义new operator，最终希望达到像下面的代码段这样，来使用自定义的new operator：
Test* test = OM_NEW(Test, arena)(0, 1, 2);
OM_DELETE(test, arena);
// ...
Test* test = OM_NEW_ARRAY(Test[3], arena);
OM_DELETE_ARRAY(test, arena);
接下来就让我们挨个实现这些宏，以及一些底层的函数，从最简单的开始吧。
OM_NEW
就像最普通的new operator一样，ME_NEW首先需要为给定的类型分配内存，然后在该内存上调用其构造函数。实现起来比较简单，就一行代码：
#define OM_NEW(type, arena) new (arena.Allocate(sizeof(type), __FILE__, __LINE__)) type
我们要做的就是在我们自定义的Arena.Allocate()函数返回的内存地址上使用placement new，同时也传递进去一些我们需要的信息，文件名，行号。另外需要特别注意的是我们最后的type，它的作用就是为了给构造函数提供构造所需的参数，可以在调用时，将参数附在宏的后面，如下所示：
// Test is a class taking 3 ints in the constructor
Test* test = OM_NEW(Test, om)(0, 1, 2);
// 宏展开后:
Test* test = new (om.Allocate(sizeof(Test), "test.cpp", 123)) Test(0, 1, 2);
使用OM_NEW，我们可以使用自定义的内存分配函数，同时传递额外的信息给它。同时也可以保留了new operator原始的语法。
OM_DELETE
每个使用OM_NEW创建的实例，都需要调用OM_DELETE来删除。切记一点，没有placement形式的delete operator，所以我们要么直接调用operator delete，要么就使用完全不同的方法。无论是哪种方法，都要确保调用实例的析构函数。我们可以通过将删除操作延迟给一个help函数去执行来实现：
#define ME_DELETE(object, arena) Delete(object, arena)
help函数使用的是模板函数的方式：
template<typename T, class ARENA>
voidDelete(T* object, ARENA& arena)
{
// call the destructor first...
object->~T();
// ...and free the associated memory
arena.Free(object);
}
编译器会帮我们推导出所有的类型参数，不需要我们显式指定任何模板参数。
OM_NEW_ARRAY
到这里事情就变得稍微复杂了一些。我们首先需要一个可以为N个实例分配内存的函数，同时能够使用placement new正确地调用构造函数。因为它需要适用所有类型，所以我们还是用函数模板的方式来实现：
template<typename T, class ARENA>
T* OM_NewArray_Helper(ARENA& arena, size_t N, const char* file, int line)
{
union
{
void* as_void;
size_t* as_size_t;
T* as_T;
};
as_void = arena.Allocate(sizeof(T)*N + sizeof(size_t), file, line);
// store number of instances in first size_t bytes
*as_size_t++ = N;
// construct instances using placement new
constT* const onePastLast = as_T + N;
while(as_T < onePastLast)
new(as_T++) T;
// hand user the pointer to the first instance
return(as_T - N);
}
上面的注释基本说明了代码的原理，我这里就提一点，就是我们在给N个实例分配内存的时候，额外分配了大小为sizeof(size_t)的空间，它的目的就是为了保存实例的数量。假如我们的sizeof(T) == 4，sizeof(size_t) == 4，那么我们分配出来的内存的布局如下：
Bytes 0-3: N
Bytes 4-7: T[0]
Bytes 8-11: T[1]
Bytes 12-15: T[2]
返回给用户的是指针式偏移了sizeof(size_t)个字节的地址。最终的使用方法如下：
Test* t = OM_NewArray_Helper<Test>(arena, 3, __FILE__, __LINE__);
这个还有个小问题，从上面的使用样例可以看出，因为类型T并没有出现在函数的参数列表中(只是用于函数的返回值类型)，所以编译器无法帮助我们直接推导出类型，所以我们必须在每次使用时显式指定类型Test，但是如果我们用宏来包裹这个函数的话，在宏里我们并不知道实例的类型，同时在宏里我们也不知道实例的数量，先看下我们设想的宏的使用方式：
Test* test = OM_NEW_ARRAY(Test[3], arena);
为了使我们的宏能够像这样工作，该如何定义它呢？
#define ME_NEW_ARRAY(type, arena) OM_NewArray_Helper<?>(arena, ?, __FILE__, __LINE__)
宏里的问号就是我们现在还缺失的信息，那么如何获取到这部分信息呢，这时候就是模板黑魔法发挥作用的时候了：
template<class T>
structTypeAndCount
{
};
template<class T, size_t N>
structTypeAndCount<T[N]>
{
typedefT Type;
staticconstsize_tCount = N;
};
第一个基础模板TypeAndCount只定义了一个模板参数，别的什么都没有做，但是它却提供了部分偏特化的方式将type从T[N]中分离出来，这样N也可以在编译期获取到，最后宏的定义就成了：
#define OM_NEW_ARRAY(type, arena) NewArray<TypeAndCount<type>::Type>(arena, TypeAndCount<type>::Count, __FILE__, __LINE__)
可能很多人对这个黑魔法感觉到有点懵逼，所以下面以OM_NEW_ARRAY(Test[3],arena)为例来说明一下它到底是如何工作的：
首先是预处理的工作：
- 宏的TypeAndCount<type>::Type部分将会替换为TypeAndCount<Test[3]>::Type.
- 宏的TypeAndCount<type>::Count部分将会替换为TypeAndCount<Test[3]>::Count.
接下来是编译器的工作：
- TypeAndCount<type>::Type的局部偏特化会产生Test
- TypeAndCount<type>::Count的局部偏特化会产生3
就这样，我们将类型和数量两个值传递到了宏，从而避免再传递多余的参数给宏。
ME_DELETE_ARRAY
同样的，我们需要一个函数，帮我们实现几个功能：一是按照反序调用实例的析构函数，然后删除相应的内存。废话少说，直接看实现：
template <typename T, class ARENA>
void DeleteArray(T* ptr, ARENA& arena, NonPODType)
{
union
{
size_t* as_size_t;
T* as_T;
};
// user pointer points to first instance...
as_T = ptr;
// ...so go back size_t bytes and grab number of instances
const size_t N = as_size_t[-1];
// call instances' destructor in reverse order
for (size_t i=N; i>0; --i)
as_T[i-1].~T();
arena.Free(as_size_t-1);
}
根据注释大家基本可以理解原理了，宏的实现也比较简单：
#define OM_DELETE_ARRAY(object, arena) DeleteArray(object, arena)
到这里，我们基本已经完成了我们的目标，实现了POD类型和NON-POD类型的自定义new / delete家族函数，但是这里面其实还有需要优化的地方，比如如果是POD类型的实例，我们不需要调用它的构造/析构函数，所以我们的NewArray和DeleteArray函数模板都可以优化。这可以通过类型派遣来实现（type-based dispatching）,这里暂时不展开讨论了，留待下节详细介绍。