八、C++之类型转换

用于类层次中基类（父类）和派生类（子类）之间指针或者引用的转换

进行上行转换（把派生类的指针或引用转换为基类表示）是安全的

进行下行转换（把基类指针或引用转换成派生类表示），由于没有动态类型检测，所以是不安全的

 

一、静态转换（static_case）

/*
    static_cast 使用   static_cast<目标类型>(原始对象)
    可以进行基础数据类型转换， 父与子类型转化
    没有父与子的关系或者自定义类型不能转换
*/
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;


// 静态转换
// static_cast 使用   static_cast<目标类型>(原始对象)


// 1. 基础类型
void test()
{
    char a = 'a';
    double d = static_cast<double>(a);
    cout << "d = " << d << endl; // d = 97
}

// 2. 父与子之间的转换

class Base{};

class Child :public Base{};

class Other{};


void test02()
{
    Base *base = NULL;
    Child * child = NULL;
    // 把 Base 转换为 Child*类型，向下转换， 不安全
    Child * child2 = static_cast<Child *>(base);
    
    // 把 child转换为 Base * 向上转换， 安全
    Base * base2 = static_cast<Base *>(child);

    // 转 other类型
    // Other * other = static_cast<Other *>(base); 直接报错， 转换无效
}



int main()
{
    test();
    test02();
    return EXIT_SUCCESS;
}

 

二、动态转换（dynamic_cast）

/*
    dynamic_cast 使用   dynamic_cast<目标类型>(原始对象)
    不可以进行基础数据类型转换
    父转子 不可以
    子转父 可以
    发生多态 都可以
*/

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;

// 动态转换

// 基础类型不可以转换,dynamic_cast非常严格，失去精度或者不安全都不可以转换
void test()
{
    char c = 'a';
    //double d = dynamic_cast<double>(a); // 直接报错
}

class Base{};
class Child : public Base{};
class Other{};

void test02()
{
    Base * base = NULL;
    Child * child = NULL;
    // 将 Child 转换为 Base*, 安全
    Base *base2 = dynamic_cast<Base *>(child);
    // 将 Base 转换为 Child*, 不安全
    //Child *child2 = dynamic_cast<Child *>(base);
}

// dynamic_cast 如果发生了多态， 那么就可以让基类转换为派生类， 向下转换
class Base2
{
public:
    virtual void func() {};
};

class Child2 : public Base2
{
public:
    virtual void func() {};
};

void test03()
{
    // 发生了多态
    Base2 * base2 = new Child2;
    Child2 * child = dynamic_cast<Child2 *>(base2);

}


int main()
{
    test();
    return EXIT_SUCCESS;
}

 

 

三、常量转换（const_cast）

/*
    不能对非指针或者引用的变量进行转换
*/
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;

// 常量转换

void test()
{
    const int *p = NULL;
    // 去除 conbst
    int *newp = const_cast<int *>(p);

    int *p2 = NULL;
    const int *newp2 = const_cast<const int *>(p2);

    // 不能对非指针或者引用的变量进行转换
    const int a = 10;
    //int b = const_cast<int>(a);  不允许操作

    int num = 10;
    int &numRef = num;
    const int &numRef2 = const_cast<const int &>(numRef);
}


// 重新在解释转换（）

//void test


int main()
{
    return EXIT_SUCCESS;
}

 

四、重新解释转换（reinterpret_cast）

/*
    最不安全，最鸡肋， 不建议使用
*/
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;

class Base{};
class Child : public Base{};
class Other{};

// 重新在解释转换（）
// 不安全，不用
void test()
{
    int a = 10;
    int *p = reinterpret_cast<int *>(a);   // 可以


    Base *base = NULL;
    Other *other = reinterpret_cast<Other *>(base);
}


int main()
{
    return EXIT_SUCCESS;
}