深入理解 C++ 类型转换：从 C 语言兼容到 C++ 增强特性

C++ 类型转换核心知识点速查表

转换大类	具体类型	适用场景	示例代码	安全注意事项
C 语言兼容转换	隐式类型转换	整形 / 浮点间、整形 / 整形间、浮点 / 浮点间（仅支持合理关联的类型转换）	int i=1; double d=i;	可能导致精度丢失（如 double→int），避免跨类型隐式转换（如无符号→有符号）
	显式强制转换	指针与整形、指针与指针间（底层有关联，如地址编号本质是整数）	int* p=&i; int addr=(int)p; int* ptr=(int*)malloc(8);	无类型安全检查，禁止无关联类型转换（如 int*→double*），可能引发内存越界
C++ 增强转换（自定义类型相关）	内置→自定义（构造函数支持）	用内置类型初始化自定义类型，单参数或多参数构造函数匹配	class A{ A(int a); A(int a1,int a2); }; A aa1=1; A aa2={2,2};	加explicit可禁止隐式转换，避免意外类型转换；多参数需用初始化列表语法
	自定义→内置（类型转换运算符支持）	自定义类型需转换为内置类型，需重载operator 目标类型()	class A{ explicit operator int() const { return _a1+_a2; } }; A aa; int x=(int)aa;	加explicit可禁止隐式转换，避免歧义；运算符需声明为const（不修改对象）
	自定义→自定义（构造函数支持）	A 类型转 B 类型，B 类需有B(const A&)构造函数	class B{ B(const A& aa); }; A aa; B bb=aa;	加explicit可禁止隐式转换；参数建议用const&避免拷贝开销
C++ 显式命名转换	static_cast	类型相近、语义明确的转换（如隐式转换的显式版本、右值引用转换）	double d=12.34; int a=static_cast<int>(d); int&& ref=static_cast<int&&>(a);	不支持无关联类型转换（如 int→int*），不支持 const 属性转换；避免跨类型强制转换
	reinterpret_cast	无关联类型的底层位模式重新解释（如整形→指针、不同类型指针间）	int a=10; int* p=reinterpret_cast<int*>(a);	风险极高，仅在明确内存布局且无替代方案时使用；可能导致非法内存访问
	const_cast	去除指针 / 引用的 const/volatile 属性（仅支持指针 / 引用类型）	volatile const int b=0; //volatile表示仅将b存在地址中，不存寄存器 int* pb=const_cast<int*>(&b);	不可修改 “真正常量”（如const int c=10）；需加volatile禁止编译器优化
	dynamic_cast	多态类型的向下转换（基类指针 / 引用→派生类指针 / 引用）	class A{ virtual void f(){} }; class B:public A{}; A* pa=new B; B* pb=dynamic_cast<B*>(pa);	基类必须含虚函数（多态类型）；指针转换失败返回nullptr，引用转换失败抛bad_cast异常
RTTI 相关转换	typeid 运算符	运行时判断对象实际类型（支持表达式 / 类型名）	A* pa=new B; if (typeid (*pa)==typeid (B)) cout<<"类型匹配";	非多态类返回静态类型；指针需解引用（typeid(*pa)）才获取对象类型

前言：

类型转换是编程语言中数据交互的基础机制，用于解决不同类型数据间的赋值、传参等场景的类型匹配问题。C++ 作为兼容 C 语言的面向对象语言，不仅保留了 C 的类型转换方式，还针对类型安全和自定义类型扩展了全新特性，同时引入了规范化的显式强制转换运算符和运行时类型识别（RTTI）机制。本文将全面拆解 C++ 类型转换的核心知识点，结合所有示例代码逐句解析其原理与实践。

一、C 语言中的类型转换

C 语言的类型转换机制简洁直接，但缺乏类型安全检查，主要分为两种形式，其适用场景和限制均有明确边界。

1. 隐式类型转换

隐式类型转换由编译器在编译阶段自动完成，无需开发者手动干预，仅支持具有合理关联的类型转换。核心适用场景包括：整形与整形、整形与浮点数、浮点数与浮点数之间的转换，转换过程需保证语义合理。

int main()
{
    int i = 1;
    // 隐式类型转换：int -> double，整形与浮点数的合理转换
    double d = i;
    printf("%d, %.2f\n", i, d); // 输出：1, 1.00

    return 0;
}

