点击上方蓝字关注我们
![6c7403699257012106b19a841a11505d.png](https://i-blog.csdnimg.cn/blog_migrate/3f9a38ec2ea06b1fe155f6a770eef994.png)
C++的const关键字会强制编译器实施保持某个值不变的约束,帮助你在编译期间就能发现错误,灵活使用const能提高代码质量还能避免不想被改变的值被修改。下面我将从const作用于变量、形参、引用、函数返回值、迭代器、成员变量和成员函数方面讲解对const的理解,以及为什么要尽可能的使用const。
![c5641a93dadfa5ae938a4a00ec98a608.png](https://i-blog.csdnimg.cn/blog_migrate/72d06448142406a864d3f22aba815a68.png)
const修饰常规变量
const关键字放在变量类型前面则表示不允许修改该变量的值,const还可以修饰指针,当const放在*后面表示该指针不允许指向其他地址,指针变量保存的地址值不能被改变。我们用代码作为示例。
char Name[10];
char Id = 0;
char *Ptr1 = Name; //普通指针,可以通过Ptr1修改Name的值
const char *Ptr = Name; //Ptr不能修改Name的值,但是可以指向新的地址
char *const Ptr2 = Name; //Ptr2能修改Name的值,但是不能指向其他地址
const char *const Ptr3 = Name; //Ptr3既不能修改Name的值,也不能指向其他地址
const int Value = 10; //正确,被const修饰的变量只能在初始化时赋值
Value = 20; //错误!!!被const修饰的变量值不能被修改!!
Ptr1[0] = 'c'; //正确,可以改变Name的值
Ptr1 = &Id; //正确,可以指向其他char类型变量的地址
Ptr[0] = 'a'; //错误!!!Ptr不能修改Name的值
Ptr++; //正确,Ptr指向其他char类型变量的地址
Ptr2[0] = 'a'; //正确,Ptr2能修改Name的值
Ptr2 = &Id; //错误!!!Ptr2不能指向其他地址
Ptr2++; //错误!!!Ptr2不能指向其他地址
Ptr3[0] = 'b'; //错误!!!Ptr3不能修改Name的值
Ptr3 = &Id; //错误!!!Ptr3不能指向其他地址
使用const关键字修饰的变量,在编译期间编译器帮你检查错误!而不加const关键字则需要人为仔细使用,还要人为的自我约束,在一个复杂的项目中经过多人维护很难避免这种情况。要尽可能的理解并掌握const基本用法,后续的讲解都是基于这个基础上进行的。
尽可能使用const关键字理由之一:尽可能让编译器强制实施你的约束,帮助你在编译期间发现可能会修改不想被修改变量的值的错误!
![c5641a93dadfa5ae938a4a00ec98a608.png](https://i-blog.csdnimg.cn/blog_migrate/72d06448142406a864d3f22aba815a68.png)
const修饰迭代器
由于C++的迭代器是由指针实现的,所以const关键字放在迭代器类型前面相当于声明一个T* const指针,可以修改迭代器所指变量的值,不能指向其他地址。迭代器中有const_iterator类型迭代器,相当于声明了一个const T*类型指针,不能修改迭代器所指变量的值,但是可以指向其他地址。我们用代码作为示例。
std::vector<int> Vec;
const std::vector<int>::iterator Iter = Vec.begin(); //const放在迭代器类型的前面,相当于T* const
*Iter = 10; //正确,T* const能修改指向变量的值
++Iter; //错误!!!T* const不能指向其他地址
std::vector<int>::const_iterator ConstIter = Vec.cbegin(); //const_iterator相当于const T*
*ConstIter = 11; //错误!!!const T*不能修改指向变量的值
++ConstIter; //正确,const T*可以指向其他地址
const std::vector<int>::const_iterator CconstIter = Vec.cbegin(); //const修饰const_iterator相当于const T* const
*CconstIter = 12; //错误!!!const T* const不能修改指向变量的值
++CconstIter; //错误!!!const T* const不能指向其他地址
尽可能使用const关键字理由之一:使用const修饰迭代器相当于增加了T* const属性,如果不想修改迭代器作用变量的值,那么就加上const关键字。
![c5641a93dadfa5ae938a4a00ec98a608.png](https://i-blog.csdnimg.cn/blog_migrate/72d06448142406a864d3f22aba815a68.png)
const修饰函数返回值
如果是C++内置类型是不能将“=”放在函数表达式的右边,也就是不能给函数返回值赋值。但是一个定义不好的自定义数据类型,则可能会出现“=”放在函数表达式右边的异常情况。我们知道C++可以重载运算符,那么如果const没有修饰函数返回值则会发生什么情况?我们看一下下面的实例代码。
class Ration{
public:
Ration() = default;
~Ration() = default;
int GetValue()const{
return Value;
}
int GetDecimal()const{
return Decimal;
}
void SeyValue(int Value){
this->Value = Value;
}
void SetDecimal(int Decimal){
this->Decimal = Decimal;
}
private:
int Value;
int Decimal;
};
Ration operator* (const Ration &lhs, const Ration &rhs)
{
Ration R;
R.SeyValue(lhs.GetValue() * rhs.GetValue());
R.SetDecimal(lhs.GetDecimal() * rhs.GetDecimal());
return R;
}
我们重载了*运算符,获取两个值的乘积。那么当使用者不小心时,可能会出现下面的用法。
Ration Value1, Value2;
Ration Value3;
(Value1 * Value2) = Value3;
因为(Value1 * Value2)产生了一个临时变量,这个时候给临时变量赋值是可以的,但是这么看就会很奇怪,为什么要给临时变量赋值?而且这也不是你想要的。那么如何避免这种情况发生呢?要避免给函数返回时产生的临时变量赋值,除了使用者的自我约束外,最有效的办法就是用const修饰函数返回值,让编译器帮你在编译期间排除这种错误!!以下代码为实例。
const Ration operator* (const Ration &lhs, const Ration &rhs)
{
Ration R;
R.SeyValue(lhs.GetValue() * rhs.GetValue());
R.SetDecimal(lhs.GetDecimal() * rhs.GetDecimal());
return R;
}
Ration Value1, Value2;
Ration Value3;
(Value1 * Value2) = Value3; //错误!!!,const修饰变量,不能重新赋值
尽可能使用const的理由之一:如果不想修改函数返回的值,那么就用const修饰函数返回值!避免出现给函数返回值赋值的奇怪现象。
![c5641a93dadfa5ae938a4a00ec98a608.png](https://i-blog.csdnimg.cn/blog_migrate/72d06448142406a864d3f22aba815a68.png)
const修饰成员函数
C++修饰成员函数表明,该成员函数不会修改成员变量的值,如果想在const修饰的成员函数改变某些成员变量的值,但是又不想改变其他成员变量的值,则用mutable修饰成员变量。我们用实例代码实际看一下。
class TextBlock{
public:
TextBlock() = default;
~TextBlock() = default;
TextBlock(const std::string &&InitText);
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 Text[Position];
}
std::size_t Length() const{
if(!TextLen){
TextLen = Text.size(); //改变了被mutable修饰成员变量的值
IsValid = true; //改变了被mutable修饰成员变量的值
}
return TextLen;
}
void Print() const;
private:
std::string Text;
mutable std::size_t TextLen;
mutable bool IsValid;
};
TextBlock::TextBlock(const std::string &&InitText)
{
std::cout << "constructor input right value" << std::endl;
Text = InitText;
}
void TextBlock::Print() const
{
std::cout << Text << std::endl;
}
尽可能使用const理由之一:如果在成员函数中,不想修改成员变量的值,则应该用const修饰成员函数!
![c5641a93dadfa5ae938a4a00ec98a608.png](https://i-blog.csdnimg.cn/blog_migrate/72d06448142406a864d3f22aba815a68.png)
尽量减少代码重复
非const修饰的成员函数可以通过调用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]);
}
尽可能使用const理由之一:非const修饰的成员函数可以通过调用const修饰的成员函数,减少代码重复。