C++における安全なシングルトンパターンの実装方法

シングルトンパターンは、ソフトウェア開発において重要なデザインパターンの一つです。このパターンは、特定のクラスがインスタンスを一つしか持たないことを保証し、そのインスタンスへのグローバルなアクセス手段を提供します。これにより、リソースの節約やデータの一貫性が求められる状況で有効です。特に、設定情報の管理やログ記録など、一つのインスタンスで十分な場面で役立ちます。しかし、マルチスレッド環境では注意が必要であり、スレッドセーフな実装が求められます。本記事では、C++におけるシングルトンパターンの安全な実装方法について詳しく解説します。

シングルトンパターンの基本概念

シングルトンパターンは、特定のクラスに対してインスタンスが一つしか存在しないことを保証するデザインパターンです。このパターンは、以下のような特徴を持ちます：

唯一のインスタンスの提供

シングルトンパターンでは、クラスのインスタンスが一つしか生成されないように制御されます。これにより、同じオブジェクトを複数の場所で共有することができます。

グローバルなアクセス

シングルトンパターンは、グローバルなアクセス手段を提供します。これにより、どこからでもシングルトンインスタンスにアクセスできるようになります。

主な用途

シングルトンパターンは、以下のようなシナリオで使用されます：

• 設定情報の管理：アプリケーション全体で共有する設定情報を管理します。
• ログ記録：ログの記録を行うオブジェクトを一つに統一します。
• リソース管理：データベース接続など、リソースを一つにまとめて管理します。

次に、シングルトンパターンの具体的な実装方法について見ていきます。

スレッドセーフなシングルトンの実装方法

シングルトンパターンをマルチスレッド環境で利用する際には、スレッドセーフな実装が必要です。スレッドセーフでない実装は、複数のスレッドが同時にインスタンスを生成しようとするときに問題を引き起こす可能性があります。

スレッドセーフなシングルトンの基本手法

スレッドセーフなシングルトンを実装する基本的な方法は、インスタンス生成時にロックを使用することです。ロックを使用することで、複数のスレッドが同時にインスタンスを生成しようとすることを防ぎます。

以下に、スレッドセーフなシングルトンの典型的な実装例を示します：

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;

    // コンストラクタをプライベートにして外部からのインスタンス化を防ぐ
    Singleton() {}

