const指针和函数声明
const修饰指针
char greeting[] = "Hello";
char* p = greeting; // non-const 指针,
// non-const 数据
const char* p = greeting; // non-const 指针,
// const 数据
char* const p = greeting; // const 指针,
// non-const 数据
const char* const p = greeting; // const 指针,
// const 数据
如果const出现在左侧：指向的是常量，const出现在右侧：指针本身是常量。
const修饰函数
void f1(const Widget* pw); // f1接受一个指向常量Widget对象的指针
void f2(Widget const* pw); // f2也一样
const出现在类型的左边，或右边是等效的。
const修饰容器
std::vector<int> vec;
//...
// iter 的行为像 T* const
const std::vector<int>::iterator iter = vec.begin();
*iter = 10; // 可以修改指向的数据
++iter; // 错误! iter 本身是 const
//cIter 的行为像 const T*
std::vector<int>::const_iterator cIter =vec.begin();
*cIter = 10; // 错误! *cIter 是 const
++cIter; // 正确, 可以修改迭代器本身
const应用在函数中
令函数返回一个常量值，往往可以降低因客户错误而造成的意外，下面是一个有理数的例子。
class Rational {
}; // 有理数!
const Rational operator*(const Rational& lhs, const Rational& rhs);
如果不小心把=写成了==
Rational a, b, c;
(a * b) = c; // 对a*b的结果调用operator=
if (a* b = c) // 糟糕, 写错了，应该是 ==
但这时候，由于我们返回的是一个const类型的，所以该做法在编译的时候就会提示错误，这也能让我们更快的找到错误。
const限定成员函数
在成员函数上使用const：
1、使类的接口意图更明确。知道哪些函数可以修改一个对象，哪些不能，这很重要。
2、使得使用const对象成为可能。
C++的一个重要特性：仅在常量上不同的成员函数可以被重载。考虑表示文本块的类:
class TextBlock {
public:
TextBlock(std::string str) {
text = str;
}
const char& operator[](std::size_t position) const // const对象的operator[]
{
return text[position];
}
char& operator[](std::size_t position) // non-const对象的operator[]
{
return text[position];
}
private:
std::string text;
};
void print(const TextBlock& ctb) // 在这个函数中，ctb是const
{
std::cout << ctb[0]; // 调用const的TextBlock::operator[]
}
//TextBlock的运算符[]可以这样使用:
TextBlock tb("Hello");
std::cout << tb[0]; // 调用non-const的TextBlock::operator[]
const TextBlock ctb("World");
std::cout << ctb[0]; // 调用const的TextBlock::operator[]
print(tb); // 调用const的TextBlock::operator[]
print(ctb); // 调用const的TextBlock::operator[]
tb[0] = 'x'; //正确
ctb[0] = 'x'; //错误
避免const重载的代码重复
假设TextBlock中的[]运算符不仅返回对适当字符的引用，还执行边界检查，记录访问信息，甚至可能进行数据完整性验证。
class TextBlock {
public:
...
const char& operator[](std::size_t position) const{
... // do bounds checking
... // log access data
... // verify data integrity
return text[position];
}
char& operator[](std::size_t position) {
... // do bounds checking
... // log access data
... // verify data integrity
return text[position];
}
private:
std::string text;
};
这边我们定义了一个const版本和一个非const版本的函数。
替代方案：让operator[]的一个版本调用另一个版本。先写const版本，然后脱离const限制。
class TextBlock {
public:
...
const char& operator[](std::size_t position) const{
// 和前面一样
...
...
...
return text[position];
}
char& operator[](std::size_t position){
//只需要调用const版本
return const_cast<char&>( //对op[]的返回类型抛弃const;
//给*this的类型添加const;调用op的const版本[]
static_cast<const TextBlock&>(*this)[position]
);
}
...
};
1、在这种情况下，去掉返回值上的const是安全的，因为调用非const操作符[]的人首先必须有一个非const对象。
2、让非const操作符[]调用const版本是避免代码重复的安全方法。
总结
- 声明const可以借助编译器检测使用错误。const可以应用于任何作用域的对象、函数参数和返回类型，以及作为一个整体的成员函数。
- 编译器强制执行位常量，但你应该使用逻辑常量进行编程。
- 当const和非const成员函数具有本质上相同的实现时，可以通过让非const版本调用const版本来避免代码重复。
