C++におけるRAIIとは何か？イディオムで安全なリソース管理を実践しよう

// 問題のあるコード例
void badExample()
{
    int* data = new int[1000];  // メモリを確保
    
    // 何らかの処理
    if (someCondition) 
    {
        return;  // ここでreturnするとメモリリークが発生！
    }
    
    // 例外が発生するとここに到達しない可能性
    processData(data);
    
    delete[] data;  // メモリを解放（実行されない場合がある）
}

#include <fstream>
#include <string>
#include <stdexcept>

class FileManager
{
private:
    std::ofstream file;

public:
    // コンストラクタでリソースを取得
    FileManager(const std::string& filename)
    {
        file.open(filename);
        if (!file.is_open()) 
        {
            throw std::runtime_error("ファイルを開けませんでした: " + filename);
        }
        std::cout << "ファイル " << filename << " を開きました" << std::endl;
    }
    
    // デストラクタで自動的にリソースを解放
    ~FileManager()
    {
        if (file.is_open()) 
        {
            file.close();
            std::cout << "ファイルを閉じました" << std::endl;
        }
    }
    
    // ファイルに書き込む機能
    void write(const std::string& text)
    {
        if (file.is_open()) 
        {
            file << text;
        }
    }
};

void useFileManager()
{
    try 
    {
        FileManager fm("output.txt");  // ここでファイルが開かれる
        
        fm.write("Hello, RAII!");
        fm.write("安全なリソース管理");
        
        // 何らかの処理...
        if (someErrorCondition) 
        {
            throw std::runtime_error("エラーが発生しました");
        }
        
        // スコープを出ると自動的にデストラクタが呼ばれ、
        // ファイルが確実に閉じられる
    }
    catch (const std::exception& e) 
    {
        std::cout << "エラー: " << e.what() << std::endl;
        // 例外が発生してもファイルは適切に閉じられる
    }
}

#include <memory>
#include <iostream>

class Player
{
private:
    std::string name;
    int level;

public:
    Player(const std::string& n, int lv) : name(n), level(lv)
    {
        std::cout << "プレイヤー " << name << " を作成しました" << std::endl;
    }
    
    ~Player()
    {
        std::cout << "プレイヤー " << name << " を削除しました" << std::endl;
    }
    
    void showInfo() const
    {
        std::cout << "名前: " << name << ", レベル: " << level << std::endl;
    }
};

void smartPointerExample()
{
    // RAIIによる安全なメモリ管理
    auto player = std::make_unique<Player>("勇者", 10);
    
    player->showInfo();
    
    // 条件によってはここでreturnすることもある
    if (someCondition) 
    {
        return;  // ここでもメモリは自動的に解放される
    }
    
    // スコープを出ると自動的にPlayerオブジェクトが削除される
    // delete を手動で呼ぶ必要がない！
}

#include <memory>
#include <vector>

class GameAsset
{
private:
    std::string assetName;

public:
    GameAsset(const std::string& name) : assetName(name)
    {
        std::cout << "アセット " << assetName << " を読み込みました" << std::endl;
    }
    
    ~GameAsset()
    {
        std::cout << "アセット " << assetName << " を解放しました" << std::endl;
    }
    
    const std::string& getName() const { return assetName; }
};

void sharedResourceExample()
{
    // 共有リソースの作成
    auto texture = std::make_shared<GameAsset>("player_texture.png");
    
    std::vector<std::shared_ptr<GameAsset>> assets;
    
    // 複数の場所で同じリソースを共有
    assets.push_back(texture);
    assets.push_back(texture);
    
    std::cout << "参照カウント: " << texture.use_count() << std::endl;  // 3が表示される
    
    // assetsベクターがスコープを出ると、参照カウントが減る
    // 最後の参照がなくなったときに自動的にリソースが解放される
}

#include <mutex>
#include <thread>
#include <iostream>

std::mutex mtx;
int sharedCounter = 0;

// RAIIを使った安全なロック管理
void safeIncrement()
{
    // std::lock_guardがRAIIパターンを実装している
    std::lock_guard<std::mutex> lock(mtx);  // ここでロックを取得
    
    // クリティカルセクション
    ++sharedCounter;
    std::cout << "カウンター: " << sharedCounter << std::endl;
    
    // 例外が発生してもここで自動的にロックが解除される
    if (sharedCounter > 10) 
    {
        throw std::runtime_error("カウンターが上限を超えました");
    }
    
    // スコープを出ると自動的にロックが解除される
}

class ResourceManager
{
public:
    ResourceManager(/* パラメータ */) { /* リソース取得 */ }
    ~ResourceManager() { /* リソース解放 */ }
    
    // コピーを禁止する（Rule of Five）
    ResourceManager(const ResourceManager&) = delete;
    ResourceManager& operator=(const ResourceManager&) = delete;
    
    // ムーブセマンティクスは許可する場合がある
    ResourceManager(ResourceManager&& other) noexcept 
    { 
        /* ムーブコンストラクタの実装 */ 
    }
    
    ResourceManager& operator=(ResourceManager&& other) noexcept 
    { 
        /* ムーブ代入演算子の実装 */ 
        return *this;
    }
};

class ExceptionSafeResource
{
private:
    Resource* resource;

public:
    ExceptionSafeResource()
    {
        try 
        {
            resource = acquireResource();
        }
        catch (...) 
        {
            // リソース取得に失敗した場合の処理
            resource = nullptr;
            throw;  // 例外を再スロー
        }
    }
    
    ~ExceptionSafeResource()
    {
        if (resource) 
        {
            releaseResource(resource);
        }
    }
};