[C++] 基本的なシングルトンクラスの書き方と使用例を解説

Q: シングルトンはなぜグローバル変数よりも優れているのか？

シングルトンは、グローバル変数に比べていくつかの利点があります。 主な理由は以下の通りです。 インスタンス管理 : シングルトンはインスタンスの生成と管理を一元化し、必要なときにのみインスタンスを生成します。 これにより、リソースの無駄遣いを防ぎます。 状態の一貫性 : シングルトンは、アプリケーション全体で一貫した状態を維持します。 グローバル変数は、異なる部分から変更される可能性があり、状態の不整合を引き起こすことがあります。 カプセル化 : シングルトンは、クラスの内部で状態を管理し、外部からの直接アクセスを制限します。 これにより、データの整合性が保たれます。

Q: シングルトンはどのような場合に使うべきではないのか？

シングルトンは便利なパターンですが、以下のような場合には使用を避けるべきです。 テストが困難になる場合 : シングルトンはグローバルな状態を持つため、ユニットテストが難しくなることがあります。 テストの独立性を保つためには、依存性注入などの手法を検討するべきです。 多くの依存関係がある場合 : シングルトンが多くの依存関係を持つと、コードの可読性や保守性が低下します。 依存関係が複雑になる場合は、他のデザインパターンを検討することが望ましいです。 アプリケーションのスケーラビリティが求められる場合 : シングルトンは、アプリケーションが大規模になるとボトルネックになる可能性があります。 スケーラビリティが重要な場合は、他のアプローチを考慮する必要があります。

シングルトンパターンは、クラスのインスタンスが1つだけ存在することを保証し、そのインスタンスへのグローバルなアクセス手段を提供するデザインパターンです。

C++でシングルトンクラスを実装する際には、以下のポイントに注意します。

この記事でわかること

シングルトンパターンの基本
スレッドセーフな実装方法
シングルトンの具体的な使用例
シングルトンの応用と注意点
テスト環境でのシングルトンの扱い方

目次から探す

シングルトンパターンとは

シングルトンパターンは、特定のクラスのインスタンスがただ一つだけ存在することを保証するデザインパターンです。

このパターンは、グローバルな状態を持つオブジェクトを管理する際に非常に便利です。

シングルトンは、インスタンスへのアクセスを提供する静的メソッドを持ち、コンストラクタを非公開にすることで、外部からのインスタンス生成を防ぎます。

これにより、アプリケーション全体で一貫した状態を維持し、リソースの無駄遣いを防ぐことができます。

シングルトンパターンは、ログ管理や設定管理、データベース接続など、さまざまな場面で利用されます。

C++でのシングルトンクラスの基本的な実装

シングルトンの基本構造

シングルトンクラスは、特定のクラスのインスタンスが一つだけであることを保証するための基本的な構造を持っています。

以下は、シングルトンの基本的な構造を示すサンプルコードです。

#include <iostream>
class Singleton {
private:
    // コンストラクタを非公開にする
    Singleton() {}
public:
    // インスタンスを取得するためのメソッド
    static Singleton& getInstance() {
        static Singleton instance; // 静的変数としてインスタンスを定義
        return instance;
    }
    // コピーコンストラクタと代入演算子を削除
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    void showMessage() {
        std::cout << "シングルトンインスタンスにアクセスしました！" << std::endl;
    }
};
int main() {
    // シングルトンインスタンスにアクセス
    Singleton::getInstance().showMessage();
    return 0;
}

シングルトンインスタンスにアクセスしました！

このコードでは、Singletonクラスのインスタンスは、getInstanceメソッドを通じてのみ取得できます。

コンストラクタは非公開にされているため、外部からインスタンスを生成することはできません。

コンストラクタの非公開化

シングルトンパターンでは、クラスのコンストラクタを非公開にすることで、外部からのインスタンス生成を防ぎます。

これにより、クラスのインスタンスは必ずgetInstanceメソッドを通じて取得されることになります。

これがシングルトンの基本的な特性です。

静的メンバ変数の定義

シングルトンのインスタンスは、静的メンバ変数として定義されます。

この静的変数は、getInstanceメソッドが呼ばれたときに初めて生成され、プログラムの実行中は一度だけ存在します。

これにより、インスタンスが一つだけであることが保証されます。

インスタンス取得メソッドの実装

インスタンスを取得するためのメソッドは、通常staticメソッドとして実装されます。

このメソッドは、シングルトンのインスタンスを返す役割を果たします。

上記の例では、getInstanceメソッドがその役割を担っています。

デストラクタの扱い