2. 显式强制类型转换

当类型转换无法通过隐式方式完成（如指针与整形、指针与指针之间），需要开发者通过括号指定目标类型，手动触发转换。但这种方式风险较高，仅支持具有底层关联的类型转换（如指针本质是地址编号，可与整形互转）。

int main()
{
    int i = 1;
    int* p = &i;
    // 显式强制类型转换：int* -> int，指针与整形的关联转换
    int address = (int)p;
    printf("%p, %d\n", p, address); // 输出：指针地址及其对应的整数编号

    // 显式强制类型转换：void* -> int*，malloc返回值的合理转换
    int* ptr = (int*)malloc(8);

    // 编译报错：无法从“int *”转换为“double”
    // 指针与浮点数无任何底层关联，即使显式强转也不支持
    // d = (double)p;

    return 0;
}

3. C 语言类型转换的局限性

C 语言的类型转换缺乏统一规范和安全检查：隐式转换可能在不知情的情况下导致数据精度丢失或逻辑错误；显式强转过于灵活，允许无意义的类型转换（如后续示例中 int转 double），进而引发内存访问越界等严重问题。

二、C++ 中的类型转换增强

C++ 完全兼容 C 语言的类型转换机制，同时针对自定义类型扩展了转换能力，支持内置类型与自定义类型、自定义类型与自定义类型之间的灵活转换，且通过构造函数和专用运算符明确了转换规则。

1. 内置类型与自定义类型的转换

C++ 为内置类型和自定义类型的双向转换提供了明确的支持机制，核心依赖构造函数和类型转换运算符。

（1）内置类型 → 自定义类型：构造函数支持

当用内置类型给自定义类型对象赋值时，编译器会自动调用该自定义类型的单参数构造函数（或可匹配的多参数构造函数）完成转换。若构造函数添加explicit关键字，则会禁止隐式转换，仅允许显式强转。

#include <iostream>
using namespace std;

class A
{
public:
    // 单参数构造函数：支持int -> A的隐式转换（去掉explicit则允许）
    // explicit A(int a) // 加explicit后，A aa1 = 1; 编译报错
    A(int a)
    : _a1(a)
    , _a2(a)
    {}

    // 多参数构造函数：支持初始化列表形式的转换
    A(int a1, int a2)
    : _a1(a1)
    , _a2(a2)
    {}

private:
    int _a1 = 1;
    int _a2 = 1;
};

int main()
{
    // 单参数隐式转换：int -> A
    A aa1 = 1;
    // 单参数显式转换：int -> A（即使构造函数加explicit也支持）
    A aa2 = (A)1;

    // 多参数隐式转换：初始化列表 -> A
    A aa3 = { 2,2 };
    const A& aa4 = { 2,2 };

    return 0;
}

（2）自定义类型 → 内置类型：类型转换运算符支持

若需将自定义类型对象转换为内置类型，需在自定义类型中重载operator 目标类型()运算符。该运算符无参数、无返回值类型声明（返回值类型由目标类型决定），通常声明为const以保证对象不被修改。

#include <iostream>
using namespace std;

class A
{
public:
    A(int a)
    : _a1(a)
    , _a2(a)
    {}

    // 类型转换运算符：支持A -> int的转换
    // explicit operator int() // 加explicit后，int x = aa1; 编译报错
    operator int() const
    {
        return _a1 + _a2;
    }

private:
    int _a1 = 1;
    int _a2 = 1;
};

int main()
{
    A aa1 = 1;
    // 显式调用类型转换运算符：A -> int
    int z = aa1.operator int();
    // 隐式转换：A -> int（去掉explicit则允许）
    int x = aa1;
    // 显式强转：A -> int
    int y = (int)aa2;

    cout << x << endl; // 输出：2（1+1）
    cout << y << endl; // 输出：2
    cout << z << endl; // 输出：2

    return 0;
}

（3）实践扩展：自定义类型的 bool 转换

很多 C++ 标准库类型（如shared_ptr）支持隐式转换为bool，用于判断对象状态（如是否为空），本质就是通过operator bool()实现的。

#include <iostream>
#include <memory>
using namespace std;

