C++的单例模式

单例模式，只实例化出一个对象（全局静态变量，各个域都可以调用）。

为了只实例化出一个对象，会将默认构造函数私有，将拷贝构造函删除，由于实例出是的同一个对象，当这个对象被多个线程使用(线程安全问题)或多个模板类使用(重复调用析构函数)，需要将析构函数私有，并需要锁进行安全保护，我们需要在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;
	 }