2024年最全C++ RTTI详解，C C++开发进大厂面试必备技能

于 2024-05-13 18:55:53 发布
阅读量935 收藏 15
点赞数 22
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978603/article/details/138815179
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

class type\_info
{
public:
    virtual ~type\_info();

    const char\* name() const _GLIBCXX_NOEXCEPT
    { return __name[0] == '\*' ? __name + 1 : __name; }

#if !\_\_GXX\_TYPEINFO\_EQUALITY\_INLINE
    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
#else
    #if !\_\_GXX\_MERGED\_TYPEINFO\_NAMES
        bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return (__name[0] == '\*' && __arg.__name[0] == '\*') ?
              __name < __arg.__name : __builtin_strcmp (__name, __arg.__name) < 0;
        }

        bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        {
            return ((__name == __arg.__name) ||
                (__name[0] != '\*' && __builtin_strcmp (__name, __arg.__name) == 0));
        }
    #else
        bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return __name < __arg.__name; }

        bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return __name == __arg.__name; }
    #endif
#endif

    bool operator!=(const type_info& __arg) const _GLIBCXX_NOEXCEPT
    { return !operator==(__arg); }

#if \_\_cplusplus >= 201103L
    size_t hash\_code() const noexcept
    {
    # if !\_\_GXX\_MERGED\_TYPEINFO\_NAMES
        return \_Hash\_bytes(name(), \_\_builtin\_strlen(name()),
             static\_cast<size_t>(0xc70f6907UL));
    # else
        return reinterpret\_cast<size_t>(__name);
    # endif
    }
#endif // C++11

    virtual bool \_\_is\_pointer\_p() const;

    virtual bool \_\_is\_function\_p() const;

    virtual bool \_\_do\_catch(const type_info \*__thr_type, void \*\*__thr_obj,
        unsigned __outer) const;

    virtual bool \_\_do\_upcast(const __cxxabiv1::__class_type_info \*__target,
        void \*\*__obj_ptr) const;

protected:
    const char \*__name;

    explicit type\_info(const char \*__n): \_\_name(__n) { }

private:
    type_info& operator=(const type_info&);
    type\_info(const type_info&);
};

从源代码中可以看出以下几点内容：

  1. 有一个类成员__name，类型是const char*，这个指针最终会指向类型的名字
  2. 我们不能直接实例化类type_info的对象，因为该类的正常构造函数是保护的，要构造type_info对象的唯一方法就是使用typeid运算符。
  3. 由于重载的赋值运算符和拷贝构造函数也是私有的，因此我们不能自己去复制或分配类type_info的对象。
  4. 其余那些成员方法大家就自己看一下吧，都是一些从名字就能看出用法的函数，比如name()返回类型名，__is_pointer_p()返回是否是指针类型等等

2.2、typeid识别静态类型

当typeid中的操作数是以下任意一种时，typeid得出的是静态类型，即编译时就确定的类型：

  • 一个任意的类型名
  • 一个基本内置类型的变量，或指向基本内置类型的指针或引用
  • 一个任意类型的指针（指针就是指针，本身不体现多态，多指针解引用才有可能会体现多态）
  • 一个具体的对象实例，无论对应的类有没有多态都可以直接在编译器确定
  • 一个指向没有多态的类对象的指针的解引用
  • 一个指向没有多态的类对象的引用

由于静态类型在程序的运行过程中并不会改变，所以并不需要等到程序运行时再去推算其类型，在编译时期就能根据操作数的静态类型，从而推导出其具体类型信息。我们先来看如下一段代码：

#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>

int main(int argc, char\* argv[])
{
    std::cout << typeid(char).name() << std::endl;
    std::cout << typeid(int).name() << std::endl;
    std::cout << typeid(double).name() << std::endl;

    std::cout << "----------" << std::endl;

    std::cout << typeid(unsigned char).name() << std::endl;
    std::cout << typeid(unsigned int).name() << std::endl;

    std::cout << "----------" << std::endl;

    std::cout << typeid(std::string).name() << std::endl;
    std::cout << typeid(std::vector<float>).name() << std::endl;
}

