命名空间
变体
操作

typeid 运算符

来自 cppreference.com
< cpp‎ | 语言
 
 
C++ 语言
一般主题
流程控制
条件执行语句
if
迭代语句(循环)
for
范围-for (C++11)
跳转语句
函数
函数声明
Lambda 函数表达式
inline 说明符
动态异常说明 (直到 C++17*)
noexcept 说明符 (C++11)
异常
命名空间
类型
说明符
const/volatile
decltype (C++11)
auto (C++11)
constexpr (C++11)
consteval (C++20)
constinit (C++20)
存储持续时间说明符
初始化
 
 

查询类型的相关信息。

用于必须了解动态类型多态对象和静态类型识别。

内容

[编辑] 语法

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

typeid 表达式是左值表达式,它引用具有静态存储持续时间的对象,该对象是多态类型std::type_info或从它派生的某个类型的 const 限定版本。

如果在使用 typeid 时,std::type_info 的标准库定义不可见,则程序格式错误。

[编辑] 解释

如果 类型表达式 的类型是类类型或对类类型的引用,则该类类型不能是不完整类型

1) 引用表示 类型std::type_info 对象。如果 类型 是引用类型,则结果将引用表示引用类型的 cv 无限定版本的 std::type_info 对象。
2) 检查 表达式 
  • 如果 表达式左值(直到 C++11)泛左值(自 C++11 起) 表达式,它标识多态类型的对象(即声明或继承至少一个虚函数的类),则 typeid 表达式将计算表达式,然后引用表示表达式动态类型的 std::type_info 对象。
  • 否则,typeid 不会 计算表达式,它标识的 std::type_info 对象表示表达式的静态类型。不会执行左值到右值、数组到指针或函数到指针的转换。
  • 然而,对于右值参数,会(正式)执行 临时对象实例化:参数必须在 typeid 表达式出现的上下文中可析构。
(从 C++17 开始)

如果 类型表达式 的类型是 cv 限定的,则 typeid 的结果指的是一个表示 cv 非限定类型的 std::type_info 对象(即,typeid(const T) == typeid(T))。

如果在正在构造或析构的对象上使用 typeid(在析构函数或构造函数中,包括构造函数的 初始化列表默认成员初始化器),那么此 typeid 所引用的 std::type_info 对象表示正在构造或析构的类,即使它不是最派生类。

  1. 在其他上下文中,计算此类 表达式 会导致未定义的行为。

[编辑] 注释

当应用于多态类型的表达式时,计算 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); // not guaranteed
assert(ti1 == ti2); // guaranteed
assert(ti1.hash_code() == ti2.hash_code()); // guaranteed
assert(std::type_index(ti1) == std::type_index(ti2)); // guaranteed

[编辑] 关键字

typeid

[编辑] 示例

该示例展示了在其中 type_info::name 返回完整类型名的实现之一中使用 typeid 的输出;如果使用 gcc 或类似的编译器,请通过 c++filt -t 进行过滤。

#include <iostream>
#include <string>
#include <typeinfo>
 
struct Base {}; // non-polymorphic
struct Derived : Base {};
 
struct Base2 { virtual void foo() {} }; // polymorphic
struct Derived2 : Base2 {};
 
int main()
{
    int myint = 50;
    std::string mystr = "string";
    double *mydoubleptr = nullptr;
 
    std::cout << "myint has type: " << typeid(myint).name() << '\n'
              << "mystr has type: " << typeid(mystr).name() << '\n'
              << "mydoubleptr has type: " << typeid(mydoubleptr).name() << '\n';
 
    // std::cout << myint is a glvalue expression of polymorphic type; it is evaluated
    const std::type_info& r1 = typeid(std::cout << myint); // side-effect: prints 50
    std::cout << '\n' << "std::cout<<myint has type : " << r1.name() << '\n';
 
    // std::printf() is not a glvalue expression of polymorphic type; NOT evaluated
    const std::type_info& r2 = typeid(std::printf("%d\n", myint));
    std::cout << "printf(\"%d\\n\",myint) has type : " << r2.name() << '\n';
 
    // Non-polymorphic lvalue is a static type
    Derived d1;
    Base& b1 = d1;
    std::cout << "reference to non-polymorphic base: " << typeid(b1).name() << '\n';
 
    Derived2 d2;
    Base2& b2 = d2;
    std::cout << "reference to polymorphic base: " << typeid(b2).name() << '\n';
 
    try
    {
        // dereferencing a null pointer: okay for a non-polymorphic expression
        std::cout << "mydoubleptr points to " << typeid(*mydoubleptr).name() << '\n'; 
        // dereferencing a null pointer: not okay for a polymorphic lvalue
        Derived2* bad_ptr = nullptr;
        std::cout << "bad_ptr points to... ";
        std::cout << typeid(*bad_ptr).name() << '\n';
    }
    catch (const std::bad_typeid& e)
    {
        std::cout << " caught " << e.what() << '\n';
    }
}

可能的输出

======== output from Clang ========
myint has type: i
mystr has type: NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE
mydoubleptr has type: Pd
50
std::cout<<myint has type : NSt3__113basic_ostreamIcNS_11char_traitsIcEEEE
printf("%d\n",myint) has type : i
reference to non-polymorphic base: 4Base
reference to polymorphic base: 8Derived2
mydoubleptr points to d
bad_ptr points to...  caught std::bad_typeid
 
======== output from MSVC ========
myint has type: int
mystr has type: class std::basic_string<char,struct std::char_traits<char>,⮠
class std::allocator<char> >
mydoubleptr has type: double * __ptr64
50
std::cout<<myint has type : class std::basic_ostream<char,struct std::char_traits<char> >
printf("%d\n",myint) has type : int
reference to non-polymorphic base: struct Base
reference to polymorphic base: struct Derived2
mydoubleptr points to double
bad_ptr points to...  caught Attempted a typeid of nullptr pointer!

[编辑] 缺陷报告

以下行为更改的缺陷报告已追溯应用到之前发布的 C++ 标准。

DR 应用于 已发布的行为 正确行为
CWG 492 C++98 typeid 应用于 cv 限定的引用的
类型时,结果表示引用的类型
结果表示
cv 非限定的引用类型
CWG 1416 C++98 关于顶层
cv 限定的措辞可能被误解
改进了措辞
CWG 1431 C++98 typeid 只能抛出 std::bad_typeid 允许抛出
可匹配的派生类
CWG 1954 C++98 不清楚是否可以在 表达式 的子表达式中检查空指针解除引用
仅在顶层检查
仅在顶层检查

[编辑] 另请参阅

包含某些类型的相关信息,由 typeid 运算符返回的类
(类) [编辑]