## 摘要
在《more effective C 》中，作者曾在限制类所能生成对象的个数章节讨论过“允许产生0个或1个对象”，其实该部分讲解的方法就是单例模式。而单例模式的底层思路就是：禁止用户自己定义对象，通过定义方法给用户调用来生成对象。
## 定义
要求一个类只能生成一个对象，且整个软件体系内对于该对象的依赖程度相同。
**单个实例可以减少内存开支，如果对象的构造需要资源时还可以减少资源的占用**
## 实现方式
单例模式的实现有常用的“饿汉模式”和“懒汉模式”。
> 所谓懒汉模式：只在初次调用该实例化函数时才创建对象，意指懒。
> 所谓饿汉模式：在main函数执行之前就已经将实例化对象构造完成，意指饿。
## 两者对比
饿汉模式没有线程安全问题，但是懒汉模式却存在线程安全问题，因此针对懒汉模式需要double-check，
## 懒汉模式实现1
```cpp
//.h文件
#include<mutex>
class Singlton
{
public:
static Singlton* instance();
private:
Singlton() = default;
Singlton(const Singlton& sing) = default;
Singlton& operator=(const Singlton& sing) = default;
private:
static Singlton* m_instance;
static std::mutex m_mutex;
};
//.cpp文件
#include "Singlton.h"
Singlton* Singlton::m_instance{ nullptr };//未实例化对象
std::mutex Singlton::m_mutex;
Singlton* Singlton::instance()
{
if (m_instance == nullptr)
{
std::unique_lock<std::mutex> lk(m_mutex);
if (m_instance == nullptr)
{
m_instance = new Singlton;
}
lk.unlock();
}
return m_instance;
}
```
**在获得实例的方法instance中，采用double-check的方法，所以该实现方法是线程安全且锁的区域也是合理的**
## 饿汉模式实现2
```cpp
//采用智能指针 call_once
class Singleton {
private:
Singleton() {
std::cout << "Constructor called!" << std::endl;
}
static void createInstance() {
m_instance_ptr = std::shared_ptr<Singleton>(new Singleton);
}
public:
typedef std::shared_ptr<Singleton> Ptr;
~Singleton() {
std::cout << "Destructor called!" << std::endl;
}
static std::shared_ptr<Singleton> get_instance() {
static std::once_flag s_flag;
//std::call_once(s_flag, createInstance);
std::call_once(s_flag, [] { m_instance_ptr = std::shared_ptr<Singleton>(new Singleton); });
return m_instance_ptr;
}
void use() const { std::cout << "in use" << std::endl; }
private:
static std::shared_ptr<Singleton> m_instance_ptr;
};
//静态成员变量初始化
Singleton::Ptr Singleton::m_instance_ptr = nullptr;
```
## 改进版的饿汉模式1
```cpp
m_instance = new Singlton;
```
当用new创建对象其实分为了三个步骤：
> 调用operator new分配内存
> 在分配的空间上调用构造函数完成对象构造
> 让m_instance指向分配的空间
虽然如上进行了DCL，但是当存在编译器优化或运行时优化，则有可能导致第二步、第三步乱序，此时m_instance获得的是未构造完成的对象。基于此，可以通过原子变量（atomic<T>）进行优化。
## 改进版的饿汉模式2
采用静态局部变量的形式（C 大师的方法）
```cpp
class Singleton {
public:
~Singleton() {
std::cout << "Destructor called!" << std::endl;
}
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
static Singleton &get_instance() {
static Singleton instance;
return instance;
}
void use() const { std::cout << "in use" << std::endl; }
private:
Singleton() {
std::cout << "Constructor called!" << std::endl;
}
};
```
## 饿汉模式实现
```cpp
//singleton.h
class singleton{
private:
singleton(){}
static singleton* p;
public:
static singleton* instance();
int a;
};
//singleton.cpp
singleton* singleton::p = new singleton();
singleton* singleton::instance()
{
return p;
}
```
实例作为静态成员会在进入main函数前进行实例化，所以不会具有线程安全问题