运行结果如下（gcc-4.8.5）：

c
i
d

h
j

Ss
St6vectorIfSaIfEE

看完我有点怀疑我的智商和人生，不是，是码生了，前面几个还好，还能大概看出是什么类型，但是后面那几个是什么鬼，尤其是这个St6vectorIfSaIfEE，谁能看出是std::vector<float>了？这些其实是被编译器转换过后的类型名，typeid也只能获取这种形式的名称。由于直接看这个实在有点反人类，所以我们只能动用点非常手段了，修改代码如下：

#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>
#include <cxxabi.h>

const char\* TypeToName(const char\* name)
{
    const char\* __name = abi::\_\_cxa\_demangle(name, nullptr, nullptr, nullptr);
    return __name;
}

int main(int argc, char\* argv[])
{
    std::cout << TypeToName(typeid(char).name()) << std::endl;
    std::cout << TypeToName(typeid(int).name()) << std::endl;
    std::cout << TypeToName(typeid(double).name()) << std::endl;

    std::cout << "----------" << std::endl;

    std::cout << TypeToName(typeid(unsigned char).name()) << std::endl;
    std::cout << TypeToName(typeid(unsigned int).name()) << std::endl;

    std::cout << "----------" << std::endl;

    std::cout << TypeToName(typeid(std::string).name()) << std::endl;
    std::cout << TypeToName(typeid(std::vector<float>).name()) << std::endl;
}

运行结果如下，现在可以看到的内容就正常多了，这里其实就是用到了abi::__cxa_demangle这个方法获取类型的真实名称，关于这部分的内容这里就不细讲了，有兴趣的读者可以去看这篇文章《C++封装一个易用的打印backtrace信息的函数》，里面就有相应的介绍。

char
int
double

unsigned char
unsigned int

std::string
std::vector<float, std::allocator >

有了前面小小的铺垫，我们可以着手编写测试代码了：

#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>
#include <cxxabi.h>

const char\* TypeToName(const char\* name)
{
    const char\* __name = abi::\_\_cxa\_demangle(name, nullptr, nullptr, nullptr);
    return __name;
}

class A
{
public:
    void print()
    {
        std::cout << "A" << std::endl;
    }
};

class B : public A
{
public:
    void print()
    {
        std::cout << "B" << std::endl;
    }
};

class C
{
public:
    virtual void print()
    {
        std::cout << "C" << std::endl;
    }
};

class D : public C
{
public:
    virtual void print()
    {
        std::cout << "D" << std::endl;
    }
};

