C++のnewとdelete完全理解 メモリの確保と解放を解説

#include <iostream>

int main() {
    // 単一のintを動的確保し、値を設定
    int* p = new int(42); // 値42で初期化
    std::cout << "pのアドレス: " << p << ", 値: " << *p << '\n';

    // 後始末
    delete p;             // メモリを解放
    p = nullptr;          // ダングリングポインタ防止

    // nullptrは解放済みを表し、デリファレンスしてはいけない
    if (p == nullptr) {
        std::cout << "pはnullptrです\n";
    }
    return 0;
}

#include <iostream>
#include <cstdlib>  // malloc, free
#include <new>      // 例外型の宣言用

class Widget {
public:
    Widget() : x(123) { std::cout << "Widget::ctor, x=" << x << '\n'; }
    ~Widget() { std::cout << "Widget::dtor\n"; }
private:
    int x;
};

int main() {
    // new/delete: コンストラクタ/デストラクタが呼ばれる
    Widget* w1 = new Widget();
    delete w1;

    // malloc/free: コンストラクタは呼ばれない
    void* raw = std::malloc(sizeof(Widget));
    if (!raw) {
        std::cerr << "malloc失敗\n";
        return 1;
    }
    std::cout << "mallocで確保しただけ: コンストラクタは未呼び出し\n";

    // 注意: 以下は未定義動作の例なので実行しないこと
    // Widget* w2 = static_cast<Widget*>(raw); // オブジェクト未構築
    // delete w2;                              // mallocとdeleteの混用はNG

    std::free(raw); // mallocしたものはfreeする
    return 0;
}

#include <iostream>

int main() {
    int* p = nullptr;    // 安全な初期化
    delete p;            // nullptrへのdeleteは安全(何もしない)
    std::cout << "nullptrをdeleteしても安全です\n";

    p = new int(7);
    delete p;            // 解放
    p = nullptr;         // ダングリング防止
    delete p;            // 再deleteも安全
    std::cout << "解放後にnullptr代入→再deleteも安全\n";
}

#include <iostream>

void leaky(bool earlyReturn) {
    std::cout << "[leaky] start\n";
    int* p = new int(10);     // 確保
    if (earlyReturn) {
        std::cout << "[leaky] 途中でreturn。deleteを忘れてリーク!\n";
        return;               // delete p; を忘れている
    }
    // ... 他の処理 ...
    delete p;                 // ここまで来れば解放
    std::cout << "[leaky] end\n";
}

void fixed(bool earlyReturn) {
    std::cout << "[fixed] start\n";
    int* p = new int(10);
    if (earlyReturn) {
        delete p;             // 早期return前に必ず解放
        std::cout << "[fixed] 途中でreturn。delete済み\n";
        return;
    }
    delete p;
    std::cout << "[fixed] end\n";
}

int main() {
    leaky(true);   // リークする経路
    fixed(true);   // 解放する経路
}

// 典型パターン
delete p;
p = nullptr;
delete p; // 2回目でも安全(nullなので何もしない)

#include <iostream>
#include <new> // std::bad_alloc

int main() {
    try {
        int* p = new int(99);             // 通常は成功
        std::cout << "new成功: " << *p << '\n';
        delete p;
    } catch (const std::bad_alloc& e) {
        std::cerr << "new失敗: " << e.what() << '\n';
    }
}

#include <iostream>
#include <new> // std::nothrow

int main() {
    int* q = new (std::nothrow) int(123); // 失敗時はnullptr
    if (!q) {
        std::cerr << "nothrow版: 確保失敗でnullptr\n";
        return 1;
    }
    std::cout << "nothrow版: 確保成功: " << *q << '\n';
    delete q;
}

#include <iostream>
#include <stdexcept>

class Holder {
public:
    Holder() : p(new int(42)) { std::cout << "Holder() でnew\n"; }
    ~Holder() { std::cout << "~Holder() でdelete\n"; delete p; }
    int value() const { return *p; }
private:
    int* p;
};

void mayThrow(bool doThrow) {
    Holder h; // スタックに生成。例外時も必ずデストラクタが走る
    std::cout << "値: " << h.value() << '\n';
    if (doThrow) {
        std::cout << "例外を投げます\n";
        throw std::runtime_error("oops");
    }
    std::cout << "正常終了\n";
}

int main() {
    try {
        mayThrow(true);  // 例外を投げる経路
    } catch (const std::exception& e) {
        std::cout << "catch: " << e.what() << '\n';
    }
}

#include <iostream>

class NumberBox {
public:
    explicit NumberBox(int v) : ptr(new int(v)) {
        std::cout << "NumberBox: newで" << v << '\n';
    }
    ~NumberBox() {
        std::cout << "NumberBox: delete\n";
        delete ptr;
    }
    int get() const { return *ptr; }
private:
    int* ptr;
};

int main() {
    NumberBox box(7);            // スコープを抜けると自動でdelete
    std::cout << "中身: " << box.get() << '\n';
}

#include <iostream>

int* createInt(int v) {               // 所有権を呼び出し側に移譲
    return new int(v);
}

void printInt(const int* p) {         // 所有権は受け取らない(解放しない)
    if (p) std::cout << "値: " << *p << '\n';
}

void takeOwnership(int* p) {          // 所有権を受け取り、ここで解放
    std::cout << "takeOwnership: " << *p << '\n';
    delete p;                         // 以後呼び出し側は使わない約束
}

int main() {
    int* a = createInt(10);           // aの所有権はmain
    printInt(a);                      // 使うだけ
    delete a;                         // mainで解放

    int* b = createInt(20);           // bの所有権を関数に移譲
    takeOwnership(b);
    b = nullptr;                      // ダングリング防止(以後使わない)
}

#include <iostream>

void localized() {
    std::cout << "localized開始\n";
    int* p = new int(5);           // new
    std::cout << "値: " << *p << '\n';
    delete p;                      // deleteを近くに置く
    p = nullptr;                   // 明示的に無効化
    std::cout << "localized終了\n";
}

// 悪い例: newとdeleteが離れて見失う(説明のためコメントのみ)
void antiPattern() {
    // int* p = new int(5);
    // if (条件) return;    // 早期returnでdelete漏れの危険
    // ...                  // 複雑なロジックの後
    // delete p;
}

int main() {
    localized();
}