C++类型转换方式总结

逃离我推掉我的手 2022-03-17 02:16 185阅读 0赞

# C++类型转换方式总结 #

## 转换运算符的应用之所 ##

const\_cast、reinterpret\_cast、static\_cast、dynamic\_cast转换运算符的使用总结如下：

1.  对于[传统的转换方式(C式或函数式)][C]，只在数值类型（包括整型、浮点型、字符类型和枚举）上使用。这也是延续C的形式，当然这类转换也是可以用static\_cast来替换，但是因为是基本类型，所以传统转换已经很直观。
2.  对于[const\_cast转换运算符][const_cast]，用在需要去除掉const限定的时候。其实这种情况出现的很少，可能的方法在const\_cast一文中已经又举例，不过还是反复强调， 使用const\_cast转换后，绝对不可试图修改结果的值。
3.  对于[reinterpret\_cast转换运算符][reinterpret_cast]，一般用在将对象指针类型转换到整数类型或者void \* （空指针）。如同在文中举出的隐患，因此注意的是，若要使用其结果，一定要将类型转换回去后使用。也不要将随意的整数转换成指针类型。
4.  对于[static\_cast转换运算符][static_cast]，将其用在对象的转换之上（虽然static\_cast也可以用在有继承关系的类型指针之间，但是还是将这方面的转换交给dynamic\_cast来操作吧）， static\_cast会调用相应的构造函数或者重载的转换运算符。
5.  通过[Google C++ Style Guide][Google C_ Style Guide]的推荐格式，知道对于单参构造函数的存在可能会引发一些隐式的转换，因此用static\_cast也可以明确的指出类型的转换过程，避免生成多余的临时对象造成效率下降。
6.  对于[dynamic\_cast转换运算符][dynamic_cast]，将其用在具有继承关系的指针类型之间的转换。无论是从基类到子类的转换，还是子类到基类的转换，都将dynamic\_cast套上去。

如果任何一种基于指针或引用的转换，套上四个转换运算符之后都失败，那么所要进行的转换可能就触到了“雷区”了：进行了没意义的转换。比如，对于没有关系的两个类型的指针进行了转换，比如试图转换指向方法的指针了。所以转换运算符对于避免代码出错也很有帮助。

## 基于引用（Reference）的转换运算符使用 ##

上述对于转换运算符的讲述和举例，都是基于指针的。但实际上，这些转换运算符也可以基于引用来展开。准确说实际上引用类型应该是作为转换的目标类型，源类型则是对象变量（当然也可能用的是引用变量，或是取出指针所指的内容，它们用到的都是实际的类对象）。

由于引用类型“定义时必须初始化”的特别，使得它不同于指针类型随时随地都调用转换运算符，基于引用的转换只在对引用进行初始化的时候才会出现。

下边是const\_cast和reinterpret\_cast基于引用的运用：

const int int\_constant = 21;

int& int\_ref = const\_cast<int&>(int\_constant);

cout << int\_ref << endl;

int int\_value = 7;

//long& long\_ref = int\_value; //Error, can not using reference cross types

float& long\_ref = reinterpret\_cast<float&> (int\_value);

cout << long\_ref << endl;

对于dynamic\_cast的应用基本也是一致的，只是还是限制在具有继承关系的类型之间。不同于基于指针在转换时返回null，dynami\_cast在基于引用转换失败时，会抛出std::bad\_cast异常，因为不能将空值赋给引用类型。如果要抓住这个异常，则需要引入如下头文件：  
\#include <typeinfo>

而static\_cast转换符前面已经说过推荐直接用在对象之上，不用在指针上，所以也不太会有需要用在引用类型上的情况出现。

## 山寨C\#的TryParse ##

C\#中有很多简洁实用的转换方法，比如从字符串到数值类型的[Parse][]和[TryParse][]，还有包含了各种从object对象到数值类型、时间类型的方法的[Convert类][Convert]，以及检查继承关系的[as运算符][as]。

从返回的结果看，C++和dynamic\_cast和C\#的[as][]很相似，两者都是在失败时候返回null。

不过面向对象的关键点在于什么都是以对象为操作单位，如前所讲dynamic\_cast看起来更像是一个全局方法。因此我便模仿C\#的数值类的TryParse方法，写了一个包裹dynamic\_cast的类型转换方法：

// dynamic\_cast\_tryparse.cpp

// Language:    C++

// Complier:    Visual Studio 2010, Xcode3.2.6

// Platform:    MacBook Pro 2010

// Application: none

// Author:      Ider, Syracuse University, ider.cs@gmail.com

///

\#include <string>

\#include <iostream>

using namespace std;

class Parents

public:

Parents(string n="Parent")\{ name = n;\}

virtual ~Parents()\{\}

virtual void Speak()

cout << "\\tI am " << name << ", I love my children." << endl;

void Work()

cout << "\\tI am " << name <<", I need to work for my family." << endl;;

