安全放置新的和明確的析構函數調用

Question

這是我的代碼示例：

template <typename T> struct MyStruct { 
    T object; 
} 

template <typename T> class MyClass { 
    MyStruct<T>* structPool; 
    size_t structCount; 

    MyClass(size_t count) { 
     this->structCount = count; 
     this->structPool = new MyStruct<T>[count]; 
     for(size_t i=0 ; i<count ; i++) { 
      //placement new to call constructor 
      new (&this->structPool[i].object) T(); 
     } 
    } 

    ~MyClass() { 
     for(size_t i=0 ; i<this->structCount ; i++) { 
      //explicit destructor call 
      this->structPool[i].object.~T(); 
     } 
     delete[] this->structPool; 
    } 
} 

我的疑問是，這是一種安全的方式呢？在某些情況下我會犯一些隱藏的錯誤嗎？它是否適用於每種類型的對象（PO​​D和非POD）？

Answer 1

不，因爲你的構造函數和析構函數都被調用了兩次。因爲你有這樣的：

template <typename T> struct MyStruct { 
    T object; 
} 

當你構建一個MyStruct<T>編譯將構建內T，當你刪除的對象內T會自動調用析構函數。

對於此示例，不需要放置新的或明確的析構函數調用。

如果您分配原始內存，則新放置將很有用。例如，如果您將新的更改爲：

this->structPool = new char[sizeof(T) * count]; 

然後您想要放置新的和explict析構函數調用。

Answer 2

不，這絕對不是遠程安全的做法。當您對非POD T執行new MyStruct<T>[count]時，數組中的每個MyStruct<T>對象都已獲取默認構造，這意味着object成員的構造函數會自動調用。然後，您嘗試在其上執行就地構建（通過值初始化）。結果的行爲是未定義的。

刪除時也存在同樣的問題。

你試圖實現什麼？只要做new MyStruct<T>[count]()（注意多餘的空()），它已經對數組中的每個元素執行了值初始化（正是你之後嘗試「手動」做的事情）。爲什麼你覺得你必須通過就地施工來完成？

同樣，當你做

delete[] this->structPool; 

它會自動要求數組中的每個成員MyStruct<T>::object的析構函數。無需手動完成。

Answer 3

1. 記住new總是會調用構造函數，不管它是否放置或不放置。

- 所以你的代碼使用兩次新。這將會調用構造函數兩次。如果你想避免這種情況，可以：

更改您的第一個新進入的malloc（或任何類型的頁頭的）

刪除你的第二個位置的新

刪除數組中的對象，最好的方法是：調用每個對象的析構函數;釋放內存。

- 所以你可以做兩種：

刪除與刪除[]如果您正在使用新的[]

調用析構函數的每個對象，做一個C風格的自由，如果你正在使用malloc和安置新

Answer 4

template <typename T> class MyClass { 
    void* structPool; 
    size_t structCount; 

    MyClass(size_t count) 
     : structPool(new char[sizeof(T)*count], structCount(count) 
    { 
     //placement new to call constructor 
     for(size_t i=0 ; i<count ; i++) 
      new (structPool+i*sizeof(T)) T(); 
    } 

    ~MyClass() { 
     //explicit destructor call 
     for(size_t i=0 ; i<structCount ; i++) 
      reinterpret_cast<T*>(structPool+i*sizeof(T))->~T(); 
     delete[] structPool; 
    } 
} 

請注意，這不是異常安全：如果一個構造函數導致異常，它不叫上已經構造的對象的析構函數和它泄漏內存。當其中一個析構函數拋出時，也會失敗。

看看你最喜歡的std lib實現中的std::vector，看看如何做到這一點。然而，這導致了一個問題：爲什麼你想這樣做呢？
一個std::vector已經做了這一切，確實是正確的，你可以用它開箱即用，每個人都在看你的代碼會立刻理解它：

template <typename T> class MyClass { 
    std::vector<T> data_; 
    MyClass(size_t count) : data() {data.resize(count);} 
    //~MyClass() not needed 
}