C++デストラクタ入門 使い方と呼ばれるタイミングを基礎から

#include <iostream>

class Buffer {
public:
    Buffer() { // コンストラクタ
        std::cout << "Buffer constructed\n";
        // 実際にはメモリ確保などの初期化を行うことがあります
    }

    ~Buffer() { // デストラクタ
        std::cout << "Buffer destructed\n";
        // ここでメモリやハンドルを解放します
    }
};

int main() {
    Buffer buf; // スコープを抜けると自動的にデストラクタが呼ばれます
    std::cout << "in main\n";
}

#include <iostream>

struct Tracer {
    const char* name;
    Tracer(const char* n) : name(n) { std::cout << "ctor: " << name << "\n"; }
    ~Tracer() { std::cout << "dtor: " << name << "\n"; }
};

int main() {
    std::cout << "enter main\n";
    {
        Tracer t("local");
        std::cout << "in block\n";
    } // ここでtのデストラクタが呼ばれる
    std::cout << "leave main\n";
}

#include <iostream>

struct Tracer {
    const char* name;
    Tracer(const char* n) : name(n) { std::cout << "ctor: " << name << "\n"; }
    ~Tracer() { std::cout << "dtor: " << name << "\n"; }
};

int main() {
    Tracer* p = new Tracer("heap");
    std::cout << "using heap object\n";
    delete p; // ここでデストラクタが呼ばれる
}

#include <iostream>

struct Tracer {
    const char* name;
    Tracer(const char* n) : name(n) { std::cout << "ctor: " << name << "\n"; }
    ~Tracer() { std::cout << "dtor: " << name << "\n"; }
};

Tracer g("global"); // 静的記憶域

int main() {
    std::cout << "main start\n";
    static Tracer s("function-static");
    std::cout << "main end\n";
}

#include <iostream>

struct T {
    int id;
    T(int i) : id(i) { std::cout << "T ctor " << id << "\n"; }
    ~T() { std::cout << "T dtor " << id << "\n"; }
};

struct Holder {
    T a; // 1番目に宣言
    T b; // 2番目に宣言
    Holder() : a(1), b(2) { std::cout << "Holder ctor\n"; }
    ~Holder() { std::cout << "Holder dtor\n"; }
};

int main() {
    Holder h; // a→b の順に構築、b→a の順に破棄
    std::cout << "--- array ---\n";
    T arr[3] = { T(10), T(11), T(12) }; // 10→11→12 の順に構築
    // スコープを抜けると 12→11→10 の順に破棄
}

#include <iostream>

struct Base {
    virtual ~Base() { std::cout << "Base dtor\n"; } // 仮想デストラクタ
};

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

int main() {
    Base* p = new Derived();
    delete p; // Derived→Base の順にデストラクタが呼ばれる
}

#include <iostream>
#include <stdexcept>

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

void work() {
    Guard g; // 例外でも確実に解放される
    std::cout << "do work\n";
    throw std::runtime_error("oops");
}

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

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

class FileGuard {
public:
    explicit FileGuard(const char* path, const char* mode)
        : fp_(std::fopen(path, mode)) {
        if (!fp_) {
            // ここで例外を投げると、コンストラクタ失敗になり、デストラクタは呼ばれません
            throw std::runtime_error("failed to open file");
        }
        std::cout << "opened: " << path << "\n";
    }

    ~FileGuard() noexcept { // 例外を投げない
        if (fp_) {
            std::fclose(fp_);
            std::cout << "closed file\n";
            fp_ = nullptr;
        }
    }

    // 書き込みヘルパ
    void writeLine(const char* s) {
        std::fprintf(fp_, "%s\n", s);
        std::cout << "wrote: " << s << "\n";
    }

    // コピー禁止(二重closeを防ぐ)
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;

private:
    std::FILE* fp_;
};

int main() {
    try {
        // スコープを抜ければ自動で閉じる
        FileGuard fg("sample.txt", "w");
        fg.writeLine("hello");
        fg.writeLine("world");
        std::cout << "done\n";
    } catch (const std::exception& e) {
        std::cout << "open failed: " << e.what() << "\n";
    }
}

#include <iostream>

struct Base {
    virtual ~Base() { std::cout << "Base dtor\n"; }
};

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

int main() {
    // new/delete の対応
    int* a = new int(42);
    delete a;         // OK

    Derived* arr = new Derived[2];
    delete[] arr;     // 配列は delete[] が必要

    // 多態 + virtual dtor
    Base* p = new Derived();
    delete p;         // Derived→Base の順で安全に破棄
}