const 使用小结

is2120@csdn
1. 修饰变量，使得在初始化变量值后不能在修改其值。
// 无const修饰
int x = 4;
x = 10;

// 有const修饰
const int x = 2;
x = 10; // err

2. const替代#define的好处
在调试时可以看见变量名，而#define后调试时只能看见值
避免了宏定义带来的种种麻烦（宏是直接的文本替代，这会带来问题）

3. const 和指针
const int x; // constant int
x = 2; //x 非法--不能修改x

const int* pX; // 一个指向const int的指针，指针值可变
*pX = 3; //x 不能使用px修改一个const int的值
pX = &someOtherIntVar; // 但是px可以指向其他的地方

int* const pY; // 指针为const，其所指向的值类型为int
*pY = 4; // 使用pY修改int的值
pY = &someOtherIntVar; //x 不能指向其他地方

const int* const pZ; // const指针，指向const变量
*pZ = 5; //x
pZ = &someOtherIntVar; //x

4. const、指针和类型转换
int y;
//z 此处const的含义是：并不是说指向的变量必须是const，而是说你不能使用该指针来变更其指向的值
const int* pConstY = &y; //x 不能使用pConstY来修改y
int* pMutableY = &y; //x 能使用pMutableY来修改y
*pMutableY = 42;

5. c++中不允许轻易绕过const属性
赋值操作符不能没有经过明确的抓换而将一个const int * 转换成int *
c++不支持将一个const type 类型的变量转换成为type类型的标准转换。
const int x; // x不可修改

const int* pX = &x;

*pX = 4; //x 错误

int* pInt; // 一般类型的指针（非const）
pInt = pX; //x 错误，不能将一个const int * 指针转换成为 int *

int *pInt; //
pInt = &x; // 错误，不能将const int* 转换成 int *

6. 强制编译器进行类型转换(const type -> type)
const int x = 4;
const int* pX = &x;

cout << x << endl;

// 强制将 px 由 const int* 转换成 int *
int* pX2 = (int *)pX;
*pX2 = 3; //错--结果是未定义的（UB）

cout << x << endl; //

上述代码在vc中所产生的会变代码
ASSEMBLER OUTPUT C++ CODE
Mov eax, DWORD PTR _pX$[ebp] int* pX2 = (int *)pX;
Mov DWORD PTR _pXX$[ebp], eax
Mov eax, DWORD PTR _pXX$[ebp] *pX2 = 3;
Mov DWORD PTR [eax], 3
Push OFFSET FLAT:?endl@@......... cout << x << endl;
Push 4

注意到这里的PUSH 4，即编译器觉得你定义了一个const变量，在使用的时候就没有解引用而直接引用其值了（优化的结果）。

7. const_cast 操作符
使用 const_cast 去除变量的常量性。
const int x = 4; //
const int* pX = &x; //

cout << x << endl; // prints "4"

int* pX2 = const_cast < int* > (pX); // 将pX显式转换成非const

*pX2 = 3; // 未定义（BH）
cout << x << endl; //
同c style的强制类型转换不同的是，const_cast 只会改变变量的常量性，而不会改变变量的类型。

8. const 存储与字符常量
char* szMyString = "Hello world."; // 定义了一个字符常量
szMyString[3] = 'q'; // 未定义，试图修改静态缓冲区
标准认为这些字符常量的类型是const，一个字符常量的类型是一个const chars的数组。

c++中不能将一个const type标准转换为 type 类型。
const char constArray[] = { 'H', 'e', 'l', 'l', 'o', '/0' };
char nonConstArray[] = { 'H', 'e', 'l', 'l', 'o', '/0' };
char* pArray = constArray; // illegal
char* pArray = nonConstArray; // legal
但是这样又是可以的
// should be illegal - converts array of 6 const char to char*
char* pArray = "Hello";
这是为了和旧式的c代码兼容

9. 同样的字符常量可能指向同一个内存区域
"The /GF option causes the compiler to pool strings and place them in read-only memory.

例如以下代码
#include <stdio.h>

int main()
{
char* szFirst = "Literal String";
char* szSecond = "Literal String";

szFirst[3] = 'q';
printf("szFirst (%s) is at %d, szSecond (%s) is at %d/n",
szFirst, szFirst, szSecond, szSecond);

return 0;
}
在启用“string pooling”后，其输出为
szFirst (Litqral String) is at 4266616, szSecond (Litqral String) is at 4266616
（我这里是运行错误）

10. 总是使用 const
class Person
{
public:
Person(char* szNewName)
{
// make a copy of the string
m_szName = _strdup(szNewName);
};

~Person() { delete[] m_szName; };

const char* const GetName() const
{
return m_szName;
};

private:

char* m_szName;
};


在返回指针、使用指针作为参数时，总是想想是否适用const。
这样会使得编程变得比较轻松。

11. const 成员函数
const成员函数：该函数不会修改函数成员并且不会调用非const成员函数。
const 或者 non-const 对象都可以调用 const 成员函数
const对象不能调用non-const成员函数

12. The Mutable Storage Specifier
A mutable member variable can be modified even by const member functions.
即便是一个const 成员函数也能修改一个 mutable 成员变量。
class MyData
{
public:
/*
the first time, do calculation, cache result in m_lCache, and set
m_bCacheValid to true. In subsequent calls, if m_bCacheValid is true
then return m_lCache instead of recalculating
*/

long ExpensiveCalculation() const
{
if (false == m_bCacheValid)
{
m_bCacheValid = true;
m_lCache = ::SomeFormula(m_internalData);
}
return m_lCache;
};

// change data and set m_bCacheValid to false to force recalc next time
void ChangeData()
{
};

private:

data m_internalData;
mutable long m_lCache;
mutable bool m_bCacheValid;

};

is2120@csdn