C++デストラクタの使い方入門：オブジェクト破棄時の自動後片付けとRAIIの基礎・実例

class Widget {
public:
    Widget();              // コンストラクタ
    ~Widget() noexcept;    // デストラクタ（通常は noexcept 推奨）
};

#include <iostream>
#include <stdexcept>
#include <string>

struct Tracer {
    std::string name;
    Tracer(std::string n) : name(std::move(n)) {
        std::cout << "construct " << name << '\n';
    }
    ~Tracer() noexcept {
        std::cout << "destroy  " << name << '\n';
    }
};

void g() {
    Tracer inner{"inner"};
    // ここで例外を投げると、inner は必ず破棄されます
    throw std::runtime_error("boom");
}

void f() {
    Tracer outer{"outer"};
    {
        Tracer block{"block"};
    } // block はここで破棄
    g(); // ここで例外発生、outer は巻き戻しで破棄
}

int main() {
    try {
        f();
    } catch (const std::exception& e) {
        std::cout << "caught: " << e.what() << '\n';
    }
}

struct SafeCloser {
    ~SafeCloser() noexcept {
        try {
            // 失敗する可能性のある処理
            // 例: ネットワークへのフラッシュ、例外を投げうるAPI呼び出し
        } catch (...) {
            // ログのみ、または無視
        }
    }
};

#include <cstdio>
#include <stdexcept>
#include <string>
#include <iostream>

class File {
    std::FILE* fp_ = nullptr;

public:
    explicit File(const char* path, const char* mode) {
        fp_ = std::fopen(path, mode);
        if (!fp_) {
            throw std::runtime_error("failed to open file");
        }
    }

    ~File() noexcept {
        if (fp_) {
            std::fclose(fp_);
        }
    }

    // コピーは禁止（所有は一意）
    File(const File&) = delete;
    File& operator=(const File&) = delete;

    // ムーブは許可
    File(File&& other) noexcept : fp_(other.fp_) {
        other.fp_ = nullptr;
    }
    File& operator=(File&& other) noexcept {
        if (this != &other) {
            if (fp_) std::fclose(fp_);
            fp_ = other.fp_;
            other.fp_ = nullptr;
        }
        return *this;
    }

    void write_line(const std::string& s) {
        std::fputs(s.c_str(), fp_);
        std::fputc('\n', fp_);
        std::fflush(fp_); // 例外を投げないC API
    }
};

int main() {
    try {
        File f{"example.txt", "w"};
        f.write_line("hello");
        std::cout << "wrote a line\n";
    } catch (const std::exception& e) {
        std::cerr << "error: " << e.what() << '\n';
    }
}

#include <memory>
#include <iostream>

struct Tracked {
    ~Tracked() noexcept { std::cout << "~Tracked\n"; }
};

struct HandleCloser {
    void operator()(int* p) const noexcept {
        std::cout << "closing handle " << *p << '\n';
        delete p;
    }
};

int main() {
    {
        std::unique_ptr<Tracked> p = std::make_unique<Tracked>();
        // スコープ終了で ~Tracked が呼ばれる
    }
    {
        std::unique_ptr<int, HandleCloser> h{new int{42}};
        // スコープ終了で HandleCloser が呼ばれる
    }
}

#include <mutex>
#include <thread>
#include <vector>
#include <iostream>

int main() {
    std::mutex m;
    int counter = 0;

    auto worker = [&] {
        for (int i = 0; i < 10000; ++i) {
            std::lock_guard<std::mutex> lg(m); // ここでロック
            ++counter;                          // スコープを抜けるとアンロック
        }
    };

    std::thread t1(worker);
    std::thread t2(worker);
    t1.join(); t2.join();
    std::cout << "counter=" << counter << '\n';
}

#include <mutex>
#include <chrono>

void example(std::mutex& m) {
    std::unique_lock<std::mutex> lk(m, std::defer_lock); // まだロックしない
    if (lk.try_lock_for(std::chrono::milliseconds(10))) {
        // ロック成功時の処理
    } // スコープ終了でアンロック（ロック済みなら）
}

#include <iostream>

struct Base {
    virtual ~Base() noexcept { std::cout << "~Base\n"; }
    // 仮想関数が1つでもあれば、デストラクタも仮想にしておくのが安全です。
};

struct Derived : Base {
    ~Derived() noexcept { std::cout << "~Derived\n"; }
};

int main() {
    Base* p = new Derived;
    delete p; // ~Derived → ~Base の順に呼ばれる
}

struct A { ~A() noexcept; };
struct B { ~B() noexcept; };

struct C {
    A a; // 先に構築、後に破棄
    B b; // 後に構築、先に破棄
    // 破棄順は b → a
};

#include <string>

const std::string& global_resource() {
    static const std::string r = "initialized on first use";
    return r; // 破棄はプログラム終了時に自動、順序問題の影響を受けにくい
}

#include <memory>
#include <iostream>

struct Node {
    std::string name;
    std::shared_ptr<Node> strong_next; // 注意: 強参照
    std::weak_ptr<Node>   weak_prev;   // 弱参照で循環を断つ
    Node(std::string n) : name(std::move(n)) {}
    ~Node() noexcept { std::cout << "~Node " << name << '\n'; }
};

int main() {
    auto a = std::make_shared<Node>("A");
    auto b = std::make_shared<Node>("B");

    a->strong_next = b; // A → B
    b->weak_prev   = a; // B ⇐(weak) A

    // スコープを抜けると A, B ともに破棄可能
}

#include <iostream>
#include <cstdlib>

struct Guard {
    ~Guard() noexcept { std::cout << "~Guard\n"; }
};

int main() {
    Guard g;
    std::cout << "before exit\n";
    std::exit(0); // ここで戻らない。g のデストラクタは呼ばれない
}

#include <memory>
#include <iostream>

int main() {
    // 配列の安全な所有
    std::unique_ptr<int[]> arr{new int[10]};
    arr[0] = 123;
    std::cout << arr[0] << '\n'; // スコープ終了で自動 delete[]
}