引子：在生活中我们经常有不同类的需求，因此我们有了特殊类的设计（有很多种模式等）。由于类型需求不同我们有了类型转换。今天我们就来略讲略讲一下这方面的知识。
特殊类设计（5个）
注意：关键字：explicit--防止隐式类型转换，final--该类不能被继承
一，设计一个类，不能被拷贝
思路：直接使用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;
}RTTI（字面上的意思）：
RTTI：Run-time Type identification的简称，即：运行时类型识别。
C++通过以下方式来支持RTTI：
1. typeid运算符
2. dynamic_cast运算符
3. decltype
今天就到这里啦，我们大家一起加油！
