C++类型转换详解

news2025/4/18 21:01:51

一、内置转内置

二、内置转自定义

三、自定义转内置

四、自定义转自定义

五、类型转换规范化

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) { 
    // 转换失败！
}