特殊类设计（5个）与类型转换-CSDN博客

本文链接：https://blog.csdn.net/creative_mind/article/details/141606029

引子：在生活中我们经常有不同类的需求，因此我们有了特殊类的设计（有很多种模式等）。由于类型需求不同我们有了类型转换。今天我们就来略讲略讲一下这方面的知识。

特殊类设计（5个）

注意：关键字：explicit--防止隐式类型转换，ﬁnal--该类不能被继承

一，设计一个类，不能被拷贝

思路：直接使用c++11新增知识delete，禁掉拷贝构造与赋值，或放到私有private中区，只声明不实现。

class objA
{
public:

	objA(const objA&) = delete;
	objA operator=(const objA&) = delete;
private:
	int _a;
};

二，设计一个类，只能在堆上创建对象

思路一：把初始构造放到私有区，在public区中流出相应的接口

class objA
{
public:
	static objA* Get_objA(int c=3)
	{
		return new objA(c);
	}

	objA(const objA&) = delete;
	objA operator=(const objA&) = delete;
private:
	objA(int a=1)
		:_a(a)
	{}
	int _a;
};

注意要禁掉拷贝构造或移动构造，否则仍能进行在其他区创建对象，如下

思路二：利用new的函数不自动调用析构函数来进行区分，同样是把析构函数弄成私有！（这里不实现了）

三，设计一个类，只能在栈上创建对象

思路：禁掉operator new(),在public，在单独写接口；

class objA final
{
public:
	static objA Get_objA(int c=3)
	{
		return objA(c);
	}

	objA(const objA&) = delete;
	objA operator=(const objA&) = delete;
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	objA(int a=1)
		:_a(a)
	{}
	int _a;
};

int main()
{
	static objA h1;
	objA h2=objA::Get_objA(4);
	objA* h3 = objA::Get_objA();
	return 0;
}

四，设计一个类，不能被继承

思路：直接利用final进行控制

五，设计一个类，只能创建一个对象

一，饿汉模式：不管你将来用不用，程序启动时就创建一个唯一的实例对象

缺点：

1、多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序启动慢

2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证

class objA final
{
public:
	static objA* Get_objA()
	{
		return &_cmp;
	}

	objA(const objA&) = delete;
	objA operator=(const objA&) = delete;
private:
	objA(int a=5)
		:_a(a)
	{}
	int _a;
	static objA _cmp;
};

objA* cmp=objA::Get_objA();
objA objA::_cmp;

二，懒汉模式：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制

优点：如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。所以这种情况使用懒汉模式（延迟加载）更好。

class objA final
{
public:
	static objA& Get_objA()
	{
		if (_cmp == nullptr)
		{
			_cmp = new objA();
		}
	}

	static void destroy()
	{
		delete _cmp;
		_cmp = nullptr;
	}
	objA(const objA&) = delete;
	objA operator=(const objA&) = delete;
private:
	objA(int a=5)
		:_a(a)
	{}
	int _a;
	static objA* _cmp;
};

objA* objA::_cmp = nullptr;

int main()
{
	
	return 0;
}

类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符： static_cast、reinterpret_cast、const_cast、dynamic_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用 static_cast，但它不能用于两个不相关的类型进行转换

// 对应隐式类型转换 -- 数据的意义没有改变
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型(强转)

// 对应强制类型转换 -- 数据的意义已经发生改变
int* p1 = reinterpret_cast<int*>(a);

const_cast最常用的用途就是删除变量的const属性，方便赋值

// 对应强制类型转换中有风险的去掉const属性
volatile const int b = 2;
int* p2 = const_cast<int*>(&b);
*p2 = 3;

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)，虽然，可以用隐私类型或强制类型进行转换，但是有越界风险！

向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)

向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

注意：

1. dynamic_cast只能用于父类含有虚函数的类

2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

class A
{
public:
	virtual void f() {}
};
class B : public A
{};
void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	B* pb1 = static_cast<B*>(pa);
	B* pb2 = dynamic_cast<B*>(pa);
	cout << "pb1:" << pb1 << endl;
	cout << "pb2:" << pb2 << endl;
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}