码迷,mamicode.com
首页 > 编程语言 > 详细

C++标准转换运算符const_cast

时间:2015-09-11 15:49:22      阅读:257      评论:0      收藏:0      [点我收藏+]

标签:

前面讲了C++继承并扩展C语言的传统类型转换方式,最后留下了一些关于指针和引用上的转换问题,没有做详细地讲述。C++相比于C是一门面向对象的语言,面向对象最大的特点之一就是具有“多态性(Polymorphism)”。

要想很好的使用多态性,就免不了要使用指针和引用,也免不了会碰到转换的问题,所以在这一篇,就把导师讲的以及在网上反复查阅了解的知识总结一下。

C++提供了四个转换运算符:

const_cast <new_type> (expression)
static_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
dynamic_cast <new_type> (expression)
它们有着相同的结构,看起来像是模板方法。这些方法就是提供给开发者用来进行指针和引用的转换的。

其实我很早就想写这篇内容的,自己不断地查看导师发来的资料,也在网上不停地看相关的知识,却一直迟迟不能完全理解C++转换运算符的用法,倒是看了那些资料后先写了一篇传统转换方面的内容。虽然从字面上很好理解它们大致是什么作用,但是真正像使用起来,却用不知道他们具体的用途,只会不断的被编译器提醒Error。所以如果出现理解不到位或错误的地方,还希望前人或来者能够指正。

在我看来这些标准运算符的作用就是对传统运算符的代替,以便做到统一。就像我们用std::endl来输出换行,而不是\n。我会用代码来说明相应的传统转换可以如何这些标准运算符。当然,这这是大致的理解,在标准运算符上,编译器肯定有做更多的处理,特别是dynamic_cast是不能用传统转换方式来完全实现的。

在这一篇文章里,我会先讲讲我对const_cast运算符的理解。

const_cast (expression)

const_cast转换符是用来移除变量的const或volatile限定符。对于后者,我不是太清楚,因为它涉及到了多线程的设计,而我在这方面没有什么了解。所以我只来说const方面的内容。

用const_cast来去除const限定

对于const变量,我们不能修改它的值,这是这个限定符最直接的表现。但是我们就是想违背它的限定希望修改其内容怎么办呢?

下边的代码显然是达不到目的的:
const int constant = 10;
int modifier = constant;

因为对modifier的修改并不会影响到constant,这暗示了一点:const_cast转换符也不该用在对象数据上,因为这样的转换得到的两个变量/对象并没有相关性。

只有用指针或者引用,让变量指向同一个地址才是解决方案,可惜下边的代码在C++中也是编译不过的:
const int constant = 21;
int* modifier = &constant 
// Error: invalid conversion from ‘const int*‘ to ‘int*‘

(上边的代码在C中是可以编译的,最多会得到一个warning,所在在C中上一步就可以开始对constant里面的数据胡作非为了)

把constant交给非const的引用也是不行的。
const int constant = 21;
int& modifier = constant;
// Error: invalid initialization of reference of type ‘int&‘ from expression of type ‘const int‘

于是const_cast就出来消灭const,以求引起程序世界的混乱。

下边的代码就顺利编译功过了:
const int constant = 21;
const int* const_p = &constant;
int* modifier = const_cast<int*>(const_p);
*modifier = 7;

传统转换方式实现const_cast运算符

我说过标:准转换运算符是可以用传统转换方式实现的。const_cast实现原因就在于C++对于指针的转换是任意的,它不会检查类型,任何指针之间都可以进行互相转换,因此const_cast就可以直接使用显示转换(int*)来代替:
const int constant = 21;
const int* const_p = &constant;
int* modifier = (int*)(const_p);

或者我们还可以把他们合成一个语句,跳过中间变量,用
const int constant = 21;
int* modifier = (int*)(&constant);

替代
const int constant = 21;
int* modifier = const_cast<int*>(&constant);

为何要去除const限定

从前面代码中已经看到,我们不能对constant进行修改,但是我们可以对modifier进行重新赋值。

但是但是,程序世界真的混乱了吗?我们真的通过modifier修改了constatn的值了吗?修改const变量的数据真的是C++去const的目的吗?

如果我们把结果打印出来:
cout << "constant: "<< constant <<endl;
cout << "const_p: "<< *const_p <<endl;
cout << "modifier: "<< *modifier <<endl;
/**
constant: 21
const_p: 7
modifier: 7
**/

constant还是保留了它原来的值。

可是它们的确指向了同一个地址呀:
cout << "constant: "<< &constant <<endl;
cout << "const_p: "<< const_p <<endl;
cout << "modifier: "<< modifier <<endl;

/**
constant: 0x7fff5fbff72c
const_p: 0x7fff5fbff72c
modifier: 0x7fff5fbff72c
**/

这真是一件奇怪的事情,但是这是件好事:说明C++里是const,就是const,外界千变万变,我就不变。不然真的会乱套了,const也没有存在的意义了。

IBM的C++指南称呼“*modifier = 7;”为“未定义行为(Undefined Behavior)”。所谓未定义,是说这个语句在标准C++中没有明确的规定,由编译器来决定如何处理。

位运算的左移操作也可算一种未定义行为,因为我们不确定是逻辑左移,还是算数左移。

再比如下边的语句:v[i] = i++; 也是一种未定义行为,因为我们不知道是先做自增,还是先用来找数组中的位置。

对于未定义行为,我们所能做的所要做的就是避免出现这样的语句。对于const数据我们更要这样保证:绝对不对const数据进行重新赋值。