int main(int argc, char\* argv[])
{
    std::cout << "---------- 一个任意的类型名 ----------" << std::endl;
    std::cout << "----- 基本内置类型名 -----" << std::endl;
    std::cout << TypeToName(typeid(char).name()) << std::endl;
    std::cout << TypeToName(typeid(int).name()) << std::endl;
    std::cout << "----- 无多态的类型名 -----" << std::endl;
    std::cout << TypeToName(typeid(std::string).name()) << std::endl;
    std::cout << TypeToName(typeid(std::vector<int>).name()) << std::endl;
    std::cout << "----- 有多态的类型名 -----" << std::endl;
    std::cout << TypeToName(typeid(std::iostream).name()) << std::endl;

    std::cout << "\n\n" << "---------- 一个基本内置类型的变量，或指向基本内置类型的指针或引用 ----------" << std::endl;
    std::cout << "----- 基本内置类型的变量 -----" << std::endl;
    long type_long = 1;
    double type_double = 1.23;
    std::cout << TypeToName(typeid(type_long).name()) << std::endl;
    std::cout << TypeToName(typeid(type_double).name()) << std::endl;
    std::cout << "----- 指向基本内置类型的指针或引用 -----" << std::endl;
    long\* type_long_ptr = &type_long;
    double& type_double_ref = type_double;
    std::cout << TypeToName(typeid(type_long_ptr).name()) << std::endl;
    std::cout << TypeToName(typeid(type_double_ref).name()) << std::endl;

    std::cout << "\n\n" << "---------- 一个任意类型的指针 ----------" << std::endl;
    std::cout << "----- 一个指向没有多态类型的指针 -----" << std::endl;
    B b;
    A\* a_ptr = &b;
    std::cout << TypeToName(typeid(&b).name()) << std::endl;
    std::cout << TypeToName(typeid(a_ptr).name()) << std::endl;
    std::cout << "----- 一个指向具有多态类型的指针 -----" << std::endl;
    D d;
    C\* c_ptr = &d;
    std::cout << TypeToName(typeid(&d).name()) << std::endl;
    std::cout << TypeToName(typeid(c_ptr).name()) << std::endl;

    std::cout << "\n\n" << "---------- 一个具体的对象实例，无论对应的类有没有多态都可以直接在编译器确定 ----------" << std::endl;
    std::cout << "----- 无多态类的实例 -----" << std::endl;
    std::string type_string;
    std::vector<int> type_vector;
    std::cout << TypeToName(typeid(type_string).name()) << std::endl;
    std::cout << TypeToName(typeid(type_vector).name()) << std::endl;
    std::cout << "----- 有多态类的实例 -----" << std::endl;
    std::iostream type\_ios(nullptr);
    std::cout << TypeToName(typeid(type_ios).name()) << std::endl;

    std::cout << "\n\n" << "---------- 一个指向没有多态的类对象的指针的解引用 ----------" << std::endl;
    std::cout << "----- 一个指向没有多态的类对象的指针的解引用 -----" << std::endl;
    std::cout << TypeToName(typeid(\*a_ptr).name()) << std::endl; // 推算出来的依然是A

    std::cout << "\n\n" << "---------- 一个指向没有多态的类对象的引用 ----------" << std::endl;
    std::cout << "----- 一个指向没有多态的类对象的引用 -----" << std::endl;
    A& a_ref = b;
    std::cout << TypeToName(typeid(a_ref).name()) << std::endl; // 推算出来的依然是A
}

运行结果如下，前面讲的六种静态类型都涉及到了，大家看一下就能明白是怎么一回事了：

---------- 一个任意的类型名 ----------
----- 基本内置类型名 -----
char
int
----- 无多态的类型名 -----
std::string
std::vector<int, std::allocator >
----- 有多态的类型名 -----
std::iostream

---------- 一个基本内置类型的变量，或指向基本内置类型的指针或引用 ----------
----- 基本内置类型的变量 -----
long
double
----- 指向基本内置类型的指针或引用 -----
long*
double

---------- 一个任意类型的指针 ----------
----- 一个指向没有多态类型的指针 -----
B*
A*
----- 一个指向具有多态类型的指针 -----
D*
C*

---------- 一个具体的对象实例，无论对应的类有没有多态都可以直接在编译器确定 ----------
----- 无多态类的实例 -----
std::string
std::vector<int, std::allocator >
----- 有多态类的实例 -----
std::iostream

---------- 一个指向没有多态的类对象的指针的解引用 ----------
----- 一个指向没有多态的类对象的指针的解引用 -----
A

---------- 一个指向没有多态的类对象的引用 ----------
----- 一个指向没有多态的类对象的引用 -----
A

2.3、typeid识别动态类型

当typeid中的操作数是以下任意一种时，typeid需要在程序运行时推算类型，因为其操作数的类型在编译时期是不能被确定的：

  • 一个指向含有多态的类对象的指针的解引用
  • 一个指向含有多态的类对象的引用

下面先来看一个典型错误案例，程序如下：

#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>
#include <cxxabi.h>

const char\* TypeToName(const char\* name)


