C++类型转换(翻译自cplusplus)

前言

　　原文翻译自http://www.cplusplus.com/doc/tutorial/typecasting/,觉得这篇文章讲C++类型转换简单明了，所以特别翻译了下。

　　在C++中，将一个已知的类型转换为另一个类型，我们称呼为类型转换,本文会介绍C++的各种类型转换。

隐式转换

隐式转换不需要任何操作符，它们会自动执行，当值被赋值到兼容类型，就会执行,例如:

short a=2000;
int b;
b=a;

隐式转换，也包括构造函数和运算符的转换，例如:

class A {};
class B { public: B (A a) {} };

A a;
B b=a;

 

显式转换

C++是一个强类型的语言。许多转换，需要显式转换,例如

short a=2000;
int b;
b = (int) a;    // c-like cast notation
b = int (a);    // functional notation

 

上述的类型转换已经满足了基本类型的转换了，但是如果应用于类和指针中,代码可以编译，但是在运行过程中会出错。例如

// class type-casting
#include <iostream>
using namespace std;

class CDummy {
    float i,j;
};

class CAddition {
    int x,y;
  public:
    CAddition (int a, int b) { x=a; y=b; }
    int result() { return x+y;}
};

int main () {
  CDummy d;
  CAddition * padd;
  padd = (CAddition*) &d;
  cout << padd->result();
  return 0;
}

这段代码会在运行期出错，在执行padd->result()时异常退出。

传统明确的类型转换，可以转换成任何其他指针类型任何指针，它们指向的类型无关。在随后的调用成员的结果，会产生一个运行时错误或意外的结果。

 

C++标准转换运算符

传统的类和指针的类型转换，十分不安全，可能会在运行时,由于类型不匹配异常退出，所以C++提供了四个标准转换运算符：dynamic_cast, reinterpret_cast, static_cast, const_cast

dynamic_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
static_cast <new_type> (expression)
const_cast <new_type> (expression)

 

dynamic_cast

dynamic_cast只能用于指针和引用的对象。其目的是确保类型转换的结果是一个有效的完成所请求的类的对象,所以当我们从一个类转换到这个类的基类，dynamic_cast总是可以成功

class CBase { };
class CDerived: public CBase { };

CBase b; CBase* pb;
CDerived d; CDerived* pd;

pb = dynamic_cast<CBase*>(&d);     // ok: derived-to-base
pd = dynamic_cast<CDerived*>(&b);  // wrong: base-to-derived

当新的类型不是被转换的类型的基类，dynamic_cast无法完成指针的转换，返回NULL，如果dynamic_cast是用来转换为引用类型的转换失败，会抛出"Bad_cast exception"异常。

dynamic_cast 可以转换NULL指针为不相关的类,也可以任何类型的指针为void指针。 

dynamic_cast的需要的运行时类型信息（RTTI），保持动态类型跟踪。一些编译器支持此功能默认情况下是禁用的选项。这必须启用运行时类型检查，使用dynamic_cast的正常工作。

 

static_cast

static_cast可以执行相关的类的指针之间的转换，不仅从派生类到基类的转换，也可以做到基类到派生类的转换。static_cast没有在运行时进行安全检查，因此，它是程序员，以确保转换是安全的，但是dynamic_cast的类型安全检查的开销,static_cast是可以避免的。

class CBase {};
class CDerived: public CBase {};
CBase * a = new CBase;
CDerived * b = static_cast<CDerived*>(a);

 

上述代码是合法的，虽然b指向一个不完整的对象，并可能在运行期导致错误。

static_cast也可以用来执行任何其他非指针的转换，例如像基本类型之间的标准转换，也可以是隐式执行

double d=3.14159265;
int i = static_cast<int>(d); 

 

reinterpret_cast

reinterpret_cast转换成任何其他指针类型，甚至无关的类，任何指针类型。操作的结果是一个简单的从一个指针到其他的值的二进制拷贝。所有的指针转换是允许的：不管是指针指向的内容还是指针本身的类型。

同时,它也可以把指针转换为整数，但是整数是平台相关的，必须保证整数足够大到可以包含指针本身的内容，最后再转换为一个合法的指针。

class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast<B*>(a)

 

const_cast

const_cast用于操纵对象的常量性，既要设置或删除。例如，一个函数要求一个非const参数,而程序需要传递一个const参数。

#include <iostream>
using namespace std;

void print (char * str)
{
  cout << str << endl;
}

int main () {
  const char * c = "sample text";
  print ( const_cast<char *> (c) );
  return 0;
}

 

typeid

typeid的允许检查表达式的类型
typeid (expression)

 

这个操作符返回一个引用在标准头文件<typeinfo>中定义的常量对象，是一个类型的type_info。这个返回值可以与另一个使用运算符==和!=进行比较两个数据类型或类的名称，或者也可以使用其name() 成员函数获得类型名字(一个0结束的的字符串)。

// typeid
#include <iostream>
#include <typeinfo>
using namespace std;

int main () {
  int * a,b;
  a=0; b=0;
  if (typeid(a) != typeid(b))
  {
    cout << "a and b are of different types:\n";
    cout << "a is: " << typeid(a).name() << '\n';
    cout << "b is: " << typeid(b).name() << '\n';
  }
  return 0;
}

当typeid应用使用RTTI来跟踪动态对象的类型,那么当typeid的是应用于表达式，其类型是一个多态类，其结果是派生的最完整的对象的类型：

// typeid, polymorphic class
#include <iostream>
#include <typeinfo>
#include <exception>
using namespace std;

class CBase { virtual void f(){} };
class CDerived : public CBase {};

int main () {
  try {
    CBase* a = new CBase;
    CBase* b = new CDerived;
    cout << "a is: " << typeid(a).name() << '\n';
    cout << "b is: " << typeid(b).name() << '\n';
    cout << "*a is: " << typeid(*a).name() << '\n';
    cout << "*b is: " << typeid(*b).name() << '\n';
  } catch (exception& e) { cout << "Exception: " << e.what() << endl; }
  return 0;
}

注意：返回的字符串成员的type_info名称取决于你的编译器和库的具体实现,其典型的类型名称,它不一定是一个简单的字符串.

如果类型typeid的参数是引用操作符（*）开头的指针，而且这个指针是NULL，typeid会抛出一个bad_typeid异常。