C++ 强制类型转换(转载)

时间  2019-11-18
标签 c++ 强制 类型 转换 转载 栏目 C&C++ 繁體版
原文   原文链接

转载自：http://www.weixueyuan.net/view/6329.htmlhtml

在C++语言中新增了四个关键字static_cast、const_cast、reinterpret_cast和dynamic_cast。这四个关键字都是用于强制类型转换的。咱们逐一来介绍这四个关键字。ios

1) static_cast

在C++语言中static_cast用于数据类型的强制转换，强制将一种数据类型转换为另外一种数据类型。例如将整型数据转换为浮点型数据。

[例1]C语言所采用的类型转换方式：数组

int a = 10;
int b = 3;
double result = (double)a / (double)b;

例1中将整型变量a和b转换为双精度浮点型，而后相除。在C++语言中，咱们能够采用static_cast关键字来进行强制类型转换，以下所示。

[例2]static_cast关键字的使用：安全

int a = 10;
int b = 3;
double result = static_cast<double>(a) / static_cast<double>(b);

在本例中一样是将整型变量a转换为双精度浮点型。采用static_cast进行强制数据类型转换时，将想要转换成的数据类型放到尖括号中，将待转换的变量或表达式放在元括号中，其格式能够归纳为以下形式：
    static_cast <类型说明符> （变量或表达式）函数

2) const_cast

在C语言中，const限定符一般被用来限定变量，用于表示该变量的值不能被修改。而const_cast则正是用于强制去掉这种不能被修改的常数特性，但须要特别注意的是const_cast不是用于去除变量的常量性，而是去除指向常数对象的指针或引用的常量性，其去除常量性的对象必须为指针或引用。

[例3]一个错误的例子：测试

const int a = 10;
const int * p = &a;
*p = 20;                  //compile error
int b = const_cast<int>(a);  //compile error

在本例中出现了两个编译错误，第一个编译错误是*p由于具备常量性，其值是不能被修改的；另外一处错误是const_cast强制转换对象必须为指针或引用，而例3中为一个变量，这是不容许的！

[例4]const_cast关键字的使用spa

#include<iostream>
using namespace std;

int main()
{
    const int a = 10;
    const int * p = &a;
    int *q;
    q = const_cast<int *>(p);
    *q = 20;    //fine
    cout <<a<<" "<<*p<<" "<<*q<<endl;
        cout <<&a<<" "<<p<<" "<<q<<endl;
    return 0;
}

在本例中，咱们将变量a声明为常量变量，同时声明了一个const指针指向该变量（此时若是声明一个普通指针指向该常量变量的话是不容许的，Visual Studio 2010编译器会报错），以后咱们定义了一个普通的指针*q。将p指针经过const_cast去掉其常量性，并赋给q指针。以后我再修改q指针所指地址的值时，这是不会有问题的。

最后将结果打印出来，运行结果以下：
10 20 20
002CFAF4 002CFAF4 002CFAF4

查看运行结果，问题来了，指针p和指针q都是指向a变量的，指向地址相同，并且通过调试发现002CFAF4地址内的值确实由10被修改为了20，这是怎么一回事呢？为何a的值打印出来仍是10呢？

其实这是一件好事，咱们要庆幸a变量最终的值没有变成20！变量a一开始就被声明为一个常量变量，无论后面的程序怎么处理，它就是一个常量，就是不会变化的。试想一下若是这个变量a最终变成了20会有什么后果呢？对于这些简短的程序而言，若是最后a变成了20，咱们会一眼看出是q指针修改了，可是一旦一个项目工程很是庞大的时候，在程序某个地方出现了一个q这样的指针，它能够修改常量a，这是一件很可怕的事情的，能够说是一个程序的漏洞，毕竟将变量a声明为常量就是不但愿修改它，若是后面能修改，这就太恐怖了。

在例4中咱们称“*q=20”语句为未定义行为语句，所谓的未定义行为是指在标准的C++规范中并无明确规定这种语句的具体行为，该语句的具体行为由编译器来自行决定如何处理。对于这种未定义行为的语句咱们应该尽可能予以免！

从例4中咱们能够看出咱们是不想修改变量a的值的，既然如此，定义一个const_cast关键字强制去掉指针的常量性到底有什么用呢？咱们接着来看下面的例子。

例5：操作系统

#include<iostream>
using namespace std;

const int * Search(const int * a, int n, int val);

int main()
{
    int a[10] = {0,1,2,3,4,5,6,7,8,9};
    int val = 5;
    int *p;
    p = const_cast<int *>(Search(a, 10, val));
    if(p == NULL)
        cout<<"Not found the val in array a"<<endl;
    else
        cout<<"hvae found the val in array a and the val = "<<*p<<endl;
    return 0;
}