シングルトンパターンでは、デストラクタは通常公開されますが、インスタンスがプログラムの終了時に自動的に破棄されるため、特別な処理は必要ありません。

ただし、リソースの解放が必要な場合は、デストラクタ内で適切に処理を行うことが重要です。

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

スレッドセーフの必要性

マルチスレッド環境では、複数のスレッドが同時にシングルトンインスタンスを取得しようとする場合があります。

このような状況では、インスタンスが複数生成されるリスクがあるため、スレッドセーフな実装が必要です。

スレッドセーフなシングルトンを実装することで、データの整合性を保ち、予期しない動作を防ぐことができます。

C++11以降のstd::call_onceを使った実装

C++11以降では、std::call_onceを使用してスレッドセーフなシングルトンを実装することができます。

以下はそのサンプルコードです。

#include <iostream>
#include <memory>
#include <mutex>
class Singleton {
   private:
    Singleton() {}

   public:
    static Singleton& getInstance() {
        static std::once_flag flag; // 一度だけ実行するためのフラグ
        std::call_once(flag, []() {
            instance.reset(new Singleton()); // インスタンスを初期化
        });
        return *instance; // インスタンスを返す
    }
    void showMessage() {
        std::cout
            << "スレッドセーフなシングルトンインスタンスにアクセスしました！"
            << std::endl;
    }

   private:
    static std::unique_ptr<Singleton>
        instance; // インスタンスを保持するユニークポインタ
};
std::unique_ptr<Singleton> Singleton::instance; // 静的メンバ変数の定義
int main() {
    Singleton::getInstance().showMessage();
    return 0;
}

スレッドセーフなシングルトンインスタンスにアクセスしました！

このコードでは、std::call_onceを使用して、インスタンスの初期化が一度だけ行われることを保証しています。

これにより、マルチスレッド環境でも安全にシングルトンインスタンスを取得できます。

C++11以降のstatic変数を使った実装

C++11以降では、static変数を使用してスレッドセーフなシングルトンを実装することも可能です。

以下はそのサンプルコードです。

#include <iostream>
class Singleton {
private:
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance; // 静的変数としてインスタンスを定義
        return instance; // インスタンスを返す
    }
    void showMessage() {
        std::cout << "スレッドセーフなシングルトンインスタンスにアクセスしました！" << std::endl;
    }
};
int main() {
    Singleton::getInstance().showMessage();
    return 0;
}

スレッドセーフなシングルトンインスタンスにアクセスしました！

この実装では、static変数が初めて使用される際に自動的に初期化されるため、スレッドセーフです。

C++11以降の仕様により、静的変数の初期化はスレッドセーフであることが保証されています。

ダブルチェックロックによる実装

ダブルチェックロックは、スレッドセーフなシングルトンを実装するためのもう一つの方法です。

以下はそのサンプルコードです。

#include <iostream>
#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; // インスタンスを返す
    }
    void showMessage() {
        std::cout << "ダブルチェックロックによるシングルトンインスタンスにアクセスしました！" << std::endl;
    }
};
Singleton* Singleton::instance = nullptr; // 静的メンバ変数の初期化
std::mutex Singleton::mutex; // 静的メンバ変数の初期化
int main() {
    Singleton::getInstance()->showMessage();
    return 0;
}

ダブルチェックロックによるシングルトンインスタンスにアクセスしました！

この実装では、最初にインスタンスがnullptrであるかをチェックし、ロックを取得した後に再度チェックを行います。

これにより、不要なロックを避けつつ、スレッドセーフなインスタンス生成を実現しています。

シングルトンの使用例

ログ管理クラスとしてのシングルトン

ログ管理クラスは、アプリケーション全体で一貫したログ出力を行うためにシングルトンパターンを利用するのに適しています。

以下は、ログ管理クラスのシングルトン実装のサンプルコードです。

#include <iostream>
#include <fstream>
#include <string>
class Logger {
private:
    Logger() {
        logFile.open("log.txt", std::ios::app); // ログファイルを開く
    }
    ~Logger() {
        logFile.close(); // ログファイルを閉じる
    }
public:
    static Logger& getInstance() {
        static Logger instance; // 静的変数としてインスタンスを定義
        return instance; // インスタンスを返す
    }
    void log(const std::string& message) {
        logFile << message << std::endl; // メッセージをログファイルに書き込む
    }
private:
    std::ofstream logFile; // ログファイルのストリーム
};
int main() {
    Logger::getInstance().log("アプリケーションが開始されました。");
    Logger::getInstance().log("エラーが発生しました。");
    return 0;
}

アプリケーションが開始されました。
エラーが発生しました。

