特殊工具与技术

 --运行时类型识别

引：

通过下面两个操作符提供RTTI:

1.typeid操作符,返回指针或引用所指对象的实际类型。

2.dynamic_cast操作符,将基类类型的指针或引用安全地转换为派生类型的指针或引用。

对于带虚函数的类,在运行时执行RTTI操作符,但对于其他类型,在编译时计算RTTI操作符。

当具有基类的引用或指针,但需要执行不是基类组成部分的派生类操作的时候,需要动态的强制类型转换。通常,从基类指针获得派生类行为最好的方法是通过虚函数。当使用虚函数的时候,编译器自动根据对象的实际类型选择正确的函数。

但是,在某些情况下,不可能使用虚函数。在这些情况下,RTTI提供了可选的机制。然而,这种机制比使用虚函数更容易出错:程序员必须知道应该将对象强制转换为哪种类型,并且必须检查转换是否成功执行了。

一、dynamic_cast操作符

可以使用dynamic_cast操作符将基类类型对象的引用或指针转换为同一继承层次中其他类型的引用或指针。与dynamic_cast一起使用的指针必须是有效的—— 它必须为0或者指向一个对象。

与其他强制类型转换不同,dynamic_cast涉及运行时类型检查。如果绑定到引用或指针的对象不是目标类型的对象,则dynamic_cast失败。如果转换到指针类型的dynamic_cast失败,则dynamic_cast的结果是0值;如果转换到引用类型的dynamic_cast失败,则抛出一个bad_cast类型的异常。

１、使用dynamic_cast操作符

1. if(Derived*derivedPtr=dynamic_cast<Derived*>(basePtr))
2. {
3. //...
4. }
5. else
6. {
7. //...
8. }

解释：在运行时,如果basePtr实际指向Derived对象,则转换将成功,并且derivedPtr将被初始化为指向basePtr所指的Derived对象;否则,转换的结果是0,意味着将derivedPtr置为0,并且if中的条件失败。同时也可以对值为0的指针应用dynamic_cast,这样做的结果是0。

【最佳实践】

在条件中执行dynamic_cast保证了转换和其转换结果测试在一个表达式中进行！

２、使用dynamic_cast和引用类型

形式：

1. dynamic_cast<Type&>(val);

只有val实际引用的是一个Type类型对象，或者val是一个Type派生类型的对象的时候，dynamic_cast操作才将操作数val转换为Type&类型。

因为不存在空引用,所以不可能对引用使用用于指针强制类型转换的检查策略,相反,当转换失败的时候,它抛出一个std::bad_cast异常,该异常在库头文件typeinfo中定义。

1. voidf(constBase&b)
2. {
3. try
4. {
5. constDerived&d=dynamic_cast<Derived&>(b);
6. }
7. catch(std::bad_cast)
8. {
10. }
11. }

1. //P648习题18.13-15
2. //1)
3. classA
4. {
5. public:
6. virtualvoidfunc()
7. {}
8. };
9. classB:publicA{};
10. classC:publicB{};
11. classD:publicB,publicA{};
13. intmain()
14. {
15. Cc;
16. A*pa=&c;
17. if(C*pc=dynamic_cast<C*>(pa))
18. {
19. cout<<"dynamic_castsuccess"<<endl;
20. }
21. else
22. {
23. cout<<"dynamic_castfail"<<endl;
24. }
25. }

1. //2)
2. try
3. {
4. C&temp=dynamic_cast<C&>(*pa);
5. }
6. catch(std::bad_cast&e)
7. {
8. cout<<e.what()<<endl;
9. }

1. //18.16什么时候可以使用dynamic_cast代替虚函数
2. /**答：
3. *当我们需要在派生类中增加函数，但又不能在基类增加虚函数时
4. *就可以使用dynamic_cast代替虚函数
5. */

二、typeid操作符

typeid操作符使程序能够问一个表达式:你是什么类型?

1. typeid(e)

如果表达式的类型是类类型且该类包含一个或多个虚函数,则表达式的动态类型可能不同于它的静态编译时类型。例如,如果表达式对基类指针解引用,则该表达式的静态编译时类型是基类类型;但是,如果指针实际指向派生类对象,则typeid操作符将说表达式的类型是派生类型。

typeid操作符可以与任何类型的表达式一起使用。内置类型的表达式以及常量都可以用作typeid操作符的操作数。如果操作数不是类类型或者是没有虚函数的类,则typeid操作符指出操作数的静态类型;如果操作数是定义了至少一个虚函数的类类型,则在运行时计算类型。

typeid操作符的结果是名为type_info的标准库类型的对象引用,要使用type_info类,必须包含库头文件typeinfo。

使用typeid操作符

typeid最常见的用途是比较两个表达式的类型，或将表达式的类型与特定类型相比较：

1. Base*pb;
2. Derived*pd;
4. if(typeid(*pb)==typeid(*pd))
5. {
6. cout<<"typeid(*pb)=typeid(*pd)"<<endl;
7. }
9. if(typeid(pb)==typeid(pd))
10. {
11. cout<<"typeid(pb)=typeid(pd)"<<endl;
12. }
14. if(typeid(*pb)==typeid(Derived))
15. {
16. cout<<"typeid(*pb)=typeid(Base)"<<endl;
17. }
19. inta;
20. if(typeid(int)==typeid(a))
21. {
22. cout<<"typeid(int)=typeid(a)"<<endl;
23. }

【小心地雷】

只有当typeid的操作数是带虚函数的类类型的对象的时候，才返回动态类型信息。测试指针（相当于指针指向的对象）返回指针的静态的、编译时类型。

1. Derivedd;
2. Base*pb=&d;
4. if(typeid(*pb)==typeid(Derived))
5. {
6. cout<<"typeid(*pb)=typeid(Base)"<<endl;
7. }

如果指针pb的值是0,那么,如果pb的类型是带虚函数的类型,则typeid(*p)抛出一个bad_typeid异常;如果p的类型没有定义任何虚函数,则结果与p的值是不相关的。

1. //P650习题18.17
2. AndQuerya;
3. Query_base*qb1=&a,*qb2;
5. if(dynamic_cast<AndQuery*>(qb1))
6. cout<<"success"<<endl;
7. else
8. cout<<"failure"<<endl;
10. if(dynamic_cast<AndQuery*>(qb2))
11. cout<<"success"<<endl;
12. else
13. cout<<"failure"<<endl;

1. //习题18.18
2. try
3. {
4. dynamic_cast<AndQuery&>(*qb1);
5. cout<<"success"<<endl;
6. }
7. catch(std::bad_cast)
8. {
9. cout<<"failure"<<endl;
10. }
12. try
13. {
14. dynamic_cast<AndQuery&>(*qb2);
15. cout<<"success"<<endl;
16. }
17. catch(std::bad_cast)
18. {
19. cout<<"failure"<<endl;
20. }

1. //习题18.19
2. AndQuerya;
3. Query_base*qb1=&a,*qb2;
5. try
6. {
7. dynamic_cast<AndQuery&>(*qb1);
9. if(typeid(*qb1)==typeid(AndQuery))
10. {
11. cout<<"Same"<<endl;
12. }
13. else
14. {
15. cout<<"NotSame"<<endl;
16. }
17. }
18. catch(std::bad_cast)
19. {
20. cout<<"failure"<<endl;
21. }
23. if(typeid(*qb1)==typeid(*qb2))
24. {
25. cout<<"Same"<<endl;
26. }
27. else
28. {
29. cout<<"NotSame"<<endl;
30. }