C++隐式转换和显示转换

原链接

http://blog.csdn.net/libaineu2004/article/details/46329447

一、隐式转换

C++隐式转换发生在四种情况下

* 在混合类型的算术表达式中

 
 
int ival = 3;  
double dval = 3.1415  
ival + dval; //ival 被提升为double 类型:3.0 

* 初始化,用一种类型的表达式赋值

 
 
int *pi = NULL; // NULL(0)被转换成了int* 类型的空指针值 
int iVap = 3.14;

* 用一个表达式传递给一个函数调用

 
 
extern double sqrt(double);  
sqrt(2); //2被提升为double类型: 2.0 

* 从一个函数返回一个表达式

 
 
double difference(int ival1, int ival2)  
{  
return ival1 - ival2; //返回值被提升为double 类型.  
} 

* 条件表达式转bool类型

1. int iVal;
2. if (iVal){}

C++内建类型(char,int,short,double etc.)对像之间默认含有隐式转换

C++用户定义类对象之间可以含有C++隐式转换.

 
 
void dosomething(A aObject);  
class A {  
public:  
A(int x = 0);  
}  
dosomething(20); // Ok 隐式转换 

二、显示转换

1、静态转换（static_cast）
 
static_cast包含的转换类型有典型的非强制变换、窄化（有信息丢失）变换、使用void*的强制转换、隐式类型变换、类层次的静态定位。static_cast是编译器允许的。
 
(1)典型的非强制变换：
从窄类型向宽类型的转换，如char向short int,int,long int,float,double,long double的转换。
char a = 1;
long b = static_cast<long>(a);
 
(2)窄化变换：
与第1种相反，从宽类型向窄类型的变换。
long b = 1;
char a = static_cast<char>(b);
 
(3)使用void*的强制变换：
struct callback_param
{
    void *vp;
};
 
int a = 1;
struct callback_param cp;
cp.vp = &a;      //编译器允许从任意类型指针向void*转换
 
int *ip = static_cast<int *>(cp.vp);
 
(4)隐式类型转换：
包括（1）（2）
 
(5)类层次的静态定位
进行向上类型转换（派生类向基类转换）时，编译器清楚派生自什么祖先类，除了多继承（多继承转换后可能不为原地址，指针会在类层次中调整）。


2、常量转换（const_cast）
从const转换为非const，从volatile转换为非volatile。取得const对象的地址，会生成一个指向const的指针，volatile同。
 
const int i = 0;
int *ip = const_cast<int *>(&i);
 
volatile int a = 0;
int *ap = const_cast<int *>(&a);
 
3、重解释转换（reinterpret_cast）
最不安全的一种转换机制，将对象转变为完全不同类型的对象，这是低级的位操作。
 
struct msg_hdr
{
    int msg_type;
    int msg_len;
    char msg_data[0];
};
 
struct msg_data
{
    int data1;
    int data2;
};
 
struct msg_hdr *p = reinterpret_cast<struct msg_hdr *>(recvbuf);
struct msg_data *pdata = reinterpret_cast<struct msg_data *>(p->msg_data);
 
4、动态转换（dynamic_cast）
类层次的向下转换（基类向派生类转换），转换过程中会通过RTTI检查转换类型是否正常，不正常将返回空。


#include <iostream>
using namespace std;

class pet
{
    public:
    virtual ~pet()
    {
    }
};

class dog : public pet
{
};

class cat : public pet
{
};


int main(void)
{
    pet *b = new cat;

    dog *d1 = dynamic_cast<dog *>(b);
    cat *d2 = dynamic_cast<cat *>(b);

    cout << "d1 = " << (long)d1 << endl;  // d1 = 0
    cout << "d2 = " << (long)d2 << endl;

}