Const int size = 512;
在编译的时候，编译器会把用到该变量的地方全部替换成对应的值。
const&可以绑定字面值，所以当用常量引用绑定一个常量时，是否可以看成那个值在编译阶段已经被替换了
如果程序有多个文件，则用了const对象的文件必须要能访问到const的初始值才行，所以每个文件中都要
有它的定义才行。为了避免同一个变量的重复定义，const对象只在文件内有效。
如果现在多个文件*享const，必需在变量前面添加extern限定符。只定义一次
在file_1.cc：
extern const int size = fcn();
在file_1.h:(和.cc中的定义的size是同一个)
extern const int size;
const引用和const指针：
int main()
{
//T&必须要类型为T的左值进行初始化
//本质：const在谁后面谁就不可修改，const在最前面则将其后移一位即可，二者等效
//1.const T&
int val1 = 100;
int &ta = 100; //error 必需为左值
int &tb = a + 1; //error
const int &ptr1 = val1; //会先赋值给一个临时量，然后再赋值给ta. 不能通过ta修改a，但能通过a修改a
ptr1++;
cout << ptr1 << endl;
system("pause");
//2.const T*
double val2 = 3.1415926;
const double *ptr2 = &val2;
cout << *ptr2 << endl;
(*ptr) += 1; //本来必需指针类型和对象类型一致 ， 但是一个指向常量的指针可以指向一个非常量对象，但是无法修改val
system("pause");
//3.T*const
double val3 = 3.14;
double *const ptr3 = &val3;
const double val4 = 3.14;
const double *const ptr4 = &val4; //指针类型和对象类型要一致
ptr3 = &val1; //error 常量指针一旦指向一个地址就再也不能改变了
cout << *ptr3 << endl;
system("pause");
//4.const T* and T* const
/*
指向常量和常量指针的区别
允许一个常量引用（）绑定非常量对象，字面值，表达式，区分常量指针和指向常量的指针，注意识别指针的引用
*/
int val5 = 2012;
int *ptr5 = &val5;
const int *ptr6 = ptr5; //同2
/*const int *&zh = &tval;*/
const int *&ptr7 = ptr5; //why?T&必须要类型为T的左值进行初始化. 但是不是说允许一个常量引用绑定非常量对象，字面值，表达式
int * const &ptr8 = ptr5; //注意const不能放在*之前，否则就是修饰指针所指的对象了(这样就不是常量对象了)
const int *&ptr9 = ptr6;
system("pause"); //5.&val不是一个左值
int* Ptr = &val5;
int* &Ptr1 = Ptr;
int* &Ptr2 = &val5; //&val5不能作为一个左值，即进行++操作等。
int* const &Ptr3 = &val5; //可以用常量指针处理，就成了常量对象的引用
//6.const对象不分配内存？可能是因为编译阶段的替代
const int val = 2012; // val不分配存储空间
int& valr = val; // error，val不能做左值
const int& valr = val; // ok，也是通过中间变量处理
//7.可以将const转换成指向常量的指针 or 用常量对象引用
const int val = 2012;
const int* p = &val;
const int* &pr = p; // ok，p是左值
const int* const& pr1 = &val; // ok，通过中间变量初始化
int* const& pr2 = &val; // error，引用的类型不符合，一个是const int*，另一个是int* /*
8.difference between constexpr and const
constexpr定义一个指针的时候，只会修饰指针
*/
constexpr int tval = 2000;
int tval1 = 1000;
constexpr int* p = &tval1;
const int* Cptr = &tval;
constexpr int* Cxptr = &val;
constexpr const int *cCxptr = &tval;
cout << *p << " " << *cCxptr << endl;
system("pause");
return 0; /*9.*/
typedef char* cptr;
const cptr ptr = 0; //const修饰cptr，所以是一个常量指针
//error:you will think it as (const char* ptr),but the const decorate pointer.
}
/*
对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：
const classA operator*(const classA& a1,const classA& a2);
operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：
classA a, b, c;
(a * b) = c; // 对a*b的结果赋值
操作(a * b) = c显然不符合编程者的初衷，也没有任何意义
*/
为什么auto忽略顶层const
假如某个函数返回类型 const T
const T SomeFunction();
你很可能希望有一个可变的变量接收这个值：
auto t = SomeFunction();
t.Modify();
初始化过程中忽略顶层const:
const int a = 100;
int b = a; //忽略顶层const