单例模式，只实例化出一个对象（全局静态变量，各个域都可以调用）。
为了只实例化出一个对象，会将默认构造函数私有，将拷贝构造函删除，由于实例出是的同一个对象，当这个对象被多个线程使用(线程安全问题)或多个模板类使用(重复调用析构函数)，需要将析构函数私有，并需要锁进行安全保护，我们需要在public下写能够调用默认构造函数(只调用一次)和析构函数的两个自定义函数。
分为懒汉模式和饿汉模式
1.懒汉模式
class singleton
{
public:
static singleton* Getobj()
{
// 要防止抛异常
if(slt == nullptr)// 只有第一次需要加锁 双检查
{
unique_lock<mutex> ul(_mtx); // 出了if(){} 域自动销毁
if (slt == nullptr)
{
slt = new singleton; // new出来（在堆上）的而非默认构造函数实例化的对象，必须手动释放空间
// std::atexit(destoryInstance); // 注册销毁函数，一个回调函数，在程序正常退出时，自动执行，在main()函数结束后调用，可行，但更推荐智能指针和Meyers Singleton
}
} // 花括号确定 域
return slt;
}
static void destoryInstance() // 调用析构函数
{
if (slt) // 如果没有if,在多个线程的情况下，可能重复释放
{
cout << "destoryInstance():" << endl;
delete slt;
slt = nullptr; //......必须置空，禁止重复释放
}
}
singleton(const singleton& slt) = delete;
private:
singleton() {};
~singleton() { cout << "~singleton()" << endl; }; // 必须为私有，防止外部直接调用析构函数， delete单例对象
// 因为单例对象是全局或静态的，外部代码或不同模板多重调用delete（会调用析构函数）导致，导致重复释放内存，只需要保证最后一次用完后释放就行
static singleton* slt;
static mutex _mtx; // 静态在类里面都是声明
};
singleton* singleton::slt = nullptr; // 懒汉模式
mutex singleton::_mtx;
destoryInstance()函数不能替换成析构函数。
public:
~singleton() // 死循环
{
if (slt)
{
unique_lock<mutex> ul(_mtx);
cout << "~singleton():" << endl;
delete slt;
slt = nullptr;
}
}
1.会被其他线程或模板类调用析构函数，导致重复释放(有了if和锁似乎不会发生)。
2.更重要的原因：单例模式的对象是自引用，就是我包含我自己，我自己就是我的成员，发生delete时，如果成员有自定义类型，要调用成员的析构函数，而单例对象的成员就是自己，导致无线死循环。
new 出的空间需要我们手动释放，可以通过智能指针自动释放。
class GC
{
public:
~GC()
{
singleton::destoryInstance();
}
};
static GC gc; // 当gc生命周期结束，优先调用类中的析构函数 // 非单例在栈上创建后自动析构（析构函数为public）
或者直接调用内置智能指针shared_ptr。
饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
优点：简单
缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。 如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用懒汉模式来避免资源竞争，提高响应速度更好。
C++的四种类型转化语法
static_cast ，reinterpret_cast，const_cast，dynamic_cast
test
{
// C中的模式
int i = 0;
double d = 8.8;
i = d;
cout << i << endl; // C中的支持近似的隐式类型转化
int* p = nullptr;
p = (int*)i;
cout << p << endl; //C中支持强转类型转化
}
static_cast对于近似类型的转化，reinterpret_cast强制转化，用于不近似类型之间的转化。
test
{
//......
i = static_cast<int>(d); // static_cast 支持近似的类型转化
cout << i << endl;
p = reinterpret_cast<int*>(i); // reinterpret_cast支持强转类型转化(不近似类型)
cout << p << endl;
}const_cast
修改最初定义为非 const 的对象： 当对象本身不是 const，但通过 const 指针/引用访问，可以用const_cast去除指针/引用的const。
int a = 1;
const int* pa = &a;
*const_cast<int*>(pa) = 20;
const int* paa = &a; //与之对应
cout << "a:" << a << " " << "*pa:" << *pa << " " << "*paa:" << *paa << endl;
*const_cast<int*>(paa) = 30;
cout << "a:" << a << " " << "*pa:" << *pa << " " << "*paa:" << *paa << endl;
结果：
a:20 *pa:20 *paa:20
a:30 *pa:30 *paa:30使用 const_cast 移除 const 后修改真正的 const 对象会导致未定义行为，虽然可以正常运行，没允许，没禁止，属于未定义的行为。
const int x = 42;
cout << "x:" << x << endl;
const int* p3 = &x;
*const_cast<int*>(p3) = 20; // 未定义行为
cout << "x:" << x << " " << "p3:" << *p3 << endl;
int* p2 = const_cast<int*>(&x);
*p2 = 100; //未定义行为
cout << "x:" << x << " " << "p3:" <<*p3 <<" " << "p2:" << *p2 << endl;
cout <<"&x:"<< & x << " " << p2 << " " << p3 << endl;
结果：
x:42
x:42 p3:20
x:42 p3:100 p2:100
&x:0075FAC8 0075FAC8 0075FAC8可以看出 p2和p3是相互影响的，而x没变，但他们的地址一样。由于x被放入了寄存器，这里从寄存器中取，不变，本质是编译器对const对象存取优化机制导致的，想要每次取内存中取x就加 volatile。
volatile const int x = 42;
cout << "x:" << x << endl;
//const int* p3 = &x;
//*const_cast<int*>(p3) = 20;
int* p3 = const_cast<int*>(&x);
*p3 = 20;
cout << "x:" << x << " " << "p3:" << *p3 << endl;
int* p2 = const_cast<int*>(&x);
*p2 = 100;
cout << "x:" << x << " " << "p3:" <<*p3 <<" " << "p2:" << *p2 << endl;
cout <<"&x:"<< & x << " " << p2 << " " << p3 << endl;
结果：
x:20 p3:20
x:100 p3:100 p2:100
&x:1 007DFC50 007DFC50加了volatile之后x的值直接从内存中拿取，但由于未定义行为，导致x的地址错误，所以使用未定义行为危害很大。
dynamic_cast
用于检测在继承关系中，转化为子类指针（引用）的是父类还是子类。
class A
{
public:
virtual void fun() {};
private:
int _c;
int _d;
};
class B :public A
{
public:
int _a;
int _b;
private:
};
void func(A* a)
{
//如何区分a是父类对象还是子类对象
//B* b = (B*)a;
B* b = dynamic_cast<B*>(a); // 如果a指向子类，则转化成功 //如果pa指向父类，则转化失败返回nullptr;
if (b)
{
cout << "转化成功:a指向子类对象" << endl;
b->_a = 1;
b->_b = 2;
}
else
{
cout << "转化失败:a指向父类对象" << endl;
}
}
void test7()
{
A a;
B b;
func(&a);
func(&b);
}
结果：
转化失败:a指向父类对象
转化成功:a指向子类对象explicit禁止隐式类型的转化
class AB
{
public:
explicit AB(const int&&a,const int&& b)
:_a(a)
,_b(b)
{
cout << "AB()" << endl;
}
//AB(initializer_list<int> p)
//{
// cout << "AB()" << endl;
//}
void func1(int a)
{
cout << "int a" << endl;
}
void func2(int a,int b)
{
cout << "int a , int b" << endl;
}
private:
int _a;
int _b;
};
void test8()
{
AB a(1, 2);
AB b = { 1,2 }; // 此处发生了隐式类型的转化，加explicit 报错 // std::initializer_list<int>
}
如果加上以下函数就不会报错了
AB(initializer_list<int> p)
{
cout << "AB()" << endl;
}