C++特殊类设计类型转换

一、特殊类设计

在普通类的设计基础上，提出一些限制条件设计的类就是特殊类。

1、请设计一个类，不能被拷贝

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

C++98中的方式：

将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

class CopyBan
{
    // ...
public:
	CopyBan()
	{}
    
private:
    CopyBan(const CopyBan&);//拷贝构造函数声明
    CopyBan& operator=(const CopyBan&);//赋值运算符重载声明
    //...
};

原因：

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

如上图代码，在对这个特殊类进行拷贝和赋值的时候，因为这两个成员函数私有而无法调用。

拷贝构造以及赋值运算符重载等成员函数，在调用时都是编译器在域外调用，所以必须是公有的。

C++11 ：

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

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

使用C++11中的给delete新赋予的意义来禁止生产拷贝构造和赋值运算符重载函数。

此时编译器也不会自动生成默认的拷贝构造和赋值运算符重载函数。

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

实现方式：

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

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

    // C++98
    // 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
 // 2.声明成私有
    HeapOnly(const HeapOnly&);

        // or

        // C++11    
        HeapOnly(const HeapOnly&) = delete;
};

定义一个静态成员函数，在该函数内部new一个HeapOnly对象。将构造函数和拷贝构造函数私有，并且禁止生成拷贝构造函数。

原因：

使用静态成员函数new一个HeapOnly对象。

非静态成员函数在调用的时候，必须使用点(.)操作符来调用，这一步是为了传this指针。

这样的前提是先有一个HeapOnly对象，但是构造函数设置成了私有，就无法创建这样一个对象。

而静态成员函数的调用不用传this指针，也就不用必须有HeapOnly对象，只需要类域::静态成员函数即可。
静态成员函数属于HeapOnly域内，所以在new一个对象的时候，可以调用私有的构造函数。

禁止调用拷贝构造函数，并且私有化。

这样的目的是为了禁止拷贝，防止使用堆区上的HeapOnly对象在栈区上拷贝，如下面代码

而禁止了拷贝构造就杜绝了这一行为，从而保证了HeapOnly对象只能在堆上创建。

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

方法一：同上将构造函数私有化，然后设计静态方法创建对象返回即可。

主要要做到不能在堆上创建类对象。
new一个对象的时候，会调用该类的operator new(size_t size)函数，在释放资源的时候又会调用该类的operator delete(void* p)函数。

class StackOnly
{
public:
 static StackOnly CreateObj()
 {
 return StackOnly();
 }
    
    // 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
 // StackOnly obj = StackOnly::CreateObj();
 // StackOnly* ptr3 = new StackOnly(obj);
 void* operator new(size_t size) = delete;//禁止调用new
 void operator delete(void* p) = delete;//禁止调用delete

private:
 int _a;
};

使用delete来禁止这两个函数的调用，那么在new一个对象的时候，就会产生编译错误，从而无法在堆区上创建类对象。

此时在堆上创建对象时就会报错，尝试引用已经删除的函数。

方法2：

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

另一种方式就是和之前一样，通过一个静态成员函数在栈区上创建一个类对象，并且将默认构造函数私有化。

此时new一个对象的时候，由于默认构造函数私有无法调用，所以报错。

但是这俩种设计方法都有一个漏洞，类对象可以在静态区(数据段)上创建：

static StackOnly num = StackOnly::CreateObject();

设计特殊类的核心点：只能通过静态成员函数来创建类，封掉其他所有创建方式。

4 .不能被继承的类

C++98方式

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

原因：

基类的构造函数私有，派生类在创建对象的时候，无法调用基类的构造函数。

此时我们就设计出了不能继承的类。

C++11的方式：

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

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

使用C++11中的final关键字修饰基类，这个基类就无法继承。

5.单例模拟

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

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

5.1 单例模式的类型

单例模式有两种类型：

懒汉式：在真正需要使用对象时才去创建该单例类对象
饿汉式：在类加载时已经创建好该单例对象，等待被程序使用

懒汉式创建单例对象

懒汉式创建对象的方法是在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象。否则则先执行实例化操作。

根据上面的流程图，就可以写出下面的这段代码

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		//如果单例对象没有创建则在堆区创建
		if (m_pInstance == nullptr)
		{
			m_pInstance = new Singleton;
		}
		return m_pInstance;
	}
