定位new表达式与显式调用析构函数

C++的核心理念之一是RAII，Resource Acquisition Is Initialization，资源获取即初始化。资源有很多种，内存、互斥锁、文件、套接字等；RAII可以用来实现一种与作用域绑定的资源管理方法（如std::lock_guard）；这些都不在本文的讨论范围之内。

内存是一种资源。从字面上来看，“资源获取”是指在栈或堆上开辟空间，“初始化”是指调用构造函数，“即”的意思是两者是绑定起来的。对应地，资源销毁即释放。这种机制保证了任何函数访问参数对象时不会访问到非法地址，除了构造和析构函数以外的任何函数的参数都不会是未初始化的。

然而，C++作为能够面向底层的语言，允许我们把内存获取与初始化分开来：std::malloc和std::free用于分配和释放内存，定位new表达式和析构函数的显式调用用于初始化和销毁对象。

malloc与free

std::malloc用于分配内存，std::free用于释放内存，两者都定义在<cstdlib>中：

void* malloc(std::size_t size);
void free(void* ptr);

比如，我想要分配一个int的动态内存，就应该给size填上sizeof(int)，返回值就是指向那个int的指针。如果是数组，就给size乘上元素个数。注意在C++中，从void*到T*的转换不能是隐式的。

要回收它，把指针传给free，不需要size：

#include <iostream>
#include <cstdlib>
int main()
{
    auto p = static_cast<int*>(std::malloc(sizeof(int) * 10));
    p[0] = 1;
    p[1] = 2;
    std::cout << p[0] << ' ' << p[1] << std::endl;
    std::free(p);
}

如果std::malloc过程中发生了错误，比如内存不足，std::malloc会返回NULL，nullptr的前身。实际使用时都应该考虑这种情况。

std::malloc得到的内存必须用free释放。std::malloc/std::free的内存分配与new/delete不互通。

定位new表达式

std::malloc分配的内存是未经初始化的，对于int等内置类型可以直接使用，而类类型则未必，需要先初始化才能使用。

我们知道，类的非静态成员函数都有一个隐式的this指针作为参数，构造函数也不例外，在未初始化的内存上构造对象，就是把这块内存的指针作为this传入构造函数。不幸的是，没有显式调用构造函数这种语法：

auto ptr = static_cast<A*>(std::malloc(sizeof(A)));
ptr->A("hello"); // error

（在MSVC中，ptr->A::A("hello");是合法的，但这是非标准的。）

我们需要定位new，它定义在<new>中，需要#include以后才能使用：

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

new运算符是可以重载的，new运算符的功能是为new表达式中的构造函数提供this指针。但是定位new不行，它总是忠实地返回它的第二个参数。

定位new表达式有以下形式：

new (ptr) Type;
new (ptr) Type(args);
new (ptr) Type[size];
new (ptr) Type[size]{list};

ptr为要当作this的指针，Type为要构造的类型，args为可能为空的参数列表，size为数组大小（可以动态），list为数组元素列表。

利用定位new，把ptr作为this的构造函数可以这样调用：

#include <iostream>
#include <cstdlib>
#include <string>
#include <utility>
class A
{
public:
    A(std::string s) : string(std::move(s))
    {
        std::cout << "A::A(std::string)" << std::endl;
    }
    std::string& get()
    {
        return string;
    }
private:
    std::string string;
};
int main()
{
    auto ptr = static_cast<A*>(std::malloc(sizeof(A)));
//  std::cout << ptr->get() << std::endl; // disaster
//  ptr->A("hello");                      // error
    new (ptr) A("hello");
    std::cout << ptr->get() << std::endl;
//  delete ptr;                           // disaster
    // what's next?
}

不要因为ptr简单就不加括号，括号不是为了什么运算符优先级，而是定位new表达式的一部分。

刚才不是说std::malloc与new不互通吗？怎么在std::malloc来的ptr上用定位new了呢？因为定位new根本不插手内存分配，和std::malloc是两回事。

定位new不止可以用于std::malloc来的动态内存，甚至可以是局部变量：

char buffer[sizeof(A)];
auto ptr = new (buffer) A("hello");
std::cout << ptr->get() << std::endl;

与常规的new一样，定位new表达式也返回一个指针，就是Type*类型的ptr。

显式调用析构函数

上面通过std::malloc得到的ptr，为什么不能直接std::free呢？因为std::string里面的资源还没释放，正确的做法是调用A的析构函数。

不能对一个对象调用构造函数，那么析构函数呢？答案是肯定的。只是~在形式上有点怪，尤其是当你把模板参数T换成int后得到ptr->~int()时，后者直接写是不合法的。

所以对于上面的ptr，要这样才能释放所有资源：

ptr->~A();
std::free(ptr);

显式调用析构函数，就像在帮编译器做事情一样。编译器会不会领情呢？写个代码测试一下吧：

#include <iostream>
#include <string>
#include <utility>
class A
{
public:
    A(std::string s) : string(std::move(s))
    {
        std::cout << "A::A(std::string)" << std::endl;
    }
    std::string& get()
    {
        std::cout << "A::get()" << std::endl;
        return string;
    }
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }
private:
    std::string string;
};
int main()
{
    {
        A a("");
        a.~A();
    }
    std::cout << "I'm OK" << std::endl;
}

程序输出：

A::A(std::string)
A::~A()
A::~A()
I'm OK

看来编译器并不领情，即使我们调用了析构函数，变量离开作用域时还会再调用一次。尽管在MSVC和GCC中，I'm OK都成功输出了，std::string都挺住了错误的析构，但是这个程序的行为仍然是未定义的。

因此，定位new语句与析构函数的显式调用必须配对。