public:
    // インスタンスを取得するための静的メソッド
    static Singleton* getInstance() {
        // ロックを使用してスレッドセーフにインスタンスを生成
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

// 静的メンバ変数の定義
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

ロックのオーバーヘッドに注意

上記の実装では、毎回インスタンスを取得するたびにロックが発生します。このロックはパフォーマンスに影響を与えるため、必要な場合にのみロックを行う工夫が求められます。

Double-Checked Locking

パフォーマンスを向上させるために、Double-Checked Lockingという手法があります。これは、最初にロックをかけずにインスタンスが既に生成されているかをチェックし、必要な場合にのみロックをかける方法です。次のセクションでは、この方法について詳しく説明します。

Meyers’ Singletonの紹介

Meyers’ Singletonは、C++におけるシングルトンパターンの実装方法の一つで、シンプルかつスレッドセーフな方法として広く知られています。この方法は、関数内で静的ローカル変数を使用してシングルトンインスタンスを生成します。

Meyers’ Singletonの特徴

Meyers’ Singletonは、以下のような特徴を持っています：

• シンプルな実装：特別なロックや複雑なコードを必要としないため、実装が非常にシンプルです。
• スレッドセーフ：C++11以降の仕様では、静的ローカル変数の初期化がスレッドセーフであることが保証されています。
• 遅延初期化：インスタンスは最初にアクセスされたときに初期化されるため、プログラムの起動時のオーバーヘッドがありません。

実装例

以下に、Meyers’ Singletonの実装例を示します：

class Singleton {
public:
    // インスタンスを取得するための静的メソッド
    static Singleton& getInstance() {
        static Singleton instance; // 初回アクセス時に初期化される静的ローカル変数
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除してシングルトンの特性を維持する
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // コンストラクタをプライベートにして外部からのインスタンス化を防ぐ
    Singleton() {}
};

Meyers’ Singletonの利点

• パフォーマンス：インスタンスの初期化が必要な場合にのみ行われるため、パフォーマンスに優れています。
• コードの簡潔さ：非常に簡潔で読みやすいコードとなるため、メンテナンスが容易です。

注意点

Meyers’ SingletonはC++11以降でのスレッドセーフな実装が保証されているため、古いコンパイラを使用している場合は注意が必要です。その場合は、スレッドセーフであることを確認する必要があります。

次に、Double-Checked Lockingによるシングルトンの実装方法について詳しく説明します。

Double-Checked Lockingの実装

Double-Checked Locking（DCL）は、シングルトンパターンの実装において、必要な場合にのみロックを行うことで、ロックのオーバーヘッドを最小限に抑える手法です。この方法は、インスタンスが既に初期化されているかを最初にチェックし、必要な場合にのみロックをかけることで、パフォーマンスの向上を図ります。

Double-Checked Lockingの概念

DCLは、次の2つのチェックを行います：

1. ロックをかけずにインスタンスが既に生成されているかをチェック。
2. インスタンスが生成されていない場合にロックをかけ、再度インスタンスの有無をチェックしてからインスタンスを生成。

実装例

以下に、Double-Checked Lockingを用いたシングルトンの実装例を示します：

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;

    // コンストラクタをプライベートにして外部からのインスタンス化を防ぐ
    Singleton() {}

public:
    // インスタンスを取得するための静的メソッド
    static Singleton* getInstance() {
        if (instance == nullptr) { // 最初のチェック（ロックなし）
            std::lock_guard<std::mutex> lock(mutex); // ロックをかける
            if (instance == nullptr) { // 第二のチェック（ロックあり）
                instance = new Singleton();
            }
        }
        return instance;
    }
};

// 静的メンバ変数の定義
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

DCLの利点と欠点

利点

• パフォーマンスの向上：必要な場合にのみロックをかけるため、ロックのオーバーヘッドが減少し、パフォーマンスが向上します。
• スレッドセーフ：インスタンス生成時にロックを行うことで、複数のスレッドが同時にインスタンスを生成することを防ぎます。

欠点

• コードの複雑さ：Meyers’ Singletonに比べて実装が複雑であり、コードの可読性が低下します。
• 古いコンパイラでの問題：C++11以前の仕様では、メモリモデルが不完全なため、DCLが正しく機能しない場合があります。

まとめ

Double-Checked Lockingは、パフォーマンスを重視する場合に有効な手法です。しかし、コードの複雑さや古いコンパイラでの互換性に注意が必要です。次に、C++11以降の標準を利用したシングルトンの実装方法について説明します。

C++11以降のシングルトン実装

C++11以降では、シングルトンパターンの実装が非常にシンプルかつスレッドセーフになりました。これは、標準ライブラリや言語機能の改善によるものです。

スレッドセーフな初期化

C++11以降、静的ローカル変数の初期化がスレッドセーフであることが保証されています。これにより、シングルトンパターンの実装が非常に簡単になります。次の実装例では、静的ローカル変数を用いたスレッドセーフなシングルトンパターンを示します。

実装例

以下に、C++11以降のシングルトンパターンの実装例を示します：

class Singleton {
public:
    // インスタンスを取得するための静的メソッド
    static Singleton& getInstance() {
        static Singleton instance; // 静的ローカル変数
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除してシングルトンの特性を維持する
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // コンストラクタをプライベートにして外部からのインスタンス化を防ぐ
    Singleton() {}
};

利点

• シンプルなコード：静的ローカル変数を使用するだけでシングルトンを実装できるため、コードが非常に簡潔です。
• スレッドセーフ：C++11以降の仕様により、静的ローカル変数の初期化がスレッドセーフであることが保証されています。
• 遅延初期化：インスタンスは最初にアクセスされたときに初期化されるため、プログラムの起動時に無駄なオーバーヘッドが発生しません。

注意点

• 初期化順序問題：静的ローカル変数を使用することで初期化順序の問題を回避できますが、複雑な依存関係がある場合は注意が必要です。
• コンパイラサポート：C++11以降のコンパイラが必要です。古いコンパイラを使用している場合は、この手法を使用できない可能性があります。

次に、シングルトンパターンの具体的な応用例について見ていきます。シングルトンパターンがどのように実践的に利用されるかを具体的な例を交えて解説します。

シングルトンパターンの応用例

シングルトンパターンは、その特性を活かしてさまざまな場面で利用されています。以下に、具体的な応用例を示します。

設定情報の管理

アプリケーション全体で共有される設定情報を管理するためにシングルトンパターンが使用されます。これにより、設定情報を一元管理し、複数のクラスで共有することができます。

class ConfigurationManager {
public:
    static ConfigurationManager& getInstance() {
        static ConfigurationManager instance;
        return instance;
    }

    // 設定情報の取得
    std::string getSetting(const std::string& key) {
        return settings[key];
    }

    // 設定情報の更新
    void setSetting(const std::string& key, const std::string& value) {
        settings[key] = value;
    }

private:
    ConfigurationManager() {}

    std::map<std::string, std::string> settings;
};

ログ記録

アプリケーションの動作ログを記録するためのクラスでもシングルトンパターンがよく使用されます。これにより、どの部分からでも一貫した方法でログを記録することができます。

#include <iostream>
#include <fstream>
#include <string>

class Logger {
public:
    static Logger& getInstance() {
        static Logger instance;
        return instance;
    }

    void log(const std::string& message) {
        std::ofstream logFile("app.log", std::ios_base::app);
        logFile << message << std::endl;
    }

private:
    Logger() {}
};

データベース接続管理

データベース接続を管理するクラスにシングルトンパターンを使用することで、複数のデータベース接続を一元管理し、リソースの効率的な利用が可能になります。

#include <memory>

class DatabaseConnection {
public:
    static DatabaseConnection& getInstance() {
        static DatabaseConnection instance;
        return instance;
    }

    void connect() {
        // データベースへの接続処理
    }

    void disconnect() {
        // データベースからの切断処理
    }

private:
    DatabaseConnection() {}
};

キャッシュ管理

アプリケーションのキャッシュを管理するためにシングルトンパターンを使用することで、キャッシュの一貫性を保ちながらリソースを効率的に使用できます。

class CacheManager {
public:
    static CacheManager& getInstance() {
        static CacheManager instance;
        return instance;
    }

    void addCache(const std::string& key, const std::string& value) {
        cache[key] = value;
    }

    std::string getCache(const std::string& key) {
        return cache[key];
    }

private:
    CacheManager() {}

    std::map<std::string, std::string> cache;
};

これらの応用例を通じて、シングルトンパターンがどのように実際のソフトウェア開発で役立つかを理解することができます。次に、シングルトンパターンのテスト方法について説明します。

シングルトンパターンのテスト方法

シングルトンパターンのクラスをテストすることは、他のクラスと同様に重要です。特に、シングルトンの特性を維持しつつ、正しく動作するかを確認する必要があります。ここでは、シングルトンパターンのユニットテストおよび統合テストの方法について説明します。

ユニットテストの基本

ユニットテストでは、シングルトンインスタンスが一意であることを確認し、クラスの各メソッドが期待通りに動作するかを検証します。以下に、Google Testフレームワークを使用したテストの例を示します。

#include <gtest/gtest.h>
#include "Singleton.h"

TEST(SingletonTest, InstanceIsUnique) {
    Singleton& instance1 = Singleton::getInstance();
    Singleton& instance2 = Singleton::getInstance();

    // 同じインスタンスであることを確認
    ASSERT_EQ(&instance1, &instance2);
}

TEST(SingletonTest, MethodWorksCorrectly) {
    Singleton& instance = Singleton::getInstance();

    // メソッドの動作をテスト
    instance.someMethod();
    ASSERT_EQ(instance.getValue(), expectedValue);
}

モックを使用したテスト

シングルトンの依存関係をモックに置き換えることで、シングルトンパターンのクラスのテストを容易にすることができます。Google Mockを使用して依存関係をモックする例を示します。

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "Singleton.h"
#include "Dependency.h"

class MockDependency : public Dependency {
public:
    MOCK_METHOD(void, someMethod, (), (override));
};

TEST(SingletonTest, DependencyInteraction) {
    MockDependency mockDependency;
    Singleton& instance = Singleton::getInstance();

    instance.setDependency(&mockDependency);

    EXPECT_CALL(mockDependency, someMethod()).Times(1);

    instance.useDependency();
}

統合テストの基本

統合テストでは、シングルトンパターンが他のクラスやコンポーネントとどのように連携するかを検証します。以下に、設定管理クラスの統合テストの例を示します。

#include <gtest/gtest.h>
#include "ConfigurationManager.h"

TEST(ConfigurationManagerTest, SettingAndGettingValues) {
    ConfigurationManager& config = ConfigurationManager::getInstance();

    config.setSetting("key1", "value1");
    std::string value = config.getSetting("key1");

    ASSERT_EQ(value, "value1");
}

注意点

• シングルトンのリセット：テスト環境では、シングルトンインスタンスの状態をリセットする必要がある場合があります。これは通常、テスト専用の方法を提供するか、シングルトンパターンの使用を最小限にする設計を検討することで解決します。
• 依存関係の管理：シングルトンの依存関係をモックやスタブに置き換えることで、テストが容易になります。

これらの方法を使用して、シングルトンパターンのクラスを効果的にテストすることができます。次に、シングルトンパターンのデメリットと注意点について説明します。

シングルトンパターンのデメリットと注意点

シングルトンパターンは便利なデザインパターンですが、いくつかのデメリットと注意点があります。これらを理解することで、適切な状況でシングルトンパターンを使用し、問題を回避することができます。

テストの難しさ

シングルトンパターンは、グローバルな状態を持つため、ユニットテストや統合テストが難しくなることがあります。特に、シングルトンインスタンスの状態をテストごとにリセットするのが困難です。

対策

• テスト専用のリセットメソッドを実装する。
• シングルトンの使用を最小限に抑え、依存関係注入（Dependency Injection）を利用する。

グローバル状態の管理

シングルトンはグローバルな状態を持つため、予期しない副作用が発生しやすくなります。これは、特に大規模なアプリケーションでは問題となります。

対策

• グローバル状態の使用を最小限に抑える。
• 明確なインターフェースを提供し、グローバル状態の変更を管理する。

スレッドセーフの実装が複雑

マルチスレッド環境でのシングルトンの実装は、スレッドセーフであることを保証するために複雑になることがあります。ロックの使用や、複雑な初期化コードが必要になる場合があります。

対策

• C++11以降の静的ローカル変数を利用する。
• Double-Checked Lockingを使用する場合は、正しく実装する。

破壊的変更のリスク

シングルトンパターンは、インスタンスが一つしかないことを前提としているため、その設計が変更された場合に大規模なコードの修正が必要になることがあります。

対策

• シングルトンパターンを使用する前に、その必要性を十分に検討する。
• 変更が必要な場合は、影響範囲を慎重に評価する。

依存関係の見えづらさ

シングルトンはグローバルにアクセス可能であるため、依存関係が明確に見えなくなり、コードの可読性や保守性が低下することがあります。

対策

• 依存関係注入を利用して、依存関係を明確にする。
• ドキュメントやコードコメントを充実させる。

まとめ

シングルトンパターンは強力なデザインパターンですが、そのデメリットと注意点を理解し、適切に対策を講じることが重要です。次に、シングルトンパターンの最適化方法について説明します。

シングルトンパターンの最適化方法

シングルトンパターンは、適切に最適化することで、パフォーマンスやメモリ効率を向上させることができます。ここでは、シングルトンパターンの最適化手法について詳しく説明します。

Lazy Initialization（遅延初期化）

シングルトンインスタンスを初めて使用する際にのみ生成する方法です。これにより、アプリケーションの起動時のオーバーヘッドを削減できます。

class LazySingleton {
public:
    static LazySingleton& getInstance() {
        static LazySingleton instance; // 初回アクセス時にのみ初期化される
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除
    LazySingleton(const LazySingleton&) = delete;
    LazySingleton& operator=(const LazySingleton&) = delete;

private:
    LazySingleton() {}
};

Eager Initialization（即時初期化）

アプリケーションの起動時にシングルトンインスタンスを生成する方法です。これにより、初回アクセス時の遅延を防ぎます。

class EagerSingleton {
public:
    static EagerSingleton& getInstance() {
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;

private:
    EagerSingleton() {}

    static EagerSingleton instance; // アプリケーション起動時に生成
};

// 静的メンバ変数の定義
EagerSingleton EagerSingleton::instance;

スマートポインタの利用

スマートポインタを使用することで、メモリ管理を簡素化し、安全性を向上させることができます。特に、std::shared_ptrやstd::unique_ptrを利用することが一般的です。

#include <memory>

class SmartPointerSingleton {
public:
    static std::shared_ptr<SmartPointerSingleton> getInstance() {
        static std::shared_ptr<SmartPointerSingleton> instance(new SmartPointerSingleton());
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除
    SmartPointerSingleton(const SmartPointerSingleton&) = delete;
    SmartPointerSingleton& operator=(const SmartPointerSingleton&) = delete;

private:
    SmartPointerSingleton() {}
};

スレッドローカルストレージの利用

特定のスレッド内でのみシングルトンインスタンスを共有する場合、スレッドローカルストレージを利用することで、スレッドごとに独立したインスタンスを保持できます。

class ThreadLocalSingleton {
public:
    static ThreadLocalSingleton& getInstance() {
        thread_local ThreadLocalSingleton instance;
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除
    ThreadLocalSingleton(const ThreadLocalSingleton&) = delete;
    ThreadLocalSingleton& operator=(const ThreadLocalSingleton&) = delete;

private:
    ThreadLocalSingleton() {}
};

シングルトンパターンのパフォーマンス最適化

• インスタンス生成の最小化：必要最低限のインスタンス生成を行い、不要なインスタンスの生成を避ける。
• ロックの最適化：必要な場合にのみロックを行うことで、ロックのオーバーヘッドを減らす。
• リソース管理：シングルトン内で管理するリソースの効率的な利用を図る。

まとめ

シングルトンパターンの最適化は、パフォーマンスの向上やメモリ効率の改善に寄与します。適切な最適化手法を選択することで、シングルトンパターンをより効果的に活用することができます。次に、シングルトンパターンと他のデザインパターンの比較について説明します。

他のデザインパターンとの比較

シングルトンパターンは、その特性から特定の状況で非常に有用ですが、他のデザインパターンとどのように異なるのか、またどのように使い分けるべきかを理解することが重要です。ここでは、シングルトンパターンを他の代表的なデザインパターンと比較します。

シングルトンパターン vs. ファクトリーパターン

ファクトリーパターンは、オブジェクトの生成を専門のクラスに委任することで、生成過程をカプセル化します。一方、シングルトンパターンは特定のクラスのインスタンスを一つだけ生成します。

主な違い

• インスタンスの数：
• シングルトンパターン：常に一つのインスタンス。
• ファクトリーパターン：必要に応じて複数のインスタンスを生成。
• 使用目的：
• シングルトンパターン：グローバルなアクセスが必要な場合。
• ファクトリーパターン：インスタンス生成のカプセル化やサブクラス選択。

シングルトンパターン vs. プロトタイプパターン

プロトタイプパターンは、既存のオブジェクトをコピーして新しいインスタンスを生成します。これは、複雑なオブジェクトの生成コストを抑えるために使用されます。

主な違い

• インスタンス生成方法：
• シングルトンパターン：一つのインスタンスを共有。
• プロトタイプパターン：既存のインスタンスをコピー。
• 使用目的：
• シングルトンパターン：一つのインスタンスをグローバルに使用する場合。
• プロトタイプパターン：同じ状態を持つ複数のインスタンスを生成する場合。

シングルトンパターン vs. デコレーターパターン

デコレーターパターンは、オブジェクトの機能を動的に追加するために使用されます。これは、既存のクラスの振る舞いを変更せずに機能を追加することが可能です。

主な違い

• 目的：
• シングルトンパターン：一つのインスタンスを共有し、そのインスタンスにアクセスを集中させる。
• デコレーターパターン：オブジェクトの機能を動的に追加。
• 使用方法：
• シングルトンパターン：インスタンスを一つに限定。
• デコレーターパターン：オブジェクトの振る舞いを変更または拡張。

シングルトンパターン vs. オブザーバーパターン

オブザーバーパターンは、オブジェクトの状態が変化したときに他のオブジェクトに通知するために使用されます。これは、イベント駆動型のシステムで広く利用されます。

主な違い

• 通知機能：
• シングルトンパターン：インスタンスの一意性とグローバルなアクセス。
• オブザーバーパターン：状態変化の通知とリアクション。
• 使用目的：
• シングルトンパターン：一つのインスタンスを使用する必要がある場合。
• オブザーバーパターン：オブジェクト間の通信が必要な場合。

まとめ

シングルトンパターンは特定の用途で非常に強力ですが、他のデザインパターンと比較することで、その適切な使用方法と限界を理解することができます。適切なデザインパターンを選択することで、コードの可読性、保守性、およびパフォーマンスを向上させることができます。次に、シングルトンパターンの理解を深めるための演習問題と解答例を提供します。

演習問題と解答例

シングルトンパターンの理解を深めるために、以下の演習問題を解いてみましょう。これらの問題は、シングルトンパターンの基本概念から応用までをカバーしています。

演習問題1：シングルトンクラスの実装

次の条件を満たすシングルトンクラスを実装してください：

• クラス名はMySingletonとする。
• インスタンスは静的メソッドgetInstanceを通じて取得できる。
• インスタンスは一度だけ生成され、以降は同じインスタンスが返される。
• コピーコンストラクタと代入演算子を削除する。

解答例

class MySingleton {
public:
    static MySingleton& getInstance() {
        static MySingleton instance; // 静的ローカル変数
        return instance;
    }

    // コピーコンストラクタと代入演算子を削除
    MySingleton(const MySingleton&) = delete;
    MySingleton& operator=(const MySingleton&) = delete;

private:
    MySingleton() {} // プライベートコンストラクタ
};

演習問題2：スレッドセーフなシングルトン

マルチスレッド環境で安全に動作するシングルトンクラスを実装してください。インスタンス生成時にロックを使用し、スレッドセーフであることを保証してください。

解答例

#include <mutex>

class ThreadSafeSingleton {
public:
    static ThreadSafeSingleton& getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new ThreadSafeSingleton();
        }
        return *instance;
    }

    // コピーコンストラクタと代入演算子を削除
    ThreadSafeSingleton(const ThreadSafeSingleton&) = delete;
    ThreadSafeSingleton& operator=(const ThreadSafeSingleton&) = delete;

private:
    ThreadSafeSingleton() {} // プライベートコンストラクタ

    static ThreadSafeSingleton* instance;
    static std::mutex mutex;
};

// 静的メンバ変数の定義
ThreadSafeSingleton* ThreadSafeSingleton::instance = nullptr;
std::mutex ThreadSafeSingleton::mutex;

演習問題3：シングルトンの応用

設定管理クラスConfigurationManagerをシングルトンとして実装し、以下の機能を追加してください：

• 設定値を格納するマップsettingsを持つ。
• 設定値を取得するメソッドgetSettingと設定するメソッドsetSettingを持つ。

解答例

#include <map>
#include <string>

class ConfigurationManager {
public:
    static ConfigurationManager& getInstance() {
        static ConfigurationManager instance;
        return instance;
    }

    // 設定値を取得するメソッド
    std::string getSetting(const std::string& key) {
        return settings[key];
    }

    // 設定値を設定するメソッド
    void setSetting(const std::string& key, const std::string& value) {
        settings[key] = value;
    }

    // コピーコンストラクタと代入演算子を削除
    ConfigurationManager(const ConfigurationManager&) = delete;
    ConfigurationManager& operator=(const ConfigurationManager&) = delete;

private:
    ConfigurationManager() {} // プライベートコンストラクタ

    std::map<std::string, std::string> settings;
};

演習問題4：テストの実装

Google Testフレームワークを使用して、MySingletonクラスのユニットテストを実装してください。シングルトンインスタンスが一意であることを確認するテストを書いてください。

解答例

#include <gtest/gtest.h>
#include "MySingleton.h"

TEST(MySingletonTest, InstanceIsUnique) {
    MySingleton& instance1 = MySingleton::getInstance();
    MySingleton& instance2 = MySingleton::getInstance();

    ASSERT_EQ(&instance1, &instance2); // 同じインスタンスであることを確認
}

これらの演習問題を通じて、シングルトンパターンの基本的な概念とその応用、さらにテスト方法について理解を深めることができます。次に、本記事のまとめを行います。

まとめ

シングルトンパターンは、特定のクラスがインスタンスを一つしか持たないことを保証し、そのインスタンスへのグローバルなアクセス手段を提供するデザインパターンです。この記事では、シングルトンパターンの基本概念から、スレッドセーフな実装方法、Meyers’ SingletonやDouble-Checked Lockingの紹介、そしてC++11以降のシンプルな実装方法を解説しました。また、シングルトンパターンの応用例、テスト方法、デメリットとその対策、最適化手法、そして他のデザインパターンとの比較についても詳しく説明しました。さらに、演習問題を通じて実践的な理解を深めるための例を提供しました。シングルトンパターンは非常に有用なデザインパターンですが、適切に使用し、その限界とデメリットを理解することが重要です。この記事が、シングルトンパターンの理解と効果的な活用に役立つことを願っています。