C 语言Struct 实现运行类型识别 RTTI

通过RTTI，能够通过基类的指针或引用来检索其所指对象的实际类型。c++通过下面两个操作符提供RTTI。

（1）typeid：返回指针或引用所指对象的实际类型。

（2）dynamic_cast：将基类类型的指针或引用安全的转换为派生类型的指针或引用。

对于带虚函数的类，在运行时执行RTTI操作符，返回动态类型信息；对于其他类型，在编译时执行RTTI，返回静态类型信息。

当具有基类的指针或引用，但需要执行派生类操作时，需要动态的强制类型转换（dynamic_cast）。这种机制的使用容易出错，最好以虚函数机制代替之。

dynamic_cast 操作符

如果dynamic_cast转换指针类型失败，则返回0；如果转换引用类型失败，则抛出一个bad_cast的异常。

可以对值为0的指针使用dynamic_cast，结果为0。

class People

{

public:

    People(){}

    People(int size):m_size(m_size){}

    virtual ~People(){}

private:

    int m_size;

};

class Son : public People

{

public:

    Son(int type):m_type(type){}

    virtual ~Son(){}

    int getType(){return this->m_type ; }

private:

    int m_type;

};

int main()

{

  People *p = new People(12);

  Son  *s = new Son(10); //

  People *p1 = new Son(34);

  s = dynamic_cast<Son*>(p1) ; 

  cout << typeid(*s).name() << endl;

  cout << typeid(*p1).name() << endl;

    try{

        Son &tmp = dynamic_cast<Son &>(*p1);

        cout <<  tmp.getType() << endl;

    }catch(bad_cast)

    {

         // ���д���;

    }

typeid操作符

typeid能够获取一个表达式的类型：typeid(e)。

如果操作数不是类类型或者是没有虚函数的类，则获取其静态类型；

如果操作数是定义了虚函数的类类型，则计算运行时类型。

— 静态

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

　　包含 #include <typeinfo>　　

struct B {} b, c;

struct D : B {} d;

int main(){

    const std::type_info& tb = typeid(b);

    const std::type_info& tc = typeid(c);

    const std::type_info& td = typeid(d);

    assert(tb == tc);   // b和c具有相同的类型

    assert(&tb == &tc); // tb和tc引用的是相同的对象

    assert(tb != td);   // 虽然D是B的子类，但是b和d的类型却不同

    assert(&tb != &td); // tb和td引用的是不同的对象

}

二运行时运行识别

　　typeid 实现运行时类型识别，必须时一个动态类(含有虚函数 virtual)

struct B { virtual void foo() {} };

struct C { virtual void bar() {} };

struct D : B, C {};

void test() {

    D d;

    B& rb = d;

    C& rc = d;

    assert(typeid(rb) == typeid(d));  // rb引用的类型与d相同

    assert(typeid(rb) == typeid(rc)); // rb引用的类型与rc引用的类型相同

}

巴特西

C 语言Struct 实现运行类型识别 RTTI

最新文章

热门文章