間違えると危険!C++のnew[]とdelete[]で防ぐメモリリーク

// NG例: new[] と delete の混在は未定義動作
int main() {
    int* a = new int[10];
    // ... 何らかの処理 ...
    delete a; // ← 必ず delete[] にしなければならない
    return 0;
}

#include <iostream>

class Tracer {
public:
    Tracer() : id_(next_id_++) {
        std::cout << "Ctor: id=" << id_ << "\n";
    }
    ~Tracer() {
        std::cout << "Dtor: id=" << id_ << "\n";
    }
private:
    int id_;
    static int next_id_;
};

int Tracer::next_id_ = 0;

int main() {
    std::cout << "Allocate array\n";
    Tracer* arr = new Tracer[3]; // デフォルトコンストラクタが3回呼ばれる

    std::cout << "Delete array\n";
    delete[] arr; // デストラクタが逆順(2,1,0)で3回呼ばれる
    return 0;
}

#include <iostream>

int main() {
    const int n = 5;                      // 要素数
    int* a = new int[n];                  // new[] で確保

    // 配列に値を入れる
    for (int i = 0; i < n; ++i) {
        a[i] = i + 1;                     // 1,2,3,4,5
    }

    // 合計を計算
    int sum = 0;
    for (int i = 0; i < n; ++i) {
        sum += a[i];
    }

    std::cout << "sum = " << sum << "\n";

    // 忘れずに解放。配列は delete[] を使う
    delete[] a;
    a = nullptr;                          // ダングリング防止のために明示的に無効化
    return 0;
}

#include <iostream>
#include <string>

class Person {
public:
    Person() : name_("unknown") {
        std::cout << "Ctor: " << name_ << "\n";
    }
    ~Person() {
        std::cout << "Dtor: " << name_ << "\n";
    }
    void set_name(const std::string& n) { name_ = n; }
    const std::string& name() const { return name_; }
private:
    std::string name_;
};

int main() {
    const int n = 3;
    Person* people = new Person[n]; // 3人分のPersonがデフォルト構築される

    // 各要素を設定
    people[0].set_name("Alice");
    people[1].set_name("Bob");
    people[2].set_name("Carol");

    // 利用
    for (int i = 0; i < n; ++i) {
        std::cout << "Hello, " << people[i].name() << "!\n";
    }

    // 破棄。各要素のデストラクタが呼ばれる
    delete[] people;
    people = nullptr;
    return 0;
}

#include <iostream>

int main() {
    const int rows = 2;
    const int cols = 3;

    // 行ポインタの配列を確保
    int** mat = new int*[rows];

    // 各行を個別に確保(行ごとに delete[] が必要)
    for (int r = 0; r < rows; ++r) {
        mat[r] = new int[cols];
    }

    // 値を設定と表示
    for (int r = 0; r < rows; ++r) {
        for (int c = 0; c < cols; ++c) {
            mat[r][c] = r * 10 + c;
            std::cout << mat[r][c] << (c + 1 == cols ? '\n' : ' ');
        }
    }

    // 解放は「各行をdelete[]」→「行ポインタ配列をdelete[]」の順
    for (int r = 0; r < rows; ++r) {
        delete[] mat[r];
    }
    delete[] mat;
    mat = nullptr;
    return 0;
}

#include <iostream>

int main() {
    const int rows = 2;
    const int cols = 3;

    // 要素数 rows*cols の1次元配列として連続確保
    int* mat = new int[rows * cols];

    auto idx = [cols](int r, int c) { return r * cols + c; };

    for (int r = 0; r < rows; ++r) {
        for (int c = 0; c < cols; ++c) {
            mat[idx(r, c)] = r * 10 + c;
            std::cout << mat[idx(r, c)] << (c + 1 == cols ? '\n' : ' ');
        }
    }

    // 解放は1回だけ
    delete[] mat;
    mat = nullptr;
    return 0;
}

// NG: new[] に delete は対応しない
int* a = new int[10];
// ...
delete a; // 必ず delete[] a; にする

// NG: new に delete[] は対応しない
int* p = new int(42);
// ...
delete[] p; // 必ず delete p; にする

#include <string>

// NG例: 途中で return して delete[] が実行されない
char* read_line_or_null(bool ok) {
    char* buf = new char[1024];      // new[]
    if (!ok) {
        return nullptr;              // ← ここでリーク
    }
    // ... bufに読み込む処理 ...
    // 正常経路では解放していないのも問題
    return buf;                      // 呼び手が必ず delete[] する契約が必要
}

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int[]> a(new int[5]); // 例外や早期returnでも自動解放
    for (int i = 0; i < 5; ++i) a[i] = i;
    std::cout << a[4] << "\n";
    // スコープ末尾で自動的に delete[] が呼ばれる
    return 0;
}

#include <memory>

void process() {
    // RAIIで自動解放。配列は unique_ptr<T[]> を使う
    std::unique_ptr<char[]> buf(new char[1024]);
    // ... bufを使った処理 ...
} // スコープを抜けると自動で delete[] buf

// 手動管理の例: 失敗時でも必ず解放
int do_work_manual(bool ok) {
    int* data = new int[100];
    int result = -1;
    if (!ok) {
        result = 0;
        goto cleanup;                 // 例外がない環境での単純な対処
    }
    // ... 処理 ...
    result = 1;
cleanup:
    delete[] data;
    return result;
}