このコードでは、Loggerクラスがシングルトンとして実装されており、アプリケーション全体で同じログファイルにログを記録します。

設定管理クラスとしてのシングルトン

設定管理クラスもシングルトンパターンを利用するのに適しています。

アプリケーションの設定を一元管理し、どこからでもアクセスできるようにします。

以下は、設定管理クラスのシングルトン実装のサンプルコードです。

#include <iostream>
#include <map>
#include <string>
class ConfigManager {
private:
    ConfigManager() {
        // デフォルト設定を初期化
        settings["version"] = "1.0";
        settings["app_name"] = "MyApp";
    }
public:
    static ConfigManager& getInstance() {
        static ConfigManager 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:
    std::map<std::string, std::string> settings; // 設定を保持するマップ
};
int main() {
    ConfigManager::getInstance().setSetting("app_name", "UpdatedApp");
    std::cout << "アプリ名: " << ConfigManager::getInstance().getSetting("app_name") << std::endl;
    return 0;
}

アプリ名: UpdatedApp

このコードでは、ConfigManagerクラスがシングルトンとして実装されており、アプリケーションの設定を一元管理します。

どの部分からでも設定を取得・更新することができます。

データベース接続管理クラスとしてのシングルトン

データベース接続管理クラスもシングルトンパターンを利用することで、アプリケーション全体で一つのデータベース接続を共有することができます。

以下は、データベース接続管理クラスのシングルトン実装のサンプルコードです。

#include <iostream>
#include <string>
class DatabaseConnection {
private:
    DatabaseConnection() {
        // データベース接続の初期化
        std::cout << "データベースに接続しました。" << std::endl;
    }
public:
    static DatabaseConnection& getInstance() {
        static DatabaseConnection instance; // 静的変数としてインスタンスを定義
        return instance; // インスタンスを返す
    }
    void query(const std::string& sql) {
        std::cout << "SQLクエリを実行: " << sql << std::endl; // SQLクエリを実行
    }
private:
    ~DatabaseConnection() {
        std::cout << "データベース接続を閉じました。" << std::endl; // デストラクタ
    }
};
int main() {
    DatabaseConnection::getInstance().query("SELECT * FROM users;");
    return 0;
}

データベースに接続しました。
SQLクエリを実行: SELECT * FROM users;
データベース接続を閉じました。

このコードでは、DatabaseConnectionクラスがシングルトンとして実装されており、アプリケーション全体で同じデータベース接続を使用します。

これにより、接続のオーバーヘッドを削減し、効率的なデータベース操作が可能になります。

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

シングルトンの派生クラスを作る方法

シングルトンパターンを使用しているクラスから派生クラスを作成することは、一般的には推奨されません。

なぜなら、シングルトンの特性を持つクラスは、インスタンスが一つだけであることを保証するため、派生クラスのインスタンスが別に存在することができないからです。

しかし、もし派生クラスを作成する必要がある場合は、基底クラスのシングルトンを利用し、派生クラスのインスタンスを管理する方法を考えることができます。

以下はそのサンプルコードです。

#include <iostream>
class BaseSingleton {
protected:
    BaseSingleton() {}
public:
    static BaseSingleton& getInstance() {
        static BaseSingleton instance; // 基底クラスのインスタンス
        return instance;
    }
    virtual void showMessage() {
        std::cout << "基底クラスのインスタンス" << std::endl;
    }
};
class DerivedSingleton : public BaseSingleton {
private:
    DerivedSingleton() {}
public:
    static DerivedSingleton& getInstance() {
        static DerivedSingleton instance; // 派生クラスのインスタンス
        return instance;
    }
    void showMessage() override {
        std::cout << "派生クラスのインスタンス" << std::endl;
    }
};
int main() {
    BaseSingleton::getInstance().showMessage(); // 基底クラスのインスタンス
    DerivedSingleton::getInstance().showMessage(); // 派生クラスのインスタンス
    return 0;
}

基底クラスのインスタンス
派生クラスのインスタンス

このコードでは、基底クラスと派生クラスの両方にシングルトンの特性を持たせています。

派生クラスのインスタンスは、基底クラスのインスタンスとは別に存在します。

マルチトンパターンとの違いと使い分け

マルチトンパターンは、特定のキーに基づいて複数のインスタンスを管理するデザインパターンです。

シングルトンはインスタンスが一つだけであるのに対し、マルチトンは複数のインスタンスを持つことができます。

以下のような場合に使い分けることができます。

スクロールできます

パターン	特徴	使用例
シングルトン	インスタンスが一つだけ	設定管理、ログ管理
マルチトン	特定のキーに基づいて複数のインスタンス	ユーザーセッション管理、データベース接続プール

シングルトンのリセットや再初期化の方法

シングルトンのリセットや再初期化は、通常は推奨されませんが、特定の状況では必要になることがあります。

リセットを行うためには、シングルトンのインスタンスを破棄し、新たにインスタンスを生成する方法があります。

以下はそのサンプルコードです。

#include <iostream>
class Singleton {
private:
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance; // 静的変数としてインスタンスを定義
        return instance;
    }
    static void reset() {
        instance = nullptr; // インスタンスをリセット
    }
    void showMessage() {
        std::cout << "シングルトンインスタンスにアクセスしました！" << std::endl;
    }
private:
    static Singleton* instance; // インスタンスを保持するポインタ
};
Singleton* Singleton::instance = nullptr; // 静的メンバ変数の初期化
int main() {
    Singleton::getInstance().showMessage(); // インスタンスにアクセス
    Singleton::reset(); // インスタンスをリセット
    return 0;
}

