C++ C++；迈耶'；s带参数的单例

可以用参数定义Meyer的单态（like）吗

我知道这是可能的与GOF风格的单身（如）

但我似乎无法与迈耶的单身汉合作：

// ...
public:

    static S& getInstance()
    {
        static S instance; // no way to pass arguments here ...
        return instance;
    }

编辑：

我想要一个

Init

函数和多个

getInstance

。 所以一个典型的用法是：

S::Init(5, 6.4);
foo(S::getInstance());
bar(S::getInstance());

---

你可以这样做：

class Singleton
{
private:
  static std::unique_ptr<Singleton>& getObject()
  {
    static std::unique_ptr<Singleton> instance;
    return instance;
  }

  Singleton(int foo);

public:
  static void Init(int foo)
  {
    auto& instance = getObject();
    if (instance) throw std::runtime_error("aleady inited");
    instance.reset(new Singleton(foo));
  }

  static Singleton& getInstance()
  {
    auto& instance = getObject();
    if (!instance) throw std::runtime_error("not inited");    
    return *instance;
  }
};

最好的解决方案可能是将初始化和构造分开：

class Singleton
{
private:
  std::atomic<bool> initialised;
  Singleton()
  : initialised(false)
  {
  }

  Singleton& instanceImpl()
  {
    static Singleton singleton;
    return singleton;
  }

public:
  void Init(int foo)
  {
    auto& instance = instanceImpl();
    if (instance.initialised) throw std::runtime_error("already inited");
    instance.initialised = true;
  }

  Singleton& getInstance()
  {
    auto& instance = instanceImpl();
    if (!instance.initialised) throw std::runtime_error("not inited");
    return instance;
  }
};

类单例
{
私人：
std：：原子初始化；
Singleton（）
：已初始化（错误）
{
}
Singleton和instanceImpl（）
{
静态单态单态；
返回单身；
}
公众：
void Init（int foo）
{
auto&instance=instanceImpl（）；
if（instance.initialized）抛出std:：runtime_错误（“已初始化”）；
instance.initialized=true；
}
Singleton&getInstance（）
{
auto&instance=instanceImpl（）；
如果（！instance.initialized）抛出std:：runtime_错误（“未初始化”）；
返回实例；
}
};

您只需将初始化参数存储在statics中即可。例如：

class S {
public:
    static void Init(int i)
    {
        i_ = i;
        initialized_ = true;
    }

    static S& getInstance()
    {
        if (!initialized_) {
            throw SomeException;
        }
        static S instance(i_);
        return instance;
    }

private:
    S(int) { }

    static int i_;
    static bool initialized_;
};

记住在实现（

.cpp

）文件中实际定义静态：

---

显然，您也可以使用Meyer Singleton来处理这些问题，但由于它们是内置类型，并且不依赖于其他数据，因此您不会获得太多收益。

与您的链接答案完全相同。您在

静态S实例

之后指定初始值设定项，如

静态S实例（…）或<代码>静态S实例{…}你能澄清问题在哪里吗？我想进行一个init调用：
S:：init（8,7.25）
然后与
S:：getInstance（）
一起使用。。。并使用其断言保护每个方法：
Init
将使用
instance==nullptr
保护，而
getInstance
将使用
instance！=nullptr
…您应该遵循单一责任原则，将惰性初始化代码从实例获取功能中移出。@user7860670请解释一下？将您的其他要求放在问题本身中，而不是放在注释中。
class S {
public:
    static void Init(int i)
    {
        i_ = i;
        initialized_ = true;
    }

    static S& getInstance()
    {
        if (!initialized_) {
            throw SomeException;
        }
        static S instance(i_);
        return instance;
    }

private:
    S(int) { }

    static int i_;
    static bool initialized_;
};

int S::i_ = 0;
bool S::initialized_ = false;