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语句与析构函数的显式调用必须配对。