C++类型转换详解

一、内置转内置

二、内置转自定义

三、自定义转内置

四、自定义转自定义

五、类型转换规范化

1.static_case

2.reinterpret_cast

3.const_cast

4.dynamic_cast

六、RTTI

一、内置转内置

C++兼容C语言，在内置类型之间转换规则和C语言一样的，C/C++语言因为允许类型转换所以不是类型安全的语言。

隐式转化：编译器识别出类型不同后，能转就转，不能转则报错。

例如：

int = 'a'
char = 4
int = 8.26

除此之外函数调用中形参和实参的类型不同时，编译器会尝试进行隐式转化。

显示转化（强制类型转化）：用户进行指定的显示转换。

例如：

int = (int)'a'
char = (char)4
int = (int)8.26

什么时候能转什么时候不能转呢？

通常有关联性的类型，有转换意义的类型都是可以转化的。比如int类型与double类型，float类型，short类型等，都是描述数字的大小，又或者各种指针类型之间。

又比如int与指针不能隐式转换，因为转化后也是无意义的。但可以显示转化（强制类型转化）。

二、内置转自定义

c++中支持内置类型转自定义类型，只需要提供相应的构造函数，就可以想怎么转就怎么转，全在于你的构造函数怎么实现。如下：

using namespace std;
class A
{
public:A(int x):a(x),b(x){}A(int x,int y,int z):a(x), b(y+z){}
private:int a;int b;
};
void fun(A x)
{//......
}
int main()
{int v = 10;A a1 = v;//int类型隐式转化为A类型A a2 = { 1,2,3 };fun(6);return 0;
}

A a1 = v：调用构造函数产生临时对象，然后调用拷贝赋值。逻辑上是这样，但实际上会被编译器优化。
A a2 = {1,2,3}：通过花括号传入多个参数构造临时对象，然后调用拷贝赋值。
fun(6)：在函数传参时，同样会隐式转换，不用单独构造出类型后传入，这样就显得方便得多。

在构造函数的函数名前加关键字explicit：不被允许隐式转换，要进行转换需要显示的进行。

三、自定义转内置

c++中支持自定义类型转内置类型，提供相应的运算符重载函数（operator），同样可以想怎么转就怎么转，都是自己设定的。

强制类型转化的运算符是()，按理来说应该重载()运算符，但是又与仿函数冲突，所以c++制定了特殊的函数来做类型转化，即：

operator 类型 ()

该函数不用写返回类型，但在函数名后面需要加目标类型，函数结束也需要return返回。

class A
{
public:A(int x,int y):_a(x),_b(y){}operator int(){return _a + _b;}
private:int _a;int _b;
};
int main()
{A a1 = { 1,3 };int x = a1;return  0;
}

同样可以使用explicit修饰，修饰后不支持隐式转化。

比如在c++智能指针shared_ptr中使用了operator bool()把指针转换为bool类型来判断指针是否为空，如下：

测试如下：

#include <iostream>
#include <memory>
using namespace std;
int main()
{shared_ptr<int> p(new int(10));if (!p)//隐式转换为bool类型cout << "p为nullptr";else cout << "p不为nullptr";return 0;
}

四、自定义转自定义

c++中自定义与自定义之间同样可以转换，核心是让构造函数产生临时对象。比如我们要让B类型转换为A类型，我们可以构造这样一个函数：

class A
{
public:A(int x):_a(x),_b(x){}int get_a(){return _a;}
private:int _a;int _b;
};
class B
{
public:B(A x):_val(x.get_a()){}
private:int _val;
};
int main()
{A a = 4;B b = a;return  0;
}

五、类型转换规范化

C 风格的类型转换过于“暴力”，允许许多不安全的转换。C++提供的 显式类型转换运算符来替代传统的 C 风格强制类型转换（如 (int)x）。这种机制的目的是提高代码的 类型安全性、可读性 和 维护性，同时限制不安全的隐式转换。

它有四种类型转换运算符，接下来我们依次来学习。

1.static_case

用于意义相近的转换，比如int与double，char与int，左值与右值，如下：

int main()
{char ch = 'm';int x = static_cast<int>(ch);return 0;
}

2.reinterpret_cast

reinterpret_cast用于高风险的类型转换，即意义不相近的类型之间，或各种指针之间的转换，比如int与int*，char*与int*。

int main()
{int x = 10;int* p = reinterpret_cast<int*>(x);return 0;
}

3.const_cast

const_cast用来添加/移除const属性的类型间转换，或者添加/移除volatile属性的类型间转换，如下：

int main()
{volatile const int n = 10;int* v = const_cast<int*>(&n);//移除const属性const int& m = const_cast<const int&>(m);//移除volatile属性return 0;
}

4.dynamic_cast

用于基类与派生类之间的类型转换。

派生类转基类也叫切片，天然就可以实现的，但是基类转派生类可能会存在越界访问的问题。用这个关键字可以有效避免。

class Base { 
public:virtual ~Base() {} 
};
class Derived : public Base {};Base* base_ptr = new Base(); // 基类指针指向基类对象// 尝试向下转型
Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
if (derived_ptr == nullptr) { // 转换失败！
}