int main()
{
    std::shared_ptr<int> foo;
    std::shared_ptr<int> bar(new int(34));

    // 隐式转换为bool：判断shared_ptr是否为空
    if (foo) // 等价于 foo.operator bool()
        std::cout << "foo points to " << *foo << '\n';
    else
        std::cout << "foo is null\n"; // 输出：foo is null

    if (bar)
        std::cout << "bar points to " << *bar << '\n'; // 输出：bar points to 34
    else
        std::cout << "bar is null\n";

    return 0;
}

2. 自定义类型与自定义类型的转换：构造函数支持

若需将 A 类型对象转换为 B 类型对象，只需在 B 类型中定义一个以 A 类型为参数的构造函数（通常声明为const A&，避免拷贝开销）。该构造函数支持隐式转换（无explicit）或显式转换（有explicit）。

#include <iostream>
using namespace std;

class A
{
public:
    A(int a)
    : _a1(a)
    , _a2(a)
    {}

    operator int() const
    {
        return _a1 + _a2;
    }

private:
    int _a1 = 1;
    int _a2 = 1;
};

class B
{
public:
    B(int b)
    : _b1(b)
    {}

    // 以A为参数的构造函数：支持A -> B的转换
    B(const A& aa)
    : _b1(aa) // 此处调用A的operator int()，将aa转换为int
    {}

private:
    int _b1 = 1;
};

int main()
{
    A aa1 = 1;
    // 隐式转换：A -> B
    B bb1 = aa1;
    B bb2(2);
    // 赋值时的隐式转换：A -> B
    bb2 = aa1;
    // 引用绑定的隐式转换：A -> B
    const B& ref1 = aa1;//此处会先用aa1创建临时对象（右值），故而引用绑定需要const修饰

    return 0;
}

3. 实战案例：list 容器的迭代器转换

在 C++ 容器中，iterator（可修改迭代器）与const_iterator（只读迭代器）的转换是自定义类型转换的典型应用。其核心通过迭代器类模板的转换构造函数实现。

（1）底层实现：ListIterator 的转换构造函数

#pragma once
#include<assert.h>

namespace zephyr
{
    template<class T>
    struct ListNode
    {
        ListNode<T>* _next;
        ListNode<T>* _prev;
        T _data;

        ListNode(const T& data = T())
        : _next(nullptr)
        , _prev(nullptr)
        , _data(data)
        {}
    };

    template<class T, class Ref, class Ptr>
    struct ListIterator
    {
        typedef ListNode<T> Node;
        typedef ListIterator<T, Ref, Ptr> Self;
        Node* _node;

        ListIterator(Node* node)
        : _node(node)
        {}

        // 类型别名：明确两种迭代器的模板参数
        // typedef ListIterator<T, T&, T*> iterator;
        // typedef ListIterator<T, const T&, const T*> const_iterator;

        // 转换构造函数：支持iterator -> const_iterator
        // 1. 当实例化为iterator时，此函数为拷贝构造函数
        // 2. 当实例化为const_iterator时，此函数为转换构造函数
        ListIterator(const ListIterator<T, T&, T*>& it)
        : _node(it._node)
        {}

        // 迭代器运算符重载（保证迭代器功能正常）
        Self& operator++()
        {
            _node = _node->_next;
            return *this;
        }

        Self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }

        Self operator++(int)
        {
            Self tmp(*this);
            _node = _node->_next;
            return tmp;
        }

        Self operator--(int)
        {
            Self tmp(*this);
            _node = _node->_prev;
            return tmp;
        }

        Ref operator*()
        {
            return _node->_data;
        }

        Ptr operator->()
        {
            return &_node->_data;
        }

        bool operator!=(const Self& it)
        {
            return _node != it._node;
        }

        bool operator==(const Self& it)
        {
            return _node == it._node;
        }
    };

    template<class T>
    class list
    {
        typedef ListNode<T> Node;
    public:
        // 实例化两种迭代器类型
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T*> const_iterator;

        // 普通对象的begin()：返回iterator
        iterator begin()
        {
            return iterator(_head->_next);
        }

        // const对象的begin()：返回const_iterator
        const_iterator begin() const
        {
            return const_iterator(_head->_next);
        }

        iterator end()
        {
            return iterator(_head);
        }

        const_iterator end() const
        {
            return const_iterator(_head);
        }

        void empty_init()
        {
            _head = new Node();
            _head->_next = _head;
            _head->_prev = _head;
        }

        list()
        {
            empty_init();
        }

        // 初始化列表构造
        list(initializer_list<T> il)
        {
            empty_init();
            for (const auto& e : il)
                push_back(e);
        }

        void push_back(const T& x)
        {
            insert(end(), x);
        }

        // 插入操作：返回新节点的iterator（无迭代器失效问题）
        iterator insert(iterator pos, const T& x)
        {
            Node* cur = pos._node;
            Node* newnode = new Node(x);
            Node* prev = cur->_prev;

            // 双向链表插入逻辑：prev -> newnode -> cur
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;

            return iterator(newnode);
        }

    private:
        Node* _head;
    };
}

