const 限定符 学习笔记 C++


const对普通变量进行修饰,以表该变量在以后的使用中不被修改。

初始化

/*
*因对象一旦创建后其值便不能被修改,所以必须进行初始化
*根据初始化的值给定的表达式,初始化时机会再编译时或运行时确定
*当编译确定时,会在调用其值的地方编译时便用其值进行替换  
*(类似于define文本替换,但是define不会作类型检查)
*/
const int i = 12;                 //编译时初始化
const int j = get_size();         //运行时初始化

等价写法:
int const i = 12;
int const j = get_size();

const 对象作用域

默认仅在当前文本文件有效
需要在多个文件中生效时,需要在其声明和定义处用extern进行修饰


xxx.cc
extern const int i = 123;
xxx.h
extern const int i;

const 引用及指针

引用 [1]
当我们使用引用时一般都期望改变其值, 但是对于const对象本身是不被允许.
修改的,因此对于想把const对象绑定到引用时需要进行const修饰, 以表该引用不会改变其值.

引用的类型必须与其引用对象的类型一致 [2], 但是在初始化常量引用时只要表达式的结果能转换成引用的类型即可。例如

double dval = 3.14;
const int &ri = dval;
原因是编译器做了如下替换:
const int temp = dval;
const int &ri = temp;
// temp 是编译器临时创建的用于暂存表达式求值结果的临时变量。

// 另const引用可以绑定在非const变量上
int i = 3;
const int &k_ri = i;
i = 5;        //此时k_ri == 5;

指针及顶层const和底层const
指针本身是个变量,那其也可被const修饰,用于表明该指针的值不会被改变。
由于指针指向的亦是一个变量,那么该变量也存在const修饰的可能性,即一个指针变量可能存在双层const. 所谓低层const即用于修饰指针本身不会被改变,顶层const用于修饰指针指向的变量不会被改变。

int i = 1, b= 2;
const int *p = &i;  //底层const, *p解引用的值无法被改变, 但是p可以指向别的变量
*p = 4;   //不合法
p = &b;   //合法
int *const p2 = &i; //顶层const, p2无法指向其它变量,但是*p解引用的值可以改变.
*p2 = 1;  //合法
p2 = &b;  //不合法

注意:
进行对象拷贝时,对象必须有相同的底层const, 而顶层const则不影响.

const 在类中的使用

class Foo {
public:
    ...
    int get_i() { ++z_; return i_;}
    int get_z() { return z_; };
    ...
private:
    int i_;  //随意...
    int z_;  //计数get_i() 被调用的次数;
}

//对于Foo这样的类,如果某一天我们头脑发热想要声明一个常量,并调用相关成员,如下
const Foo k_var;
k_var.get_i();        //调用出错
k_var.get_z();       //调用出错
//对于成员函数的调用会提示报错,因为这些函数的调用可能会改变内部成员变量的值,
//这与你的期望不匹配。因此我们必须声明一个可被常量调用的版本, 通常如下,

class Foo {
public:
    ...
    int get_i() { ++z_; return i_;}
    int get_i() const { ++z_; return i_;}    //常量版本
    int get_z() { return z_; };
    int get_z() const { return z_; };          //常量版本
    ...
}

k_var.get_i();        //调用出错
k_var.get_z();       //正确
//此时对get_z()的调用是正确的,但是get_i()仍然是错误的,
//因为它试图在const成员函数里面改变成员变量的值z_,
//成员函数一旦被const修饰,通常意味着this指针的形态在其内部是const *this(便于理解),
//那么++this->z_这样的操作肯定是不合法的。
//但是对于z_这样我们希望无论在常量或非常量中都希望能够改变的值,我们可以在声明前加mutable修饰,表明是个可变的数据

class Foo {
public:
    ...
    int get_i() { ++z_; return i_;}
    int get_i() const { ++z_; return i_;}    //常量版本
    int get_z() { return z_; };
    int get_z() const { return z_; };          //常量版本
    ...
private:
    int i_;  //随意...
    mutable int z_;  //计数get_i() 被调用的次数;
}

k_var.get_i();   //正确

  1. 实际上引用的底层实现即是指针.

  2. C++ primer 2.4.1.

推荐阅读更多精彩内容