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

妖狐艹你老母 2022-05-21 13:04 277阅读 0赞

# 引入 #

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);
    }

# ![20210430140727967.png][] #

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

# 作用 #

*  查询类型的信息。
 *  用于必须知晓[多态对象][Link 1]的[动态类型][Link 2]的场合以及静态类型鉴别。

# 语法 #

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><code><strong>typeid</strong></code>&nbsp;<code><strong>(</strong></code>&nbsp;类型&nbsp;<code><strong>)</strong></code></td> 
   <td>(1)</td> 
  </tr> 
  <tr> 
   <td><code><strong>typeid</strong></code>&nbsp;<code><strong>(</strong></code>&nbsp;表达式&nbsp;<code><strong>)</strong></code></td> 
   <td>(2)</td> 
  </tr> 
 </tbody> 
</table>

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

# 注解 #

*  当应用于多态类型的表达式时，typeid 表达式的求值可能涉及运行时开销（虚表查找），其他情况下 typeid 表达式都在编译时解决。
 *  `typeid` 所指代的对象的析构函数是否在程序结束时执行是未指明的。
 *  不保证同一类型上的 typeid 表达式的所有求值都指代同一个 [std::type\_info][std_type_info] 实例，不过这些 type\_info 对象的 [std::type\_info::hash\_code][std_type_info_hash_code] 相同，其 [std::type\_index][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();
    }

![2021031817463888.png][]

#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';
        }
    }

![20210318175444257.png][]

[20210430140727967.png]: /images/20220521/aa2dde0952a94489b417264b6998102f.png
[Link 1]: https://zh.cppreference.com/w/cpp/language/object#.E5.A4.9A.E6.80.81.E5.AF.B9.E8.B1.A1
[Link 2]: https://zh.cppreference.com/w/cpp/language/type#.E5.8A.A8.E6.80.81.E7.B1.BB.E5.9E.8B
[Link 3]: https://zh.cppreference.com/w/cpp/language/type#.E4.B8.8D.E5.AE.8C.E6.95.B4.E7.B1.BB.E5.9E.8B
[Link 4]: https://zh.cppreference.com/w/cpp/language/initializer_list
[Link 5]: https://zh.cppreference.com/w/cpp/language/data_members#.E6.88.90.E5.91.98.E5.88.9D.E5.A7.8B.E5.8C.96
[std_type_info]: https://zh.cppreference.com/w/cpp/types/type_info
[std_type_info_hash_code]: https://zh.cppreference.com/w/cpp/types/type_info/hash_code
[std_type_index]: https://zh.cppreference.com/w/cpp/types/type_index
[2021031817463888.png]: /images/20220521/b2d33fc72f5e45a4ac8802345a790674.png
[20210318175444257.png]: /images/20220521/92433c2320af49e2bb789859e7cf4aed.png