private:
	//构造函数
	Singleton()
	{}
	Singleton(const Singleton& s) = delete;//禁止拷贝
	Singleton& operator=(const Singleton& s) = delete;//禁止赋值

	//静态单例对象指针
	static Singleton* m_pInstance;//单例对象指针
};

Singleton* Singleton::m_pInstance = nullptr;//初始化为空

将构造函数私有，拷贝构造和赋值运算符重载函数禁止调用，用来保证单例模式的唯一性。
增加静态单例对象指针成员变量。

在类外实例化静态指针变量的时候，并没有创建单例对象，而是将其初始化为空。

int main()
{
	Singleton* ps = Singleton::GetInstance();//获取单例对象

	return 0;
}

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

优点：

第一次使用单例对象时才创建对象，进程启动过程中无负载。
多个互相依赖的单例可以控制启动顺序(通过代码顺序)。

饿汉式创建单例对象

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

class Singleton
{
public:
	//获取单例对象接口
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
private:
	Singleton()
	{}
	Singleton(const Singleton& s) = delete;//禁止使用拷贝构造
	Singleton& operator=(const Singleton& s) = delete;//禁止使用赋值运算符重载

	//保证单例对象在静态区且只有一个
	static Singleton m_instance;//单例对象
};

Singleton Singleton::m_instance;//在程序入口之前就完成单例对象初始化

静态成员变量只能在类域外进行定义初始化。

所以在main函数之前就将单例对象定义初始化，此时该单例对象创建在静态区上，而且仅有一个，后面就无法再创建。

想要获取该单例对象只能通过静态成员函数GetInstance()来获取。
静态成员函数可以直接访问静态成员变量m_instance。

int main()
{
	Singleton* s = Singleton::GetInstance();//获取单例对象

	return 0;
}

不管将来会不会使用到这个单例对象，但是在程序一启动还没有进入main函数之前就创建一个唯一的实例对象。

就像一个饿汉一样，一上来就创建单例对象。

缺点：

可能会导致进程启动较慢，如过实例对象很复杂，在创建实例对象时就会花费很多时间。
实例顺序不确定，如果有多个单例对象，并且对象之间存在互相依赖关系，由于对象的实例对象不确定(和代码顺序无关，由编译器决定)，此时就会发生错误。

线程安全问题：

在C++11之后饿汉模式是没有线程安全问题的(做了相关补丁)，因为单例对象是在main函数之前就实例化的，而多线程都是在main函数里面启动的。

但是懒汉模式是存在线程安全问题的，当多个线程使用到单例对象时候，在使用GetInstance()获取对象时，用因为调度问题出现误判，导致new多个单例对象。

在GetInstance()中判断是否创建单例的时候加锁，判断完后再解锁，让多线程串行访问单例对象的指针。

互斥锁必须放在静态区：

单例对象只有一个，所以全局只使用一把锁即可，放在静态区刚合适。
GetInstance()是静态成员函数，没有this指针，如果互斥锁是普通成员变量的化，无法访问。而静态成员函数可以直接访问静态成员变量。

通过加锁的方式就能保证懒汉模式的线程安全问题。

双检查加锁：

此时，每个调用GetInstance()的线程都需要申请锁然后释放锁，对锁的操作也是有开销的，会有效率上的损失。

单例模式在单例一经创建以后就不会再创建了，无论多少线程在访问已经创建的单例对象时都不会再创建，线程就已经安全了。所以在单例对象创建以后，根本没有必要再去申请锁和释放锁。

将GetInstance()原本加锁代码放在一个if(m_pInstacne == nullptr)的代码快中，进行双重检查。

当单例对象已经被new出来以后，就不会再进行加锁检查了，可以直接通过if进行判断，提高了性能。

new出来对象的释放：

new出来的单例对象如何释放呢？

一般情况下我们选择不释放，因为全局只有一个单例对象，而且会被一直使用，所以就不用释放，释放了反而后面的使用会出问题。

当进程结束的时候，操作系统会回收该进程的所有资源，包括堆区上的资源。

如果就要主动释放呢？在释放的同时将一些信息保存到磁盘。

如上图代码所示，在单例模式的类中创建一个内部类，内部类是外部类的友元。

在内部类对象Gabro的析构函数中释放new出来的单例对象，并且进行相关的文件操作。
内部类对象同样设置成静态成员，在类域外进行定义初始化。

二、类型转换

在C语言中，如果赋值运算符(=)两边的类型不同，或者形参和实参类型不匹配，或者返回值类型和接收值类型不一致，就需要发生类型转换。

