C++中const

【const】

0.普通const对象定义在栈空间中

{
    int a = 10;
    const int b = 100;
    cout << &a << ' ' << &b;
}

Result:

　0x22abec 0x22abe8

注：Code::Blocks + Cygwin测得。

 

1.对变量类型加以限定，使之不能被修改；

const int e1 = 100;

e1 = 101; // error

 

2.const对象必须被初始化；

const int e2; // error

 

3.const对象和non-const对象可以通过彼此进行赋值；const对象也可以通过表达式进行初始化；

int get_size() { return 100; }

int main()
{
    int i = 10;
    const int a = i; // non-const to const
    const int b = a; // const to const
    int c = a; // const to non-const
    int d = i; // non-const to non-const

    int e = get_size();

    return 0;
}

 

4.默认情况下，const对象仅在文件内有效（From定义之后To文件末尾）；

 

5.要在多个文件内共享一个const对象，需要使用extern关键字；

《C++ Primer》第五版的说法有一点问题，即“对于const变量不管是声明还是定义都添加extern关键字，这样只需定义一次就可以了”。

经过测试：可以在定义时不添加extern关键字，即下面的代码是可行的：

// file1.cpp
const int a = 100;

// file2.cpp
extern const int a;

但在声明和定义时都添加extern关键字应该是“最佳实践”，即在定义时就说明此const变量为整个工程可见。

 

6.const引用

6.1 不能通过const引用修改对象的值，无论其指向的对象是否为const对象；

6.2 非const引用不能指向一个const对象；

{
    int i = 10;
    const int a = i;

    int& b = i;
    int& c = a; // error, 6.2
    const int& d = i;
    d = 1000; // error, 6.1
    const int& e = a;
    e = 1000; // error, 6.1
}

6.3 将一个const引用绑定到另外一种类型上发生了什么：

{
    double dval = 3.14;

    const double& rd = dval;
    const int& ri = dval;

    cout << &dval << ' ' << &rd << endl;
    cout << &dval << ' ' << &ri << endl;
}

Result:
0x22abd8 0x22abd8 // ok
0x22abd8 0x22abe4 // wrong!

整形const引用的地址和dval的地址不一致。《C++ Primer》解释说，这是因为类型转换发生时，ri指向的是一个临时变量，并且，C++将这种行为归为非法。

但却能run起来。

 

7.指向和const

7.1 指向const对象的指针（pointer to const）：a.禁止指向非const对象的指针 指向 const对象；b.禁止将 指向const的指针 赋值给 指向非const的指针；

7.2 不能更改指向const对象的指针的值；

{
    const double cpi = 3.14;
    double *ppi = &cpi; // error, 7.1.a
    const double *cppi = &cpi;

    double pi = 3.14;
    double *ppi2 = π
    *ppi2 = 1000.0;
    const double *cppi2 = π
    ppi2 = cppi2; // error, 7.1.b
    *cppi2 = 100.0; // error, 7.2
}

7.3 常量指针（const pointer）：必须初始化、一旦完成初始化就不能更改、若所指对象非const，则可以修改其值；

{
    int a = 100;
    int b = 1000;

    int *p1 = &a;
    *p1 = 200;
    p1 = &b;

    int* const cp2 = &b;
    *cp2 = 201; // ok
    cp2 = &b; // error, pointer is const

    int* const cp3; // error, uninitialized
}

 

8.顶层const，底层const

顶层const：对象本身是否为常量，整数本身、对象本身、指针本身，即自己，不能改变自己；

底层const：指针 所指对象是否为常量，不能改变指针 所指对象 的值；

const int * const pi = &a; // 1.前一个const为底层const，后一个const为顶层const；2.从右往左阅读法；

 

9.类与const

9.1 const成员函数

作用：修改隐式this指针的类型。添加const之后，this指针所指对象的普通数据成员（非static非mutable）不能被更改。

类型转换实值：将 T* const this 更改为 const T* const this，此时，this指针所指对象可以是const对象。

9.2 const对象，以及const对象的引用或指针都只能调用const成员函数；

struct X {
    X(int x, int y) : ex(x), ey(y) {};

    void display1() { cout << ex << endl; }
    void display2() const { cout << ey << endl; }

    int ex;
    int ey;
};

int main()
{
    X x(12, 23);
    x.display1();
    x.display2();

    const X cx(34, 45);
    cx.display1(); // error, display1为非const成员函数
    cx.display2();

    return 0;
}

9.3 若成员函数为const，则其声明和定义都必须添加const（与上面说的extern的用法不同）；

9.4 成员函数可以根据const属性进行重载；

struct X {
    void display() {}
    void display() const {}
};

 

9.5 const成员变量：a.不能被修改；b.能进行类内初始化；c.若已类内初始化，则可以使用默认构造函数；d.可以在构造函数初始化列表中初始化；

struct X {
    X() {}; // 默认构造函数
    X(int x, int y) : ex(x), ey(y) {};

    void display1() { cout << ex << endl; }
    void display2() const;

    const int ex = 99; // 类内初始化
    const int ey = 100; // 类内初始化
};
void X::display2() const { cout << ey << endl; }

若未进行类内初始化，则默认构造函数不能通过编译，即当上面代码的8、9行没有赋值时，上面的默认构造函数不能通过编译，无论是否用到此默认构造函数；

若未进行类内初始化，又需要使用默认构造函数，可以在默认构造函数的初始化列表中给const成员变量赋值：

X() : ex(99), ey(100) {};

其中的99、100可以更改为其它表达式：

int out1 = 99;

struct X {
    X() : ex(out1), ey(out1+1) {}
    ...
};

 

-------------------------------------------------------------------

其它：

1.用于声明引用的const都是底层const，即不存在顶层const

const int a = 100;
const int & const b = a; // error: 'const' qualifiers cannot be applied to 'const int&'

2.引用可以赋值给引用

int a = 10;

int& b = a;

int& c = b; // ok, b is a reference

但const引用不能赋值给非const引用

const int& c = a;

int& d = c; // error