Effective C++条款03笔记

“尽可能的使用const”

        C++的const关键字会强制编译器实施保持某个值不变的约束，帮助你在编译期间就能发现错误，灵活使用const能提高代码质量还能避免不想被改变的值被修改。下面我将从const作用于变量、形参、引用、函数返回值、迭代器、成员变量和成员函数方面讲解对const的理解，以及为什么要尽可能的使用const。

一、const修饰常量

        const关键字放在变量类型前面则表示不允许修改该变量的值，const还可以修饰指针，当const放在*后面表示该指针不允许指向其他地址，指针变量保存的地址值不能被改变。

#include <iostream>
using namespace std;
int main() {
	char name[10];
	char age = 0;

	//指针指向的数据(name)可以修改，指针ptr1也可以指向不同的位置
	char* ptr1 = name;

	//指针指向的数据(name)不可以修改，指针ptr2可以指向不同的位置
	const char* ptr2 = name;

	//指针指向的数据(name)可以修改，指针ptr3只能指向这一个位置
	char* const ptr3 = name;

	//指针指向数据(name)不可以修改，指针ptr4只能指向这一个位置
	const char* const ptr4 = name;

	ptr1[0] = 'a';//正确
	ptr1 = &age;//正确

	ptr2[0] = 'a';//错误
	ptr2 = &age;//正确

	ptr3[0] = 'a';//正确
	ptr3 = &age;//错误

	ptr4[0] = 'a';//错误
	ptr4 = &age;//错误

	return 0;
}

二、const修饰迭代器

        const关键字放在迭代器类型前面相当于声明一个T* const指针，可以修改迭代器所指变量的值，不能指向其他地址。迭代器中有const_iterator类型迭代器，相当于声明了一个const T*类型指针，不能修改迭代器所指变量的值，但是可以指向其他地址。

#include <iostream>
#include <vector>
using namespace std;
int main() {
	vector<int> v1;
	//迭代器指向可以改变，内容可以改变
	vector<int>::iterator it1 = v1.begin();

	//迭代器指向不可以改变，内容可以改变
	const vector<int>::iterator it2 = v1.begin();

	//迭代器指向可以改变，内容不可以改变
	vector<int>::const_iterator it3 = v1.begin();

	//迭代器指向不可以改变，内容可以改变
	const vector<int>::const_iterator it4 = v1.begin();

	*it1 = 10;//正确
	it1++;//正确

	*it2 = 10;//正确
	it2++;//错误

	*it3 = 10;//错误
	it3++;//正确

	*it4 = 10;//错误
	it4++;//错误
	return 0;
}

三、const修饰参数

        如果是函数没有对类的成员进行修改，只是访问，可以将函数声明为const。如果形参是自定义的类或者c++自定义的类（string.....）则传参数的时候用常引用传递。

#include <iostream>
using namespace std;
class Person {
public:
	Person() :name("hello world") {
		cout << "构造函数" << endl;
	}
	string name;

};

ostream& operator<<( ostream& cout, const Person& p) {
	cout << "--->string  " << p.name << endl;
	return cout;
}
int main() {
	Person p;
	cout << p;
	return 0;
}

四、mutable和const成员函数

        加了const修饰的成员函数只能访问其他加const修饰的成员函数，而使用mutable可以打破const的限制，加了mutable的成员变量可以在加了const修饰的成员函数中修改数值

class test03 {
public:

	mutable int t_age;
	mutable const int t_cons;

    //可以发现t_cons前加了mutable，代表这个常量可以在函数中修改
    void show() const {//本来只能访问t_cons，但是t_age加了mutable所以也可以访问mutable
	    t_age = 20;
	    cout << "--->t_age----   " << t_age << "    ";
	    cout << "--->t_cons----   " << t_cons << "    ";
    }
}

五、const修饰参数返回值

        如果是C++内置类型是不能将“=”放在函数表达式的右边，也就是不能给函数返回值赋值。但是一个定义不好的自定义数据类型，则可能会出现“=”放在函数表达式右边的异常情况。我们知道C++可以重载运算符，那么如果const没有修饰函数返回值则会发生什么情况？

class Ration{
public:
private:
    int Value;
};

Ration operator* (const Ration &lhs, const Ration &rhs)
{
    Ration R;
    R.Value = lhs.Value * rhs.Value;
  	return R;
}

此时若一个程序员写并不会报错

Rational a,b,c;
...
if(a * b = c)
...

如果改为

const Ration operator* (const Ration &lhs, const Ration &rhs)
{
    Ration R;
    R.Value = lhs.Value * rhs.Value;
  	return R;
}

此时再写if(a * b = c)就会发生报错，因为返回的是const类型不能进行修改，大家可以想想为什么会写出if(a * b = c)这个代码，很明显他想写if(a * b == c)！！用const修饰函数返回值，让编译器帮你在编译期间排除这种错误！！

六、在const和non-const成员函数中避免代码重复

        非const修饰的成员函数可以通过调用const修饰的成员函数减少代码重复，但是const修饰的成员函数不能通过调用非const修饰的成员函数减少代码重复，因为非const修饰的成员函数可能会改变成员变量的值！这和const修饰成员函数的初衷是相违背的！

const char& operator[](std::size_t Position) const
{
    std::cout << "const operator" << std::endl;
    return Text[Position];
}
    
char& operator[](std::size_t Position)
{
    std::cout << "not const operator" << std::endl;
    return const_cast<char &>(static_cast<const TextBlock&>(*this)[Position]);
}

        我们先将 *this 由原来的 TextBlock& 转型为 const TextBlock& ，使它可以调用 cosnt 版本的函数，const 版本的函数返回的是一个 const char&，因此我们还要对返回值转型，使用 const_cat<char&> 移除返回值的 const。

七、总结

• 将某些东西声明为 cosnt 可帮助编译器侦测出错误用法。const 可以被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。
• 编译器强制实施 bitwise constness ，但你编写的程序应该使用 logical constness 。
• 当 const 和 non-const 成员函数有着相同的实现时（内部代码相同），令 nono-const 版本调用 const 版本可以避免重复，反之则错误。