1. RTTI
RTTI是运行阶段类型识别(Running Type Identificarion)的简称。
如何知道指针指向的是哪种对象？
这是个很常见的问题,由于我们允许使用基类指针指向派生类,所以基类指针指向的对象可能是基类对象,也可能是派生类对象。但是我们需要知道对象种类,因为我们需要使用正确的类方法。
RTTI能解决上述问题。
1.1 dynamic_cast运算符
dynamic_cast是最常用的RTTI组件,它不能回答"指针指向的是哪类对象",但是它能回答"是否可以安全的将对象的地址赋给特定类型指针"。
什么是安全?
例如:A是基类,B是A的派生类,C是B的派生类。那么将BC对象的地址赋给A指针是安全的,而反向就是不安全的。因为公有继承满足is-a关系,指针和引用进行向上转换是安全的,向下转换就是不安全的。
dynamic_cast的用法是:
dynamic_cast<Type*>(ptr)或dynamic_cast<Type&>(ref)
可以看到的是,dynamic_cast是一种类型转换符,它支持指针间的转换,他将ptr的类型转换成Type*,如果这种转换是安全的,那会返回转换后的指针;如果不安全那就会返回空指针。对于引用的话,他将ref的类型转换成Type&,如果这种转换是安全的,那就返回转换后的引用;如果不安全那就会引发bad_cast异常。
总之,dynamic_cast类型转换运算符比C风格的类型转换要安全的多,而且它能够判断转换是否安全。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
//RTTI1.cpp
#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
class Grand
{
protected:
int hold;
public:
Grand(int h=0):hold(h){};
virtual void Speak() const {cout<<"I am Grand class!\n";}
};
class Superb:public Grand
{
public:
Superb(int h=0):Grand(h){}
virtual void Speak() const {cout<<"I am a superb class!\n";}
virtual void Say() const {cout<<"the value: "<<Grand::hold<<endl;}
};
class Magnificent:public Superb
{
private:
char ch;
public:
Magnificent(int h=0,char c='A'):Superb(h),ch(c){}
virtual void Speak() const{cout<<"I am a Magnificent class!\n";}
virtual void Say() const{cout<<"the character: "<<ch<<endl<<"the value: "<<Grand::hold<<endl;}
};
Grand *GetOne();
int main()
{
srand(time(0));
Grand *pg;
Superb *ps;
for(int i=0;i<5;i++)
{
pg=GetOne();
pg->Speak();
if(ps=dynamic_cast<Superb*>(pg))
{
ps->Say();
}
}
delete pg;
return 0;
}
Grand * GetOne()
{
Grand *p;
switch (rand()%3)
{
case 0:
p=new Grand(rand()%100);
break;
case 1:
p=new Superb(rand()%100);
break;
case 2:
p=new Magnificent(rand()%100,'A'+rand()%26);
break;
}
return p;
}
|
I am a Magnificent class!
the character: I
the value: 74
I am a superb class!
the value: 50
I am Grand class!
I am Grand class!
I am a Magnificent class!
the character: V
the value: 99
上面这个例子说明了重要的一点:尽可能使用虚函数,而只在必要时使用RTTI。
如果将dynamic_cast用于引用,当请求不安全的时候,会引发bad_cast异常,这种异常时从exception类派生而来的,它在头文件typeinfo中定义。
则我们可以使用如下方式处理异常:
|
1
2
3
4
5
6
7
8
9
10
|
#include<typeinfo>
...
try{
Superb & rs= dynamic_cast<Superb &>(rg);
....
}
catch(bad_cast &)
{
...
};
|
1.2 typeid运算符
type_info类是在头文件typeinfo中定义的一个类。type_info类重载了==和!=运算符。
typeid是一个运算符,它返回一个对type_info的引用,它可以接受2种参数:类名和对象。typeid是真正回答了"指针指向的是哪类对象"。
(实际上,typeid也可以用于其他类型,例如结构体,函数指针,各种类型,只要sizeof能接受的,typeid都能接受)
用法：
typeid(Magnificent)==typeid(*pg)
如果pg是一个空指针,则会引发bad_typeid异常。
type_info类中包含一个name()接口,该接口返回字符串,一般情况下是类的名称。
cout<<typeid(*pg).name()<<".\n"
例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
//RTTI2.cpp
#include<iostream>
#include<cstdlib>
#include<ctime>
#include<typeinfo>
using namespace std;
class Grand
{
protected:
int hold;
public:
Grand(int h=0):hold(h){};
virtual void Speak() const {cout<<"I am Grand class!\n";}
};
class Superb:public Grand
{
public:
Superb(int h=0):Grand(h){}
virtual void Speak() const {cout<<"I am a superb class!\n";}
virtual void Say() const {cout<<"the value: "<<Grand::hold<<endl;}
};
class Magnificent:public Superb
{
private:
char ch;
public:
Magnificent(int h=0,char c='A'):Superb(h),ch(c){}
virtual void Speak() const{cout<<"I am a Magnificent class!\n";}
virtual void Say() const{cout<<"the character: "<<ch<<endl<<"the value: "<<Grand::hold<<endl;}
};
Grand *GetOne();
int main()
{
srand(time(0));
Grand *pg;
Superb *ps;
for(int i=0;i<5;i++)
{
pg=GetOne();
cout<<"Now processing type "<<typeid(*pg).name()<<".\n";
pg->Speak();
if(ps=dynamic_cast<Superb*>(pg))
{
ps->Say();
}
if(typeid(Magnificent)==typeid(*pg))
{
cout<<"Yes,you are really magnificent.\n";
}
}
delete pg;
return 0;
}
Grand * GetOne()
{
Grand *p;
switch (rand()%3)
{
case 0:
p=new Grand(rand()%100);
break;
case 1:
p=new Superb(rand()%100);
break;
case 2:
p=new Magnificent(rand()%100,'A'+rand()%26);
break;
}
return p;
}
|
Now processing type 6Superb.
I am a superb class!
the value: 64
Now processing type 11Magnificent.
I am a Magnificent class!
the character: Y
the value: 30
Yes,you are really magnificent.
Now processing type 5Grand.
I am Grand class!
Now processing type 11Magnificent.
I am a Magnificent class!
the character: C
the value: 3
Yes,you are really magnificent.
Now processing type 5Grand.
I am Grand class!
注意,你可能发现了typeid远比dynamic_cast优秀的多,typeid会直接告诉你类型是什么,而dynamic_cast只告诉你是否可以类型转换。但是typeid的效率比dynamic_cast低很多,所以,请优先考虑dynamic_cast和虚函数,如果不行才使用typeid。
2. cast运算符
C语言中的类型转换符太过随意,C++创始人认为,我们应该使用严格的类型转换,则C++提供了4个类型转换运算符:
- dynamic_cast
- const_cast
- static_cast
- reinterpret_cast
dynamic_cast运算符已经介绍过了,它的用途是,使得类层次结构中进行向上转换,而不允许其他转换。
const_cast运算符,用于除去或增加 类型的const或volatile属性。
它的语法是:
const_cast<type-name>(expression)
如果类型的其他方面也被修改,则上述类型转换就会出错,也就是说,除了cv限定符可以不同外,type_name和expression的类型必须相同。
提供该运算符的目的是:有时候我们需要一个值:它在大多数情况下是常量,而有时候我们需要更改它。
看一个有趣的例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//cast运算符1.cpp
//cast运算符1.cpp
#include <iostream>
int main()
{
using std::cout;
using std::endl;
volatile const int a=100;
volatile const int & ra=a;//无法通过ra修改a
int &change_a=const_cast<int &>(ra);//可以通过change_a修改a;
change_a=255;
cout<<a<<endl;
}
|
上面最后这个a常量被修改成255,这是我们预期的结果。但是如果我把volatile关键词去掉,那么a的值还是100。其实是编译器在这里玩了个小聪明，const int a=100，编译器认为a就不会发生改变了，所以就把a放在了寄存器中，因为访问寄存器要比访问内存单元快的多，每次都从寄存器中取数据，但是后来a在内存中发生变化后，寄存器中的数据没有发生变化，所以打印的是寄存器中的数据。解决这一问题,就使用volatile关键词,那么对a的存取都是直接对内存做操作的。
static_cast运算符
它的语法是:
static_cast<type-name>(expression)
仅当type-name可被隐式转换成expression所属的类型或者expression可以隐式转换成type-name类型时,上述转换才合法,否则出现bad_cast异常。
例如,枚举值可以隐式转换成整型,那么整型就可以通过static_cast转换成枚举型。
总之,static_cast只允许"相似"的类型间的转换,而不允许"差异很大"的类间的转换。
reinterpret_cast运算符:重新诠释类型,进行疯狂的类型转换
它的语法时:
reinterpret_cast<type-name>(expression)
它可以进行类型间"不可思议"的互换,但是它不允许删除const,也不允许进行丧失数据的转换
例如下面这两个例子:
|
1
2
3
4
5
6
7
8
9
|
#include<iostream>
int main()
{
using namespace std;
struct dat {short a; short b;};
long value =0xA224B118;
dat *pd=reinterpret_cast<dat*>(&value);
cout<<hex<<pd->a;
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#include<iostream>
void fun()
{
std::cout<<"hello world!\n";
}
int main()
{
using namespace std;
void (*foo)();
foo=fun;
int* p=reinterpret_cast<int*>(foo);
}
|
通常,reinterpret_cast转换符适用于底层编程技术,是不可移植的,因为不同系统可能使用不同大小,不同顺序来存储同一类型的数据。
总之,C语言类型转换比reinterpret_cast还要"疯狂",非常不安全,所以推荐使用cast运算符来实现类型转换
