带可变参数构造函数的Singleton模板单实例保持方案咨询

我尝试实现一个Singleton模板，该模板可通过带一组参数的构造函数，依据模板参数实例化对应类的对象。现有代码看似正常可用，但存在问题：当使用不同构造参数调用instance()方法时，直觉上期望得到同一个实例，可由于模板instance()函数的不同实例化，实际会生成不同实例。若采用基于成员指针的老式Meyer版本单例可解决该问题，现咨询：是否存在技术手段，既能保持“引用式”单例，又能将实例置于instance()函数之外以避免多实例？

当然有可行方案，核心是把构造参数的处理逻辑和单例实例的存储解耦，让instance()的不同参数版本共享同一处实例存储。下面给出两种实用实现方式：

方式一：静态成员存储实例，instance()做初始化与校验 #

将单例实例作为Singleton模板的静态成员变量，instance()方法内先判断实例是否已存在：

• 未初始化时，用传入参数构造实例并存储
• 已初始化时，直接返回引用，还可额外校验传入参数是否与初始化参数一致（避免误用）

代码示例：

#include <mutex>
#include <stdexcept>
#include <tuple>

template<typename T>
class Singleton {
private:
    static inline T* instance_ = nullptr;
    static inline std::mutex mutex_;
    static inline std::tuple<> init_args_; // 存储初始化参数，用于校验

    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    template<typename... Args>
    static void create_instance(Args&&... args) {
        instance_ = new T(std::forward<Args>(args)...);
        init_args_ = std::make_tuple(std::forward<Args>(args)...);
    }

public:
    template<typename... Args>
    static T& instance(Args&&... args) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!instance_) {
            create_instance(std::forward<Args>(args)...);
        } else {
            // 可选：校验参数一致性，不一致则抛出异常
            if (std::make_tuple(std::forward<Args>(args)...) != init_args_) {
                throw std::runtime_error("Singleton已用其他参数初始化，无法重复初始化");
            }
        }
        return *instance_;
    }

    // 手动销毁实例（可选，适用于需要控制生命周期的场景）
    static void destroy() {
        std::lock_guard<std::mutex> lock(mutex_);
        delete instance_;
        instance_ = nullptr;
        init_args_ = std::tuple<>();
    }
};

方式二：CRTP结合静态成员，强化类绑定 #

如果希望单例与目标类绑定更紧密，可使用CRTP（奇异递归模板模式），将实例存储在模板的静态成员中，Singleton仅提供访问接口：

#include <mutex>
#include <stdexcept>
#include <iostream>

template<typename Derived>
class Singleton {
protected:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    static inline Derived* instance_ = nullptr;
    static inline std::mutex mutex_;

public:
    template<typename... Args>
    static Derived& instance(Args&&... args) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!instance_) {
            instance_ = new Derived(std::forward<Args>(args)...);
        }
        return *instance_;
    }

    static void destroy() {
        std::lock_guard<std::mutex> lock(mutex_);
        delete instance_;
        instance_ = nullptr;
    }
};

// 使用示例：目标类继承Singleton
class MyClass : public Singleton<MyClass> {
    friend class Singleton<MyClass>;
private:
    int value_;
    MyClass(int value) : value_(value) {}
public:
    void print_value() {
        std::cout << value_ << std::endl;
    }
};

关键注意事项 #

• 线程安全：两种方案均使用std::mutex保证初始化阶段的线程安全，避免多线程竞态条件
• 参数校验：若需严格控制初始化逻辑，可像第一种方案那样存储并校验参数，防止用户误传不同参数调用
• 生命周期控制：提供的destroy()方法可手动销毁实例，但需注意销毁后再次调用instance()的逻辑，避免空指针访问

内容的提问来源于stack exchange，提问作者amigo421