C++ 类型转化

概述

• C++中的类型转换分为两种：

  • 隐式类型转换；
  • 显式类型转换。

• 而对于隐式变换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。

• 在标准C++中有四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将对它们一一的进行总结。

const_cast

• 常量指针被转化成非常量指针，并且仍然指向原来的对象；
• 常量引用被转换成非常量引用，并且仍然指向原来的对象；
• const_cast一般用于修改指针。如const char *p形式。
• const_cast的作用是用来改变表达式里面的常量性（const）或易变性（volatile）。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  #include <iostream> using std::cout; using std::endl; int main(void) { const int b = 10; //b = 11 报错，因为b是一个常量对象 int * pc = const_cast<int *>(&b); *pc = 11; cout << "*pc = " << *pc << endl;//b原来地址的数据现在可由*pc来改变，即解除const cout << "b = " << b << endl; //b其实类似(编译器处理问题)#define b 10 不会变的 return 0; }

static_cast

• static_cast的转换格式：

  1	static_cast <type-id> (expression)

• 将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

  • 1.基本数据类型之间的转换，如把int转换成char，把int转换成enum

  • 2.用于类层次结构中基类和子类之间指针或引用的转换。

    • 进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
    • 进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。

  • 3.把void指针转换成目标类型的指针(不安全!!)

1
2
3
4
5
6
7
8

//隐式的类型转换
int firstnumber=10, secondnumber = 100 ;
double result=(double)firstnumber/secondnumber;
cout << result << endl;

//使用static_dynamic
double result2 = static_cast<double>(firstnumber)/static_cast<double> (secondnumber);
cout << result2 << endl;

dynamic_cast

• 用于多态类型的转换

• dynamic_cast的转换格式：

  1	dynamic_cast <type-id> (expression)

• 将expression转换为type-id类型，type-id必须是 类的指针、类的引用 或者是 void*

  • 如果type-id是指针类型，那么expression也必须是一个指针
  • 如果type-id是一个引用，那么expression也必须是一个引用

• dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。

• dynamic_cast主要用于 父类 & 子类 对象之间的转换

• 子类对象 -> 父类对象 时，dynamic_cast和static_cast的效果是一样的；

• 父类对象 -> 子类对象 时，dynamic_cast具有类型检查的功能，比static_cast更安全。

• 在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。

子类对象 -> 父类对象

• 比如B继承自A，B转换为A，进行上行转换时，是安全的，于static_cast相同，如下：

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

  #include <iostream> using namespace std; class A {}; class B : public A {}; int main() { B *pB = new B; A *pA = dynamic_cast<A *>(pB); // Safe and will succeed }

多重继承之间的上行转换

• C继承自B，B继承自A，这种多重继承的关系；但是，关系很明确，使用dynamic_cast进行转换时，也是很简单的：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  class A {}; class B : public A {}; class C : public B {}; int main() { C *pC = new C; B *pB = dynamic_cast<B *>(pC); // OK A *pA = dynamic_cast<A *>(pC); // OK }

• 而上述的转换，static_cast和dynamic_cast具有同样的效果。而这种上行转换，也被称为隐式转换；比如我们在定义变量时经常这么写：B *pB = new C;这和上面是一个道理的，只是多加了一个dynamic_cast转换符而已。

父类对象 -> 子类对象

• （这个真的是重点）如果expression是type-id的基类，使用dynamic_cast进行转换时，在运行时就会检查expression是否真正的指向一个type-id类型的对象，如果是，则能进行正确的转换，获得对应的值；否则返回NULL，如果是引用，则在运行时就会抛出异常

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  class B { virtual void f(){}; }; class D : public B { virtual void f(){}; }; void main() { B* pb = new D; // unclear but ok B* pb2 = new B; D* pd = dynamic_cast<D*>(pb); // ok: pb actually points to a D D* pd2 = dynamic_cast<D*>(pb2); // pb2 points to a B not a D, now pd2 is NULL }