如果我们不想修改const变量的值,那我们又为什么要去const呢?

原因是,我们可能调用了一个参数不是const的函数,而我们要传进去的实际参数确实const的,但是我们知道这个函数是不会对参数做修改的。于是我们就需要使用const_cast去除const限定,以便函数能够接受这个实际参数。


#include <iostream>
using namespace std;

void Printer (int* val,string seperator = "\n")
{
    cout << val<< seperator;
}

int main(void) 
{    
    const int consatant = 20;
    //Printer(consatant);//Error: invalid conversion from ‘int‘ to ‘int*‘
    Printer(const_cast<int *>(&consatant));
    
    return 0;
}
出现这种情况的原因,可能是我们所调用的方法是别人写的。还有一种我能想到的原因,是出现在const对象想调用自身的非const方法的时候,因为在类定义中,const也可以作为函数重载的一个标示符。有机会,我会专门回顾一下我所知道const的用法,C++的const真的有太多可以说的了。

在IBM的C++指南中还提到了另一种可能需要去const的情况:

#include <iostream>
using namespace std;

int main(void) {
    int variable = 21;
    int* const_p = &variable;
    int* modifier = const_cast<int*>(const_p);
    
    *modifier = 7
    cout << "variable:" << variable << endl;
    
    return 0;
} 
/**
variable:7
**/
我们定义了一个非const的变量,但用带const限定的指针去指向它,在某一处我们突然又想修改了,可是我们手上只有指针,这时候我们可以去const来修改了。上边的代码结果也证实我们修改成功了。

不过我觉得这并不是一个好的设计,还是应该遵从这样的原则:使用const_cast去除const限定的目的绝对不是为了修改它的内容,只是出于无奈。(如果真像我说是种无奈,似乎const_cast就不太有用到的时候了,但的确我也很少用到它)

Director: Jim Fawcett
C++ Language Tutorial - Type Casting
Object Oriented Design
IBM Complilers - XL C/C++ V9.0 for Linux - The const_cast operator (C++ only)
stackoverflow: Is const_cast safe?

一. 函数描述:
const_cast < type-id > ( expression )
主要是用来去掉const属性,当然也可以加上const属性。主要是用前者,后者很少用。

去掉const属性:const_case<int*> (&num),常用,因为不能把一个const变量直接赋给一个非const变量,必须要转换。

加上const属性:const int* k = const_case<const int*>(j),一般很少用,因为可以把一个非const变量直接赋给一个const变量,比如:const int* k = j;

二. 使用范围:
1. 常量指针被转化成非常量指针,转换后指针指向原来的变量(即转换后的指针地址不变)。

[cpp] view plaincopy
class A    
{    
public:    
     A()    
     {    
      m_iNum = 0;    
     }    
        
public:    
     int m_iNum;    
};    
        
void foo()    
{    
    //1. 指针指向类    
    const A *pca1 = new A;    
    A *pa2 = const_cast<A*>(pca1);  //常量对象转换为非常量对象    
    pa2->m_iNum = 200;    //fine    
       
    //转换后指针指向原来的对象    
    cout<< pca1->m_iNum <<pa2->m_iNum<<endl; //200 200    
        
    //2. 指针指向基本类型    
    const int ica = 100;    
    int * ia = const_cast<int *>(&ica);    
    *ia = 200;    
    cout<< *ia <<ica<<endl;   //200 100    
}  
2. 常量引用转为非常量引用。


[cpp] view plaincopy
class A  
{  
public:  
  A()  
  {  
    m_iNum = 1;  
  }  
  
public:  
  int m_iNum;  
};  
  
void foo()    
{    
   
  A a0;  
  const A &a1 = a0;  
  A a2 = const_cast<A&>(a1); //常量引用转为非常量引用  
      
  a2.m_iNum = 200;    //fine    
  
  cout<< a0.m_iNum << a1.m_iNum << a2.m_iNum << endl; //1 1 200    
}  
2. 常量对象(或基本类型)不可以被转换成非常量对象(或基本类型)。

[c-sharp] view plaincopy
void foo()  
{  
 //常量对象被转换成非常量对象时出错  
 const A ca;  
 A a = const_cast<A>(ca);  //不允许  
  
 const int i = 100;  
 int j = const_cast<int>(i);  //不允许  
  
}  

记住这种转换只是开了一个接口,并不是实质上的转换。(其实也算是实质上的转换了,只不过表达上不允许这样写)

3. 添加const属性

[c-sharp] view plaincopy
int main(int argc, char ** argv_)   
{  
 int i = 100;  
 int *j = &i;  
 const int *k = const_cast<const int*>(j);  
 //const int *m = j;   感觉和这样写差不多  
  
 //指的地址都一样  
 cout <<i<<","<<&i<<endl; //100, 0012FF78  
 cout <<*j<<","<<j<<endl; //100, 0012FF78  
 cout <<*k<<","<<k<<endl; //100, 0012FF78  
  
 *j = 200;  
 //*k = 200;   //error  
  
 return 0;  
}  


三. 总结:
1. 使用const_cast去掉const属性,其实并不是真的改变原类类型(或基本类型)的const属性,它只是又提供了一个接口(指针或引用),使你可以通过这个接口来改变类型的值。也许这也是const_case只能转换指针或引用的一个原因吧。


2. 使用const_case添加const属性,也是提供了一个接口,来不让修改其值,不过这个添加const的操作没有什么实际的用途(也许是我认识太浅了)。

 

C++标准转换运算符const_cast

标签:

原文地址:http://www.cnblogs.com/yaowen/p/4800894.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!