C++のRAIIとスマートポインタを使ったデザインパターンの完全ガイド

#include <mutex>

std::mutex mtx;

void safeFunction() {
    std::lock_guard<std::mutex> lock(mtx);
    // クリティカルセクションのコード
} // スコープを抜けると自動的にロックが解放される

#include <memory>
#include <iostream>

void useSmartPointers() {
    // unique_ptrの使用例
    std::unique_ptr<int> uniquePtr(new int(10));
    std::cout << "unique_ptr: " << *uniquePtr << std::endl;

    // shared_ptrの使用例
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(20);
    std::shared_ptr<int> sharedPtr2 = sharedPtr1;
    std::cout << "shared_ptr1: " << *sharedPtr1 << ", shared_ptr2: " << *sharedPtr2 << std::endl;

    // weak_ptrの使用例
    std::weak_ptr<int> weakPtr = sharedPtr1;
    if (auto tempPtr = weakPtr.lock()) {
        std::cout << "weak_ptr: " << *tempPtr << std::endl;
    } else {
        std::cout << "weak_ptr: リソースが解放されています" << std::endl;
    }
}

#include <iostream>
#include <memory>

void useUniquePtr() {
    // unique_ptrの作成
    std::unique_ptr<int> uniquePtr(new int(100));
    std::cout << "Value: " << *uniquePtr << std::endl;

    // 所有権の移動
    std::unique_ptr<int> movedPtr = std::move(uniquePtr);
    if (!uniquePtr) {
        std::cout << "uniquePtrは空です" << std::endl;
    }
    std::cout << "Moved Value: " << *movedPtr << std::endl;
}

#include <iostream>
#include <memory>

void transferOwnership() {
    std::unique_ptr<int> sourcePtr(new int(42));
    std::unique_ptr<int> destinationPtr = std::move(sourcePtr);

    if (!sourcePtr) {
        std::cout << "sourcePtrは所有権を失いました" << std::endl;
    }
    std::cout << "destinationPtrの値: " << *destinationPtr << std::endl;
}

#include <iostream>
#include <memory>

struct CustomDeleter {
    void operator()(int* ptr) const {
        std::cout << "カスタムデリータが呼び出されました" << std::endl;
        delete ptr;
    }
};

void useCustomDeleter() {
    std::unique_ptr<int, CustomDeleter> customPtr(new int(123), CustomDeleter());
    std::cout << "Value: " << *customPtr << std::endl;
}

#include <iostream>
#include <memory>

void useSharedPtr() {
    // shared_ptrの作成
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(200);
    std::cout << "Value: " << *sharedPtr1 << std::endl;

    // 共有
    std::shared_ptr<int> sharedPtr2 = sharedPtr1;
    std::cout << "Shared Value: " << *sharedPtr2 << std::endl;
    std::cout << "Use count: " << sharedPtr1.use_count() << std::endl;
}

#include <iostream>
#include <memory>

void referenceCountingExample() {
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(300);
    std::cout << "Use count after creation: " << sharedPtr1.use_count() << std::endl;

    {
        std::shared_ptr<int> sharedPtr2 = sharedPtr1;
        std::cout << "Use count after sharedPtr2: " << sharedPtr1.use_count() << std::endl;
    } // sharedPtr2がスコープを抜けると、use_countが減少

    std::cout << "Use count after sharedPtr2 out of scope: " << sharedPtr1.use_count() << std::endl;
}

#include <iostream>
#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node destroyed" << std::endl; }
};

void circularReference() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->next = node1; // 循環参照が発生

    // node1とnode2がスコープを抜けても、循環参照によりリソースが解放されない
}

#include <iostream>
#include <memory>

void useWeakPtr() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(400);
    std::weak_ptr<int> weakPtr = sharedPtr;

    std::cout << "Use count: " << sharedPtr.use_count() << std::endl;

    if (auto tempPtr = weakPtr.lock()) {
        std::cout << "Weak Pointer Value: " << *tempPtr << std::endl;
    } else {
        std::cout << "リソースが解放されています" << std::endl;
    }
}

#include <iostream>
#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // 弱ポインタで循環参照を防止
    ~Node() { std::cout << "Node destroyed" << std::endl; }
};

void preventCircularReference() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->prev = node1; // 循環参照を防止するためにweak_ptrを使用

    // node1とnode2がスコープを抜けると、リソースが正しく解放される
}

#include <iostream>
#include <memory>

class Observer {
public:
    virtual void notify() = 0;
};

class Subject {
    std::vector<std::weak_ptr<Observer>> observers;
public:
    void addObserver(const std::shared_ptr<Observer>& observer) {
        observers.push_back(observer);
    }

    void notifyObservers() {
        for (auto it = observers.begin(); it != observers.end();) {
            if (auto obs = it->lock()) {
                obs->notify();
                ++it;
            } else {
                it = observers.erase(it); // 解放されたオブジェクトを削除
            }
        }
    }
};

class ConcreteObserver : public Observer, public std::enable_shared_from_this<ConcreteObserver> {
public:
    void notify() override {
        std::cout << "Observer notified" << std::endl;
    }
};

void observerPatternExample() {
    auto subject = std::make_shared<Subject>();
    auto observer = std::make_shared<ConcreteObserver>();

    subject->addObserver(observer);
    subject->notifyObservers();

    observer.reset();
    subject->notifyObservers(); // Observerは解放されているため通知されない
}

#include <iostream>
#include <fstream>
#include <memory>

