C++【类型转换】

一、C语言的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败
2. 显式类型转化：需要用户自己处理

using namespace std;

void Test ()
{
    int i = 1;
// 隐式类型转换
    double d = i;
    printf("%d, %.2f\n" , i, d);
    int* p = &i;
// 显示的强制类型转换
    int address =(int)p;
    printf("%x, %d\n" , p, address);
}
int main() {
    Test();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

隐式类型转换：意义相近的类型
char int short float double…整形家族
（它们都是用来表示数据大小的，区别就是存储的数据范围不同）
强制类型转换：意义不相近
比方说int和指针的意义不想近，所以不可以进行隐式类型转换。
但是它们的值转换后有意义。
虽然指针表示一个地址（虚拟地址，都是一个一个的编号），所以可以转。
但如果是一个学生类的话，我们不能将其转换成整型

隐式类型转换的潜在问题

//在pos位置插入一个字符
void Insert(size_t pos,char ch)
{
    size_t _size=10;
    //我们需要把数据向后挪动
    size_t end=_size-1;
    //即使我们将size_t写成了int，依旧会进入死循环
    //因为这里的符号运算也会发生整形类型提升
    //也就是隐式类型提升，让我们的end变成一个无符号整形
    while(end>=pos)
    {
//        _str[end+1]=_str[end];
        --end;
    }
}
int main() {
    Insert(5,'a');
    //会陷入死循环，因为我们的end是一个无符号整型，所以根本就不可能为负数，所以会一直进行插入操作。
    Insert(0,'a');
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

C风格的转换格式很简单，但是有不少缺点的：

1. 隐式类型转化有些情况下可能会出问题：比如数据精度丢失
2. 显式类型转换将所有情况混合在一起，代码不够清晰
   因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。

二、C++的强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：
static_cast、reinterpret_cast、const_cast、dynamic_cast

1.static_cast静态转换

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关的类型进行转换（用于意义相近的类型：整型，浮点）

int main()
{
    double d = 12.34;
    int a = static_cast<int>(d);
    cout<<a<<endl;
    return 0;
}
1
2
3
4
5
6
7

那如果不是相近的类型能不能转换呢？
不可以的！

int main()
{
    int*p=&a;
    int address=static_cast<int>(p);
    return 0;
}
1
2
3
4
5
6

2.reinterpret_cast重新诠释

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型
（可以用于不同的数据类型进行转换）

typedef void (* FUNC)();
int DoSomething (int i)
{
    cout<<"DoSomething" <<endl;
    return 0;
}
void Test ()
{
    //
    // reinterpret_cast可以编译器以FUNC的定义方式去看待DoSomething函数
    // 所以非常的BUG，下面转换函数指针的代码是不可移植的，所以不建议这样用
    // C++不保证所有的函数指针都被一样的使用，所以这样用有时会产生不确定的结果
    //
    FUNC f = reinterpret_cast< FUNC>(DoSomething );
    f();
}
int main()
{
    Test();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值

int main()
{
    const int a = 2;
    int* p = const_cast< int*>(&a );
    *p = 3;
    cout<<a <<endl;
    cout<<*p<<endl;
    cout<<&a<<endl;
    cout<<p<<endl;

}
1
2
3
4
5
6
7
8
9
10
11

在C++中，这里的常量为常变量，可以修改，但是不能直接进行修改，我们可以通过上面的形式进行修改。

为什么是2和3，不是3和3
编译器对于const类型是有优化的，因为编译器认为const类型的变量不会被修改，那每次从内存中取的话，就会非常慢，那C++就将上面的a直接加载到一个寄存器当中，每次访问的时候（读取数据）直接去这个寄存器中读取数据就可以了。虽然你的内存中的数据被改成3了，但是寄存器中的数据并没有被修改。

为什么const_cast需要单独拿出来？
因为const_cast很危险，所以我们将其单独拿出来

int main()
{
    //告诉编译器不要优化了，每次都去内存中取我们的值
    volatile const int a = 2;
    int* p = const_cast< int*>(&a );
    *p = 3;
    cout<<a <<endl;
    cout<<*p<<endl;

}
1
2
3
4
5
6
7
8
9
10

int main()
{
    //告诉编译器不要优化了，每次都去内存中取我们的值
    volatile const int a = 2;
//    int* p = const_cast< int*>(&a );
    //C语言的也是可以使用的
    int *p=(int*)&a;
    *p = 3;
    cout<<a <<endl;
    cout<<*p<<endl;

}
1
2
3
4
5
6
7
8
9
10
11
12

小总结

1.兼容C隐式类型转换和强制类型转换
2.期望不要用了，期望你通用规范的C++显式的强制类型转换
3.static_cast对应隐式类型转换
reinterpret_cast、const_cast对应的是强制类型转换

4.dynamic_cast动态转换

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

注意：

1. dynamic_cast只能用于==含有虚函数的类 ==
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

子类给父类是向上转换，是C++的一个特例，是赋值兼容的，虽然两个对象的类型不一样，但是所有的类型转换都会产生临时变量

int main()
{
    int i=0;
    //将i转给临时变量，然后再将这个值给d
    double d=i;
    //临时变量具有常性，所以我们不能直接将i赋值给rd
//    double& rd=i;
    //加上const就可以了
    //c语言的写法
    const double& rd1=i;
    //C++的写法
    const double& rd2=static_cast<int>(i);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

class A
{
public:
    int _a=0;
};
class B:public A{
public:
    int _b=0;
};
int main()
{
    B bb;
    //进行切片，然后转换。
    A aa1=bb;
    A& ra1=bb;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

父类是不允许转换成子类的，无论是我们上面说的C++中的四个转换中的任何一个都是不可以的。
指针也引用要允许转换！
为什么指针和引用要允许转换（为什么允许指针或者对象向下转换呢？）
因为父类的指针有可能指向父类对象，也有可能指向子类对象。

如果你是一个父类的指针，你原本只能查看四个字节的大小，但是你如果现在能查看8个字节的大小，那么，这就是越界访问了。
（你的父类的指针指向一个子类的对象，但是你如果访问到了子类的部分，你就是越界访问，这是不被允许的）
但是你用dynamic_cast去转换，那么你就是安全的

class A
{
public :
    virtual void f(){}
    int _a;
};
class B : public A
{
    int _b;
};

//A*的指针有可能指向父类，也有可能指向子类，
void fun (A* pa)
{
    //如果pa指向子类，那么可以转换，重新转换成子类，这种方式是安全的
    //如果pa指向父类，那么不能转换，转换表达式为nullptr
// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
    B* pb1 = dynamic_cast<B*>(pa);
    cout<<"pb1:" <<pb2<< endl;
}
int main ()
{
    A a;
    B b;
    fun(&a);
    fun(&b);
    fun(nullptr);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

如果是static_cast或者c语言的转换的话，可以转换，但是其实已经越界访问了

class A
{
public :
    virtual void f(){}
    int _a;
};
class B : public A
{
    int _b;
};

//A*的指针有可能指向父类，也有可能指向子类，
void fun (A* pa)
{
    //如果pa指向子类，那么可以转换，重新转换成子类，这种方式是安全的
    //如果pa指向父类，那么不能转换，转换表达式为nullptr
    B* pb1 = static_cast<B*>(pa);
    B* pb2=(B*)pa;
    cout<<"pb1:" <<pb1<< endl;
    cout<<"pb2:" <<pb2<< endl;
}
int main ()
{
    A a;
    B b;
    fun(&a);
    fun(&b);
    fun(nullptr);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在多继承中的使用情况

class A1
{
public :
    virtual void f(){}
    int _a1;
};


class A2
{
public :
    virtual void f(){}
    int _a2;
};
class B : public A1,public A2
{
public:
    int _b;
};

int main ()
{

    B bb;
    A1* ptr1=&bb;
    A2* ptr2=&bb;
    cout<<ptr1<<endl;
    cout<<ptr2<<endl<<endl;

    B* pb3=(B*)ptr1;
    B* pb4=(B*)ptr2;
    cout<<pb3<<endl;
    cout<<pb4<<endl<<endl;


    B* pb5=dynamic_cast<B*>(ptr1);
    B* pb6=dynamic_cast<B*>(ptr2);
    cout<<pb5<<endl;
    cout<<pb6<<endl<<endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

它会把我们的指针偏移给修改回去。都会重新指向子类对象的起始位置，不会因为两个不同的父类的指针指向子类的对象而产生不同。

强制类型转换能够将我们的类型转换给规范起来，我们最好去遵守这些规范。

RAII
初始化一个对象。将资源交给这个对象进行管理
（资源获得即初始化）
RTTI（Run_time Type identification）
运行时类型识别
1.typeid运算符，拿到对象的类型的字符串，帮助我们观察
2.dynamic_cast运算符，用来识别父类的指针是指向父类的对象还是指向子类的对象、
3.decltype
推导一个对象类型，可以用来定义另一个对象。