/\*\*\*\*\*\*\*\*\*\*\*\*\*\* TryParseTo \*\*\*\*\*\*\*\*\*\*\*\*\*\*/

template<typename T> bool TryParseTo(T\*\* outValue)

T\* temp = dynamic\_cast<T\*> (this);

if (temp == NULL) return false;

\*outValue = temp;

return true;

protected:

string name;

\};

class Children : public Parents

public:

Children(string n="Child"):Parents(n)\{ \}

virtual ~Children()\{\}

virtual void Speak()

cout << "\\tI am " << name << ", I love my parents." << endl;

/\*

\*\*Children inherit Work() method from parents,

\*\*it could be treated like part-time job.

\*/

void Study()

cout << "\\tI am " << name << ", I need to study for future." << endl;;

private:

//string name; //Inherit "name" member from Parents

\};

class Stranger

public:

Stranger(string n="stranger")\{name = n;\}

virtual ~Stranger()\{\}

void Self\_Introduce()

cout << "\\tI am a stranger" << endl;

void Speak()

//cout << "I am a stranger" << endl;

cout << "\\tDo not talk to "<< name << ", who is a stranger." << endl;

private:

string name;

\};

int main()

Children \* parsedChild;

Parents \* parsedParent;

Stranger \* parsedStranger;

Parents \* mother = new Parents("Mother who pretend to be a my daugher");

if(mother->TryParseTo<Children>(&parsedChild))

parsedChild->Speak();

else

cout << "Parents parse to Children failed" << endl;

delete mother;

mother = new Children("Daughter who pretend to be a my mother");

if(mother->TryParseTo<Children>(&parsedChild))

parsedChild->Speak();

else

cout << "Parents parse to Children failed" << endl;

delete mother;

Children \* son = new Children("Son who pretend to be a my father");

if(son->TryParseTo<Parents>(&parsedParent))

parsedParent->Speak();

else

cout << "Children parse to Parents failed" << endl;

if(son->TryParseTo<Stranger>(&parsedStranger))

parsedStranger->Speak();

else

cout << "Children parse to Stranger failed" << endl;

delete son;

//pointer of child class could pointer to base class object

/\*

\* son = new Parents("Father who pretend to be a my son");

if(son->TryParseTo<Parents>(&parsedParent))

parsedParent->Speak();

else

cout << "Parse failed" << endl;

delete son;

\*/

return 0;

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* Result \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

//Parents parse to Children failed

//    I am Daughter who pretend to be a my mother, I love my parents.

//    I am Son who pretend to be a my father, I love my parents.

//Children parse to Stranger failed

这段代码中使用到的类跟dynamic\_cast一文中使用的基本一样，只是在基类中多了一个模板方法：

template<typename T> bool TryParseTo(T\*\* outValue)

T\* temp = dynamic\_cast<T\*> (this);

if (temp == NULL) return false;

\*outValue = temp;

return true;

该方法需要指定的目标类型，将自身指针转换成目标指针。转换成功，则将结果赋值给相应的变量，并返回真值；若失败则返回假值，不改变指针变量。因为要让外部的指针变量能够接受到改值，因此不得不使用指向指针的指针。

因为在基类中以公共结果的形式出现，所以每一个子类都继承了该方法，无论是基类的对象还是子类的对象都可以调用该方法。而该方法又不是虚方法，因此不并不希望子类去修改它。只是因为方法是模板方法，可能在编译的时候需要多花一些时间。

由于引用必须在定义时就赋值，并且dynamic\_cast对于基于引用的转换不成功时将抛出异常，因此对于基于引用的转换，我还没有想出有什么好的山寨形式。

从测试代码的结果也可以看出，对于该发放的调用都是成功有效的。

所以又应了一句话：When use C++, the good news is that you can do everything you want, the bad news is that you have to do everything you want.

[C]: http://www.cnblogs.com/ider/archive/2011/07/03/cpp_cast_operator_part1.html
[const_cast]: http://www.cnblogs.com/ider/archive/2011/07/22/cpp_cast_operator_part2.html
[reinterpret_cast]: http://www.cnblogs.com/ider/archive/2011/07/30/cpp_cast_operator_part3.html
[static_cast]: http://www.cnblogs.com/ider/archive/2011/07/31/cpp_cast_operator_part4.html
[Google C_ Style Guide]: http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Explicit_Constructors#Explicit_Constructors
[dynamic_cast]: http://www.cnblogs.com/ider/archive/2011/08/01/cpp_cast_operator_part5.html
[Parse]: http://msdn.microsoft.com/en-us/library/b3h1hf19.aspx
[TryParse]: http://msdn.microsoft.com/en-us/library/f02979c7.aspx
[Convert]: http://msdn.microsoft.com/en-us/library/system.convert.aspx
[as]: http://msdn.microsoft.com/en-us/library/cscsdfbt.aspx