C++类型转化、运行期型式信息

淡淡的烟草味﹌ 2023-03-02 04:58 22阅读 0赞

### 目录 ###

*   *  运行期型式信息
     *   *  typeid操纵符与type\_info类
         *   *  type\_info 类
             *  typeid操纵符
     *  对象转型模板
     *   *  使用方法
         *   *  转型操作
             *  模板的工作原理
             *  模板特点
             *  模板用途
         *  dynamic\_cast
         *   *  动态转型的三种方式
             *  指针的动态转型
             *  引用的动态转型
             *  示例
         *  static\_cast
         *  const\_cast
         *   *  示例
         *  reinterpret\_cast
         *   *  重释转型的目的
             *  重释转型的问题
             *  示例

## 运行期型式信息 ##

RTTI

*  运行期标识对象的型式信息
 *  优势：允许使用指向基类的指针或引用自如自如地操作派生类对象
 *  `typeid`：获取表达式的型式；`type_info`：型式信息类
 *  头文件：`typeinfo`

### typeid操纵符与type\_info类 ###

#### type\_info 类 ####

*  编译器实现的动态型式信息转型
 *  用于在程序运行时保存数据对象的型式信息
 *  不能直接使用该类，只能通过`typeid`操作符
 *  调用成员函数`name()`可获得类的名称

#### typeid操纵符 ####

#include <typeinfo>
    Programmer p;
    Employee & e = p;
    
    // 输出p实际类名的子字串 "Programmer"
    cout << typeid(e).name() << endl;

## 对象转型模板 ##

*  `dynamic_cast`：动态转型
 *  `static_cast`：静态转型
 *  `reinterpret_cast`：重释转型
 *  `const_cast`：常量转型

### 使用方法 ###

#### 转型操作 ####

*  尖括号`<>`接受**目标型式**作为模板参数
    
        Programmer * p = dynamic_cast<Programmer*>(e);

#### 模板的工作原理 ####

*  使用`template<typename T>`定义函数模板或类模板
 *  实体化（instantiation）：使用特定的模板实际参数，生成真正的模板函数和类模板
 *  编译模板函数和类模板，生成最终程序代码
 *  **模板代码一般放在头文件中：因为编译器需要看到模板源代码**

#### 模板特点 ####

*  抽象性：模板代码高度抽象，是函数和类的模范
 *  安全性：型式检查能够发现大多数型式失配问题
 *  通用性：函数和模板定义一次，按需要生成函数或类的实体
 *  易用性：接口相对直观且高度一致
 *  效率：减少冗余代码，提升编程效率；通过编译优化，提升程序执行效率

#### 模板用途 ####

*  函数模板：构造函数集，实现不依赖特定结构的抽象算法
 *  类模板：构造类集，实现抽象数据结构
 *  元编程：构造在编译期执行的运算，提升程序执行效率

### dynamic\_cast ###

#### 动态转型的三种方式 ####

*  向上转型：沿着类继承层次向基类转型
 *  向下转型：沿着类继承层次向派生类转型
 *  交叉转型：沿着类多重继承层次横向转型

#### 指针的动态转型 ####

*  正确执行时，结果为指向目标类对象的指针
 *  错误执行时，结果为`0/NULL`(C++11：`nullptr`)

#### 引用的动态转型 ####

*  执行正确时，结果为目标类对象的引用
 *  错误执行时，引发`bad_cast`异常

#### 示例 ####

假设软件公司包括程序员和经理两类职员，需要按照不同规则支付薪水和奖金。如何实现？

class Employee
    { 
     public:
        virtual void PaySalary();
        virtual void PayBonus();
    };
    class Manager:public Employee
    { 
     public:
        virtual void PaySalary();
        virtual void PayBonus();
    };
    class Programmer:public Employee
    { 
     public:
        virtual void PaySalary();
        virtual void PayBonus();
    };
    class Company
    { 
    public:
        virtual void PayRoll(Employee * e);
        virtual void PayRoll(Employee & e);
    private:
        vector<Employee*> _employees;
    };
    
    // 版本一
    void Company::PayRoll( Employee * e)
    { 
        // 调用哪个成员函数？如何区分程序员和经理？
        e->PaySalary();
        e->PayBonus();
    };
    
    // 版本二
    void Company::PayRoll(Employee * e)
    { 
        // 核心实现: 尖括号类面传递"目标型"
        Programmer * p = dynamic_cast<Programmer*>(e); // 本质上时模板类
        if(p) // p确实指向程序员对象
        { 
            p->PaySalary();
            p->Bonus();
        }
        else // p不指向程序员，不发奖金
            e->PaySalary();
        
    };
    
    // 版本三
    void Company::PayRoll(Employee & e)
    { 
        try
        { 
            Programmer & p = dynamic_cast<Programmer &>(e); // 引用转型错误就会抛出异常bad_cast
            p.PaySalary();
            p.PayBonus();
        }
        catch(std::bad_cast)
        { 
            e.PaySalary();
        }
    };

### static\_cast ###

静态转型的用途

*  与`dynamic_cast`不同，`static_cast`不仅可以用于**指针**和**引用**，还可用于去他型式
 *  一般用于**非类**型式的普通数据对象转型
 *  可以在类继承层次上进行向上或向下转型

静态转型的问题

*  不进行运行期型式检查，不安全
 *  如转型失败，则结果无定义

### const\_cast ###

常量转型的目的

*  用于**取消**或**设置**量的`const`状态

常量转型的问题

*  如果原始数据对象不能写入，则取消常量修饰可能会导致未知结果

#### 示例 ####

#include <iostream>
    class ConstCastTest
    { 
     public:
        void SetNum(int num)P{  _num = num; }
        void PrintNum() const;
     private:
        int _num;
    };
    
    void ContCastTest::PrintNum() const
    { 
        // 临时取消常量对象约束，修改目标对象的内容
        const_cast<ConstCastTest*>(this)->_num--;
        std::cout << _num;
    }

### reinterpret\_cast ###

#### 重释转型的目的 ####

*  将**任意型式**的数据对象转型为目标型式，即重新解释其位序列的意义
 *  可以用于整型与指针型的互转

#### 重释转型的问题 ####

*  由程序员保证重新解释的数据对象是否有意义，编译器简单按照目标型式理解该存储区的内容
 *  注意：在64位操作系统中，指针型可能位64为，而整型可能为32位，重释转型有可能丢失数据或得到错误结果

#### 示例 ####

#include <iostream>
    using namespace std;
    
    int f(void* p)
    { 
        unsigned int n = reinterpret_cast<unsigned int>(p);
        return n;
    }
    int main()
    { 
        int a[8] = { 1,2,3,4,5,6,7,8};
        int n = f(a);
        cout << n << endl;
    }