场景一 用于修饰指针
char greeting[] = "Hello";
char* p = greeting; // non-const pointer, non-const data
const char* p = greeting; // non-const pointer, const data
char* const p = greeting; // const pointer, non-const data
const char* const = greeting; // const pointer, const data
const在*左边，表示被指物是常量，指针所指向的内容不能修改，但是可以修改指针，让指针指向其他对象。
const在*右边，表示指针自身是常量，指针不能修改，不能指向其他对象，但是当前指向的内容可以修改。
const在*的两侧，表示指针自身是常量，被指物也是常量，指针不能指向其他对象，当前指向的内容也不能改变。
场景二 用于对象前、后
void f1(const Widget* pw);
void f2(Widget const * pw);
两种表达式的效果是一样的，都在*的左边，说明被指物是常量。
场景三 用于对STL迭代器的修饰
std::vector<int> vec;
const std::vector<int>::iterator iter = vec.begin(); // iter的作用相当于 T* const
＊iter = 10; // 没问题，改变iter所指物
iter++; // 错误，iter是const
std::vector<int>::const_iterator cIter = vec.begin(); // cIter的作用相当于 const T*
*cIter = 10; // 错误，＊cIter是个const
++cIter; // 没问题，改变cIter
场景四 用于返回值
class Rational {...};
const Rational operator* (const Rational& lhs, const Rational& rhs);
Rational a, b, c;
...
(a * b) = c; // 显然在把返回结果设置为const以后，就不允许这样的操作发生
if (a * b = c) // 如果设置返回值为const的时候，这种手误的操作也不会发生
场景五 用于成员函数本体
const成员函数
class TextBlock {
public:
'''
const char& operator[](std::size_t position) const // operator[] for const对象
{return text[position];}
char& operator[](std::size_t position)
{return text[position];]}
private:
std::string text;
}
// 调用一
TextBlock tb("Hello");
std::cout << tb[0]; // 调用non-const TextBlock::operator[]
const TextBlock ctb("World");
std::cout << ctb[0]; // 调用const TextBlock::operator[]
// 调用二
void print(const TextBlock& ctb) {
std::cout << ctb[0]; // 调用const TextBlock::operator[]
...
}
// 调用三
std::cout << tb[0]; //没问题，读一个non-const TextBlock
tb[0] = 'x'; //没问题，写一个non-const TextBlock
std::cout << ctb[0]; //没问题， 读一个const TextBlock
ctb[0] = 'x'; //错误，写一个const TextBlock, 错误的原因在于operator[]的返回值为const
注意以上两个函数的返回值都为&，如果返回值是一个char的话，tb[0]＝ ‘x’;是无法通过编译的；
那是因为，如果函数的返回类型是个内置类型，那么改动函数返回值从来就不合法。纵使合法，C++以by value返回对象这个事实意味被改动的其实是tb.text[0]的一个副本，不是tb.text[0]自身，那不会是你想要的行为。
场景六 bitwise constness和logical constness
class CTextBlock {
public:
...
char& operator[](std::size_t position) const //bitwise const 声明，但其实不适当
private:
char* pText;
}
// 调用
const CTextBlock cctb("Hello"); // 声明一个常量对象
char* pc = &cctb[0]; // 调用const operator[]取得一个指针，指向cctb的数据
*pc = 'J'; // cctb现在有了"Jello"这样的内容
// 说明
// const 修饰函数体，说明函数体内不能修改任何non-static成员变量，在函数题内却是没有修改成员变量，但是最后还是修改成功了，那是因为返回值不是char；bitwise constness的主张是成员变量一个bit都不能修改，以上情况导出所谓的logical constness。
class CTextBlock {
public:
...
std::size_t length() const;
private:
char* pText;
std::size_t textLength; //最近一次计算的文本区块长度
bool lengthIsValid; //目前的长度是否有效
};
// 成员函数实现
std::size_t length() const {
if (!lengthIsValid) {
textLength = std::strlen(pText); //错误，在const成员函数内不能赋值给textLength和lengthIsValid
lengthValid = true;
}
return textLength;
}
场景七 mutable用法
// 用mutable(可变的)释放掉non-static成员变量的bitwise constness约束
class CTextBlock {
public:
...
std::size_t length() const;
private:
char* pText;
mutable std::size_t textLength; //这些成员变量可能总是被更改，即使在const成员函数内。
mutable bool lengthIsValid;
};
std::size_t CTextBlock::length() const {
if (!lengthIsValid) {
textLength = std::strlen(pText);
lengthIsValid = true;
}
return textLength;
}
场景八 const实现non-const成员函数
在const和non-const成员函数中避免重复
class TextBlock {
public:
...
const char& operator[](std::size_t position) const {
... // 边界检查
... // 日志记录数据
... // 检验数据完整性
return text[position];
}
char& operator[](std::size_t position) {
... // 边界检查
... // 日志记录数据
... // 检验数据完整性
return text[position];
}
private：
std::string text;
};
// 可以看到以上有非常严重的代码重复, 改进就是用const operator[] 实现 non-const operator[]
class TextBlock {
public:
...
const char& operator[](std::size_t position) const {
...
...
...
return text[position];
}
char& operator[](std::size_t position) {
return const_cast<char&>(static_cast<const TextBlock&>(*this)[position]);
// const_cast转型是因为返回类型，static_cast转型是为了转成const对象。
}
}；
总结
- 将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。
- 编译器强制实施bitwise constness，但你编写程序时应该使用"概念上的常量性(conceptual constness)"。
- 当const和non-const 成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复.