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

点击上方蓝字关注我们

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

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

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

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修饰函数返回值！避免出现给函数返回值赋值的奇怪现象。

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修饰成员函数！

尽量减少代码重复

        非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修饰的成员函数，减少代码重复。