单例的实现要点
单例模式要求类能够有返回对象一个引用（永远是同一个）和一个获得该实例的方法（必须是静态方法）。
## 单例的实现主要是通过以下三个步骤：
1.将类的构造方法定义为私有方法。这样其他类的代码就无法通过调用该类的构造方法来实例化该类的对象，只能通过2·该类提供的静态方法来得到该类的唯一实例。
3.定义一个私有的类的静态实例。
4.提供一个公有的获取实例的静态方法。
## **单例追求的目标**
线程安全。
懒加载。
调用效率高。
以下是懒汉模式实现：
懒汉模式在多线程情况下是线程不安全的，所以下面的实现已经加互斥锁，所以不存在线程安全问题
class LazySingleton
{
private:
explicit LazySingleton();
~LazySingleton();
explicit LazySingleton(const LazySingleton& lazy) = delete;
LazySingleton& operator=(const LazySingleton& lazy) = delete;
explicit LazySingleton(LazySingleton&& lazy) = delete;
LazySingleton& operator=(const LazySingleton&& lazy) = delete;
public:
static LazySingleton* getInstance();
private:
static LazySingleton* m_pLazy;
};
LazySingleton* LazySingleton::m_pLazy = nullptr;
LazySingleton::LazySingleton()
{
}
LazySingleton::~LazySingleton()
{
}
LazySingleton* LazySingleton::getInstance()
{
if (m_pLazy == nullptr)
{
static std::once_flag flag;
std::call_once(flag, [&]()
{
if (nullptr == m_pLazy)
{
m_pLazy = new LazySingleton();
}
});
}
return m_pLazy;
}
以下是饿汉模式实现：
饿汉模式，比较常见的一种写法。在类加载的时候就对实例进行初始化，没有线程安全问题；获取实例的静态方法没有使用同步，调用效率高；但是没有使用懒加载，如果该实例从始至终都没被使用过，则会造成内存浪费。
总结：线程安全、非懒加载、效率高。
是否推荐：可以使用。
class HungrySingleton
{
private:
explicit HungrySingleton();
~HungrySingleton();
explicit HungrySingleton(const HungrySingleton& hungry) = delete;
HungrySingleton& operator=(const HungrySingleton& hungry) = delete;
explicit HungrySingleton(HungrySingleton&& hungry) = delete;
HungrySingleton& operator=(const HungrySingleton&& hungry) = delete;
public:
static HungrySingleton& getInstance();
private:
static HungrySingleton m_hungry;
};
HungrySingleton HungrySingleton::m_hungry;
HungrySingleton::HungrySingleton()
{
std::cout << "hungry creator" << std::endl;
}
HungrySingleton::~HungrySingleton()
{
}
HungrySingleton& HungrySingleton::getInstance()
{
return m_hungry;
}
|
