Welcome to 9ilk's Code World
(๑•́ ₃ •̀๑) 个人主页: 9ilk
(๑•́ ₃ •̀๑) 文章专栏： C++之旅
const是个奇妙且非比寻常的东西，博主从《Effective C++》一书中认识到关于const更深层次的理解，写此博客进行巩固。
🏠 const的作用
- const可以指定一个“不该被改动的对象”，编译器会强制实施这个约束
- const可修饰类外的作用域(全局域,命名空间域等)中的常量，文件，函数或静态常量等
- const可修饰类内的static和non-static成员
🏠 const修饰指针和迭代器
📌 const修饰指针
const修饰指针无外乎三种：
char greet[] = "hello";
char* pg = greet;
//指针指向内容不可变
const char * pg = greet;
char const * pg = greet;
//指针本身不可变
char * const pg = greet;
//指针本身和指针执行内容都不可变
const char * const pg = greet;总结：
1.const出现在*号左边时,表示指针指向的内容是常量。
2.const出现在*号右边时,表示指针本身是常量。
3.const出现在*号左右边时,表示指针本身和指针指向的内容都是常量
📌 const与迭代器
- 声明迭代器为const
我们把迭代器看作一个类型，它的作用就像个T*的指针，当声明迭代器为const时，类比const int是int这个int类型变量不可能，此时说明迭代器类型变量是不能变的，也就是类比修饰一个T* const的指针。
vector<int> v = {4,1,2,9,10};
const vector<int>::iterator it = v.begin();
it++; //错误，迭代器类型对象不可变
(*it)++; //正确，指向内容可以变 我们也可以利用下面代码进行验证，当生成解决方案时会对其进行报错：
template<class T>
void fun()
{
const T x;
cout << typeid(x).name() << endl;
x++;
}
int main()
{
//op o;
//cout << o[1];
vector<int> v = {3,5};
vector<int>::iterator it = v.begin();;
fun<vector<int>::iterator>();
return 0;
}- const迭代器
如果你希望迭代器所指的东西不可被改动(也就是类似希望模拟个const T*指针)，你需要的是const_iterator.
std::vector<int> v = {1,5,2,3,4};
std::vector<int>::const_iterator it = v.begin();
*it = 10; //错误，此时是const迭代器，指向内容不可改变。
it++; //此时不是声明迭代器为const，本身迭代器可以改变。注：我们平时所说的const迭代器就是const_iterator，请注意区分与前者声明迭代器为const进行区分。
🏠 const与函数
📌 const与函数参数
建议：如果对于局部对象或对于函数参数没有改动的需求时，建议将他们声明为const，此时可以避免不必要的麻烦。比如：将“==”键值的“=”。
📌const与函数返回值
- 函数返回一个常量，往往可以降低因客户错误而造成的意外，而且具有安全性和高效性
假设有这样的一个有理数类：
class Rational;
const Rational operator*(const Rational& r1,const Rational& r2)
{//...};
Rational a,b,c;
...
(a*b) = c;由于是有理数类，客户可能会将乘积再做一次赋值，此时将operator*的返回值类型设置为const就可以避免这样无意义的赋值动作。
🏠 const与成员函数
📌 const成员函数的好处
1. const成员函数易使class接口比较容易被理解，清楚知道哪个函数可以改动对象内容而哪个函数不行。
2. 有了const成员函数，const对象就能被“操作”，因为const对象只能调用const成员函数；能操作const对象，就能利用传引用(const 类类型 &)提高效率。
- const成员函数与普通成员函数的区别
我们知道普通成员函数参数都有一个隐含的this指针，是不能修改的，也就是类 * const this;而const成员函数的this指针，类型是const 类 * const this，也就是说此时对象的内容也不能被修改。
class Date
{
public:
//...
const char& operator[](size_t position)const //operator[]for const对象
{
return _date[position];
}
char& operator[](size_t position) //operator[]for non-const 对象
{
return _date[position];
}
private:
string _date;
};
int main()
{
Date d1("2024/08/04");
cout << d1[0] << endl; //调用的是non-const版本
const Date d2("2024/08/04")
cout << d2[0]; //调用的是const版本
return 0;
}- 说明
1. 两成员函数如果只是常量性不同，也是可以被重载的。因为两个版本隐含的this类型不同，同时
返回值类型也跟着不同。
2.const对象d2的对象指针为const Date* ，更匹配const版本的operator[]，因此调用const版本；
而非const对象d1的对象指针为Date*,更匹配非const版本。
📌 bitwise const VS logical const
到这里，我们思考一下什么成员函数如果是const意味着什么？目前有以下两个流行概念需要向大家介绍一下：
- bitwise constness
这种观点的人认为，成员函数只有在不改变对象之任何成员变量时才可以说是const,也就是说不改变对象内的任何一个bit。这种论点的好处是很容易找到违反点：只需找到对成员变量的赋值动作即可。
这种观点正是C++对常量性的定义，因此const成员函数不可以更改对象内任何非静态成员变量。
如果只有指针(而非所指向内容)隶属于对象，(比如有这样的一个类，将数据存储于char*而不是string)，不修改char*而修改char*指向内容，此时编译器是认为是bitwise constness的,可以正常通过编译。
class Block
{
public:
Block( char* ch )
:pText(ch)
{}
char& operator[](size_t position)const
{
return pText[position];
}
private:
char* pText;
};
int main()
{
char arr[] = "hello";
char* ch = arr;
const Block cctb(ch);
char* pc = &cctb[0];
*pc = 's';
return 0;
}此时可以通过这个漏洞修改成员变量指针指向的内容而不违法const
(注：如果成员变量是string,由于operator[]需要访问pText成员变量，并且你需要保证Block对象的状态不被修改，所以pText的operator[]调用也必须是const的，因此不会出现上述漏洞。)
这种情况导出所谓的logical constness.
- logical constness
class BigArray
{
vector<int> v;
int accessCounter;
public:
int getItem(int index) const
{
accessCounter++;
return v[index];
}
};此类提供了一个
getItem接口，除此之外，为了计算外部访问数组的次数，该类还设置了一个计数器accessCounter，可以看到用户每次调用getItem接口，accessCounter就会自增，很明显，这里的成员v是核心成员，而accessCounter是非核心成员。
我们希望接口 getItem 不会修改核心成员，而不考虑非核心成员是否被修改，此时 getItem 所具备的 const 特性就被称为 logic constness。
问题：在这个函数中虽然accesCounter修改对对象而言可以被接受，但是编译器只认bitwise constness不允许修改怎么办？
- mutable
mutable是C++中一个与const相关的摆动场，他可以释放掉non-static成员变量的bitwise constness约束。
class BigArray {
vector<int> v;
mutable int accessCounter; //像这样的成员变量可能总是会被更改。
public:
int getItem(int index) const {
accessCounter++;
return v[index];
}
};总结：当const成员函数接受某些修改之后不改变成员函数逻辑状态的成员变量时，这时可以使用mutable来释放const约束。但注意mutable可能会违反对象的不变性，需要慎用。
📌 在const和non-const成员函数中避免重复
对于“bitwise constness”非我所欲的问题，mutable是个解决办法，但并不能解决所有的难题。假设有个类，类内的operator[ ]不单只是返回一个引用指向某字符，也执行边界检验，志记访问信息，甚至可能进行数据完善性检验等...把所有这些放进const版本和非const版本的operator[ 里的问题是会导致代码膨胀以及大量代码重复：
class Text
{
public:
char& operator[](size_t pos)
{
//... 边界检验
//... 志记数据访问
//... 检验数据完整性
return text[pos];
}
const char& operator[](size_t pos)const
{
//... 边界检验
//... 志记数据访问
//... 检验数据完整性
return text[pos];
}
private:
string text;
};避免代码重复的安全做法：
class Text
{
public:
const char& operator[](size_t pos)
{
//... 边界检验
//... 志记数据访问
//... 检验数据完整性
return text[pos];
}
char& operator[](size_t pos)const
{
return (char&)(((const Text &)(*this))[pos]);
}
private:
string text;
};- 说明
1. 这份代码进行了两次转型实现了了“运用const成员函数实现其non-const兄弟”，避免了代码重
复。
2.第一次转型将(*this)也就是这个对象类型强转为const Text&是为了匹配const版本调用const版
本的operator[ ]，否则会陷入无限调用非const版本；第二次转型则是用来从const operator[ ]的
返回值中移除const,这其中并未有权限放大的问题，强转是可行的。
3. 反向调用也就是“令const版本调用non-const版本以避免代码重复”是一件错误的事，因为non-
const并未承诺绝不改变其对象的逻辑状态，因此这种做法可能使得对象被改动，当然编译器也不
允许const调用非const，也是一种权限的放大。
总结：
1. 将某些东西声明为const可帮助编译器侦测出错误用法，比如错误的赋值行为使得不必要的对象改动。
2.const可施加于任何作用域的对象,函数参数，函数返回值，成员函数。
3.如果在const成员函数内想改变非核心成员变量以达目的，可利用mutable解除const约束。
4.当const与非const成员函数实质有着等价的实现且代码有大量重复时，可考虑复用const版本以实现非const版本。
