智能指針是否需要兩階段構造？

Question

兩相結構採用以下形狀：

struct something { 
    something() 
     : p1(NULL) 
     , p2(NULL) 
    { } 

    ~something() { 
     if (p1) delete p1; 
     if (p2) delete p2; 
    } 

    void initialize() { 
     p1 = new int(2); 
     p2 = new int(5); // May throw if allocation fails! 
    } 

    int* p1; 
    int* p2; 
}; 

的點，這是一個天真的構造（即不看用於分配失敗）將泄漏存儲器：的局部構造的對象的析構函數是從來沒有所謂。

我的問題：下面的代碼是否安全，並且通過確認，智能指針是否消除了兩階段構造？

struct something { 
    something() 
     : p1(new int(2)) 
     , p2(new int(5)) 
    { } 

    std::unique_ptr<int> p1; 
    std::unique_ptr<int> p2; 
}; 

Answer 1

是的，你的新代碼很好。但是請注意，有可能在微妙更復雜的情況：

#include <memory> 

struct foo { 
    foo(std::shared_ptr<int> a, std::shared_ptr<int> b) { } 
}; 

struct bar { 
    foo f; 
    bar() : f(std::shared_ptr<int>(new int), std::shared_ptr<int>(new int)) { } 
}; 

int main() { 
    bar b; 
} 

不會是安全然而，由於的foo在bar初始化列表構造函數的參數計算順序是不確定的。符合標準的編譯器可能會選擇進行深度或廣度的第一級評估（或者只要它們全部都得到正確評估）。這意味着如果第一個new int成功，但第二個在shared_ptr構建對象之前拋出，則要執行的第一個分配仍可能泄漏。

如果你發現自己想要做到這一點，除了迴歸到兩階段結構之外，還有兩種可能的解決方案：第一種可能是重構，第二種可能是先構建單獨的shared_ptr作爲條形的成員，之前f。哪一個最合適是我認爲需要根據具體情況進行的判斷呼叫。

Answer 2

我的問題：下面的代碼安全，

是的，這將是確定。

struct something { 
    something() 
     : p(new int(5)) 
    { } 

    std::unique_ptr<int> p; 
}; 

注意，天真代碼

struct something { 
    something() 
     : p(new int(5)) 
    { } 

    int* p; 
}; 

將是異常安全，也因爲只有一個分配，這可能會失敗。我認爲你說的是​​

struct something { 
    something() 
     : p(new int(5)), q(new int) 
    { } 

    int *p, *q; 
}; 

哪個不會。智能指針也適用於這種情況。

Answer 3

如果您只是處理異常情況，則根本不需要兩相結構。這是RIAA的方式。

struct something { 
    something() 
     : p1(NULL) 
     , p2(NULL) 
    { 
     p1 = new int(2); 
     try { 
      p2 = new int(5); // May throw if allocation fails! 
     } catch (std::bad_alloc&) { 
      delete p1; //cleanup 
      throw; //rethrow 
     } 
    } 

    ~something() { 
     delete p1; 
     delete p2; 
    } 

    int* p1; 
    int* p2; 
};