デストラクタを手動で呼び出すことは、常に悪い設計の兆候ですか？

Question 1

私は考えていました：彼らはあなたが手動でデストラクタを呼んでいるなら-あなたは何か間違ったことをしていると言います。しかし、それは常に当てはまりますか？反例はありますか？手動で呼び出す必要がある状況、またはそれを回避することが難しい/不可能/非現実的な状況ですか？

Question 2

operator new()「std::nothrow」オーバーロードを使用する場合を除いて、オブジェクトがオーバーロードされた形式のを使用して構築された場合は、デストラクタを手動で呼び出す必要があります。

T* t0 = new(std::nothrow) T();
delete t0; // OK: std::nothrow overload

void* buffer = malloc(sizeof(T));
T* t1 = new(buffer) T();
t1->~T(); // required: delete t1 would be wrong
free(buffer);

ただし、上記のようにデストラクタを明示的に呼び出すような低レベルでメモリを管理することは、設計が悪いことを示しています。おそらく、それは実際には悪い設計であるだけでなく、完全に間違っています（はい、明示的なデストラクタの後に代入演算子でコピーコンストラクタ呼び出しを使用することは悪い設計であり、間違っている可能性があります）。

C ++ 2011では、明示的なデストラクタ呼び出しを使用する別の理由があります。一般化された共用体を使用する場合、現在のオブジェクトを明示的に破棄し、表現されるオブジェクトのタイプを変更するときに、placementnewを使用して新しいオブジェクトを作成する必要があります。また、ユニオンが破棄されたときに、破棄が必要な場合は、現在のオブジェクトのデストラクタを明示的に呼び出す必要があります。

Question 3

すべての回答は特定のケースを説明していますが、一般的な回答があります。

オブジェクトが存在するメモリを解放せずに、（C ++の意味で）オブジェクトを破棄する必要があるたびに、dtorを明示的に呼び出します。

これは通常、メモリの割り当て/割り当て解除がオブジェクトの構築/破棄とは独立して管理されているすべての状況で発生します。そのような場合、構築は既存のメモリチャンクに新しい配置を介して行われ、破棄は明示的なdtor呼び出しを介して行われます。

これが生の例です：

{
  char buffer[sizeof(MyClass)];

  {
     MyClass* p = new(buffer)MyClass;
     p->dosomething();
     p->~MyClass();
  }
  {
     MyClass* p = new(buffer)MyClass;
     p->dosomething();
     p->~MyClass();
  }

}

別の顕著な例では、デフォルトであるstd::allocatorが使用するstd::vector要素が中に構築される：vector時push_back、それは要素contructionを事前に存在するように、メモリは、チャンクに割り当てられています。したがって、vector::erase要素を破棄する必要がありますが、必ずしもメモリの割り当てを解除する必要はありません（特に、新しいpush_backがすぐに発生する必要がある場合...）。

厳密なOOPの意味での「悪い設計」（メモリではなくオブジェクトを管理する必要があります。オブジェクトがメモリを必要とするという事実は「インシデント」です）、「低レベルプログラミング」の「良い設計」、またはメモリがデフォルトでoperator new購入する「無料ストア」から取得されません。

コードの周囲でランダムに発生する場合は悪い設計ですが、その目的のために特別に設計されたクラスに対してローカルで発生する場合は良い設計です。

Question 4

いいえ、2回呼び出されるため、明示的に呼び出すべきではありません。1回は手動呼び出し用で、もう1回はオブジェクトが宣言されているスコープが終了するときです。

例えば。

{
  Class c;
  c.~Class();
}

本当に同じ操作を実行する必要がある場合は、別のメソッドが必要です。

プレースメントを使用して動的に割り当てられたオブジェクトのデストラクタを呼び出したいが、必要なものが聞こえないという特定の状況がありますnew。

Question 5

いいえ、状況によっては、合法で優れたデザインの場合もあります。

デストラクタを明示的に呼び出す必要がある理由と時期を理解するために、「new」と「delete」で何が起こっているかを見てみましょう。

T* t = new T;内部でオブジェクトを動的に作成するには、次の手順に従います。1。sizeof（T）メモリが割り当てられます。2. Tのコンストラクターが呼び出され、割り当てられたメモリが初期化されます。new演算子は、割り当てと初期化の2つのことを行います。

delete t;ボンネットの下のオブジェクトを破壊するには：1。Tのデストラクタが呼び出されます。2.そのオブジェクトに割り当てられたメモリが解放されます。演算子deleteは、破棄と割り当て解除の2つのことも行います。

