最近，我遇到了C++的Singleton设计模式的实现/实现。它看起来是这样的（我采用了现实生活中的例子）：
// a lot of methods are omitted here
class Singleton
{
public:
static Singleton* getInstance( );
~Singleton( );
private:
Singleton( );
static Singleton* instance;
};
从这个声明中，我可以推断实例字段是在堆上启动的。这意味着存在内存分配。对我来说完全不清楚的是，内存将在何时被释放？或者是否存在错误和内存泄漏？似乎在实现方面存在问题。
我的主要问题是，如何以正确的方式实现它？
当前回答
有人提到过std:：call_once和std:：once_flag吗？大多数其他方法——包括双重检查锁定——都是失败的。
单例模式实现中的一个主要问题是安全初始化。唯一安全的方法是用同步屏障保护初始化序列。但这些障碍本身需要安全启动。std:：once_flag是保证安全初始化的机制。
其他回答
接受答案中的解决方案有一个明显的缺点——在控件离开main（）函数后调用单例的析构函数。当一些依赖对象被分配到main中时，可能真的会有问题。
我在尝试在Qt应用程序中引入Singleton时遇到了这个问题。我决定，我的所有设置对话框都必须是Singleton，并采用了上面的模式。不幸的是，Qt的主类QApplication被分配在主函数的堆栈上，当没有应用程序对象可用时，Qt禁止创建/销毁对话框。
这就是为什么我更喜欢堆分配的单件。我为所有单例提供了显式的init（）和term（）方法，并在main内部调用它们。因此，我可以完全控制单体创建/销毁的顺序，而且我保证无论是否有人调用getInstance（），都会创建单体。
C++11线程安全实现：
#include <iostream>
#include <thread>
class Singleton
{
private:
static Singleton * _instance;
static std::mutex mutex_;
protected:
Singleton(const std::string value): value_(value)
{
}
~Singleton() {}
std::string value_;
public:
/**
* Singletons should not be cloneable.
*/
Singleton(Singleton &other) = delete;
/**
* Singletons should not be assignable.
*/
void operator=(const Singleton &) = delete;
//static Singleton *GetInstance(const std::string& value);
static Singleton *GetInstance(const std::string& value)
{
if (_instance == nullptr)
{
std::lock_guard<std::mutex> lock(mutex_);
if (_instance == nullptr)
{
_instance = new Singleton(value);
}
}
return _instance;
}
std::string value() const{
return value_;
}
};
/**
* Static methods should be defined outside the class.
*/
Singleton* Singleton::_instance = nullptr;
std::mutex Singleton::mutex_;
void ThreadFoo(){
std::this_thread::sleep_for(std::chrono::milliseconds(10));
Singleton* singleton = Singleton::GetInstance("FOO");
std::cout << singleton->value() << "\n";
}
void ThreadBar(){
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
Singleton* singleton = Singleton::GetInstance("BAR");
std::cout << singleton->value() << "\n";
}
int main()
{
std::cout <<"If you see the same value, then singleton was reused (yay!\n" <<
"If you see different values, then 2 singletons were created (booo!!)\n\n" <<
"RESULT:\n";
std::thread t1(ThreadFoo);
std::thread t2(ThreadBar);
t1.join();
t2.join();
std::cout << "Complete!" << std::endl;
return 0;
}
我没有在答案中找到CRTP实现，所以这里是：
template<typename HeirT>
class Singleton
{
public:
Singleton() = delete;
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
static HeirT &instance()
{
static HeirT instance;
return instance;
}
};
要使用，只需从此继承类，例如：class Test:public Singleton＜Test＞
作为单身汉，你通常不希望它被破坏。
当程序终止时，它将被拆除并释放，这是单例的正常行为。如果您希望能够显式地清理它，那么向类中添加一个静态方法非常容易，该方法允许您将其恢复到干净状态，并在下次使用时重新分配，但这超出了“经典”单例的范围。
2008年，我提供了一个Singleton设计模式的C++98实现，该模式是惰性评估的、保证破坏的，在技术上不是线程安全的：有人能给我提供一个c++中的Singleton示例吗？
这里是Singleton设计模式的一个更新的C++11实现，它是延迟评估的、正确销毁的和线程安全的。
class S
{
public:
static S& getInstance()
{
static S instance; // Guaranteed to be destroyed.
// Instantiated on first use.
return instance;
}
private:
S() {} // Constructor? (the {} brackets) are needed here.
// C++ 03
// ========
// Don't forget to declare these two. You want to make sure they
// are inaccessible(especially from outside), otherwise, you may accidentally get copies of
// your singleton appearing.
S(S const&); // Don't Implement
void operator=(S const&); // Don't implement
// C++ 11
// =======
// We can use the better technique of deleting the methods
// we don't want.
public:
S(S const&) = delete;
void operator=(S const&) = delete;
// Note: Scott Meyers mentions in his Effective Modern
// C++ book, that deleted functions should generally
// be public as it results in better error messages
// due to the compilers behavior to check accessibility
// before deleted status
};
请参阅本文，了解何时使用单例：（不经常）辛格尔顿：应该如何使用
请参阅这两篇关于初始化顺序和如何处理的文章：静态变量初始化顺序查找C++静态初始化顺序问题
请参阅这篇描述寿命的文章：C++函数中静态变量的生存期是多少？
请参阅本文，其中讨论了单线程的一些线程含义：Singleton实例声明为GetInstance方法的静态变量，它是线程安全的吗？
请参阅这篇文章，解释为什么双重检查锁定在C++上不起作用：C++程序员应该知道哪些常见的未定义行为？Dobbs博士：C++和双重检查锁定的危险：第一部分
