【C++】スマートポインタ入門！unique_ptr, shared_ptr, weak_ptrを初心者にもわかりやすく解説

void problemExample()
{
    int* ptr = new int(42);
    // 何らかの処理...
    // delete ptr; を忘れると、メモリリークが発生
}

int* ptr = new int(42);
delete ptr;
delete ptr;  // エラー！同じメモリを2回削除

void riskyFunction()
{
    int* ptr = new int(42);
    someFunction();  // ここで例外が発生すると...
    delete ptr;      // この行に到達せず、メモリリーク
}

{
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    // ここでptrが作られ、メモリが確保される
    
    // 何らかの処理...
    
}  // ここでptrのデストラクタが呼ばれ、自動的にメモリが解放される

#include <memory>
#include <iostream>

int main()
{
    // unique_ptrの作成（推奨方法）
    auto ptr = std::make_unique<int>(42);
    
    // 値の確認
    std::cout << "値: " << *ptr << std::endl;  // 42
    
    // 自動的にメモリが解放される
    return 0;
}

#include <memory>
#include <iostream>

void processValue(std::unique_ptr<int> ptr)
{
    std::cout << "処理中の値: " << *ptr << std::endl;
    // 関数終了時に自動的にメモリが解放される
}

int main()
{
    auto ptr = std::make_unique<int>(42);
    
    // moveで所有権を移動
    processValue(std::move(ptr));
    
    // この時点でptrはnullptrになっている
    if (ptr == nullptr) 
    {
        std::cout << "所有権が移動しました" << std::endl;
    }
    
    return 0;
}

#include <memory>
#include <iostream>

int main()
{
    // 配列のunique_ptr
    auto array_ptr = std::make_unique<int[]>(5);
    
    // 配列の初期化
    for (int i = 0; i < 5; ++i) 
    {
        array_ptr[i] = i * 10;
    }
    
    // 配列の表示
    for (int i = 0; i < 5; ++i) 
    {
        std::cout << array_ptr[i] << " ";
    }
    std::cout << std::endl;
    
    // 自動的に配列が解放される
    return 0;
}

#include <memory>
#include <iostream>

int main()
{
    // shared_ptrの作成
    auto ptr1 = std::make_shared<int>(42);
    std::cout << "参照カウント: " << ptr1.use_count() << std::endl;  // 1
    
    {
        auto ptr2 = ptr1;  // コピー（参照カウント増加）
        std::cout << "参照カウント: " << ptr1.use_count() << std::endl;  // 2
        
        auto ptr3 = ptr1;  // さらにコピー
        std::cout << "参照カウント: " << ptr1.use_count() << std::endl;  // 3
        
    }  // ptr2, ptr3がスコープを抜ける
    
    std::cout << "参照カウント: " << ptr1.use_count() << std::endl;  // 1
    
    return 0;
}  // ptr1がスコープを抜けて、メモリが解放される

#include <memory>
#include <iostream>
#include <vector>

class Resource 
{
public:
    Resource(int id) : id_(id) 
    {
        std::cout << "Resource " << id_ << " が作成されました" << std::endl;
    }
    
    ~Resource() 
    {
        std::cout << "Resource " << id_ << " が削除されました" << std::endl;
    }
    
    void use() 
    {
        std::cout << "Resource " << id_ << " を使用中" << std::endl;
    }
    
private:
    int id_;
};

int main()
{
    std::vector<std::shared_ptr<Resource>> users;
    
    {
        auto resource = std::make_shared<Resource>(100);
        
        // 複数のユーザーが同じリソースを共有
        users.push_back(resource);
        users.push_back(resource);
        users.push_back(resource);
        
        std::cout << "参照カウント: " << resource.use_count() << std::endl;  // 4
        
    }  // resourceはスコープを抜けるが、まだ削除されない
    
    std::cout << "resourceはまだ生きています" << std::endl;
    
    // 各ユーザーがリソースを使用
    for (auto& user : users) 
    {
        user->use();
    }
    
    users.clear();  // 全てのユーザーがリソースを解放
    std::cout << "リソースが削除されました" << std::endl;
    
    return 0;
}

#include <memory>
#include <iostream>

class Node 
{
public:
    std::shared_ptr<Node> next;
    
