一、特殊类设计
在普通类的设计基础上，提出一些限制条件设计的类就是特殊类。
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
double类型转int类型，在C语言中是隐式类型转换，在C++中为了更加明确使用了static_cast。
static_cast后的<>里放要转换的类型，()里放被转换的类型。
如果将static_cast看成是类模板，
2、reinterpret_cast
C语言的显式类型转换在C++中就可以reinterpret_cast，用于将一种类型转换为另一种不同的类型。
int a = 1;
int* pa = &a;
int address = reinterpret_cast
int*类型转换为int类型，在C语言中是显式类型转换，在C++中为了不混乱使用了reinterpret_cast。
这里如果使用static_cast进行类型转换的话会报错，必须使用reinterpret_cast。
3、 const_cast
用在删除变量的const属性，方便赋值。
const int a = 2;
int* p = const_cast
*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是在多态转换中必须使用外，其他三种方式建议使用，可以增加代码的规范性。
感谢阅读！！！！！！！！！！！！！
参考阅读
发表评论