一、在特定内存区上构造对象
有时候我们希望在某些C++触及不到的地方放置C++对象，就需要用到这个方法。方法是使用new的就地初始化形式，即new(void*)调用构造函数构建对象，并在必要的时机手动调用析构函数进行销毁。

<code class="lang-cpp">#include <iostream>
using namespace std;
                                   
struct MyClass {
    MyClass() {
        cout << "构造函数" << endl;
    }
    virtual ~MyClass() {
        cout << "析构函数" << endl;
    }
};
                                    
int main()
{
    char k[sizeof(MyClass)]; // 预先分配内存k[]
    MyClass* ptr1 = new(k) MyClass; // 在k[]中生成新对象 new(void*) MyClass();
    ptr1->~MyClass(); // 直接调用析构函数，销毁对象
                                    
    char m[sizeof(int) + 2*sizeof(MyClass)]; // 预先分配内存m[]（计数空间+数据空间）
    MyClass* ptr2 = new(m) MyClass[2]; // 在m[]中生成新MyClass对象
    ptr2[1].~MyClass(); // 直接调用析构函数，销毁对象
    ptr2[0].~MyClass(); // 直接调用析构函数，销毁对象
                                    
    return 0;
}</iostream></code>

上边出现了显式调用析构函数的语句，C++中析构函数是可以直接调用的。而构造函数却不能直接调用（直接调用的含义是新建临时值对象），需要使用new(void*)这种特殊方法。

二、重载new和delete运算符
大多数运算符只有一种已知形式（有的如++或--有两种），但是new、new[]比较特别，标准形式的有三种。以单变量new和delete为例，适用于数组的new[]和delete[]与之类似：
1. 常规new运算符（new）分配内存，并调用构造函数；可能会返回有效地址，也可能抛出bad_alloc异常。
2. 无抛出new运算符（new(nothrow)）分配内存，并调用构造函数；可能会返回有效地址，也可能会返回NULL。
3. 就地new运算符（new(void*)）不分配内存，只调用构造函数；直接返回有效地址。
4. delete运算符（delete）调用析构函数，并释放内存。
对于new[]，特别的，在内存中分配时还需要一个int计数字段。所以，对于new[]，需要的内存总数是sizeof(int) + n * sizeof(MyClass)。
三个new和一个delete的显式调用方法如下：

<code class="lang-cpp">// 单变量形式
ptr1 = new MyClass(...);
ptr2 = new(nothrow) MyClass(...);
ptr3 = new(&buffer) MyClass(...); // 此处需要 sizeof(MyClass) 字节空间
delete ptr1; // 示例：析构并释放ptr1指向的对象
                             
// 数组形式
ptr1 = new MyClass[3](...);
ptr2 = new(nothrow) MyClass[3](...);
ptr3 = new(&buffer) MyClass[3](...); // 此处需要 sizeof(int) + 3 * sizeof(MyClass) 字节空间
delete[] ptr1; // 示例：析构并释放ptr1指向的对象数组</code>

new和delete运算符的重载（operator new、operator delete）并不需要调用构造函数或析构函数，operator new只需分配内存，并返回内存块的起始地址，而operator delete只需释放内存。
operator new和operator delete也分三种，而且每一种要成对重载。其中operator delete只有第一种能显式调用，其它两种都不能，它们的用途是在对应的new运算符执行期间，分配内存成功但构造函数抛出异常时，被隐式调用：

<code class="lang-cpp">// 单变量形式
void* operator new(size_t sz);                 // 常规new（可抛出bad_alloc异常）
void* operator new(size_t sz, nothrow_t nt);   // 无抛出new（可返回NULL）
void* operator new(size_t sz, void *place);    // 就地new（直接返回place，不分配内存）
void operator delete(void *obj);               // 显式delete & “常规new”的隐式delete
void operator delete(void *obj, nothrow_t nt); // “无抛出new”的隐式delete
void operator delete(void *obj, void *place);  // “就地new”的隐式delete
                          
// 数组形式
void* operator new[](size_t sz);                 // 常规new[]（可抛出bad_alloc异常）
void* operator new[](size_t sz, nothrow_t nt);   // 无抛出new[]（可返回NULL）
void* operator new[](size_t sz, void *place);    // 就地new[]（直接返回place，不分配内存）
void operator delete[](void *obj);               // 显式delete[] & “常规new[]”的隐式delete[]
void operator delete[](void *obj, nothrow_t nt); // “无抛出new[]”的隐式delete[]
void operator delete[](void *obj, void *place);  // “就地new[]”的隐式delete[]</code>

比如以下代码可以让C++调用对应的隐式delete——

<code class="lang-cpp">#include <iostream>
using namespace std;
                                   
struct MyClass{
    MyClass() { // 构造函数
        cout << "抛出异常的构造函数" << endl;
        throw exception(""); // 抛出异常
    }
};
                                                       
int main() {
    try {
        MyClass *ptr = new(nothrow) MyClass; // 分配成功，但构造函数抛出异常
        delete ptr; // 这句不会被执行
    } catch (exception& e) {
        // 自动执行void operator delete(void *, nothrow_t)
    }
    return 0;
}</iostream></code>

如果在类中重载了一对new和delete，那么在new或delete这个类的对象时，C++只会在类中搜索new或delete，不会在全局搜索。所以，对于重载new或delete运算符的C++类，需要同时重载三种形式。
如果不想自己写内存分配，只想给这些运算符添加功能，可以直接调用顶级命名空间的::operator new和::operator delete等来完成运算符的功能（这些预定义重载总是存在且可以被显式调用的），例如

<code class="lang-cpp">struct MyClass {
    void* operator new(size_t sz) {
        cout << "operator new" << endl;
        return ::operator new(sz); // 调用全局new
    }
    void operator delete(void * ptr) {
        cout << "operator delete" << endl;
        return ::operator delete(ptr); // 调用全局delete
    }
};</code>

实际上operator new和operator new[]的参数数量并没有限制，形式可以为void* operator new(size_t, ...)，只需要保证第一个参数size_t和返回值void*的类型正确即可。这些重载形式均可以用new(...)形式调用。但是也要注意，如果写了某一个new重载，那么还需要再写一个相对应形式的void operator delete(void*, ...)以处理构造函数抛出异常的情况，同样需要注意第一个参数void*和返回值void的类型正确。

<code class="lang-cpp">struct MyClass {
    void* operator new(size_t sz, string msg, int val) // 自定义new运算符
    {
        cout << "new: " << msg.c_str() << " " << val << endl;
        return ::operator new(sz);
    }
    void operator delete(void *ptr, string msg, int val) // 对应的隐式delete
    {
        cout << "delete: " << msg.c_str() << " " << val << endl;
        return ::operator delete(ptr);
    }
};
                              
MyClass *ptr1 = new("creating object...", 2) MyClass; // 调用方法
::delete ptr1; // 没有重载显式delete，所以要调用::delete</code>

程序可以调用::new和::delete访问全局的new或delete，但是除非有必要，不建议这样做。
最好只在自己的类中重载默认三种形式的new、new[]、delete、delete[]运算符，不建议全局重载，以免产生麻烦。

如上所述。如有疏漏请指正。