（2）使用示例：iterator 到 const_iterator 的转换

#include<iostream>
#include"List.h"
using namespace std;

int main()
{
    zephyr::list<int> lt = { 1,2,3,4 };
    // 转换：iterator（lt.begin()返回值）-> const_iterator（cit的类型）
    // 核心：调用ListIterator的转换构造函数，复制节点指针_node
    zephyr::list<int>::const_iterator cit = lt.begin();
    while (cit != lt.end())
    {
        cout << *cit << " "; // 输出：1 2 3 4
        ++cit;
    }
    cout << endl;

    return 0;
}

（3）转换本质说明

• iterator的模板参数为T&（可修改引用）和T*（可修改指针），支持通过迭代器修改元素。
• const_iterator的模板参数为const T&（只读引用）和const T*（只读指针），仅支持读取元素。
• 转换构造函数ListIterator(const ListIterator<T, T&, T*>& it)实现了 “可修改迭代器→只读迭代器” 的安全转换（权限缩小，符合类型安全），转换后const_iterator与原iterator指向同一个节点，但仅能执行只读操作。

三、C++ 显式强制类型转换运算符

为解决 C 语言强制转换的安全性问题和规范性问题，C++ 引入了 4 个命名显式转换运算符：static_cast、reinterpret_cast、const_cast、dynamic_cast，每个运算符有明确的适用场景，增强了代码的可读性和安全性。

1. 类型安全的核心意义

类型安全是指编程语言在编译和运行时提供保护机制，避免非法类型转换导致的内存访问错误、数据异常等问题。C 语言不是类型安全语言，而 C++ 通过规范显式转换运算符，在一定程度上提升了类型安全性。

（1）C 语言类型转换的安全隐患示例

// 示例1：隐式类型转换导致的逻辑错误
void insert(size_t pos, char ch)
{
    int end = 10;
    // 风险：size_t是无符号整数，end（int）会隐式转换为size_t
    // 当pos=0时，end--后变为-1，转换为size_t是极大值，导致循环无限执行
    while (end >= pos)
    {
        cout << end << endl;
        --end;
    }
}

// 示例2：非法强制转换导致的内存访问错误
int main()
{
    insert(5, 'x');
    // insert(0, 'x'); // 触发无限循环

    // 风险：int* -> double*，两种类型的内存布局不同
    int x = 100;
    double* p1 = (double*)&x;
    cout << *p1 << endl; // 输出乱码（非法访问内存）

    // 风险：去掉const属性后修改常量
    const int y = 0;
    int* p2 = (int*)&y;
    (*p2) = 1;
    // 输出：1 和 0（编译器优化：y被视为常量，直接替换为0）
    cout << *p2 << endl;
    cout << y << endl;

    return 0;
}

2. 四个显式转换运算符详解

（1）static_cast：相近类型的安全转换

static_cast用于转换具有明确语义、类型相近的场景，本质是 C 语言隐式转换的显式版本。不支持无关联类型的转换（如指针与浮点数），也不支持指针 / 引用的 const 去除（如 const int* → int*），但支持 const 值类型的普通转换（如 const int → int）。

int main()
{
    // 场景1：内置类型的合理转换（int -> double）
    double d = 12.34;
    int a = static_cast<int>(d);
    cout << a << endl; // 输出：12（截断小数）

    // 场景2：右值引用转换
    int&& ref = static_cast<int&&>(a);

    // 错误场景1：不支持无关联类型转换
    // int* p = static_cast<int*>(d); // 编译报错

    // 错误场景2：不支持const指针引用属性转换
    // const int b = 10;
    // int* pb = static_cast<int*>(&b); // 编译报错

    const int num = 10; // 原变量是const int（真正常量）
    const int& const_ref = num; // const左值引用：绑定到const变量

    // 尝试用static_cast去除引用的const属性 → 编译报错
    // 错误原因：static_cast不支持去除指针/引用的const属性
    // int& non_const_ref = static_cast<int&>(const_ref); 
    return 0;
}

