[C++] new演算子を使わず、スマートポインタでメモリ管理を行う

MyClass* obj = new MyClass();
// 何らかの処理
// delete obj; // 解放を忘れるとメモリリークが発生

MyClass* obj1 = new MyClass();
MyClass* obj2 = new MyClass();
// 何らかの処理
delete obj1; // obj1は解放されるが、obj2は解放されない可能性がある
// delete obj2; // これを忘れるとメモリリーク

try {
    MyClass* obj = new MyClass(); // メモリ確保
    // 何らかの処理
    throw std::runtime_error("エラー発生"); // 例外が発生
    delete obj; // ここには到達しないため、objは解放されない
} catch (const std::exception& e) {
    // エラーハンドリング
}

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ\n"; }
    ~MyClass() { std::cout << "MyClassのデストラクタ\n"; }
};
int main() {
    std::unique_ptr<MyClass> ptr1(new MyClass()); // MyClassのインスタンスを作成
    // std::unique_ptr<MyClass> ptr2 = ptr1; // エラー: コピーできない
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 所有権を移動
    return 0; // ptr2がスコープを抜けると自動的にメモリが解放される
}

MyClassのコンストラクタ
MyClassのデストラクタ

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ\n"; }
    ~MyClass() { std::cout << "MyClassのデストラクタ\n"; }
};
int main() {
    std::shared_ptr<MyClass> ptr1(new MyClass()); // MyClassのインスタンスを作成
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1を共有
        std::cout << "ptr2がスコープ内にあります\n";
    } // ptr2がスコープを抜けるが、ptr1がまだ存在するためメモリは解放されない
    return 0; // ptr1がスコープを抜けると自動的にメモリが解放される
}

MyClassのコンストラクタ
ptr2がスコープ内にあります
MyClassのデストラクタ

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ\n"; }
    ~MyClass() { std::cout << "MyClassのデストラクタ\n"; }
};
int main() {
    std::shared_ptr<MyClass> ptr1(new MyClass()); // MyClassのインスタンスを作成
    std::weak_ptr<MyClass> weakPtr = ptr1; // weakPtrはptr1を参照
    if (auto sharedPtr = weakPtr.lock()) { // weakPtrからshared_ptrを取得
        std::cout << "オブジェクトはまだ存在します\n";
    } else {
        std::cout << "オブジェクトは解放されています\n";
    }
    ptr1.reset(); // ptr1をリセットしてメモリを解放
    if (auto sharedPtr = weakPtr.lock()) {
        std::cout << "オブジェクトはまだ存在します\n";
    } else {
        std::cout << "オブジェクトは解放されています\n";
    }
    return 0;
}

MyClassのコンストラクタ
オブジェクトはまだ存在します
オブジェクトは解放されています
MyClassのデストラクタ

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ\n"; }
    ~MyClass() { std::cout << "MyClassのデストラクタ\n"; }
    void display() { std::cout << "MyClassのメソッド\n"; }
};
void createObject() {
    std::unique_ptr<MyClass> ptr(new MyClass()); // MyClassのインスタンスを作成
    ptr->display(); // メソッドを呼び出す
} // ptrがスコープを抜けると自動的にメモリが解放される
int main() {
    createObject(); // createObjectを呼び出す
    return 0;
}

MyClassのコンストラクタ
MyClassのメソッド
MyClassのデストラクタ

#include <iostream>
#include <memory>
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ\n"; }
    ~MyClass() { std::cout << "MyClassのデストラクタ\n"; }
    void display() { std::cout << "MyClassのメソッド\n"; }
};
void useObject(std::shared_ptr<MyClass> ptr) {
    ptr->display(); // メソッドを呼び出す
    std::cout << "参照カウント: " << ptr.use_count() << "\n"; // 参照カウントを表示
}
int main() {
    std::shared_ptr<MyClass> ptr1(new MyClass()); // MyClassのインスタンスを作成
    useObject(ptr1); // useObjectに渡す
    std::cout << "メイン関数の参照カウント: " << ptr1.use_count() << "\n"; // メイン関数の参照カウントを表示
    return 0; // ptr1がスコープを抜けると自動的にメモリが解放される
}

MyClassのコンストラクタ
MyClassのメソッド
参照カウント: 2
メイン関数の参照カウント: 1
MyClassのデストラクタ

#include <iostream>
#include <memory>
class Child; // 前方宣言
class Parent {
public:
    std::shared_ptr<Child> child; // 子オブジェクトへの共有ポインタ
    ~Parent() { std::cout << "Parentのデストラクタ\n"; }
};
class Child {
public:
    std::weak_ptr<Parent> parent; // 親オブジェクトへの弱いポインタ
    ~Child() { std::cout << "Childのデストラクタ\n"; }
};
int main() {
    std::shared_ptr<Parent> parentPtr(new Parent()); // 親オブジェクトを作成
    std::shared_ptr<Child> childPtr(new Child()); // 子オブジェクトを作成
    parentPtr->child = childPtr; // 親が子を持つ
    childPtr->parent = parentPtr; // 子が親を弱く参照する
    return 0; // 親と子のオブジェクトがスコープを抜けると自動的にメモリが解放される
}

Childのデストラクタ
Parentのデストラクタ

#include <iostream>
#include <memory>
void customDeleter(int* p) {
    std::cout << "カスタムデリータが呼ばれました\n";
    delete p; // メモリを解放
}
int main() {
    std::unique_ptr<int, decltype(&customDeleter)> ptr(new int(42), customDeleter);
    std::cout << "値: " << *ptr << "\n"; // 値を表示
    return 0; // ptrがスコープを抜けるとカスタムデリータが呼ばれる
}

値: 42
カスタムデリータが呼ばれました

#include <iostream>
#include <memory>
class Resource {
public:
    Resource() { std::cout << "リソースを取得しました\n"; }
    ~Resource() { std::cout << "リソースを解放しました\n"; }
};
int main() {
    {
        std::unique_ptr<Resource> resPtr(new Resource()); // RAIIによりリソースを管理
    } // resPtrがスコープを抜けると自動的にリソースが解放される
    return 0;
}

リソースを取得しました
リソースを解放しました

#include <iostream>
#include <memory>
#include <thread>
class MyClass {
public:
    void display() { std::cout << "MyClassのメソッド\n"; }
};
void threadFunction(std::shared_ptr<MyClass> ptr) {
    ptr->display(); // メソッドを呼び出す
}
int main() {
    std::shared_ptr<MyClass> sharedPtr(new MyClass()); // MyClassのインスタンスを作成
    std::thread t1(threadFunction, sharedPtr); // スレッド1を作成
    std::thread t2(threadFunction, sharedPtr); // スレッド2を作成
    t1.join(); // スレッド1の終了を待つ
    t2.join(); // スレッド2の終了を待つ
    return 0; // sharedPtrがスコープを抜けると自動的にメモリが解放される
}

MyClassのメソッド
MyClassのメソッド