求指教，是关于C++，const_cast的用法的问题，麻烦看一下哦！

Question

const int a=789 ; const_cast<int>(a)=987;================================================1>------ 已启动生成: 项目: 2, 配置: Debug Win32 ------1>正在编译...1>Main.cpp1>c:\users\administrator\desktop\2\2\2\main.cpp(9) : error C2440: “const_cast”: 无法从“const int”转换为“int”1>        转换是有效的标准转换，可以隐式执行或通过使用 static_cast、C 样式转换或函数样式转换执行1>生成日志保存在“file://c:\Users\Administrator\Desktop\2\2\2\Debug\BuildLog.htm”1>2 - 1 个错误，0 个警告========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========

Answer 1

C++标准转换运算符const_cast
C++相比于C是一门面向对象的语言，面向对象最大的特点之一就是具有“多态性(Polymorphism)”。
C++提供了四个转换运算符：
const_cast <new_type> (expression)
static_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
dynamic_cast <new_type> (expression)
它们有着相同的结构，看起来像是模板方法。这些方法就是提供给开发者用来进行指针和引用的转换的。
标准运算符的作用就是对传统运算符的代替，以便做到统一。就像用std::endl来输出换行，而不是'\n'。用代码来说明相应的传统转换可以如何这些标准运算符。在标准运算符上，编译器肯定有做更多的处理，特别是dynamic_cast是不能用传统转换方式来完全实现的。
const_cast (expression)
const_cast转换符是用来移除变量的const或volatile限定符。它涉及到了多线程的设计，
用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进行重新赋值。
如果我们把结果打印出来： 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_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限定的指针去指向它，
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?

Answer 2

显式强制类型转换（cast）包括以下操作符：
static_cast, dynamic_cast, const_cast, reinterpret_cast，对各种显式类型转换解释：
static_cast:编译器隐式执行的转换都可以有static_cast显式执行。
例子：
double num = 12.32;
int data = num;
这个例子完成了显式类型转换，当然我们完全可以显式告诉编译器我要转换类型不且不关心转换后精度损失，就可以写成是：int data = static_cast<int>(num);

dynamic_cast:支持运行时识别指针或引用所指向的对象，如果绑定到引用或指针的对象不是目标类型的对象，则dynamic_cast失败，如果转换到指针类型的dynamic_cast失败，则dynamic_cast的结果为0值；如果转换到引用类型的dynamic_cast失败，则抛出一个bad_cast类型的异常。
因此，dynamic_cast操作符一次执行两个操作。首先验证被请求的转换是否有效，只有转换有效，操作符才实际进行转换。基类的指针可以赋值为指向派生类的对象，同样，基类的引用也可以用派生类对象初始化，因此，dynamic_cast操作符执行的验证必须在运行时进行。

const_cast:将转换掉表达式的const性质.
例子：
const char * source = "zhangsan";
char * dest = source;
编译出现错误提示：error C2440: 'initializing' : cannot convert from 'const char *' to 'char *'
这时我们可以运用const_cast去掉source的const性质。改为
char * dest = const_cast<char *>(source);就通过了编译。

reinterpret_cast：顾名思义reinterpret:重新解释。就是将操作数内容解释为另一种不同的类型。这种强制转换本质上依赖于机器，而且非常危险。

例子：
int * source ;
char *dest = reinterpret_cast<char *>(source);
如上，本来source本来指向的对象时int类型，但是想把这块内存重新解释为char类型，就用reinterpret_cast，但是这很危险，编程人员必须记住dest指向的真实对象其实是int类型。

你的例子问题在于，既然你用const定义常量，就不能改变a的值，但是你赋值了，所以错误。const_cast只是去掉const属性，并没说你可以改变其内容，只是可以讲const定义的常量赋值给其他的变量而已。