首页 > 代码库 > C++Primer学习——const

C++Primer学习——const

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

 

 

C++Primer学习——const