const关键字总结

const关于变量，指针，引用的修饰作用：
（1）修饰一般常量。 一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。如int const x = 2;或者const int x = 2;
（2）修饰常数组 定义或说明一个常数组可采用如下格式：int const a[5]={1, 2, 3, 4, 5};
（3）修饰常对象 常对象是指对象常量，定义格式如下：class A; 然后const A a;或者 A const a;定义常对象时，同样要进行初始化，并且该对象不能再被更新。常对象只能使用const成员函数和修改有mutable关键字修饰的成员变量。
（4）修饰常指针
const int *A; //const修饰指向的对象，A可变，A指向的对象不可变
int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
int *const A; //const修饰指针A， A不可变，A指向的对象可变
const int *const A;//指针A和A指向的对象都不可变
（5）修饰常引用 使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下： const double & v;
（6）修饰成员常量 有一点特殊的地方，成员常量的初始化必须在类构造函数的初始化列表中
注：其实这里面没有什么奇怪的地方，都很好理解。唯独const int a定义，即使通过const_cast

/*************************************************************************
    > File Name: const_test.cpp
    > Author: canispeakchinese
    > Mail: canispeakchinese@qq.com
    > Created Time: Sun 30 Apr 2017 11:02:43 PM CST
 ************************************************************************/

#include <iostream>
using namespace std;

class A {
public:
    A() : e(0) {
        c = new int[5];
        c[0] = 0;
        d[0] = 0;
    }
    void test() const {
        d[0] = 5;
    }
    const void test2() {
        A *ptr = static_cast<A*>(this);
        cout << "this:" << this << endl;
        ptr = NULL;
        cout << "this:" << this << endl;
    }
    void test3() {

    }
    int *c;
    mutable int d[5];
    const int e;
};

int main() {
    double a9 = 1;
    double &a10 = const_cast<double&>(a9);
    a10 = 2;
    cout << a9 << " " << a10 << endl;
    const A a7;
    a7.d[0] = 12356;
    cout << a7.d[0] << endl;
    //a7.test2();常量只能调用const成员函数
    a7.test();
    A a11;
    a11.test2();
    A &a8 = const_cast<A&>(a7);
    a8.c[0] = 123;
    a8.d[0] = 456;
    //a8.e = 789;
    cout << &a7 << " " << &a8 << " " << a7.c[0] << " " << a7.d[0] << " " << a7.e << " " << a8.c[0] << " " << a8.d[0] << " " << a8.e << endl;
    int b = 234;
    const int a3[5]={1, 2, 3};//必须初始化,感觉可能类似于定义了5个const int*,所以当它对应的内存的只改变了，他真正的值也就变了
    int *a4 = const_cast<int *>(a3);
    *a4 = 4;
    cout << a3 << " " << a4 << " " << *a4 << " " << a3[0] << endl;
    //*(a3) = 6;还是不能直接改的
    volatile const int a = 2;//有说法即使改了a对应地址的值，a的值也不会发生改变，后来发现这只是因为a没有从地址读取值，加上volatile就不会出现这种情况了
    cout << "&a:" << &a << endl;
    //volatile int const a = 2;//和上面没区别
    int &a5 = const_cast<int&>(a);
    a5=7;
    cout << "a的值到底有没有发生变化:" << &a5 << " " << &a << " " << a5 << " " << a << endl;
    const int *A = &b;
    //int const *A = &b;//和上面没区别
    const int *A2;//指针本身并不是常量，可以不用初始化
    b = 5;
    cout << *A << " " << b << endl;
    //*A = 6;*A是常量，所以不能变
    //A = &a;//但A不是常量，所以可以变
    //int *const B;常量没有初始化
    int *const B=&b;
    *B = 8;
    //B = &a;常量不能改变
    cout << *B << " " << b << endl;
    const int *const D = &b;//指针和指针指向的对象都不能变
    b = 66;
    cout << b << " " << *D << endl;
    double d=2, e=4;
    const double &v = d;//常引用
    d = 6;
    //double & const v2=d;不能这么使用
    //v = 3;引用所引用的对象不能被更新
    cout << d << " " << v << endl;
    return 0;
}
运行结果如下：
2 2
12356
this:0x7ffe4f2f93c0
this:0x7ffe4f2f93c0
0x7ffe4f2f93a0 0x7ffe4f2f93a0 123 456 0 123 456 0
0x7ffe4f2f9380 0x7ffe4f2f9380 4 4
&a:1
a的值到底有没有发生变化:0x7ffe4f2f9324 1 7 7
5 5
8 8
66 66
6 6