前言：刚找到新工作，这两天忙着搬家，添加一些日用品，好方便日后使用，浪费了蛮多时间的。所以到现在才补上这一章节。
之前跳过了RTTI，去看下一部分的类型转换运算符，被dynamic_cast搞的很头晕（主要是因为没搞懂为什么用这个），只能回头补上这一节，这时才发现，这一节是不能跳过的。
另外，这小节说实话，蛮难理解的（主要是指其原理，和为什么要有dynamic_cast这个类型转换运算符），这里简单的来概括，就是让指针只有在能安全使用转换后的类方法的情况下，才会被强制转换。
————————————————————————————————————————————————————————————
注：跳过了第十五章的异常。
所谓RTTI，是运行阶段类型识别（Runtime TypeIdentification）的简称，这是添加到C++中的特性之一。
很多老式的实现不支持，另一些实现可能包含开关RITI的编译器设置。
RTTI旨在为程序在运行阶段确定对象的类型提供一种标准方式。很多类库已经为其类对象提供了实现这种功能的方式，但是由于C++内部并不支持，因此各个厂商的机制通常互不兼容。创建一种RTTI语言标准将使得未来的库能够彼此兼容。
RTTI的用途：
假如有一个类层次结构，其中的类都是从同一个基类M派生而来的（他们可能之中可能有二代、三代甚至更多的派生类，但都不是多重继承，并且基类是M或者是M的派生类）。因此，可以让基类指针（M*）指向其中任何一个类的对象（因为基类指针可以指向派生类对象）。
然后，基类指针调用这样一个函数：这个函数的功能是处理一些信息后，选择一个类，并创建该类的对象（例如A类方法内，创建一个B类对象；而在C类方法内，创建一个D类对象。但此时，我们并不知道这个基类指针调用的是A类的方法，还是C类的方法，因此自然也不知道创建的什么类的对象了）。
然后返回创建的新对象的地址，并将这个对象的地址赋给基类指针（这是可以的，这个基类指针指向了另一个派生类的对象）。
那么问题来了，在这个时候，这个基类指针是指向B类对象，还是D类对象呢？
当我们需要解决某些问题的时候，我们需要知道这件事，因此这也就是RTTI的用途。
为什么要知道指针指向的类型：
当我们需要知道类型时，在以上的基础上，有三种情况：
①我们可能需要调用类方法的正确版本。
例如：如果我们需要调用某一个类方法时。
（1）该类方法都是虚方法，且需要调用对应类的类方法，则无需知道，指针会根据指向对象的类型调用对应的类方法。
（2）该类方法都是虚方法，但需要调用基类的类方法，需要知道类型。因为基类A可能是派生类C的基类B的私有成员（即B是A类的派生类，且是私有继承，而C类又是B类的基类），若是这种情况，则无法使用基类的方法（因为不能访问基类对象，更不要说基类的方法了）。
②需要使用不同的方法。例如假如是派生类B，则使用a方法，如果是派生类c，则使用b方法。那么自然需要知道类型，才能正确的使用计划之中的方法。
③可能出于调试目的，想跟踪生成的对象的类型。看看生成的对象，是不是自己计划中想要生成的，会不会出现想要生成一个A类对象，却生成了一个B类对象。因此，需要通过知道类型，来检测。
可以看出，以上三种情况，都需要知道类型。因此，需要RTTI。
RTTI的工作原理：
C++有3个支持RTTI的元素：
①如果可能的话，dynamic_cast运算符将使用一个指向基类的指针来生成一个指向派生类的指针。如果做不到，则该运算符返回一个空指针（0）。
②typeid运算符返回一个指出对象的类型的值。
③type_info结构存储了有关特定类型的信息。
只能将RTTI用于包含虚函数的类层次结构，原因在于，只有在这种情况下，才应该将派生类地址赋给基类指针。
警告：RTTI只适用于包含虚函数的类。
也就是说，如果想使用RTTI，基类和派生类必须要有虚函数，否则无法使用。
dynamic_cast运算符：（总的来说，有的迷糊）
dynamic_cast运算符的作用在于，其用于确定和回答“是否可以安全的将对象的地址赋给特定类型的指针”。
其格式为：A类*ph= dynamic_cast <B类*>( pl ) ;
解释：
①一般A类是派生类，B类是A类或者A类的派生类（如果B类是A类的派生类的话，意思是将指向派生类对象的地址(因为将其进行类型转换了)的指针pl赋值给基类指针ph，因为基类指针指向派生类对象的地址是安全的，反过来则不安全）；
②作用是：将一个指针pl（其类型待定，也不确定其指向对象是基类还是派生类），将其类型转换为B类（类型不定）后赋值给A类的（A类是B类的基类或者是B类，但总之是基类的派生类）指针ph。
此时， A类的指针，指向了另一个对象的地址，而这个对象的类型有三种可能：A类／A类的基类／A类的派生类。只有当对象是A类和A类的派生类时，这种转换才是安全的。
③使用dynamic_cast的前提是多态（但不太明白为什么）。
④之所以这么做，有一种可能是基类指针虽然可能指向派生类对象，但只能调用基类的方法。如果想要调用派生类方法，则需要转换，但强制转换不一定是安全的（因为我们不确定其是否指向派生类对象），因此需要这个命令来告诉我们是否是安全的。
⑤这个过程不转换pl的类型
举个例子，例如A类是基类，B类是A类的派生类，C类是B类的派生类（A->B->C）。
①当A类指针a，指向C类对象时，这是可以的（基类指针可以指向派生类对象）。注意，A类指针a的值，是C类对象的地址。
那么将这个A类指针a，强制类型转换为C类指针是否可以呢，答案是可以的。
因为这样做的结果是，C类指针c，指向一个C类对象（强制类型转换后，其值相同，只不过类型变了）。
之所以说是安全的，因为不会产生那种派生类指针调用方法时，调用的是派生类方法，却因为指向基类对象而导致在基类中不存在派生类的同名方法，从而出现调用失败。（见下面代码）（基类指针指向派生类对象之所以安全，是因为基类方法必然被派生类所继承，必然存在继承而来的方法或者同名方法）。
②那么假如A类指针a，指向A类对象，被强制转换为C类指针并被赋值给C类指针c（此时，派生类指针指向一个基类对象）
那么这种做法就是不安全的。
假如c调用的方法是基类有的，那么可能不出现问题。
但是假如c调用的方法，是基类A没有的（这是可能的，因为派生类指针理应可以使用派生类有方法，所以编译器无法检测出这种错误）；
那就会出现问题（预料之外的问题）。
如代码：
#include<iostream>
class B
{
int a = 0;
public:
virtual void add() { a++; }
};
class A :private B
{
int c = 1;
public:
virtual void add() { B::add(); c ++; }
void mm() { std::cout << c << std::endl; }
};
int main()
{
using namespace std;
B b;
B*ph = &b; //基类指针指向基类的地址
A*pl = (A*)ph; //将基类指针强行转换为派生类指针，并将地址赋值给派生类指针。此时派生类指针指向了一个基类对象的地址
pl->mm(); //指向基类对象的派生类指针调用派生类方法。因此方法调用会输出错误的结果
pl = dynamic_cast<A*>(ph); //使用dynamic_cast进行转换，如果是安全的，pl则不是空指针
if (pl == nullptr)cout << "qqqq" << endl; //如果是空指针，则输出qqqq
A*pll = new A; //派生类指针指向派生类对象
pll->mm(); //因此方法调用是正常的
delete pll;
A pp;
A* qq = &pp; //派生类指针指向派生类对象
pll = dynamic_cast<A*>(qq); //使用dynamic_cast进行转换，如果是安全的，则不是空指针
if (pll == 0)cout << "3333" << endl; //如果输出了3333，则说明是空指针，上一行代码的转换并不安全
system("pause");
return 0;
}
其输出结果是：
-858993460 qqqq 1 请按任意键继续. . .
可以从输出结果看到，正常指向派生类对象的mm方法输出的内容是1（因为c被初始化为1），而指向基类对象的mm方法输出的内容是错误的，甚至可能运行出错。
因此，指向基类对象的派生类指针，是不安全的。
而一个指向派生类对象的基类指针，是安全的；
并且，将该指针转换为一个不高于其派生类层次的（即是该派生类或该派生类的基类的类型的）指针，并赋值给同样不高于该派生类层次的指针，也是安全的。
因为有区别，所以这是dynamic_cas的存在目的。
上代码，用代码表示其作用：
//程序目的：随机创造一个类型的对象，并对其初始化，然后将地址以A类形式返回，并赋给A类指针，然后用A类指针调用show函数（虚函数，三个类都有）
//之后，再尝试用A类指针用dynamic_cast转化为B类指针，查看是否安全，如果安全，则调用take函数（虚的，只有B和C有）
//在第二步的时候，如果不安全，则输出一个提示信息，如果安全，因为take函数是虚的，因此会根据其指向的对象，输出对应类的take函数。
#include<iostream>
#include<ctime>
using namespace std;
class A
{
public:
virtual void show() { cout << "This is A show." << endl; }
};
class B :public A
{
public:
virtual void show() { cout << "This is B show." << endl; }
virtual void take() { cout << "B take out one thing." << endl; }
};
class C :public B
{
public:
virtual void show() { cout << "This is C show." << endl; }
virtual void take() { cout << "C take out one thing." << endl; }
};
A* GetOne() //随机创造A、B、C对象之一，并返回其地址（以指针形式，类型为A*）
{
int i = rand() % 3;
A* one;
if (i == 0)
one = new A;
else if (i == 1)
one = new B;
else one = new C;
return one;
}
int main()
{
A* pp;
srand(time(0));
for (int i = 0; i < 5; i++)
{
pp = GetOne(); //随机创造一个类对象，返回其地址，用基类（A）指针指向它
pp->show(); //基类指针根据指向对象输出对应的虚方法
B* pa = dynamic_cast<B*>(pp); //B类指针
if (pa == NULL)cout << "错误的转换，pa是空指针" << endl; //如果不安全，则输出提示信息
else pa->take(); //如果安全，则输出对应的方法
cout << endl; //空一行表示间隔
delete pp;
}
system("pause");
return 0;
}
显示：
This is B show. B take out one thing. This is A show. 错误的转换，pa是空指针 This is B show. B take out one thing. This is C show. C take out one thing. This is A show. 错误的转换，pa是空指针 请按任意键继续. . .
总结：
①可以发现，在转换并不安全时（即B类指针pa指向的是A类对象时，基类调用派生类方法是不正确的），返回NULL。因此可以鉴别。
②程序可能不支持RTTI，或者支持，但是关闭了这个功能。如果是后者，那么可能编译的时候没问题，但是运行的时候出现问题。
③另外，dynamic_cast也可以用于引用。只不过，由于没有与NULL对应的引用值，因此当请求不正确时，dynamic_cast将引发类型为bad_cast的异常。该异常是从exception类派生而来的，他是在头文件typeinfo定义的。书上另外给了一个例子，但是因为我跳过了异常章节，所以看不懂。
typeid运算符和type_info类：
typeid运算符使得能够确定 两个对象是否为
同种类型。
格式为：typeid ( 对象A )== typeid (
对象B);
解释：它与sizeof有些相像，可以接受两种参数（即对象A和对象B所在的位置）：
①类名；
②结果为对象的表达式。（如对象名，或者是指向对象的指针使用了解除引用运算符。
这段看到这里是不懂的，只知道可以用“==”和“!=”来判断左右两边类型是否相同==>>typeid运算符返回一个对type_info对象的引用（这句话的意思可以看后面的解释）。其中，type_info是在头文件typeinfo（以前是typeinfo.h）中定义的一个类。type_info类重载了“==”和“!=”运算符，以便可以使用这些运算符来对类型进行比较。
另外：不能使用cout<< typeid( xxx)来输出，只能使用==和!=
例如，如果pg指向的是一个C类对象，则下述表达式的结果为boo值true，否则为false：
typeid (C) ==typeid (*pg);
注意：如果pg是一个空指针NULL，将引发bad_typeid异常。该异常类型是从exception类派生而来的，是在头文件typeid中声明的。
type_info类的实现随厂商而异，但包含一个name()成员，该函数返回一个随实现而异的字符串：通常（但并非一定）是 类的名称。
其格式为：typeid ( 某类型对象).name();
如：
cout << "当前类型为："
<< typeid(*pp).name()<<endl;
//输出pp指针指向对象的类型
修改上面代码的主函数部分为：
int main()
{
A* pp;
srand(time(0));
for (int i = 0; i < 5; i++)
{
pp = GetOne(); //随机创造一个类对象，返回其地址，用基类（A）指针指向它
pp->show(); //基类指针根据指向对象输出对应的虚方法
B* pa = dynamic_cast<B*>(pp); //B类指针
if (pa == NULL)cout << "错误的转换，pa是空指针" << endl; //如果不安全，则输出提示信息
else pa->take(); //如果安全，则输出对应的方法
if (typeid(B) == typeid(*pp))cout << "对象类型为B" << endl; //指针指向对象的类型是否为B，如果是B返回true，否则false
else cout << "对象类型不为B" << endl;
cout << "当前类型为：" << typeid(*pp).name() << endl; //输出pp指针指向对象的类型
cout << endl; //空一行表示间隔
delete pp;
}
int mm;
cout << "int类型变量mm的类型为：" << typeid(mm).name() << endl; //调用name()方法输出int类型的变量的类型
system("pause");
return 0;
}
输出结果：
This is C show. C take out one thing. 对象类型不为B 当前类型为：class C This is C show. C take out one thing. 对象类型不为B 当前类型为：class C This is B show. B take out one thing. 对象类型为B 当前类型为：class B This is A show. 错误的转换，pa是空指针 对象类型不为B 当前类型为：class A This is A show. 错误的转换，pa是空指针 对象类型不为B 当前类型为：class A int类型变量mm的类型为：int 请按任意键继续. . .
总结：
①问题：书上说需要头文件typeinfo，但是我不加这个头文件也可以使用，不知道为什么。我的编译器是VS2015。
②之前说过，typeid运算符返回的是一个对type_info对象的引用。
例如typeid(*pp) 之所以能调用name()方法，正是因为其表示的是一个类对象，name方法是该类的类方法。
③编译器不同时，name()方法输出的内容有可能不同（例如我目前使用的vs2015，输出的内容是class xx）。
误用RTTI的例子：
判断是否安全，应使用dynamic_cast，判断类型是否一样，用typeid。
所谓的误用，我大概概括了一下，就指的是错误的使用，反而让代码更复杂和繁琐了。
假如需要当指针指向不同类型时，调用对应类型对象的同名方法，则应该是使用dynamic_cast和虚函数（因为是同名方法，使用虚函数会根据指针指向的对象类型而决定选择哪个，如果是NULL，则不调用）。
例如可以将以下代码修改：
B* pa =
dynamic_cast<B*>(pp);
//B类指针
if (pa ==
NULL)cout<<"错误的转换，pa是空指针"
<< endl; //如果不安全，则输出提示信息
else pa->take();
//如果安全，则输出对应的方法
修改为：
B* pa;
//B类指针
if (pa =
dynamic_cast<B*>(pp))pa->take();
//如果安全，则输出对应的方法
else cout <<"错误的转换，pa是空指针"
<< endl; //如果不安全，则输出提示信息
if判断语句中的pa=dynamic_cast<B*>(pp)表达式，假如是空指针，则表达式的结果为0（将0赋值给pa），执行else；如果不是空指针，则执行pa->take()。
问题：
书上说，如果放弃dynamic_cast和虚函数，将代码改为类似这样的：
int main()
{
srand(time(0));
for (int i = 0; i < 5; i++)
{
A *pp = GetOne(); //随机创造一个类对象，返回其地址，用基类（A）指针指向它
if (typeid(C) == typeid(*pp))
cout << "1" << endl;
else if (typeid(B) == typeid(*pp))
cout << "2" << endl;
else
cout << "3" << endl;
cout << endl; //空一行表示间隔
delete pp;
}
system("pause");
return 0;
}
可以起作用（即根据pp指向的对象决定输出哪个）。
但是我实际操作中，假如不使用虚函数，pp的类型则只为A类，而不会成为B类和C类。
只有加上虚函数后，代码才会和书上的运行结果相同。
我的编译器是VS2015，不知道是不是因为编译器的原因。
按书上的说法，假如if else句式中使用了typeid，则应该考虑是否应该使用dynamic_cast。
备注：
这小节我学的还是有点头晕，可能是因为没有和实际结合使用的原因。也许遇见了实际情况，就知道该如何使用了。