extern const int size = fcn();

extern const int size;

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显然不符合编程者的初衷，也没有任何意义
*/

假如某个函数返回类型 const T
const T SomeFunction();
你很可能希望有一个可变的变量接收这个值：
auto t = SomeFunction();
t.Modify();