![img](https://img-blog.csdnimg.cn/img_convert/827f28308799da8ae70ba3655db1f399.png)
![img](https://img-blog.csdnimg.cn/img_convert/1fad681ea209c2fa302476f32736e04e.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

einfo>
#include <cxxabi.h>

const char\* TypeToName(const char\* name)


[外链图片转存中...(img-IdZW6tbb-1715597730437)]
[外链图片转存中...(img-Mm0Wg39x-1715597730437)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84978603
关注
  • 22
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中的RTTI机制详解
09-04
RTTI（Runtime Type Information）是C++语言提供的一种在运行时获取对象类型信息的机制。在C++中，RTTI允许程序在运行时检查对象的实际类型，这对于多态性编程和动态类型检查非常有用。本篇文章将深入探讨C++中的...
C++ 中RTTI的使用方法详解
08-29
C++中的RTTI，即运行时类型识别，是一种在程序执行期间识别对象实际类型的能力。这一特性对于多态编程尤其有用，特别是在处理继承层次结构时。C++通过三种主要手段来支持RTTI： 1. `dynamic_cast` 运算符：`dynamic...
C++ RTTI详解
热门推荐
彼方的博客
07-09 1万+
C++ RTTI详解1、RTTI简介2、typeid详解2.1、type_info2.2、typeid识别静态类型2.3、typeid识别动态类型2.4、typeid实现原理3、dynamic_cast详解4、总结 1、RTTI简介 RTTI（Runtime Type Identification）是“运行时类型识别”的意思。C++引入这个机制是为了让程序在运行时能根据基类的指针或引用来获得该指针或引用所指的对象的实际类型。但是现在RTTI的类型识别已经不限于此了，它还能通过typeid操作符识别出所有的基
RTTI: 观念，机制解析和实现原理
君之剑的专栏
04-08 998
C++的 RTTI 观念和用途 https://www.cnblogs.com/findumars/p/6358194.html 自从1993年Bjarne Stroustrup 〔注1 〕提出有关C++ 的RTTI功能之建议﹐以及C++的异常处理(exception handling)需要RTTI；最近新推出的C++ 或多或少已提供RTTI。 然而，若不小心使用RTTI，可能会导致软件弹性的...
RTTI介绍
后台开发
05-29 1万+
说明：部分内容来自>和RTTI百度百科。 RTTI(run type identification):通过运行时类型信息程序能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际派生类型。有些读者认为设计类时使用虚函数就已经足够了，可是虚函数本身有局限性，当涉及类别阶层时，需要判断某个对象所属的类别，而因为类别设计中大量使用虚函数，所以使得这一工作难以实现，但又极其重要，于是使用RTTI的
RTTI symbol not found for class ‘QWidget‘
aMaCoder
02-04 2885
属性，WA_DeleteOnClose的作用是在窗口关闭时，调用析构函数销毁此窗（QWidget关闭时默认是隐藏的），所以，我先关闭d窗口，实际的d窗口已经被销毁，然后我在关闭主窗口，主窗口会在调用d窗口的销毁函数，但是此时d窗口已经被销毁，所以会提示找不到QWidget。这样，主窗口在关闭时不会再调用d的析构函数。这里面涉及到一个知识点就是，在父窗口的对象，当父窗口销毁时，其子窗口也会销毁。首先，导致这个问题的原因是找不到QWidget符号，在QWidget派生类里设置。关闭主窗口提示段错误。
c++ 运行时类型识别RTTI
yizhiniu_xuyw的专栏
11-11 477
通过RTTI，能够通过基类的指针或引用来检索其所指对象的实际类型。c++通过下面两个操作符提供RTTI。 （1）typeid：返回指针或引用所指对象的实际类型。 （2）dynamic_cast：将基类类型的指针或引用安全的转换为派生类型的指针或引用。 对于带虚函数的类，在运行时执行RTTI操作符，返回动态类型信息；对于其他类型，在编译时执行RTTI，返回静态类型信息。 当具有基类的指针或引用，但需要执行派生类操作时，需要动态的强制类型转换（dynamic_cast）。这种机制的使用容易出错，最好以虚
c++ rtti 根据类名创建对象
08-08
实现c++根据类名创建c++ 对象，一个文件简单明了，，，，，
识别c++ RTTI的ida脚本1
08-08
《C++ RTTI识别与IDA脚本应用解析》 C++的运行时类型信息（Runtime Type Information，简称RTTI）是一种强大的特性，它允许在程序运行时查询对象的实际类型。在深入探讨RTTI的实现机制之前，我们首先理解RTTI的基本...
C++的RTTI
little_startoo的博客
05-26 74
C++的RTTI
iBOOT源代码
02-11
iBOOT源代码
c++ RTTI解析
09-23
c++ RTTI深度解析， 运行时类型识别技术
C++中的RTTI机制解析
weixin_45596153的博客
05-12 328
RTTI概念 RTTI(Run Time Type Identification)即通过运行时类型识别，程序能够使用基类的指针或引用来检查着这些指针或引用所指的对象的实际派生类型。 RTTI机制的产生 为什么会出现RTTI这一机制，这和C++语言本身有关系。和很多其他语言一样，C++是一种静态类型语言。其数据类型是在编译期就确定的，不能在运行时更改。然而由于面向对象程序设计中多态性的要求，...
C++类型预断——RTTI
master-计算机科学专栏
09-07 481
C++没有类似 Java 语言的 instanceof 的类型预断，有什么方法可以做到类似 java 的类型预断功能呢？和Java相比，C++要想获得运行时类型信息，只能通过 RTTI （Run Time Type Identification）机制，并且C++最终生成的代码是直接与机器相关的（也就是不同编译器实现RTTI的方式不一样，C++标准只是做了约定）。 RTTI 提供了两个操作符：typeid 和 dynamic_cast typeid：返回指...
C++运行阶段类型识别（Runtime Type Identification）（C++新特性）
DayDayUp
12-30 1662
编译时开销 编译器在编译代码时，主要进行：词法分析（识别单词，确认词类：标识符、关键字、字符串、数字等等）、语法分析（识别短语和句型的语法属性，生成语法树）、语义分析（确认单词，句型的语义特征，如加减乘除等）、代码优化和代码生成等。模板、类层次结构、强制类型检查等新特性，以及大量使用了这些新特性的STL标准库都增加了编译器负担。 运行时开销 C++中有可能引入额外运行时开销的新特性包括： 虚基类 虚函数 RTTI（dynamic_cast和typeid） 异常 对象的构造和析构 RTTI
RTTI实现详解
heyuhang112的专栏
12-17 5715
在使用C++进行面向对象编程时，我们经常用到RTTI（运行时类型识别）。我们常常使用typeid判断某个对象的类型，dynamic_cast动态转换对象的指针或引用类型。每次使用起来我们都大呼过瘾，这用起来确实非常方便。那么，RTTI到底是如何实现的呢？这是我一直都想搞清楚的问题。于是，乘着这两天砖量不大（呼~~搬砖、搬砖、>_）的大好时机，学习了一下RTTI的原理，顺便写下这边博文做个总结，希望
C++  RTTI机制
xiangxianghehe的博客
05-08 274
java深浅拷贝及hashmap1.8的源码分析
u011747152的博客
02-27 303
hashmap1.8的源码分析 类定义 public class HashMap&lt;K,V&gt; extends AbstractMap&lt;K,V&gt; implements Map&lt;K,V&gt;, Cloneable, Serializable 由图看出，hashmap1.8的主要优化是当发生多次哈希冲突时加入了红黑树 jav...
c++中的RTTI
malina90的专栏
12-16 308
http://blog.csdn.net/mannhello/article/details/5217954
什么是RTTI，C++支持的RTTI有哪些？
最新发布
06-03
RTTI指的是运行时类型信息（Run-Time Type Information），它允许在程序运行时检查对象的类型。在C++语言中，通过使用dynamic_cast、typeid和type_info等关键字和类来实现RTTI。 C++支持的RTTI包括： 1. typeid运算符：返回一个type_info对象，该对象包含有关表达式类型的信息。 2. dynamic_cast运算符：用于在继承层次结构中进行向下转型，它返回指向派生类类型的指针。 3. static_cast运算符：用于在继承层次结构中进行向上或向下转型，但不能在基类和派生类之间进行动态转型。 需要注意的是，RTTI的使用应该尽可能地避免，因为它可能会影响程序的性能和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值