RTTI 运行时类型识别
依靠两个工具:
- dynamic_cast
- typeid
dynamic_cast
可以转换指针类型, 引用类型, 和非左值类型(也就是&&)
常用于: 基类的指针想使用派生类的方法, 并且该方法不是虚函数的时候.
对于指针, 进行dynamic_cast运算的时候, 返回值如果为0, 代表转换失败
对于引用类型, 如果dynamic_cast转换失败, 那么那么会抛出std::bad_cast异常
typeid()
向其中传入类类型, 可以将两者进行比对.
如果传入的类型中没有虚函数, 那么会直接在编译的时候确定下来, 成为静态类型. 否则只有在运行的时候才知道类型.
Base *bp;
Derived *dp = bp;
typeid(dp) ==typeid(Base);
注意不能对指针使用typeid, 因为指针类型是没有虚函数的, 因此会直接在编译的时候就得到结果, 而且永远不会和派生类型相等.
RTTI使用举例
比较两个对象类型和成员完全相等.
- 首先保证两个传入的对象, 类型完全相等.
- 进行dynamic_cast类型转换
- 比较成员
首先, 在基类Base中定义友元函数
friend bool operator==(const Base&, const Base&);
定义虚函数 bool equal(const Base&) const;,在虚函数中进行当前类型的成员的比较
bool equal(const Base& r) const
{
//需要前文保证传入的r一定可以转换成Derived类型
auto r = dynamic_cast<const Derived&> r;
//开始比较
}
operator==的操作为
bool operator==(const Base& l, const Base& r)
{
//如果typeid判断不相等, 就不会进入到后面的转换
return typeid(l) == typeid(r) && l.equal(r);
}
typeid()返回值的类型
是type_info类型, 提供了以下方法:
.name(), 返回了C类型的字符串, 这是什么类型. 但是这个类型还会有其他信息, 不是在源代码中定义的名字. 具体信息根据不同的编译器行为不尽相同.
枚举
将所有变量组织在一起. 他们都是constexpr类型
定义的时候可以在enum变量之后加上:unsigned long long来指定这个enum使用什么整数类型来保存.
C++11之后enum分成两种, 一种是不限定作用域的enum, 一种是限定作用域的enum.
不限定作用域: 和C的用法一样.
全局可见.
enum color{red, yellow, green};
color myColor = red;
同时注意不能再声明enum beauty{red, green}, 因为red, green已经在全局出现了.
不限定作用域的enum可以隐式转换成int类型, 因此可以用来给int赋值.
限定作用域: 带上class或者struct
enum class color{red, yellow, green};
color eyes = green; //WRONG: no green in overall namespace
color eyes = color::green;
同时red, green可以在不同的类重复定义
限定作用域enum不可以隐式转换成int类型
类的成员指针
注意, 是类的成员指针, 不是对象的成员指针
我的理解是, 类的成员指针更像是某一种typedef或者using, 只是类的成员的另一种别名, 用的时候并没有被绑定到某一个对象上, 使用时还需要外部指定某一个对象.
class myClass{
string s;
}
string myClass::*pdata;//如果成员变量是const类型, 也要同时声明pdata的时候带上const
pdata = &myClass::s;
//使用的时候
myClass myObj, *myPointer = &myObj;
string s = myObj.*pdata;
s = myPointer->*pdata;
这样看来, 可能使用对象的.成员, 可能后面的东西并不一定是这个对象的成员方法/函数, 也有可能是后期外部声明的一个类的成员指针, 要注意.
如果本来是private成员, 使用类的成员指针也不能让他从外部被访问到, 所以这样看来, 类的成员指针更像是一个"别名"
也可以是指向成员函数的指针
char (Screen::*p) (string, string) const;
p = &Screen::append;
注意一定要给*p加括号; 而且指向成员函数的指针不会隐式转换, 必须在函数前加上取地址符
应用
创建一个函数列表.
class Screen{
//原有函数定义
Screen& up();
Screen& down();
Screen& left();
Screen& right();
//Action是一个指针, 可以指向任何一个上述的函数
using Action = Screen& (Screen::*)();
//创建一个enum
enum Directions {UP, DOWN, LEFT, RIGHT};
Screen& move(Directions);
private:
static Action Table[];
}
//move的定义
Screen& Screen::move(Directions d){
return (this->*Table[d])();
}
//table初始化
Screen::Action Screen::Table[] = {
&Screen::UP,
&Screen::DOWN,
&Screen::LEFT,
&Screen::RIGHT,
};
//使用的时候
Screen myScreen;
myScreen.move(Screen::LEFT);
类的成员函数作为可调用对象
正常情况下, 类的成员函数不是可调用对象, 除非使用.*或者-> *运算符绑定到特定的对象上. 因此标准库的算法运算符不可以直接接受类的成员函数指针.
auto fp = &string::empty;
find_if(vec.begin(), vec.end(), fp);//错误! 必须使用.*或者->*
因为find_if内部展开后, 会变成if(fp(*it)), 但是我们想要的是if( (it->*fp)() )
我们可以使用标准库的function, 生成"翻译"代码.
function<bool (const string&)> fcn = &string::empty;
find_if(vec.begin(), vec.end(), fcn);
if(fcn(it))会被翻译成if( ((it).*p)() )
相比于使用function, 还可以使用标准库的mem_fn, 他同时兼容了传入的成员是引用还是指针
auto f = mem_fn(&string::empty), 这个玩意可以传入string指针或者引用
或者选用bind, 需要手动提供一个原本应该隐式提供的参数(使用哪个对象的成员), 使其变成显式的.
find_if(vec.begin(), vec.end(), bind(&string::empty, _1)), bind做出来的也是同时接受string指针和引用的
union 联合
多个变量同用一个空间
和class和struct一样, 不过默认是public的.
union Token{
char cval;
int ival;
double dval;
}
Token myToken = {'c'};//初始化了char成员cval
char c = myToken.cval;
匿名union可以直接赋值, 使用成员. 一般适用于类内union, 因为union中如果有非内置类型, 那么每一次改变都需要析构原来的变量, 并构造新变量. 但是编译器不知道当前union里面存的是不是非内置类型, 所以只能手动控制析构: 每一次换类型, 要手动析构上一个非内置类型.
类似的, 还要考虑拷贝构造函数.(是new一个还是直接拷贝构造?)
不可移植的特性
意味着这次的编译针对一种环境适用, 但是其他机器不一定符合这种(如内存布局)
位域
unsigned type: 2;
unsigned size:5;
变量名字后面跟冒号, 代表占用了多少位
相邻定义的位域会被压缩在同一整数的相邻位, 相比于十七章提出的bitset, 这种方法只是压缩了空间, 并没有那么多类似于bitset的方法.
==========================
本系列终.
