char* 赋值 const char* 释放_Effective C++读书笔记之条款3：尽可能使用const

点击上方蓝字关注我们

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

const修饰常规变量

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

charName[10];

charId = 0;

char*Ptr1 = Name; //普通指针，可以通过Ptr1修改Name的值

constchar*Ptr = Name; //Ptr不能修改Name的值，但是可以指向新的地址

char*constPtr2 = Name; //Ptr2能修改Name的值，但是不能指向其他地址

constchar*constPtr3 = Name; //Ptr3既不能修改Name的值，也不能指向其他地址

constintValue = 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关键字理由之一：尽可能让编译器强制实施你的约束，帮助你在编译期间发现可能会修改不想被修改变量的值的错误！

const修饰迭代器

由于C++的迭代器是由指针实现的，所以const关键字放在迭代器类型前面相当于声明一个T* const指针，可以修改迭代器所指变量的值，不能指向其他地址。迭代器中有const_iterator类型迭代器，相当于声明了一个const T*类型指针，不能修改迭代器所指变量的值，但是可以指向其他地址。我们用代码作为示例。

std::vector<int> Vec;

conststd::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*可以指向其他地址

conststd::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关键字。

const修饰函数返回值

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

classRation{

public:

Ration() = default;

~Ration() = default;

intGetValue()const{

returnValue;

}

intGetDecimal()const{

returnDecimal;

}

voidSeyValue(intValue){

this->Value = Value;

}

voidSetDecimal(intDecimal){

this->Decimal = Decimal;

}

private:

intValue;

intDecimal;

};

Ration operator* (constRation &lhs, constRation &rhs)

{

Ration R;

R.SeyValue(lhs.GetValue() * rhs.GetValue());

R.SetDecimal(lhs.GetDecimal() * rhs.GetDecimal());

returnR;

}

我们重载了*运算符，获取两个值的乘积。那么当使用者不小心时，可能会出现下面的用法。

Ration Value1, Value2;

Ration Value3;

(Value1 * Value2) = Value3;

因为(Value1 * Value2)产生了一个临时变量，这个时候给临时变量赋值是可以的，但是这么看就会很奇怪，为什么要给临时变量赋值？而且这也不是你想要的。那么如何避免这种情况发生呢？要避免给函数返回时产生的临时变量赋值，除了使用者的自我约束外，最有效的办法就是用const修饰函数返回值，让编译器帮你在编译期间排除这种错误！！以下代码为实例。

constRation operator* (constRation &lhs, constRation &rhs)

{

Ration R;

R.SeyValue(lhs.GetValue() * rhs.GetValue());

R.SetDecimal(lhs.GetDecimal() * rhs.GetDecimal());

returnR;

}

Ration Value1, Value2;

Ration Value3;

(Value1 * Value2) = Value3; //错误！！！，const修饰变量，不能重新赋值

尽可能使用const的理由之一：如果不想修改函数返回的值，那么就用const修饰函数返回值！避免出现给函数返回值赋值的奇怪现象。

const修饰成员函数

C++修饰成员函数表明，该成员函数不会修改成员变量的值，如果想在const修饰的成员函数改变某些成员变量的值，但是又不想改变其他成员变量的值，则用mutable修饰成员变量。我们用实例代码实际看一下。

classTextBlock{

public:

TextBlock() = default;

~TextBlock() = default;

TextBlock(conststd::string&&InitText);

constchar& operator[](std::size_tPosition) const{

std::cout<< "const operator"<< std::endl;

returnText[Position];

}

char& operator[](std::size_tPosition){

std::cout<< "not const operator"<< std::endl;

returnText[Position];

}

std::size_tLength() const{

if(!TextLen){

TextLen = Text.size(); //改变了被mutable修饰成员变量的值

IsValid = true;//改变了被mutable修饰成员变量的值

}

returnTextLen;

}

voidPrint()const;

private:

std::stringText;

mutablestd::size_tTextLen;

mutableboolIsValid;

};

TextBlock::TextBlock(conststd::string&&InitText)

{

std::cout<< "constructor input right value"<< std::endl;

Text = InitText;

}

voidTextBlock::Print() const

{

std::cout<< Text << std::endl;

}

尽可能使用const理由之一：如果在成员函数中，不想修改成员变量的值，则应该用const修饰成员函数！

尽量减少代码重复

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

constchar& operator[](std::size_tPosition) const

{

std::cout<< "const operator"<< std::endl;

returnText[Position];

}

char& operator[](std::size_tPosition)

{

std::cout<< "not const operator"<< std::endl;

returnconst_cast<char&>(static_cast<constTextBlock&>(*this)[Position]);

}

尽可能使用const理由之一：非const修饰的成员函数可以通过调用const修饰的成员函数，减少代码重复。