特殊类的设计与类型转换

特殊类的设计

1.请设计一个不能被拷贝的类

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

C++98

C++98是怎么设计的呢？

class CopyBan
{
public:
	CopyBan() = default;
private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);
};

（将拷贝构造与赋值重载函数封装为私有）

原因：

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了

2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11

C++11之后新增了delete 关键字

class CopyBan
{
public:
	CopyBan() = default;
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
};

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。

2. 请设计一个只能在堆上创建对象的类

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

class HeapOnly
{
public:
	static HeapOnly* Creatobj()
	{
		return new HeapOnly;
	}

private:
	HeapOnly()
	{

	}

	HeapOnly(const HeapOnly&) = delete;
};

int main()
{
	//HeapOnly();
	//static HeapOnly hp1;

	HeapOnly* hp2 = HeapOnly::Creatobj();
	//HeapOnly hp3(*hp2);
	return 0;
}

还有一种比较另类的方法，把析构函数给私有化。

class HeapOnly
{
public:
	void destroy()
	{
		delete this;
	}

private:
	~HeapOnly()
	{

	}
};

int main()
{
	//HeapOnly();
	//static HeapOnly hp1;

	HeapOnly* hp2 = new HeapOnly;
	hp2->destroy();
	//HeapOnly* hp2 = HeapOnly::Creatobj();
	//HeapOnly hp3(*hp2);
	return 0;
}

但是我们就要用写一个成员函数来调用析构函数。

3. 请设计一个只能在栈上创建对象的类

先看下面这种写法有什么问题没有？

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
private:
	StackOnly()
	{

	}
	void* operator new(size_t size) = delete;

private:
    int _a = 1;
};

下面这种写法虽然不可以再堆上创建对象了，但是可以在静态区创建对象。有点封不死。

我们可以像下面这样写呢?：

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}

	StackOnly(StackOnly&& s)
	{

	}

	StackOnly(const StackOnly& s) = delete;
private:
	StackOnly()
	{

	}
};

所以相对而言还是第一种方法更好一点。

4. 请设计一个不能被继承的类

C++98方式：

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

C++11：

final关键字，final修饰类，表示该类不能被继承。

class A final
{
	// ....
};

5. 请设计一个类，只能创建一个对象(单例模式)

设计模式：

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单例模式：

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

class InfoMgr
{
public:
	static InfoMgr& GetInstance()
	{
		return _ins;
	}

private:
	InfoMgr()
	{

	}

	InfoMgr(const InfoMgr& i) = delete;
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	size_t buffsize = 1024 * 1024;
	static InfoMgr _ins;
};

InfoMgr InfoMgr::_ins;

int main()
{
	InfoMgr& Im1 = InfoMgr::GetInstance();
}

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

懒汉模式

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

class InfoMgr
{
public:
	static InfoMgr& GetInstance()
	{
		if (_pins == nullptr)
		{
			_pins = new InfoMgr;
		}
		return *_pins;
	}

private:
	InfoMgr()
	{

	}

	InfoMgr(const InfoMgr& i) = delete;
private:
	string _ip = "127.0.0.1";
	int _port = 80;
	size_t buffsize = 1024 * 1024;
	static InfoMgr* _pins;
};

InfoMgr* InfoMgr::_pins = nullptr;

int main()
{
	InfoMgr& Im1 = InfoMgr::GetInstance();
}

类型转换

1. C语言中的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败

2. 显式类型转化：需要用户自己处理

隐式类型转化：整形与整形之间，整形与浮点数之间。

显式类型转化：整形与指针，指针与指针之间。

void Test()
{
	int i = 1;
	// 隐式类型转换
	double d = i;
	printf("%d, %.2f\n", i, d);
	int* p = &i;

	// 显示的强制类型转换
	int address = (int)p;
	printf("%p, %d\n", p, address);
}

内置类型与自定义类型转换

内置类型是可以隐式转换为自定义类型但需要借助成员函数。

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(a)
	{}

	A(int a, int b)
		:_a1(a)
		, _a2(b)
	{}

private:

	int _a1;
	int _a2;
};

int main()
{
    //单参数
	A aa1 = 1;
    //多参数
	A aa2 = {1, 2};
}

不想隐式类型转换可以加个explicit 关键字

自定义类型如何转换内置类型：


	int operator()()
	{
		return _a1 + _a2;
	}

这种写法是错误的因为 operator ()被仿函数占用了，所以C++就有一种特殊的写法。

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(a)
	{}

	A(int a, int b)
		:_a1(a)
		, _a2(b)
	{}

	operator int()
	{
		return _a1 + _a2;
	}

private:

	int _a1;
	int _a2;
};

同样加上explicit 就不能隐式类型转换。

但是还是可以显式类型转换

自定义类型转换自定义类型

两个没有关联的类型是不能进行转换的。（需要对应构造函数的支持）

2.C++强制类型转换

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

2.1 static_cast

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

static_cast：对应隐式类型转换——数据的意义没有改变

2.2 reinterpret_cast

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

reinterpret_cast：对应强制类型转换——数据的意义已经发生改变

2.3 const_cast

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

const_cast：对应的是强制类型转换中的去掉const 属性

可以看到用强制类型转换也是可以的但是C++为了规范一下增加了const_cast ，我们通过调试可以发现a1 在监视窗口已经变成了2，但是打印出来还是3。

这是因为a1 被直接替换成了常量。

所以上面场景还是建议加上 volatile 关键字，表示告诉编译器再取这个值的时候，不要替换成常量或者去寄存器取值，而是直接去内存中取。

2.4 dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)

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

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

注意：

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

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

dynamic_cast为什么要先检查是否能转换成功呢？

我们来看下面场景：

class A
{
public:
	virtual void f() {}

	int _a = 1;
};
class B : public A
{
public:
	int _b = 2;
};

void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	B* pb1 = dynamic_cast<B*>(pa);

	if (pb1)
	{
		cout << pb1->_a << endl;
		cout << pb1->_b << endl;
	}
	else
	{
		cout << "转换失败"<<endl;
	}
}

int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}

可以看到_b 是随机值，如果对_b 进行写操作就会报错。所以指向父类向下转换是有越界访问风险的，指向子类转换时安全。