C/C++编程：typeid 运算符

引入

C++虽然说是一种静态类型语言，但它在C++98中就部分支持动态类型了。C++98对动态类型支持就是C++中的运行时类型识别RTTI。

 

RTTI的机制就是为每个类型产生一个type_info类型的数据，程序员可以在程序中使用typeid随时查询一个变量的类型，typeid就会返回变量响应的type_info数据。而type_info的name成员函数可以返回类型的名字。而在C++11中，又增加了hash_code这个成员函数，返回该类型唯一的hash值，以供程序员对变量的类型随时进行比较：

#include <iostream>
class White{};
class Black{};

int main(){
    White a;
    Black b;
    printf("%s, %s\n", typeid(a).name(), typeid(b).name());

    White c;
    bool a_b_sametype = (typeid(a).hash_code() == typeid(b).hash_code());
    bool a_c_sametype = (typeid(a).hash_code() == typeid(c).hash_code());

    printf("Same type? (A && B) is %d, (A && C) is %d", a_b_sametype, a_c_sametype);
}

除了typeid之外，RTTI还包括了C++中的dynamic_cast等特性。不过，由于RTTI会带来一些运行时开销，所以一些编译器会提供选项让我们关闭这个特性。

作用

• 查询类型的信息。
• 用于必须知晓多态对象的动态类型的场合以及静态类型鉴别。

语法

typeid ( 类型 )	(1)
typeid ( 表达式 )	(2)

 

• 在所有情况下，typeid 都忽略顶层的 cv 限定符（即 typeid(T) == typeid(const T)）。
• 若 typeid 的操作数为类类型或到类类型的引用，则该类类型不得为不完整类型。
• 若对处于构造和销毁过程中的对象（在构造函数或析构函数之内，包括构造函数的初始化器列表或默认成员初始化器）使用 typeid，则此 typeid 所指代的 std::type_info 对象表示正在构造或销毁的类，即便它不是最终派生类。

注解

• 当应用于多态类型的表达式时，typeid 表达式的求值可能涉及运行时开销（虚表查找），其他情况下 typeid 表达式都在编译时解决。
• typeid 所指代的对象的析构函数是否在程序结束时执行是未指明的。
• 不保证同一类型上的 typeid 表达式的所有求值都指代同一个 std::type_info 实例，不过这些 type_info 对象的 std::type_info::hash_code 相同，其 std::type_index 也相同。

const std::type_info& ti1 = typeid(A);
const std::type_info& ti2 = typeid(A);
 
assert(&ti1 == &ti2); // 不保证
assert(ti1.hash_code() == ti2.hash_code()); // 保证
assert(std::type_index(ti1) == std::type_index(ti2)); // 保证

示例

//C++动态获取数据类型
//typeid是关键字
#include <iostream>
#include <cstring>
#include <typeinfo>
using namespace std;


int  main()
{
    char a;
    cout << typeid(a).name() << endl;
    cout << typeid(10).name() << endl;
    cout << typeid(10 + 1.2).name() << endl;
    cout << typeid("calc").name() << endl;   //const char [5]
    cout << typeid("冷").name() << endl;  //const char [3]

    int *px;
    int *py;

    if (strcmp(typeid(px).name(), typeid(py).name()) == 0)
    {
        cout << "==";
    }
    cin.get();
}

#include <iostream>
#include <string>
#include <typeinfo>
 
struct Base {}; // 非多态
struct Derived : Base {};
 
struct Base2 { virtual void foo() {} }; // 多态
struct Derived2 : Base2 {};
 
int main() {
    int myint = 50;
    std::string mystr = "string";
    double *mydoubleptr = nullptr;
 
    std::cout << "myint 的类型：" << typeid(myint).name() << '\n'
              << "mystr 的类型：" << typeid(mystr).name() << '\n'
              << "mydoubleptr 的类型：" << typeid(mydoubleptr).name() << '\n';
 
    // std::cout << myint 为多态类型的泛左值表达式；求值
    const std::type_info& r1 = typeid(std::cout << myint);
    std::cout << '\n' << "std::cout<<myint 的类型：" << r1.name() << '\n';
 
    // std::printf() 不是多态类型的泛左值表达式；不求值
    const std::type_info& r2 = typeid(std::printf("%d\n", myint));
    std::cout << "printf(\"%d\\n\",myint) 的类型：" << r2.name() << '\n';
 
    // 非多态左值时为静态类型
    Derived d1;
    Base& b1 = d1;
    std::cout << "非多态基类的引用：" << typeid(b1).name() << '\n';
 
    Derived2 d2;
    Base2& b2 = d2;
    std::cout << "多态基类的引用：" << typeid(b2).name() << '\n';
 
    try {
        // 解引用空指针：对于非多态表达式 OK
        std::cout << "mydoubleptr 指向 " << typeid(*mydoubleptr).name() << '\n'; 
        // 解引用空指针：对多态左值则不行
        Derived2* bad_ptr = nullptr;
        std::cout << "bad_ptr 指向...";
        std::cout << typeid(*bad_ptr).name() << '\n';
    } catch (const std::bad_typeid& e) {
         std::cout << " 捕获 " << e.what() << '\n';
    }
}