const int * Search(const int * a, int n, int val)
{
    int i;
    for(i=0; i<n; i++)
    {
        if(a[i] == val)
            return &a[i];
    }
    return  NULL;
}

在例5中咱们定义了一个函数，用于在a数组中寻找val值，若是找到了就返回该值的地址，若是没有找到则返回NULL。函数Search返回值是const指针，当咱们在a数组中找到了val值的时候，咱们会返回val的地址，最关键的是a数组在main函数中并非const，所以即便咱们去掉返回值的常量性有可能会形成a数组被修改，可是这也依然是安全的。

对于引用，咱们一样能使用const_cast来强制去掉常量性，如例6所示。

例6：.net

#include<iostream>
using namespace std;

const int & Search(const int * a, int n, int val);

int main()
{
int a[10] = {0,1,2,3,4,5,6,7,8,9};
int val = 5;
int &p = const_cast<int &>(Search(a, 10, val));
if(p == NULL)
cout<<"Not found the val in array a"<<endl;
else
cout<<"hvae found the val in array a and the val = "<<p<<endl;
return 0;
}

const int & Search(const int * a, int n, int val)
{
int i;
for(i=0; i<n; i++)
{
if(a[i] == val)
return a[i];
}
return NULL;
}

了解了const_cast的使用场景后，能够知道使用const_cast一般是一种无奈之举，同时也建议你们在从此的C++程序设计过程当中必定不要利用const_cast去掉指针或引用的常量性而且去修改原始变量的数值，这是一种很是很差的行为。设计

3) reinterpret_cast

在C++语言中，reinterpret_cast主要有三种强制转换用途：改变指针或引用的类型、将指针或引用转换为一个足够长度的整形、将整型转换为指针或引用类型。在使用reinterpret_cast强制转换过程仅仅只是比特位的拷贝，所以在使用过程当中须要特别谨慎！

例7

int *a = new int;
double *d = reinterpret_cast<double *>(a);
在例7中，将整型指针经过reinterpret_cast强制转换成了双精度浮点型指针。
reinterpret_cast能够将指针或引用转换为一个足够长度的整形，此中的足够长度具体长度须要多少则取决于操做系统，若是是32位的操做系统，就须要4个字节及以上的整型，若是是64位的操做系统则须要8个字节及以上的整型。   

4) dynamic_cast

dynamic_cast用于类的继承层次之间的强制类型转换，咱们将在讲到类的继承的时候再来介绍dynamic_cast。
转载自：http://www.weixueyuan.net/view/6377.html

在C++中，编译期的类型转换有可能会在运行时出现错误，特别是涉及到类对象的指针或引用操做时，更容易产生错误。Dynamic_cast操做符则能够在运行期对可能产生问题的类型转换进行测试。

#include<iostream>
using namespace std;

class base
{
public :
    void m(){cout<<"m"<<endl;}
};

class derived : public base
{
public:
    void f(){cout<<"f"<<endl;}
};

int main()
{
    derived * p;
    p = new base;
    p = static_cast<derived *>(new base);
    p->m();
    p->f();
    return 0;
}

本例中定义了两个类：base类和derived类，这两个类构成继承关系。在base类中定义了m函数，derived类中定义了f函数。在前面介绍多态时，咱们一直是用基类指针指向派生类或基类对象，而本例则不一样了。本例主函数中定义的是一个派生类指针，当咱们将其指向一个基类对象时，这是错误的，会致使编译错误。可是经过强制类型转换咱们能够将派生类指针指向一个基类对象，p = static_cast<derived *>(new base);语句实现的就是这样一个功能，这样的一种强制类型转换时合乎C++语法规定的，可是是很是不明智的，它会带来必定的危险。在程序中p是一个派生类对象，咱们将其强制指向一个基类对象，首先经过p指针调用m函数，由于基类中包含有m函数，这一句没有问题，以后经过p指针调用f函数。通常来说，由于p指针是一个派生类类型的指针，而派生类中拥有f函数，所以p->f();这一语句不会有问题，可是本例中p指针指向的确实基类的对象，而基类中并无声明f函数，虽然p->f();这一语句虽然仍没有语法错误，可是它却产生了一个运行时的错误。换言之，p指针是派生类指针，这代表程序设计人员能够经过p指针调用派生类的成员函数f，可是在实际的程序设计过程当中却误将p指针指向了一个基类对象，这就致使了一个运行期错误。


产生这种运行期的错误缘由在于static_cast强制类型转换时并不具备保证类型安全的功能，而C++提供的dynamic_cast却能解决这一问题，dynamic_cast能够在程序运行时检测类型转换是否类型安全。固然dynamic_cast使用起来也是有条件的，它要求所转换的操做数必须包含多态类类型（即至少包含一个虚函数的类）。