シングルトンインスタンスにアクセスしました！

このコードでは、resetメソッドを使用してインスタンスをリセットしています。

ただし、リセット後に再度インスタンスを取得するための処理が必要です。

テスト環境でのシングルトンの扱い方

テスト環境でシングルトンを扱う際には、テストの独立性を保つために、シングルトンのインスタンスをリセットする必要があります。

これにより、各テストが独立して実行され、他のテストの影響を受けないようにすることができます。

以下はそのサンプルコードです。

#include <iostream>
class Singleton {
private:
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance; // 静的変数としてインスタンスを定義
        return instance;
    }
    static void reset() {
        instance = nullptr; // インスタンスをリセット
    }
    void showMessage() {
        std::cout << "テスト用シングルトンインスタンスにアクセスしました！" << std::endl;
    }
private:
    static Singleton* instance; // インスタンスを保持するポインタ
};
Singleton* Singleton::instance = nullptr; // 静的メンバ変数の初期化
void testSingleton() {
    Singleton::getInstance().showMessage(); // テスト中のインスタンスにアクセス
}
int main() {
    testSingleton(); // テストを実行
    Singleton::reset(); // テスト後にインスタンスをリセット
    return 0;
}

テスト用シングルトンインスタンスにアクセスしました！

このコードでは、テスト関数内でシングルトンのインスタンスにアクセスし、テスト後にリセットしています。

これにより、テストの独立性が保たれます。

よくある質問

シングルトンはなぜグローバル変数よりも優れているのか？

シングルトンは、グローバル変数に比べていくつかの利点があります。

主な理由は以下の通りです。

インスタンス管理: シングルトンはインスタンスの生成と管理を一元化し、必要なときにのみインスタンスを生成します。

これにより、リソースの無駄遣いを防ぎます。

状態の一貫性: シングルトンは、アプリケーション全体で一貫した状態を維持します。

グローバル変数は、異なる部分から変更される可能性があり、状態の不整合を引き起こすことがあります。

カプセル化: シングルトンは、クラスの内部で状態を管理し、外部からの直接アクセスを制限します。

これにより、データの整合性が保たれます。

シングルトンはどのような場合に使うべきではないのか？

シングルトンは便利なパターンですが、以下のような場合には使用を避けるべきです。

テストが困難になる場合: シングルトンはグローバルな状態を持つため、ユニットテストが難しくなることがあります。

テストの独立性を保つためには、依存性注入などの手法を検討するべきです。

多くの依存関係がある場合: シングルトンが多くの依存関係を持つと、コードの可読性や保守性が低下します。

依存関係が複雑になる場合は、他のデザインパターンを検討することが望ましいです。

アプリケーションのスケーラビリティが求められる場合: シングルトンは、アプリケーションが大規模になるとボトルネックになる可能性があります。

スケーラビリティが重要な場合は、他のアプローチを考慮する必要があります。

シングルトンのインスタンスが破棄されるタイミングは？

シングルトンのインスタンスは、通常、プログラムの終了時に破棄されます。

具体的には、以下のタイミングでインスタンスが破棄されます。

プログラムの終了時: シングルトンのインスタンスは、静的変数として定義されているため、プログラムが終了する際に自動的に破棄されます。
明示的なリセットが行われた場合: シングルトンのクラスにリセットメソッドが実装されている場合、そのメソッドを呼び出すことでインスタンスをリセットし、次回の呼び出し時に新しいインスタンスが生成されることになります。

ただし、これは一般的には推奨されません。

このように、シングルトンのインスタンスは、プログラムのライフサイクルに従って管理されます。