C语言中有两种类型转换：

隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败。
显式类型转换：需要用户自己处理。

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

	int* p = &i;
	int address = (int)p;//显式类型转换
	printf("%x, %d\n", p, address);

	return 0;
}

double d = i是发生了隐式类型转换，将整形转换成了double类型。

隐式类型转换只发生在相近类型，比如整形家族直接，或者这些int，double等表示数值直接的变量类型。

int address = (int)p是发生了显式类型转换，将int*类型的变量转换为int类型。

显式类型需要用户自己维护，在两种类型没有任何关系的时候需要进行显式类型转换，比如将指针类型转换成普通类型等等。

但是C语言的类型转换存在缺陷：

隐式类型转换有些情况下会出现问题，比如数据精度发生丢失(整形提升等)。
显式类型转换将所有情况混合在一起，代码不够清晰。

所以C++提出了自己的类型转换风格，但是仍然可以使用C语言的转换风格，因为要兼容C语言。

1、static_cast

C语言的隐式类型转换在C++中就可以使用static_cast来转换，但是不能用于两个不相关的类型进行转换。

double d = 3.14;
int a = static_cast<int>(d);

double类型转int类型，在C语言中是隐式类型转换，在C++中为了更加明确使用了static_cast。

static_cast后的<>里放要转换的类型，()里放被转换的类型。

如果将static_cast看成是类模板，<int>就是在实例化，(d)就是在拷贝构造，siatic_cast<int>(d)就是在用d构建一个匿名对象。

2、reinterpret_cast

C语言的显式类型转换在C++中就可以reinterpret_cast，用于将一种类型转换为另一种不同的类型。

int a = 1;
int* pa = &a;
int address = reinterpret_cast<int>(pa);

int*类型转换为int类型，在C语言中是显式类型转换，在C++中为了不混乱使用了reinterpret_cast。

这里如果使用static_cast进行类型转换的话会报错，必须使用reinterpret_cast。

3、 const_cast

用在删除变量的const属性，方便赋值。

const int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;

变量a原本是const属性的，不能被修改，使用了const_cast以后去除了常量属性，可以修改了，如*p = 3。

在调试窗口中可以看到，成功修改了原本是const属性的变量a。

const_cast更多的是一种警示，表示去除了const属性，要谨慎操作。

4 、dynamic_cast

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

向上转换：子类对象的指针或引用 → 父类对象的指针或引用。(不发生类型转换，是语法允许的，发生了切片)
向下转换：父类对象的指针或引用 → 子类对象的指针或引用。(用dynamic_cast转换是安全的)

//父类
class A
{
public:
	virtual void f()
	{}

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

class A是父类，class B是子类，父类中有成员变量int _a，子类中有成员变量_b。

在main函数中，传父类指针&aa给函数，在函数中将A* pa父类指针接收该值，然后将其强转为子类指针B*，使用子类指针访问子类成员，bptr->_b = 4发生运行时错误。

形参A* pa是父类指针，接收的也是父类指针，所以强转成子类指针后访问子类成员_b会发生越界。

如果传的是子类指针就不会报错，因为即使形参是父类指针，强转成子类以后并不会越界。

使用dynamic_cast将父类指针强转为父类指针。

传父类指针，然后强转为子类指针后，打印出来的结构是nullptr，表示该次转换不能进行。

传子类指针，形参的父类指针接收后再强转为子类，打印出来的结构是强转后的地址，表示该次强转可以成功。

pa如果指向的是子类对象，那么子类向上转换为父类没有问题。
pa如果指向的是父类对象，那么父类向下转换为子类是存在越界风险的。

注意：

dynamic_cast只能用于父类含有虚函数的类。
dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回nullptr。
dynamic_cast是安全的，直接使用C语言的转换方式是不安全的。

C++中的类型转换，尤其是前两种static_cast和reinterpret_cast是建议用法，可以采用也可以不采用。const_cast是一种新用法，但是存在风险，dynamic_cast是一种安全的类型转换。

三、总结

特殊类的设计中，要掌握好一点，就是只能通过一个接口来获取类，其他的方式不允许，让成员函数或私有或禁掉就可以。特别是单例模式，变成中我们经常用到。

对于类型转换，除了dynamic_cast是在多态转换中必须使用外，其他三种方式建议使用，可以增加代码的规范性。

感谢阅读！！！！！！！！！！！！！