例2：

#include<iostream>
using namespace std;

class base
{
public :
    void m(){cout<<"m"<<endl;}
};

class derived : public base
{
public:
    void f(){cout<<"f"<<endl;}
};

int main()
{
    derived * p;
    p = new base;
    p = dynamic_cast<derived *>(new base);
    p->m();
    p->f();
    return 0;
}

在本例中利用dynamic_cast进行强制类型转换，可是由于base类中并不存在虚函数，所以p = dynamic_cast<derived *>(new base);这一句会编译错误。dynamic_cast可否正确转换与目标类型是否为多态类类型无关，dynamic_cast要求被转换的类型必须为多态类类型。为了解决本例中的语法错误，咱们能够将base类中的函数m声明为虚函数，virtual void m(){cout<<"m"<<endl;}。

dynamic_cast还要求<>内部所描述的目标类型必须为指针或引用。如例3所示，若是咱们将例2中的主函数换成例3的形式，这也是没法经过编译的。

例3：

  
int main()
{
        base b;
        dynamic_cast<derived>(b);
    return 0;
}

咱们来看一下正确使用dynamic_cast的代码。

例4：

#include<iostream>
using namespace std;

class base
{
public :
    virtual void m(){cout<<"m"<<endl;}
};

class derived : public base
{
public:
    void f(){cout<<"f"<<endl;}
};


int main()
{
    derived * p;
    p = dynamic_cast<derived *>(new base);
    if(p)
    {
        p->m();
        p->f();       
    }
    else
        cout<<"Convert not safe!"<<endl;
    return 0;
}

在本例中经过dynamic_cast来初始化指针p，在初始化过程当中dynamic_cast会检测操做数new base转换为目标类型derived *是否能保证类型安全，若是类型安全则将new base结果赋给p指针，不然返回0，也即false。而本例中是要用基类对象地址去初始化派生类指针，这显然是没法保证类型安全的，所以p最后获得的返回值是0。在主函数中通过判断语句，最终程序输出“Convert not safe!”。

Dynamic_cast转换有本身的规则，下面将经过示例来介绍转换规则。

例4：

#include<iostream>
using namespace std;

class base
{
public :
    virtual void m(){cout<<"m"<<endl;}
};

class derived : public base
{
public:
    virtual void f(){cout<<"f"<<endl;}
};

int main()
{
    derived * d;
    d = dynamic_cast<derived *>(new base);
    if(d)
    {
        cout<<"Base to Derived is ok"<<endl;
        delete d;
    }
    else
        cout<<"Base to Derived is error"<<endl;
    base * b;
    b = dynamic_cast<base *>(new derived);
    if(b)
    {
        cout<<"Derived to Base is ok"<<endl;
        delete b;
    }
    else
        cout<<"Derived to Base is error"<<endl;

    return 0;
}

本例分别定义了两个类：base类和derived类，这两个类构成继承关系，为了测试dynamic_cast转换规则，咱们在类中各自定义了一个虚函数。在本例的主函数中咱们分别测试基类转换为派生类和派生类转换为基类时dynamic_cast转换返回值。本例最终运行结果以下：
    Base to Derived is error
    Derived to Base is ok

从结果能够看出从不能将指向基类对象的指针转换为指向派生类对象的指针，可是能够将指向派生类对象的指针转换为指向基类对象的指针。

例5：

#include<iostream>
using namespace std;

class A
{
public :
    virtual void m(){cout<<"m"<<endl;}
};

class B
{
public:
    virtual void f(){cout<<"f"<<endl;}
};

int main()
{
    A * a;
    a = dynamic_cast<A *>(new B);
    if(a)
    {
        cout<<"B to A is ok"<<endl;
        delete a;
    }
    else
        cout<<"B to A is error"<<endl;
    B * b;
    b = dynamic_cast<B *>(new A);
    if(b)
    {
        cout<<"A to B is ok"<<endl;
        delete b;
    }
    else
        cout<<"A to B is error"<<endl;

    return 0;
}
在本例中，定义了两个类A和B，这两个类不构成继承关系，咱们尝试将指向两个类对象的指针进行互相转换，看程序运行结果：     B to A is error     A to B is error 从程序运行结果不难看出，任意两个不相关的多态类类型之间的转换也是不能进行的。 总结一下dynamic_cast转换规则，只容许指向派生类对象的指针转换为指向基类对象的指针。 C++提供的两个类型转换操做符static_cast和dynamic_cast，static_cast能够用于任何类型的强制类型转换，可是它不保证转换过程当中的类型安全，dynamic_cast只能用于多态类类型的转换，并且要求转换的目的类型必须为指针或引用，而且它能够保证转换过程当中类型安全。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程