C++相关概念和易错语法（32）（单例模式、类型转换）

1.单例模式

（1）设计模式是什么？

简单来说，被反复使用，多数人知晓、经过分类的代码设计经验的总结就叫设计模式 ，它建立在特殊类的设计之上，实现特殊的功能，运用的知识也十分综合。如迭代器模式就是一种常见的设计模式。 下面再分享一个常见的设计模式，单例模式。

（2）单例模式

单例模式： 全局中定义的一个类只能创建一个对象，即单例模式可以保证系统中该类只有一个实例 ，并提供一个访问该对象的全局访问点，该实例化的对象被所有程序模块共享，即能在不同模块访问这个唯一的对象。

单例模式又分为饿汉模式和懒汉模式，下面分别介绍

（3）饿汉模式

先看一下下面的代码，会输出什么呢？

cpp 复制代码

#include <iostream>
using namespace std;

class A
{
public:
	static A& constructor()
	{
		return a;
	}

	A(const A& a) = delete;//移动版本也不会生成
	A& operator=(const A& a) = delete;//移动版本也不会生成

private:
	A(int m = 10)
		:_m(m)
	{
		cout << "私有化A()" << endl;
	}
	~A()
	{
		cout << "私有化~A()" << endl;
	}

	int _m;

	static A a;
};

A A::a(5);

int main()
{
	cout << sizeof(A) << endl;

	return 0;
}

结果是

相信看到这个结果会有很多疑惑，下面将逐一回答

①为什么A的静态成员变量类型是A还没有导致无限递归？

我们先来看看无限递归的情况是怎样的

在这种情况下编译会直接报错，但是为什么加了static就没事了呢？

类中的static函数和变量虽然和其它成员函数和变量都是在同一个类下面声明的，但其实有很大差别。类中的static对象属于整个类而不是单个对象，当实例化类的时候并不会为static对象单独开辟空间。 只有当要使用的时候直接到类里面取，我们可以将类里面的static对象当作公共区域，每个实例化对象按需来取。

但使用公共区域来解释类中类又不太严谨。 还有一种理解方式可以更好地解释为什么A不会无限递归。我们先忽略所有的静态对象，剩下的就是类A该有的东西。 注意我们所忽略的静态成员变量A a中，A对应的内容也是如此，没有静态对象。按照这样理解，我们这个时候就能发现**静态成员变量A a中并没有另一个A a，因为A中我们先是忽略了所有静态对象。**最后我们将这些忽略的对象还原回去。

这就像在一座房子里有一个很小的房子模型，这个模型非常精妙，包含了这个房子的一切，就是模型里没有另一个房子模型，不然的话就会无限递归了。其实我们再进一步，这个小模型放在房子外面和房子里面都长一样。模型在外面的话那么这个模型和房子就一模一样，造出来的房子也一模一样。模型在房子里面的话房子虽然多了一个小模型，但小模型的样子没有变，而后面我们造房子是按照模型来造的，根本不会受到影响。

这里需要我们仔细体会，找到自己的理解方式。总的来说静态成员变量可以说是一个仅受类域限制的对象，这个对象在类里还是类外都不会对这个类造成任何影响，只有调用时才会感受到影响。

用已有的知识解释下面的现象

我们发现计算类的大小时，静态成员变量都不会算在其中，这也进一步验证了刚刚的解释。

②为什么使用static函数？

关于这点，我在特殊类中也讲过。static函数属于整个类而不是单个对象。类的所有成员函数（包括static）都会在编译或链接时存入代码段。不管实不实例化这些函数都只会有一份，所以static在唯一性上体现不出不同，但像我前面所说，static对象只是受类域限制，其他东西和类没有关系，所以static函数没有this，避免了先有鸡还是先有蛋的问题。

③为什么可以在全局定义类中的私有成员？

要注意私有成员保护的是调用，即不能在类外面调用

只要是成员函数，非静态成员变量都能在全局定义（能够随便调用类里面的私有对象），注意格式，static定义时不写

④为什么什么都不做就会调用A的构造和析构？

static A a在全局中定义也就意味着它的生命周期和全局对象、静态对象一样，在调用main函数前创建，在程序结束时销毁。在开始执行main函数的时候，a已经调用了构造函数创建了。

⑤如何实现单例模式的？

和特殊类一样，我们要根据需求来处理，由于我们需要单例，把这个单例放在类里面作为static成员变量是最好的选择 ，因为这样我们就可以直接私有化构造函数，将拷贝赋值全部封死，完全失去了任何创建新对象的机会。唯一的一份对象只能通过static来获取 ，这里其实也借助了static作为成员变量的一个特点。因此我们只能通过接口获取A的唯一的实例化对象，符合单例模式需求。

⑥为什么叫做饿汉模式？

