秒懂C++之类型转换-CSDN博客

本文链接：https://blog.csdn.net/fax_player/article/details/142345450

前言

其实就是学习一下新的语法规范，跟前面的异常规范一样，能掌握的话可以避免一些类型转换所出现的错误~ 首先我们得先来介绍一下有关C语言与C++相关的类型转换~

C语言类型转换

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);
}

总体分为隐式类型转换与强制类型转换~

我们再来根据使用场景来划分~

整形之间 隐式类型转换
整形和浮点数 隐式类型转换
bool和整形 bool和指针 隐式类型转换
指针和整形 强制类型转换
不同类型的指针之间 强制类型转换

C++类型转换

学完C++后我们可以见到以下三种场景

内置类型->自定义类型之间，本质借助构造隐式类型转换如：string和const char*

int main()
{
	// 单参数的构造函数，支持内置类型隐式转换成自定义类型
	string s1 = "111111";
	const string& s2 = "11111";

	return 0;
}

自定义类型之间->自定义类型之间，本质借助构造，隐式类型转换如：initializer_list和容器

自定义类型之间->内置类型, 本质要重载一个operator类型隐式类型转换

//特殊重载让一个自定义类型的类变成内置类型
class A
{
public:
	operator int()
	{
		return _a1 + _a2;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	A aa;
	int ii1 = aa;
	int ii2 = (int)aa;

	return 0;
}

感觉很少见到，了解即可~

static_cast

static_cast用于非多态类型的转换，其实就是隐式类型转换的标识~

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	//int a = d;
	cout << a << endl;
	return 0;
}

reinterpret_cast

reinterpret_cast就是强制类型转换的标识~

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;
	// 这里使用static_cast会报错，应该使用reinterpret_cast
	//int *p = static_cast<int*>(a);
	int* p = reinterpret_cast<int*>(a);
	return 0;
}

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;


	return 0;
}

不过编译器会对const进行优化，以为const不会改变就放到寄存器中，打印的时候取的是寄存器里面的，但实际上a在内存中的值已经改变了~

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


	return 0;
}

所以我们再来添加上关键字 volatile 确保a是在内存中取的而非寄存器~

dynamic_cast

dynamic_cast 用于将一个父类对象的指针 / 引用转换为子类对象的指针或引用 ( 动态转换 )

向上转型：子类对象指针 / 引用 -> 父类指针 / 引用 ( 不需要转换，赋值兼容规则 )

向下转型：父类对象指针 / 引用 -> 子类指针 / 引用 ( 用 dynamic_cast 转型是安全的 )

注意：

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

其实很好理解，首先认识一点 ：父类无法转换为子类，但父类指针可以转换为子类指针。而父类指针指向子类对象，再转为子类指针是没问题的， 不过父类指针指向父类对象再转为子类指针就会出现越界访问的情况~

class A
{
public:
	virtual void f() {}

	int _a = 0;
};

class B : public A
{
public:
	int _b = 1;
};

void fun(A* pa)
{
	// 向下转换：父->子
	// pa指向子类对象，转回子类，是安全的
	// pa指向父类对象，转回子类，是不安全的，存在越界的风险问题

	// 不安全
	//B* pb = (B*)pa;

	//  pa指向子类对象，转回子类，正常转换
	//  pa指向父类对象，转回子类，转换失败
	B* pb = dynamic_cast<B*>(pa);
	if (pb)
	{
		cout << pb << endl;
		cout << pb->_a << endl;
		cout << pb->_b << endl;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

int main()
{
	A a;
	B b;

	fun(&a);
	fun(&b);

	return 0;
}

这个还是很不错的，可以有效避免父类指针指向父类对象时转换为子类指针的越界访问问题~