C++のメモリ管理入門：malloc/freeの代わりにnew/deleteを使う方法【違い・使い分け・注意点】

#include <iostream>
#include <memory>

struct Point {
    int x;
    // コンストラクタで初期化
    explicit Point(int v) : x(v) {
        std::cout << "Point ctor: x=" << x << "\n";
    }
    ~Point() {
        std::cout << "Point dtor: x=" << x << "\n";
    }
};

int main() {
    // newでオブジェクトを生成（コンストラクタが呼ばれる）
    Point* p = new Point(42);

    std::cout << p->x << "\n"; // 利用

    // deleteで解放（デストラクタが呼ばれる）
    delete p;
    p = nullptr; // ダングリング対策としてヌルクリア
}

#include <iostream>

struct Logger {
    ~Logger(){ std::cout << "Logger destroyed\n"; }
};

int main() {
    Logger* lg = new Logger();

    // ここでlgを使い切ったと判断できるタイミングで解放する
    delete lg;
    lg = nullptr; // 二重解放や誤用の予防

    // if (lg) delete lg; // こうした冗長なガードはnullptr化があれば不要
}

#include <iostream>
#include <stdexcept>

struct Widget {
    Widget(){ std::cout << "Widget constructed\n"; }
    ~Widget(){ std::cout << "Widget destroyed\n"; }
};

void risky() {
    Widget* w = new Widget();
    // ここで例外が発生すると、deleteに到達しない
    throw std::runtime_error("oops");
    delete w; // 実行されない
}

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

#include <iostream>
#include <memory>
#include <stdexcept>

struct Widget {
    Widget(){ std::cout << "Widget constructed\n"; }
    ~Widget(){ std::cout << "Widget destroyed\n"; }
};

void safe() {
    auto w = std::make_unique<Widget>(); // スコープを抜ければ自動で破棄
    throw std::runtime_error("oops");
}

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

#include <iostream>

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

int main() {
    Tracer* arr = new Tracer[3]; // 配列のコンストラクタが3回呼ばれる

    // 正しい解放
    delete[] arr; // 各要素のデストラクタが3回呼ばれる

    // 誤り例（実行しないこと）:
    // Tracer* arr2 = new Tracer[3];
    // delete arr2; // 未定義動作：一部しか破棄されない可能性
}

#include <iostream>
#include <vector>

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

int main() {
    // トリビアルなint配列
    int* a = new int[3]{1,2,3}; // 値初期化が行われる（初期化リスト使用）
    std::cout << a[0] << "," << a[1] << "," << a[2] << "\n";
    delete[] a;

    // 非トリビアルな型の配列
    NonTrivial* b = new NonTrivial[3]; // デフォルト引数で3回コンストラクト
    delete[] b; // 3回デストラクト
}

#include <iostream>
#include <new>
#include <limits>

int main() {
    try {
        // 失敗しやすい極端なサイズで例
        std::size_t huge = std::numeric_limits<std::size_t>::max();
        int* p = new int[huge]; // ほぼ確実にbad_alloc
        delete[] p; // 到達しない想定
    } catch (const std::bad_alloc& e) {
        std::cout << "bad_alloc caught: " << e.what() << "\n";
    }

    // 例外を使わない方針
    int* q = new (std::nothrow) int[10'000'000'000ull]; // 失敗時nullptr
    if (!q) {
        std::cout << "allocation failed, got nullptr\n";
    } else {
        delete[] q;
    }
}

#include <cstdlib>
#include <iostream>
#include <memory>

// C APIを模した: mallocで確保、freeで解放を要求
void* c_api_get_buffer(std::size_t n) {
    return std::malloc(n);
}

// freeを呼ぶデリータ
struct FreeDeleter {
    void operator()(void* p) const noexcept {
        std::free(p);
        std::cout << "freed by free\n";
    }
};

int main() {
    // unique_ptrでCのバッファを安全に管理
    std::unique_ptr<void, FreeDeleter> buf(c_api_get_buffer(128));
    if (!buf) {
        std::cerr << "allocation failed\n";
        return 1;
    }
    std::cout << "buffer acquired\n";
    // スコープを抜けると自動でfree
}

// 危険: ダングリングの例（実行しないこと）
int* raw = nullptr;
{
    auto up = std::make_unique<int>(10);
    raw = up.get();
} // upが破棄、rawはダングリング
// *raw = 5; // 未定義動作

// 対策: 所有権を共有するならshared_ptrを使う
// auto sp = std::make_shared<int>(10);
// int* alias = sp.get(); // spの寿命中のみ有効

#include <iostream>
#include <cstdint>

struct alignas(64) CacheLine {
    char data[64];
};

int main() {
    CacheLine* p = new CacheLine; // C++17以降は64バイト境界に整列が保証
    std::uintptr_t addr = reinterpret_cast<std::uintptr_t>(p);
    std::cout << "addr % 64 = " << (addr % 64) << "\n";
    delete p;
}

#include <iostream>
#include <memory>

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

int main() {
    auto up = std::make_unique<Obj>();  // 例外安全、最小オーバーヘッド
    {
        auto sp = std::make_shared<Obj>(); // 複数箇所で共有可能
        auto sp2 = sp; // 参照カウント+1
        std::cout << "shared owners present\n";
    } // sp, sp2がスコープアウトしても、最後の所有者が消えるまで存続
}

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int[]> arr(new int[3]{1,2,3}); // または std::make_unique<int[]>(3)
    std::cout << arr[0] << "," << arr[1] << "," << arr[2] << "\n";
} // 自動でdelete[]

#include <memory>
#include <string>

struct Connection {
    explicit Connection(std::string url) : url_(std::move(url)) {}
    // ...
private:
    std::string url_;
};

// 工場関数：所有権はunique_ptrで返す
std::unique_ptr<Connection> make_connection(std::string url) {
    return std::make_unique<Connection>(std::move(url));
}

int main() {
    auto conn = make_connection("https://example.com");
    // connがスコープを抜ければ自動で解放
}