当调用main函数之前，static A a就在全局中定义出来了，也就是说，我们将这个对象准备好了才开始执行main函数的代码。 就像亲人在家早早做好饭，饥饿的人一回家就能吃饭。这个代码也是同样的意思，先把这些特殊类的对象准备好，当我需要的时候直接拿来用就可以了。

⑦这个模式有什么缺点吗？

多个饿汉模式的单例会导致启动慢 ，在main函数前不存在多线程的概念，main函数前的处理也不会有什么反馈，有的时候让人无法分辨到底是启动慢还是程序陷入死循环了。并且某些对象初始化内容较多（有的程序启动要读很多文件）。 还有一个致命的问题：A和B两个饿汉，如果对象初始化存在依赖关系，很难控制顺序（A和B在不同文件中） ，这个时候就需要懒汉模式来处理了。

（4）懒汉模式

理解了饿汉模式，懒汉模式就很简单了。总的来说就是在第一次调用的时候才会创建对象，并且因为能够显式创建对象，创建顺序的问题也能解决。

看一下下面的代码

cpp 复制代码

#include <iostream>
using namespace std;

class A
{
public:
	static A* constructor(int m = 10)//模拟构造函数
	{
		if (a)
			return a;
		return new A(m);
	}

	A(const A& a) = delete;//移动版本也不会生成
	A& operator=(const A& a) = delete;//移动版本也不会生成

private:
	A(int m = 10)
		:_m(m)
	{
		cout << "私有化A()" << endl;
	}
	~A()
	{
		cout << "私有化~A()" << endl;
	}

	int _m;

	static A* a;
};



class B
{
public:
	static B* constructor(int m = 10)//模拟构造函数
	{
		if (b)
			return b;
		return new B(m);
	}

	B(const B& b) = delete;//移动版本也不会生成
	B& operator=(const B& b) = delete;//移动版本也不会生成

private:
	B(int m = 10)
		:_m(m)
	{
		cout << "私有化B()" << endl;
	}
	~B()
	{
		cout << "私有化~B()" << endl;
	}

	int _m;

	static B* b;
};

A* A::a = nullptr;

B* B::b = nullptr;


int main()
{
	B* p1 = B::constructor(0);

	A* p2 = A::constructor(5);

	return 0;
}

结果是

注意堆区的空间回收的时候都不会调用析构，和生命周期结束调用析构存在区别。

懒汉模式依然是借助static变量来写的 ，只不过先用nullptr初始化保证程序启动快 ，后续需要的时候先检查是不是nullptr，是的话就创建变量，不是的话就直接用现有的对象返回数据。我们显式调用可以保证严格控制创建对象顺序，并且整体运行速度也有上升。

之所以叫懒汉模式，是因为这类似于饿了才去做饭，需要的时候才去干的生活模式。我们写代码的时候要慎用饿汉模式，懒汉模式在很多方面都有优势。

2.类型转换

在C/C++中，我们难免会遇到类型转换的问题，如int和double之间的转换，short和int之间转换。注意权限的缩小和放大仅限于指针和引用，其余的都叫类型转换 ，**类型转换只要是自定义类型都要手动写转换的构造函数。**接下来就讲讲C++中类型转换的规则。

类型转换分为隐式类型转换 和显式（强制）类型转换 。后面我会讲哪些场景必须使用强制类型转换。C++有四种显式类型转换：static_cast、reinterpret_cast、const_cast、dynamic_cast

注意：这四个操作符都是以static_cast<int>(a)方式写，但并不是仿函数，它们和仿函数有很大区别

（1）static_cast<T>

①内置类型之间

static_cast<T> 适用于大多数类型转换的场景。它必要时能调用构造函数，专门进行安全转换。

这种转换方式都能使用 隐式类型转换（不意味着隐式类型转换只支持这一种） ，我们写不写都是能运行的，写了相当于给别人一个更明显的标志。这类转换方式有个很大的特点就是数据的意义不会发生大的改变 ，如我前面int转short，也可以说是内置类型之间的转换

指针类型和void*之间，这种只能进行强转，不能隐式类型转换

编译器认为像int*和char*之间的转换不够安全，所以就不支持static_cast强转

针对这种有互相关联的类型，我们可以选择不写，走隐式类型转换也是可以的。

②内置类型 -> 自定义类型

这类转换我们应该见过很多了，单参数构造函数支持隐式类型转换

如果不想隐式类型转换可用explicit，但显式转换不受影响

多参数比较特殊，它不支持使用static_cast强转

多参数构造要么直接写()构造函数，要么使用列表初始化，static_cast识别不了列表，不能使用

③自定义类型 -> 内置类型

这应该我第一次提到用自定义类型转内置类型。如果有一个A a，我想转为int，那么我应该会写作int b = (int)a，由于这个(int)，我们应该写一个重载函数出来，C++中这个重载函数是operator int，其实operator()也很合理，但这有弊端，不仅和仿函数的冲突了，还无法确定类型。因此重载一个int函数其实也很清晰。

重载函数形式：operator 类型