（2）reinterpret_cast：底层重新解释的转换

reinterpret_cast用于转换无关联类型，本质是对内存位模式的重新解释，风险极高，仅在明确知晓内存布局且确保安全时使用。

int main()
{
    int a = 10;
    // 场景：int -> int*（无关联类型，重新解释内存）
    int* p1 = reinterpret_cast<int*>(a);
    cout << p1 << endl; // 输出：0x0000000A（将10解释为地址）

    // 风险示例：int* -> double*（与C语言强制转换效果一致）
    int x = 100;
    double* p2 = reinterpret_cast<double*>(&x);
    cout << *p2 << endl; // 输出乱码（非法访问）

    return 0;
}

（3）const_cast：去除 const/volatile 属性

const_cast是唯一能修改类型 const 或 volatile 属性的转换运算符，仅用于指针或引用类型，不支持对象类型的转换。使用时需注意：若原变量是真正的常量（如const int y=0），修改其值会导致未定义行为。

int main()
{
    // 正确场景：去除非真正常量的const属性
    volatile const int b = 0; // volatile禁止编译器优化
    int* p2 = const_cast<int*>(&b);
    *p2 = 1;
    // 输出：1 和 1（volatile确保读取内存中的最新值）
    cout << b << endl;
    cout << *p2 << endl;

    // 错误场景：修改真正的常量（未定义行为）
     //const int c = 10;
     //int* pc = const_cast<int*>(&c);
     //*pc = 20; // 行为未定义
     //cout << c << endl;//10
     //cout << *pc << endl;//20

    return 0;
}

（4）dynamic_cast：多态类型的向下转换

dynamic_cast专门用于将基类指针 / 引用转换为派生类指针 / 引用（向下转换），是唯一支持运行时类型检查的转换运算符，需满足两个条件：

1. 基类必须是多态类型（包含至少一个虚函数）；
2. 转换成功返回派生类指针 / 引用，失败时：指针返回nullptr，引用抛出bad_cast异常。

#include <iostream>
#include <exception>
using namespace std;

class A
{
public:
    virtual void f() {} // 基类为多态类型（有虚函数）
    int _a = 1;
};

class B : public A
{
public:
    int _b = 2;
};

// 普通强制转换：无类型检查，风险高
void fun1(A* pa)
{
    B* pb1 = (B*)pa;
    cout << "pb1:" << pb1 << endl;
    cout << pb1->_a << endl;
    cout << pb1->_b << endl; // 若pa指向A对象，此处越界访问
    pb1->_a++;
    pb1->_b++;
    cout << pb1->_a << endl;
    cout << pb1->_b << endl;
}

// dynamic_cast：有类型检查，安全
void fun2(A* pa)
{
    B* pb1 = dynamic_cast<B*>(pa);
    if (pb1) // 转换成功（pa指向B对象）
    {
        cout << "pb1:" << pb1 << endl;
        cout << pb1->_a << endl;
        cout << pb1->_b << endl;
        pb1->_a++;
        pb1->_b++;
        cout << pb1->_a << endl;
        cout << pb1->_b << endl;
    }
    else // 转换失败（pa指向A对象）
    {
        cout << "转换失败" << endl;
    }
}

// dynamic_cast引用：失败抛出异常
void fun3(A& pa)
{
    try {
        B& pb1 = dynamic_cast<B&>(pa);
        cout << "转换成功" << endl;
    }
    catch (const exception& e) {
        cout << e.what() << endl; // 输出：bad_cast
    }
}

int main()
{
    A a;
    B b;

    // fun1(&a); // 风险：pa指向A对象，访问pb1->_b越界
    // fun1(&b); // 正常：pa指向B对象

    fun2(&a); // 输出：转换失败
    fun2(&b); // 正常输出B对象的成员

    fun3(a); // 抛出bad_cast异常
    fun3(b); // 输出：转换成功

    return 0;
}

四、RTTI：运行时类型识别

RTTI（Runtime Type Identification）即运行时类型识别，允许程序在运行时获取对象的实际类型信息，核心通过typeid运算符和dynamic_cast实现（dynamic_cast已在前面讲解）。

1. RTTI 的核心作用

