【C++】类型转换

原创已于 2025-11-29 13:32:43 修改 · 539 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2025-11-24 16:25:10 首次发布

C++ 专栏收录该内容

19 篇文章

订阅专栏

1. 常见的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化。C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换
1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败
2. 显式类型转化：需要用户自己处理
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);
}
单参数的构造函数支持隐式类型转化，如果不想让单参数的构造函数支持隐式类型转化，可以在函数声明前加上 explicit 关键字。
class A
{
public:
	//explicit A(int a) 
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

int main()
{
	A aa1 = 1;// 单参数的构造函数支持隐式类型转化
	return 0;
}

常见类型转化的缺陷

1、转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换

2、size_t 与 int 之间的转化有时候出乎意料：
void insert(size_t pos, char ch)
{
	int end = 10;
	while (end >= pos)
	{
		cout << end << endl;
		//...
		--end;
	}
}
当传入的 pos 为 0 时，end 减为 -1，size_t 的 -1 为 unsigned int 的最大值。

3、用指针和强制类型转化可以破坏 const 变量的常性，但会产生一些奇怪的现象
int main()
{
	const int n = 10;
	int* p = (int*)&n;
	(*p)++;

	cout << n << endl;
	cout << *p << endl;

	return 0;
}
打印的结果应该都是 11，但实际上是 10 和 11。更奇怪的是在调试时明明 n 都已经变为 11 了，但打印出来仍然是 10。原因是编译器做了优化，cout << n << endl; 本来要去内存取 n 的值，但编译器在编译阶段直接像宏一样将 n 替换为 10 了，但我们仍然认为 cout << n << endl; 中的 n 是实际内存中存储的 n 。要解决这个问题，只需在声明 const 变量时加上 volatile 关键字，它的作用是告诉编译器每次都要去内存取它的值，不要把它放在寄存器或者直接替换。
volatile const int n = 10;
4、任何类型的指针之间都可以相互转化，可能会导致越界访问
class A
{
public:
	virtual void f() {}

	int _x = 0;
};

class B : public A
{
public:
	int _y = 0;
};

void func(A* pa)
{
	B* pb = (B*)pa;

	pb->_x = 1;
	pb->_y = 1; // 越界访问
}

int main()
{
	A aa;
	func(&aa);

	return 0;
}

2、C++强制类型转换

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

2.1 static_cast

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

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

  int* p = &a;
  int address = static_cast<int>(p); // error
  return 0;
}

2.2 reinterpret_cast

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

int main()
{
 double d = 12.34;
 int a = static_cast<int>(d);
 cout << a << endl;
    
 int* p = &a;

 // 这里使用static_cast会报错，应该使用reinterpret_cast
 //int address = static_cast<int>(p); // error
 
 int address = reinterpret_cast<int>(p); // 不会报错
 return 0;
}

2.3 const_cast

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

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

2.4 dynamic_cast

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

向上转型：子类对象指针/引用赋值给父类指针/引用(天然可以转换，赋值兼容规则)
向下转型：父类对象指针/引用赋值给子类指针/引用

1、如果父类对象指针/引用指向/引用的是子类，赋值后不会发生越界访问

2、如果父类对象指针/引用指向/引用的是父类，赋值后可能发生越界访问

使用 dynamic_cast 可以防止父类对象指针/引用赋值给子类指针/引用时发生越界访问

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

	int _x = 0;
};

class B : public A
{
public:
	int _y = 0;
};

void fun(A* pa)
{
	// 如果 pa 指向子类对象，转换可以成功，正常返回地址
	// 如果 pa 指向父类对象，转换失败，返回空指针
	B* pb = dynamic_cast<B*>(pa);
	if (pb)
	{
		cout << "转换成功" << endl;
		pb->_x++;
		pb->_y++;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

int main()
{
	A aa;
	fun(&aa);

	B bb;
	fun(&bb);

	return 0;
}