    ~Node() 
    {
        std::cout << "Nodeが削除されました" << std::endl;
    }
};

int main()
{
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    
    // 循環参照を作成（これは問題！）
    node1->next = node2;
    node2->next = node1;
    
    // この状態では、メモリリークが発生する可能性がある
    return 0;
}

#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> weak;
    
    {
        auto shared = std::make_shared<int>(42);
        weak = shared;  // weak_ptrに代入
        
        std::cout << "shared参照カウント: " << shared.use_count() << std::endl;  // 1
        std::cout << "weakは有効: " << !weak.expired() << std::endl;  // true
        
    }  // sharedがスコープを抜ける → オブジェクトが削除される
    
    std::cout << "weakは有効: " << !weak.expired() << std::endl;  // false
    
    return 0;
}

#include <memory>
#include <iostream>

int main()
{
    auto shared = std::make_shared<int>(42);
    std::weak_ptr<int> weak = shared;
    
    // weak_ptrから安全にアクセス
    if (auto locked = weak.lock()) 
    {
        std::cout << "値: " << *locked << std::endl;  // 42
        std::cout << "参照カウント: " << locked.use_count() << std::endl;  // 2
    } 
    else 
    {
        std::cout << "オブジェクトは既に削除されています" << std::endl;
    }
    
    return 0;
}

#include <memory>
#include <iostream>

class Node 
{
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> parent;  // 親への参照はweak_ptrで
    int value;
    
    Node(int val) : value(val) 
    {
        std::cout << "Node(" << value << ") が作成されました" << std::endl;
    }
    
    ~Node() 
    {
        std::cout << "Node(" << value << ") が削除されました" << std::endl;
    }
    
    void printParent() 
    {
        if (auto p = parent.lock()) 
        {
            std::cout << "親ノードの値: " << p->value << std::endl;
        } 
        else 
        {
            std::cout << "親ノードはありません" << std::endl;
        }
    }
};

int main()
{
    auto parent = std::make_shared<Node>(1);
    auto child = std::make_shared<Node>(2);
    
    // 親から子への参照（shared_ptr）
    parent->next = child;
    
    // 子から親への参照（weak_ptr）
    child->parent = parent;
    
    child->printParent();  // 親ノードの値: 1
    
    return 0;
}  // 適切にメモリが解放される

// ファクトリー関数の例
std::unique_ptr<Database> createDatabase(const std::string& type)
{
    if (type == "sqlite") 
    {
        return std::make_unique<SQLiteDatabase>();
    } 
    else if (type == "mysql") 
    {
        return std::make_unique<MySQLDatabase>();
    }
    return nullptr;
}

class TextureManager 
{
private:
    std::map<std::string, std::shared_ptr<Texture>> textures_;
    
public:
    std::shared_ptr<Texture> getTexture(const std::string& filename) 
    {
        auto it = textures_.find(filename);
        if (it != textures_.end()) 
        {
            return it->second;  // 既存のテクスチャを共有
        }
        
        auto texture = std::make_shared<Texture>(filename);
        textures_[filename] = texture;
        return texture;
    }
};

class GameEngine 
{
private:
    std::unique_ptr<Renderer> renderer_;        // エンジンが単独所有
    std::shared_ptr<AudioSystem> audioSystem_; // 複数システムで共有
    std::weak_ptr<Scene> currentScene_;        // シーンへの弱参照

public:
    GameEngine() 
    {
        renderer_ = std::make_unique<Renderer>();
        audioSystem_ = std::make_shared<AudioSystem>();
    }
    
    void setCurrentScene(std::shared_ptr<Scene> scene) 
    {
        currentScene_ = scene;
    }
    
    void update() 
    {
        if (auto scene = currentScene_.lock()) 
        {
            scene->update();
        }
    }
};

// 推奨されない方法
std::unique_ptr<int> ptr(new int(42));

// 推奨される方法
auto ptr = std::make_unique<int>(42);

// 危険な使用方法
int* raw_ptr = new int(42);
std::shared_ptr<int> shared1(raw_ptr);
std::shared_ptr<int> shared2(raw_ptr);  // 二重削除のリスク！

// 安全な使用方法
auto shared1 = std::make_shared<int>(42);
auto shared2 = shared1;  // 適切なコピー