[C++] デストラクタを明示的に呼び出す方法

#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "コンストラクタが呼ばれました" << std::endl;
    }
    ~MyClass() {
        std::cout << "デストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    MyClass obj; // スタック上のオブジェクト
    obj.~MyClass(); // 明示的にデストラクタを呼び出す
    return 0;
}

コンストラクタが呼ばれました
デストラクタが呼ばれました

#include <iostream>
class StackObject {
public:
    StackObject() {
        std::cout << "スタックオブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~StackObject() {
        std::cout << "スタックオブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    StackObject obj; // スタック上のオブジェクト
    obj.~StackObject(); // 明示的にデストラクタを呼び出す
    return 0;
}

スタックオブジェクトのコンストラクタが呼ばれました
スタックオブジェクトのデストラクタが呼ばれました

#include <iostream>
class HeapObject {
public:
    HeapObject() {
        std::cout << "ヒープオブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~HeapObject() {
        std::cout << "ヒープオブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    HeapObject* obj = new HeapObject(); // ヒープ上のオブジェクト
    obj->~HeapObject(); // 明示的にデストラクタを呼び出す
    delete obj; // メモリを解放
    return 0;
}

ヒープオブジェクトのコンストラクタが呼ばれました
ヒープオブジェクトのデストラクタが呼ばれました

#include <iostream>
#include <memory>
class SmartPointerObject {
public:
    SmartPointerObject() {
        std::cout << "スマートポインタオブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~SmartPointerObject() {
        std::cout << "スマートポインタオブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    std::unique_ptr<SmartPointerObject> obj = std::make_unique<SmartPointerObject>();
    obj->~SmartPointerObject(); // 明示的にデストラクタを呼び出す
    // objは自動的に解放されるため、deleteは不要
    return 0;
}

スマートポインタオブジェクトのコンストラクタが呼ばれました
スマートポインタオブジェクトのデストラクタが呼ばれました

#include <iostream>
class DoubleFreeObject {
public:
    DoubleFreeObject() {
        std::cout << "ダブルフリーオブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~DoubleFreeObject() {
        std::cout << "ダブルフリーオブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    DoubleFreeObject* obj = new DoubleFreeObject(); // ヒープ上のオブジェクト
    obj->~DoubleFreeObject(); // 明示的にデストラクタを呼び出す
    delete obj; // 再度解放しようとする
    return 0;
}

ダブルフリーオブジェクトのコンストラクタが呼ばれました
ダブルフリーオブジェクトのデストラクタが呼ばれました

#include <iostream>
class MemoryLeakObject {
public:
    MemoryLeakObject() {
        std::cout << "メモリリークオブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~MemoryLeakObject() {
        std::cout << "メモリリークオブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    MemoryLeakObject* obj = new MemoryLeakObject(); // ヒープ上のオブジェクト
    obj->~MemoryLeakObject(); // 明示的にデストラクタを呼び出す
    // delete obj; // これを忘れるとメモリリークが発生する
    return 0;
}

メモリリークオブジェクトのコンストラクタが呼ばれました
メモリリークオブジェクトのデストラクタが呼ばれました

#include <iostream>
class UndefinedBehaviorObject {
public:
    UndefinedBehaviorObject() {
        std::cout << "未定義動作オブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~UndefinedBehaviorObject() {
        std::cout << "未定義動作オブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    UndefinedBehaviorObject* obj = new UndefinedBehaviorObject(); // ヒープ上のオブジェクト
    obj->~UndefinedBehaviorObject(); // 明示的にデストラクタを呼び出す
    // obj->someMethod(); // ここで未定義動作が発生する可能性がある
    return 0;
}

未定義動作オブジェクトのコンストラクタが呼ばれました
未定義動作オブジェクトのデストラクタが呼ばれました

#include <iostream>
#include <fstream>
class FileManager {
private:
    std::fstream file;
public:
    FileManager(const std::string& filename) {
        file.open(filename, std::ios::out);
        std::cout << "ファイルをオープンしました: " << filename << std::endl;
    }
    ~FileManager() {
        if (file.is_open()) {
            file.close();
            std::cout << "ファイルをクローズしました" << std::endl;
        }
    }
};
int main() {
    FileManager fm("example.txt"); // ファイルをオープン
    fm.~FileManager(); // 明示的にデストラクタを呼び出す
    return 0;
}

ファイルをオープンしました: example.txt
ファイルをクローズしました

#include <iostream>
#include <vector>
class PoolObject {
public:
    PoolObject() {
        std::cout << "プールオブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~PoolObject() {
        std::cout << "プールオブジェクトのデストラクタが呼ばれました" << std::endl;
    }
};
class ObjectPool {
private:
    std::vector<PoolObject*> pool;
public:
    PoolObject* acquire() {
        PoolObject* obj = new PoolObject();
        pool.push_back(obj);
        return obj;
    }
    void release(PoolObject* obj) {
        obj->~PoolObject(); // 明示的にデストラクタを呼び出す
        // プールからオブジェクトを削除する処理を追加することも可能
    }
};
int main() {
    ObjectPool pool;
    PoolObject* obj = pool.acquire(); // オブジェクトを取得
    pool.release(obj); // オブジェクトを解放
    return 0;
}

プールオブジェクトのコンストラクタが呼ばれました
プールオブジェクトのデストラクタが呼ばれました

#include <iostream>
class ReusableObject {
public:
    ReusableObject() {
        std::cout << "再利用可能オブジェクトのコンストラクタが呼ばれました" << std::endl;
    }
    ~ReusableObject() {
        std::cout << "再利用可能オブジェクトのデストラクタが呼ばれました" << std::endl;
    }
    void reset() {
        std::cout << "オブジェクトをリセットしました" << std::endl;
    }
};
int main() {
    ReusableObject* obj = new ReusableObject(); // オブジェクトを生成
    obj->reset(); // オブジェクトをリセット
    obj->~ReusableObject(); // 明示的にデストラクタを呼び出す
    new (obj) ReusableObject(); // 再利用のために新しいオブジェクトを配置
    delete obj; // 最後に解放
    return 0;
}

再利用可能オブジェクトのコンストラクタが呼ばれました
オブジェクトをリセットしました
再利用可能オブジェクトのデストラクタが呼ばれました
再利用可能オブジェクトのコンストラクタが呼ばれました