《Effective C++》《让自己习惯C++——3、尽可能的使用const》

1、term3:Use const whenever possible

const允许你定义一个语义约束，指定一个"不该被改动的”对象。

（1）const 修饰指针，迭代器，函数返回值。

const修饰指针

char greeting[] = "Hello";
char* p = greeting;
const char* p = greeting; 		  //指向字符常量的指针,p指向的字符不能修改
char* const p = greeting; 		  //指向字符的常量指针，p本身的值不能够被修改
const char* const p = greeting;   //指向字符常量的常量指针，p指向的字符,p本身都不能被修改

为了方便理解：
在第一个声明中，p 是一个指针，它指向一个 const char。
在第二个声明中，p 是一个 const 指针，它指向一个 char。
在第三个声明中，p 是一个const指针，它指向一个const char。
const修饰迭代器
举个栗子：

std::vector<int> vec //整数类型的std::vector
...
const std::vector<int>::iterator iter = vec.begin();
//定义一个常量迭代器，相当于T* const
//迭代器不得指向不同的东西，但他所指向的东西的值是可以改动的；
*iter = 10; //正确
++iter;		//错误
std::vector<int>::const_iterator cIter = vec.begin();
//声明一个常量迭代器，相当于const T*
//迭代器不能修改容器中的元素，但是可以修改迭代器的指向；
*citer = 10;	//错误
++citer;		//正确

const修饰函数返回值

const int max(int a,int b){
	return (a > b ? a:b) ;
}
int c = 7;
max(a,b) = c;
//将一个常量的值,赋值给一个函数调用的返回值是没有意义的；
//const关键字在这里确保了函数不会进行任何可能影响程序状态
//的修改，并且使得函数的输出具有确定性。

（2）const修饰成员函数

首先要明确const在成员函数中的作用：
逻辑常量性（Logical constness）：
作用： const 关键字表示该成员函数在逻辑上不会修改对象的状态。这是一种承诺，告诉编译器和其他程序员，调用这个成员函数不会改变对象的内部数据成员。
实现： 在 const 成员函数中，你不能修改非 mutable 数据成员，也不能调用非 const 成员函数。这样确保了对象在逻辑上的不变性。
允许 const 对象调用：
作用： 将 const 关键字应用于成员函数使得可以在常量对象上调用这个函数。如果一个对象被声明为 const，那么只能调用它的 const 成员函数，而不能调用普通的非 const 成员函数。
实现： 在 const 成员函数中，编译器会将 this 指针视为指向常量对象的指针，这意味着在这个函数中不能修改对象的非 mutable 成员。
我举个栗子：

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;
};

TextBlock tb("hello");
std::cout << tb[0]; //调用non-const TextBlock::operator[]
TextBlock ctb("world");
std::cout << ctb[0]; //调用const TextBlock::operator[]

在介绍之前先引入两个概念：Bitwise Constness和Logical Constness
Bitwise Constness:
定义： “Bitwise constness” 关注的是对象在二进制表示层面是否保持不变。在这个概念中，如果对象被声明为 const，那么其底层二进制表示不应该发生变化。
实现： 通常通过将成员函数声明为 const 来实现 “bitwise constness”，以确保在 const 对象上调用这些函数时，对象的二进制表示不会发生变化。这样的函数不应修改任何非 mutable 的成员。
Logical Constness:
定义： “Logical constness” 关注的是对象的逻辑状态是否保持不变。在这个概念中，即使对象的物理状态（内部数据成员的值）发生了改变，它在外部的视角下仍然是常量。
实现： 通常通过将成员函数声明为 const，并在这些函数中不修改对象的逻辑状态。这允许在 const 对象上调用这些函数，保持对象在外部视角下的常量性。
区别:
“Bitwise constness” 关注对象底层二进制表示的变化，主要通过成员函数的 const 修饰符来实现，限制对数据成员的修改。
“Logical constness” 关注对象的逻辑状态的变化，同样通过成员函数的 const 修饰符来实现，限制对逻辑状态的修改。
在很多情况下，这两个概念是相关的，因为 “logical constness” 的实现通常涉及不修改对象的物理状态，从而保持 “bitwise constness”。然而，它们的重点略有不同，前者侧重于二进制表示，而后者更关注对象在逻辑上的不变性。

来举个栗子：

class CTextBlock{
public:
	...
	std::size_t length() const;
private:
	char* pText;
	std::size_t textLength;
	bool lengthIsValid;
};
std::size_t CTextBlock::length() const
{
	if(!lengthIsValid){
		textLength = std::strlen(pText);
		lengthIsValid = true;			//error!!!
		}
		return textLength;
}
//在const成员函数内不能赋值给textLength和lengthIsValid

用mutable释放掉non-static成员变量的bitwise constness的约束：

class CTextBlock{
public:
	...
	std::size_t length() const;
private:
	char* pText;
	mutable std::size_t textLength;
	mutable bool lengthIsValid;
};
std::size_t CTextBlock::length() const
{
	if(!lengthIsValid){
		textLength = std::strlen(pText);
		lengthIsValid = true;			//这样就是没问题的
		}
		return textLength;
}

const成员函数不能改变（除static)成员变量的值，同理const对象不可以调用non-const函数。但是若成员变量是一个指针，仅仅改变指针指向的值却不改变指针地址，则不算事const函数，但能通过bitwise测试。
解决方法：使用mutable可以消除non-static成员变量的bitwise constness约束。
举一个其他栗子：

#include <iostream>
using namespace std;
class MyClass{
public:
	//带有mutable 关键字的非静态成员变量
	mutable int mutableData;
	//构造初始化函数 mutableData
	Myclass(int data):mutableData(data){}
	//const成员函数，逻辑上保持不变性，但允许修改mutableData
	int getData() const{
		//修改mutableData，不违反const成员函数的规定
		mutableData++;
		return mutableData
	}
}
int main(){
	Myclass obj(42);
	cout << "Initial data: " <<obj.getData()<<endl;
	const Myclass constobj(100);
	cout << "Const object data: "<<constObj.getData()<<endl;
	return 0;
}

这个函数运行后的输出结果是：

Initial data: 43
Const object data: 101

在const 和non-const成员函数中避免重复
但是很遗憾mutable不能解决所有问题，假设你要做若干操作，同时放进const和non-const的operator[]中，就会发生代码重复的问题。
举个栗子：

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;
};

这段代码的问题很多，代码重复伴随的维护，代码膨胀等问题。最好的方法是只实现一次，但是调用的时候灵活一些。从内容看两个operator[]做的工作一样，但是留下哪个呢，留下non-const的那个，因为不论谁调用non-const operator[]，都一定要首先有个non-const对象。所以利用non-const operator[]调用 const是一个避免代码重复的安全做法。
举个栗子：

class TextBlock{
public:
	...
	const char& operator[](std::size_t position) const //保持不变
	{
		...		//边界检验
		...		//日志记数据访问
		...		//检验数据完整性
		return text[position];
	}
	char& operator[](std::size_t position)
	{
		return
			const_cast<char&> //移除第一次转型添加的const
				(static_cast<const TextBlock&>(*this)[position]);
				//将TextBlock类型转化cosnt TextBlock
				//使得能够调用const operator[]
	}
	...
}

这份代码有2个转型操作，第一次用来为*this 添加const,这就告诉operator[]调用const的版本，第二次从const operator[]的返回值中移除const。

2、总结

书山有路勤为径，学海无涯苦作舟。

3、参考

3.1 《More Effective C++》