编译时类型识别（静态类型）仅能获取变量声明时的类型，而运行时类型识别能获取对象的实际类型（如基类指针指向派生类对象时，获取派生类类型），常用于多态场景中的类型判断。

2. typeid 运算符详解

typeid(e)返回type_info类（或其派生类）的引用，e可以是表达式或类型名。type_info类支持==和!=比较，name()成员函数返回类型的 C 风格字符串（不同编译器输出格式不同）。

（1）typeid 的基本使用

#include<iostream>
#include<string>
#include<vector>
#include<list>
using namespace std;

int main()
{
    int a[10];
    int* ptr = nullptr;

    // 输出各种类型的名称（编译器差异导致输出格式不同）
    cout << typeid(10).name() << endl;         // vs：int；gcc：i
    cout << typeid(a).name() << endl;          // vs：int [10]；gcc：A10_i
    cout << typeid(ptr).name() << endl;        // vs：int *；gcc：Pi
    cout << typeid(string).name() << endl;     // vs：class std::basic_string<char,...>；gcc：NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
    cout << typeid(string::iterator).name() << endl; // 迭代器类型名称
    cout << typeid(vector<int>).name() << endl;     // 容器类型名称
    cout << typeid(vector<int>::iterator).name() << endl;

    return 0;
}

（2）typeid 的类型判断规则

• 若e是非类类型或无虚函数的类类型：typeid(e)返回静态类型（编译时确定）；
• 若e是包含虚函数的类类型的左值：typeid(e)返回运行时类型（实际对象类型）；
• 若e是指针，typeid(e)返回指针的静态类型（而非指向对象的类型），需通过typeid(*e)获取指向对象的类型。

根据 C++ 标准，typeid 仅在一种场景下会抛出 std::bad_typeid 异常：当 typeid 的运算对象是指向多态类的空指针（即指针为 nullptr，且该类包含虚函数）时，由于无法获取空指针指向的实际对象的类型，typeid 会抛出 std::bad_typeid 异常。（即解引用nullptr操作会抛异常）

#include<iostream>
#include<exception>
using namespace std;

class A
{
public:
    virtual void func() {} // 有虚函数：多态类型
protected:
    int _a1 = 1;
};

class B : public A
{
protected:
    int _b1 = 2;
};

int main()
{
    try
    {
        B* pb = new B;
        A* pa = (A*)pb; // pa指向B对象
      
        // 1. typeid(*pb)：pb指向B对象，返回B类型（运行时类型）
        if (typeid(*pb) == typeid(B))
            cout << "typeid(*pb) == typeid(B)" << endl; // 输出

        // 2. typeid(*pa)：pa指向B对象（A是多态类型），返回B类型（运行时类型）
        if (typeid(*pa) == typeid(B))
            cout << "typeid(*pa) == typeid(B)" << endl; // 输出

        // 3. typeid(pa) vs typeid(pb)：pa是A*，pb是B*，静态类型不同
        if (typeid(pa) == typeid(pb))
            cout << "typeid(pa) == typeid(pb)" << endl; // 不输出
        //当 typeid 的运算对象是指向多态类的空指针（即指针为 nullptr，且该类包含虚函数）时，
        //由于无法获取空指针指向的 “实际对象类型”，typeid 会抛出 std::bad_typeid 异常。
        A* _nu = nullptr;
        cout << typeid(*_nu).name() << endl;
    }
    catch (const std::exception& e)
    {
        cout << e.what() << endl;
    }

    return 0;
}

五、总结

C++ 的类型转换机制是对 C 语言的兼容与大幅增强，核心围绕 “类型安全” 和 “自定义类型支持” 展开：

1. 兼容 C 语言的隐式转换和显式强制转换，但不推荐直接使用（缺乏安全性和规范性）；
2. 扩展了自定义类型的转换能力，通过构造函数和类型转换运算符实现灵活的类型转换；
3. 引入 4 个显式转换运算符，明确各场景的转换规则，提升代码可读性和安全性；
4. RTTI 机制（typeid和dynamic_cast）支持运行时类型识别，为多态场景提供类型判断能力。

在实际开发中，应优先使用 C++ 的增强特性：避免无意义的类型转换，用static_cast替代 C 风格隐式转换，用const_cast谨慎处理 const 属性，用dynamic_cast保障多态类型转换的安全，通过合理设计构造函数和类型转换运算符实现自定义类型的友好交互。