class FileManager {
public:
    FileManager(const std::string& filename) : file(std::make_unique<std::ifstream>(filename)) {
        if (!file->is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }

    void readFile() {
        std::string line;
        while (std::getline(*file, line)) {
            std::cout << line << std::endl;
        }
    }

private:
    std::unique_ptr<std::ifstream> file;
};

void useFileManager() {
    try {
        FileManager fileManager("example.txt");
        fileManager.readFile();
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

#include <iostream>
#include <memory>

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& dbUri) {
        // データベース接続を確立する（擬似コード）
        std::cout << "Connecting to database: " << dbUri << std::endl;
    }

    ~DatabaseConnection() {
        // データベース接続を閉じる（擬似コード）
        std::cout << "Disconnecting from database" << std::endl;
    }

    void executeQuery(const std::string& query) {
        // クエリを実行する（擬似コード）
        std::cout << "Executing query: " << query << std::endl;
    }
};

void useDatabase() {
    std::shared_ptr<DatabaseConnection> dbConn = std::make_shared<DatabaseConnection>("db://example");
    dbConn->executeQuery("SELECT * FROM users");
    // dbConnがスコープを抜けると、自動的にデータベース接続が閉じられる
}

#include <iostream>
#include <memory>
#include <mutex>

class Singleton {
public:
    // シングルトンインスタンスを取得するための静的メソッド
    static std::shared_ptr<Singleton> getInstance() {
        std::call_once(initInstanceFlag, &Singleton::initSingleton);
        return instance;
    }

    void showMessage() {
        std::cout << "Singleton instance at work!" << std::endl;
    }

private:
    Singleton() {
        std::cout << "Singleton Constructor" << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton Destructor" << std::endl;
    }

    // インスタンスの初期化を行う静的メソッド
    static void initSingleton() {
        instance.reset(new Singleton());
    }

    // シングルトンインスタンスを保持する静的メンバ変数
    static std::shared_ptr<Singleton> instance;
    static std::once_flag initInstanceFlag;
};

// 静的メンバ変数の定義
std::shared_ptr<Singleton> Singleton::instance = nullptr;
std::once_flag Singleton::initInstanceFlag;

void useSingleton() {
    std::shared_ptr<Singleton> singletonInstance = Singleton::getInstance();
    singletonInstance->showMessage();
}

#include <iostream>
#include <memory>

// 抽象製品クラス
class Product {
public:
    virtual void use() const = 0;
    virtual ~Product() = default;
};

// 具体製品クラスA
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

// 具体製品クラスB
class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

// ファクトリークラス
class Factory {
public:
    enum class ProductType { TypeA, TypeB };

    static std::unique_ptr<Product> createProduct(ProductType type) {
        switch (type) {
            case ProductType::TypeA:
                return std::make_unique<ConcreteProductA>();
            case ProductType::TypeB:
                return std::make_unique<ConcreteProductB>();
            default:
                throw std::invalid_argument("Unknown ProductType");
        }
    }
};

void useFactory() {
    auto productA = Factory::createProduct(Factory::ProductType::TypeA);
    productA->use();

    auto productB = Factory::createProduct(Factory::ProductType::TypeB);
    productB->use();
}

#include <iostream>
#include <memory>

// プロトタイプの抽象クラス
class Prototype {
public:
    virtual std::unique_ptr<Prototype> clone() const = 0;
    virtual void use() const = 0;
    virtual ~Prototype() = default;
};

// 具体的なプロトタイプクラスA
class ConcretePrototypeA : public Prototype {
public:
    ConcretePrototypeA(int value) : value_(value) {}

    std::unique_ptr<Prototype> clone() const override {
        return std::make_unique<ConcretePrototypeA>(*this);
    }

    void use() const override {
        std::cout << "Using ConcretePrototypeA with value: " << value_ << std::endl;
    }

private:
    int value_;
};

// 具体的なプロトタイプクラスB
class ConcretePrototypeB : public Prototype {
public:
    ConcretePrototypeB(std::string text) : text_(text) {}

    std::unique_ptr<Prototype> clone() const override {
        return std::make_unique<ConcretePrototypeB>(*this);
    }

    void use() const override {
        std::cout << "Using ConcretePrototypeB with text: " << text_ << std::endl;
    }

private:
    std::string text_;
};

void usePrototypes() {
    // プロトタイプのインスタンスを作成
    std::unique_ptr<Prototype> prototypeA = std::make_unique<ConcretePrototypeA>(42);
    std::unique_ptr<Prototype> prototypeB = std::make_unique<ConcretePrototypeB>("Hello, World!");

    // クローンを作成
    std::unique_ptr<Prototype> cloneA = prototypeA->clone();
    std::unique_ptr<Prototype> cloneB = prototypeB->clone();

    // クローンを使用
    cloneA->use();
    cloneB->use();
}

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

class ResourceManager {
public:
    ResourceManager(const std::string& filename) 
        : file(std::make_unique<std::ifstream>(filename)) {
        if (!file->is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }

    void readData() {
        std::string line;
        while (std::getline(*file, line)) {
            std::cout << line << std::endl;
        }
    }

private:
    std::unique_ptr<std::ifstream> file;
};

void useResourceManager() {
    try {
        ResourceManager rm("example.txt");
        rm.readData();
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

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

class Observer {
public:
    virtual void update() = 0;
    virtual ~Observer() = default;
};

class Subject {
public:
    void addObserver(const std::shared_ptr<Observer>& observer) {
        observers.push_back(observer);
    }

    void notifyObservers() {
        for (auto& observer : observers) {
            if (auto obs = observer.lock()) {
                obs->update();
            }
        }
    }

private:
    std::vector<std::weak_ptr<Observer>> observers;
};

class ConcreteObserver : public Observer, public std::enable_shared_from_this<ConcreteObserver> {
public:
    void update() override {
        std::cout << "Observer notified" << std::endl;
    }
};

void useObserverPattern() {
    auto subject = std::make_shared<Subject>();
    auto observer = std::make_shared<ConcreteObserver>();

    subject->addObserver(observer);
    subject->notifyObservers();
}