const 限定符 extern 对常量的引用 指向常量的指针 常量指针

1. 
   main.cpp

extern const int x = 10;//必须加extern
int main(){
return 0;
}

fun.cpp

extern const int x;
void fun(){
cout<<x<<endl;//可以使用x；
}

2.
对于非const变量而言
main.cpp

int x = 10;//必须是全局变量
int main(){
return 0;
}

fun.cpp

extern int x;
void fun(){
cout<<x<<endl;//可以使用x；
}

const的引用–对常量的引用

    //常引用
    int a = 10;
    const int aa = 11;//可以引用非常量值
    //int &bb = aa;//错误，必须加const
    const int &b = a;//不允许b修改a值，
    b = 13;//报错，b是不可修改的值
    cout << b << "  " << a << endl;//10 10
    a = 12;
    cout << b << "  " << a << endl;//12 12
    const int &c = 1;//常量引用的初始值可以为右值
    cout << c <<  endl;//1
    //int &d = 1;//错误，非常量引用的初始值必须为左值

初始化常量引用时，允许用任意表达式或常数做初始值
一般而言，引用类型必须与其被引用对象的类型一致，这是个例外，即允许一个常量引用引用一个非常量的变量

double dval = 3.14;
const int &val = dval;
/*此处val引用了一个int型的数。但是dval是一个双精度的数，因此为了确保让val绑定一个整数，编译器把上述代码变成了如下形式*/
******************************************************
const int temp = dval;//由双精度浮点数生成一个临时的整型变量
const int &val = temp;//把val绑定这个临时量
*******************************************************
//当引用不是常量时，
int &val2 = dval;//测试中也不通过
val2 = 10;//此时改变的不是dval值，而是dval生成的临时量值

指向常量的指针
一般而言，指针的类型必须与其所指对象的类型一致，这是个例外，即允许一个指向常量的指针指向一个非常量对象

double dval = 3.14;
const double *pdval = &dval;//不能修改dval的值
//上述等价于：
const double dval = 3.14;
const double *pdval = &dval;//指向常量的指针

常量指针–将指针本身定义为常量
常量指针必须初始化，一旦初始化，则该指针指向的地址值不能再改变。将* 放在const之前说明指针是一个常量（从又向左读）

int val = 10;
int *const ptr = &val;//指针是个常量--常量指针，ptr左边是const，说明ptr是个常量，*代表这个常量是个指针
const int *const ptr2 = &val;//ptr2是一个指向常量对象的常量指针  从右向左读

顶层const 底层const
顶层const：指针本身是个常量 int *const ptr;
底层const：指针指向的内容是个常量：const int *ptr;

int i = 0;
 int *const p = &i;//顶层const
 const int c = 42;//顶层const
 const int * p = &i;//底层const
const int *const p3 = p2;//左边是个底层const，右边是顶层const
const int &r = c;//用户声明引用的都是底层const

当执行拷贝操作时，顶层const没有影响，当拷贝底层const时，拷入和拷出的对象必须是具有相同的底层const资格（非常量可以转换为const）

int i;
const int ii = i;//

    const int i = 1;
    const int &p = i;//对常量的引用
    //int & const pp = i;//错误，引用是个常量

const形参和实参
因为顶层const变量去初始化变量时，会忽略顶层const

const int i = 1;
int c = i;//拷贝构造，忽略掉顶层const

可以用非常量初始化一个底层/顶层const对象，但是反过来
可以用顶层const对象初始化非常量对象（如上）
不可以用底层const对象初始化非常量对象

    int x1 = 1;
    const int x2 = x;//非常量初始化顶层const
    const int *x3 = &x;//非常量初始化底层const
    int x4 = x2;//顶层const初始化非常量，忽略顶层const
    //int *x5 = x3;// 错误，底层const初始化非常量
    const int *x5 = x3;//必须与x3是同类型