C++ const用法详解

最新推荐文章于 2024-08-23 11:14:29 发布

SmileySure

最新推荐文章于 2024-08-23 11:14:29 发布

阅读量875

点赞数 2

分类专栏： C++

本文链接：https://blog.csdn.net/u010557442/article/details/99235573

版权

C++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

C++ const用法详解

const可被施加于任何作用域内的对象,函数参数,函数返回类型,成员函数本体. const修饰的好处就是首先告诉阅读你这段代码的人返回的值不可修改，也可以用过编译器检查出不可预知的错误。

文章目录

C++ const用法详解

`const` 用来修饰变量

用const修饰指针,如果const出现在*之前,表明指针不能更改（p）所指向的对象的内容(const int *p 或者 int const * p),如果const出现在*之后(int * const p),表明指针只能指向同一块内存（p）*.
如果对象成员有普通指针,那么构造该类的一个const对象时,const修饰使得该指针只能指向同一块内存,但指针指向的内容可以改变(即int * const p对象的const修饰会在int * 之后生效，因此不能修改p只能修改*p).

const int a = 1;
int const a = 1; //对于普通变量，const的位置在类型前后的意义等价

char greeting[] = "Hello";
char* p = greeting;         //non-const pointer,non-const data
const char* p = greeting;   //non-const pointer,const data
char* const p = greeting;   //const pointer,non-const data
const char* const p = greeting; //const pointer,const data
char const* const p = greeting; //const pointer,const data 
//对于指针变量而言，顶层const和底层const的区别在于出现在星号的那一边。
//就近原则，const离类型近不能修改指向的内容，离声明的变量名近不能修改地址

需要注意的是，STL 迭代器形式上如 std::vector<int>::iterator 在指针基础上塑造出来的，它的作用就像个 T* 指针。将迭代器声明为 const 就跟声明指针为 const 一样（T* const），此时迭代器不可改变。如果希望迭代器所指之物不能被改变(const T*)，需要用到 const_iterator。

std::vector<int> vec;
const std::vector<int>::iterator iter = vec.begin();
*iter = 10; //ok
++iter;     //error

std::vector<int>::const_iterator cIter = vec.begin();
*cIter = 10; //error
++cIter;     //ok

`const` 用来修饰函数的参数以及返回值

这本质上与 const 修饰普通变量的作用一致，但在修饰的变量时函数参数或返回值时起到很大的威力。

修饰函数的参数可以防止传入的参数在函数内部发生修改，特别是对于指针或引用类型的参数。对于这两种类型之外的变量，如 int ，则没必要用 const 修饰，因为采用复制传值并不会改变外部的传入参数。
修饰函数的返回值可以防止返回值被修改，同时也能防范一些低级错误。

class Rational{};
const Rational operator* (const Rational& lhs, const Rational& rhl);

Rational a, b, c;
(a * b) = c; //用const修饰返回值的话，这样的错误就能被立马侦查出来

`const` 用来修饰成员函数

const 成员函数可以防止在函数内部修改成员变量（可以调用成员变量但不能修改)，同时也防止函数内部调用 non-const 成员函数，这保证了 const 成员函数不会改变对象的状态。

然而，编译器对 const 成员函数不修改对象状态执行的是 bitwise const(又称physical constness,物理上的常量性,即成员函数不更改对象的任何一个bit时才可以说是const)) ，并不能保证对象内部变量不会被改变。

class CTextBlock
{
public:
    char& operator[](std::size_t pos) const { return pText[pos];} //bitwise const声明
private:
    char* pText;
}

此时，虽然 const 成员函数保证了不会修改对象的 pTest 变量，但它的引用返回值却可以在外部修改 pTest 的所指之物。这在逻辑上并非是 const 的。此外，一个 const 成员函数即使修改了对象的某些 bit, 它在逻辑上仍然是 const 的。譬如在 CTextBlock 这个类中，可能会高速缓存文本区块的长度以应付访问，这种数据的修改对 const CTextBlock 对象来说是可以接受的。

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); //error
        lengthIsValid = true; //error
    }
    return textLength;
}

程序员编写程序时应该使用conceptual constness(概念上的常量性或logical constness,逻辑上的常量性,即一个const成员函数可以处理它所修改的对象的某些bits,但只有在客户端侦测不出的情况下才得如此),例如对于某些特殊类,其中的某些成员的值注定是要改变的,因此可以用mutual关键字修饰,从而实现即使对象被设定为const,其特定成员的值仍然可以改变的效果.此时该类符合conceptual constness而不符合bitwise constness.
当const和non-const成员函数拥有重复的实现时,令non-const版本调用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&>(
             static_cast<const TextBlock&>(*this)[position]);
    }
    ...
};

可以看出,经过了两次类型转换,第一次通过static_cast将*this转为const TextBlock&以确保调用的是operator[]的const版本,否则会调用非const版本导致递归调用造成栈溢出;第二次通过const_cast去掉const版本的opsrator[]返回的const char&的const特性以与函数的返回类型相匹配.

注意,不能用const版本调用non-const版本,因为non-const版本极有可能改变对象的值,这与const版本的const特性相矛盾.