linux 变量引用 和 变量的自动类型转换 c++,c++类型转换 - memristor的个人空间 - OSCHINA - 中文开源技术交流社区...

C风格的强制类型转换(Type Cast)

不管什么类型的转换统统是：TYPE b = (TYPE)a。

缺点：

可以在任意类型之间转换，比如你可以把一个指向const对象的指针转换成指向非const对象的指针，把一个指向基类对象的指针转换成指向一个派生类对象的指针，这两种转换之间的差别是巨大的，但是传统的c语言风格的类型转换没有区分这些

c风格的转换不容易查找，由一个括号加上一个标识符组成，而这样的东西在c++程序里一大堆

C++风格的类型转换

提供了4种类型转换操作符来应对不同场合的应用。

1.static_cast  2.const_cast  3.dynamic_cast  4.reinterpret_cast.

static_cast

最常用的类型转换符，在正常状况下的类型转换，如把int转换为float，没有运行时类型检查来保证转换的安全性

1. 基类和子类之间转换：其中子类指针转换成父类指针是安全的；但父类指针转换成子类指针是不安全的。(基类和子类之间的动态类型转换建议用dynamic_cast)

2. 基本数据类型转换。enum, struct, int, char, float等。static_cast不能进行无关类型(如非基类和子类)指针之间的转换

3. 把空指针转换成目标类型的空指针

4. 把任何类型的表达式转换成void类型

5. static_cast不能去掉类型的const、volitale属性

int n =6;

double d = static_cast(n); // 基本类型转换

int*pn =&n;

double*d = static_cast(&n) //无关类型指针转换，编译错误

void*p = static_cast(pn); //任意类型转换成void类型

const_cast

转换对象为指针或引用

用于取出const属性和volatile属性，把const类型的指针变为非const类型的指针

常量指针被转化成非常量指针，并且仍然指向原来的对象；

常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象

class B

{

public:

int m_iNum;

B(int temp){

m_iNum=temp;

}

};

void foo()

{

const B b1(100);

//b1.m_iNum = 100; //comile error

B &b2 = const_cast(b1);

b2.m_iNum = 200; //fine

cout<

cout<

//b1.m_iNum = 400; //comile error

b2.m_iNum = 800;

cout<

cout<

}

output：

b1.m_iNum: 200

b2.m_iNum: 200

b1.m_iNum: 800

b2.m_iNum: 800

dynamic_cast

该操作符用于运行时检查该转换是否类型安全

1. 安全的基类和子类之间转换。

2. 必须要有虚函数。

3. 相同基类不同子类之间的交叉转换。但结果是NULL

与static_cast的区别：dynamic_cast与static_cast具有相同的基本语法，dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全

#include 

#include 

using namespace std;

//基类必须有虚函数。保持多态才能使用dynamic_cast

class BaseClass {

public:

int m_iNum;

virtual void foo() {

}

};

class DerivedClass: public BaseClass {

public:

char*m_szName[100];

void bar() {

}

};

int main(int argc, char *argv[]) {

BaseClass* pb = new DerivedClass();

DerivedClass *pd1 = static_cast(pb); //子类->父类，静态类型转换，正确但不推荐

DerivedClass *pd2 = dynamic_cast(pb); //子类->父类，动态类型转换，正确

BaseClass* pb2 = new BaseClass();

DerivedClass *pd21 = static_cast(pb2); //父类->子类，静态类型转换，危险！访问子类m_szName成员越界

DerivedClass *pd22 = dynamic_cast(pb2); //父类->子类，动态类型转换，安全的。结果是NULL

system("PAUSE");

return EXIT_SUCCESS;

}

reinterpret_cast

1. 转换的类型必须是一个指针、引用、算术类型、函数指针或者成员指针。

2. 在比特位级别上进行转换。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针(先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值)。但不能将非32bit的实例转成指针。

3. 最普通的用途就是在函数指针类型之间进行转换。

4. 很难保证移植性。

int doSomething(){return0;};

typedef void(*FuncPtr)(); //FuncPtr is 一个指向函数的指针，该函数没有参数，返回值类型为 void

FuncPtr funcPtrArray[10]; //10个FuncPtrs指针的数组 让我们假设你希望(因为某些莫名其妙的原因)把一个指向下面函数的指针存入funcPtrArray数组：

funcPtrArray[0] =&doSomething;// 编译错误！类型不匹配，reinterpret_cast可以让编译器以你的方法去看待它们：funcPtrArray

funcPtrArray[0] = reinterpret_cast(&doSomething); //不同函数指针类型之间进行转换

总结：

去const属性用const_cast。

基本类型转换用static_cast。

多态类之间的类型转换用daynamic_cast。

不同类型的指针类型转换用reinterpret_cast。