初期化を行うコンストラクタと破棄を行うデストラクタを記述します。デストラクタを明示的に呼び出すと、破棄のみが実行され、割り当て解除は実行されません。

したがって、デストラクタを明示的に呼び出す正当な使用法は、「オブジェクトを破棄したいだけですが、メモリ割り当てを解放しません（または解放できません）」ということです。

この一般的な例は、動的に割り当てる必要がある特定のオブジェクトのプールにメモリを事前に割り当てることです。

新しいオブジェクトを作成するときは、事前に割り当てられたプールからメモリのチャンクを取得し、「新規配置」を実行します。オブジェクトの処理が完了したら、デストラクタを明示的に呼び出して、クリーンアップ作業があれば終了することをお勧めします。ただし、演算子deleteが行ったように、実際にはメモリの割り当てを解除することはありません。代わりに、チャンクをプールに戻して再利用します。

Question 6

FAQで引用されているように、placement newを使用する場合は、デストラクタを明示的に呼び出す必要があります。

これは、明示的にデストラクタを呼び出す唯一の時間です。

私はこれがめったに必要とされないことに同意します。

Question 7

割り当てを初期化から分離する必要があるときはいつでも、デストラクタを手動で新しく明示的に呼び出す必要があります。現在、標準のコンテナーがあるため、これが必要になることはめったにありませんが、新しい種類のコンテナーを実装する必要がある場合は、それが必要になります。

Question 8

それらが必要な場合があります：

私が取り組んでいるコードでは、アロケーターで明示的なデストラクタ呼び出しを使用しています。新しい配置を使用してメモリブロックをstlコンテナに返す単純なアロケーターを実装しています。破壊することで私は持っています：

  void destroy (pointer p) {
    // destroy objects by calling their destructor
    p->~T();
  }

構築中：

  void construct (pointer p, const T& value) {
    // initialize memory with placement new
    #undef new
    ::new((PVOID)p) T(value);
  }

プラットフォーム固有のallocおよびdeallocメカニズムを使用して、allocate（）で割り当てが行われ、deallocate（）でメモリの割り当てが解除されます。このアロケータは、ダグリアマロックをバイパスし、たとえばWindowsでLocalAllocを直接使用するために使用されました。

Question 9

私はこれを行う必要がある3つの機会を見つけました：

memory-mapped-ioまたは共有メモリによって作成されたメモリ内のオブジェクトの割り当て/割り当て解除
C ++を使用して特定のCインターフェイスを実装する場合（はい、残念ながら今日でもこれは発生します（変更するのに十分な影響力がないため））
アロケータクラスを実装する場合

Question 10

手動でデストラクタを呼び出す必要がある状況に遭遇したことはありません。Stroustrupでさえ、それは悪い習慣だと主張していることを覚えているようです。

Question 11

これはどうですか？
コンストラクタから例外がスローされた場合、デストラクタは呼び出されないため、例外の前にコンストラクタで作成されたハンドルを破棄するには、デストラクタを手動で呼び出す必要があります。

class MyClass {
  HANDLE h1,h2;
  public:
  MyClass() {
    // handles have to be created first
    h1=SomeAPIToCreateA();
    h2=SomeAPIToCreateB();        
    try {
      ...
      if(error) {
        throw MyException();
      }
    }
    catch(...) {
      this->~MyClass();
      throw;
    }
  }
  ~MyClass() {
    SomeAPIToDestroyA(h1);
    SomeAPIToDestroyB(h2);
  }
};

Question 12

デストラクタを手動で呼び出す必要がある別の例を見つけました。いくつかのタイプのデータの1つを保持するバリアントのようなクラスを実装したとします。

struct Variant {
    union {
        std::string str;
        int num;
        bool b;
    };
    enum Type { Str, Int, Bool } type;
};

場合はVariant、インスタンスを持っていたstd::string、そして今あなたが組合に異なるタイプを割り当てている、あなたは破壊しなければならないstd::string最初に。コンパイラはそれを自動的には行いません。

Question 13

デストラクタを呼び出すのが完全に合理的であると思う別の状況があります。

オブジェクトを初期状態に復元するための「リセット」タイプのメソッドを作成する場合、デストラクタを呼び出して、リセットされている古いデータを削除することは完全に合理的です。

class Widget
{
private: 
    char* pDataText { NULL  }; 
    int   idNumber  { 0     };

public:
    void Setup() { pDataText = new char[100]; }
    ~Widget()    { delete pDataText;          }

    void Reset()
    {
        Widget blankWidget;
        this->~Widget();     // Manually delete the current object using the dtor
        *this = blankObject; // Copy a blank object to the this-object.
    }
};