定位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語句與析構函數的顯式調用必須配對。