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的方法.

==========================

本系列终.

Chapter 19 Special Tools& Technology 特殊工具和方法