C++中const的使用

一、C语言和C++中const的区别

       在C语言中const所修饰的变量为常变量，其处理是在预编译阶段看常变量有没有做左值，其他和普通变量的处理方式相同。

       C++中const所修饰的变量为常量，在编译阶段把用到常量的地方替换成常量出初始化的值。

二、C++中const使用的特点

       1、一定要进行初始化

       2、不能有修改常量内存块的风险

       3、const修饰的全局变量的符号是一个local属性

       4、用变量初始化常量，常量会退化成常变量

三、引用

       1、引用一定要初始化（引用是内存单元的别名）

       2、引用引用的变量一定要能取地址

       3、引用是不可改变的

       4、引用只能访问引用变量所引用的内存块的内容

       （底层以指针的方式来支持引用，在引用使用的地方，系统自带解引用过程）

int a = 10;//立即数放到临时变量中
 int &b = a; //常引用引用临时变量，相当于int *p = &a;

 int *p1 = &a;
 const int& c = 10;//不加const时不能对立即数取地址，加上const编程常引用可以对立即数取地址

四、const和*  &的结合

若const在*左边，则是用来修饰指针所指向的变量，即指针指向为常量。

若const在*右边，则是用来修饰指针本身，即指针本身是常量。

   int a = 10;
   int*p = &a;//p指向a的地址
   int* q = p;//q指向a

   const int a = 10;//a变成常量
   int* p = &a;//有修改常量内存块的风险  前面加上const
   int* q = p; //const int*==>int*  权限扩大（不允许），前面加上const

   直接访问   a
   间接访问   *p *q
   加上const，是为了杜绝间接访问修改常量内存块。

   int a = 10;
   const int*p = &a;//   const int* <== int*
   int* q = p;//    int* <== const int*权限扩大

int a = 10;
 int*const p = &a; // int* const<==  int*权限缩小
 int* q = p; // int*  <==  int* const权限扩大
 const不参与类型
 直接访问   p
 没有间接访问

  int a = 10;
  int*p = &a;
  const int* q = p;  *///  const int*  <==  int*

直接访问  a
间接访问  *q 有const修饰已经杜绝了修改常量内存块的风险

int a = 10;
 int*p = &a;
 int*const q = p;

 直接访问   q
 没有间接访问

五、const和**的结合

int a = 10;                  
 int* p = &a;
 int**q = &p;   

 const int a = 10;
 int* p = &a; //int* <== const int* 权限扩大，前面加上const
 int**q = &p;
 直接访问   a
 间接访问   *p, **q, 

 int a = 10;
 const int* p = &a;  // const int*  <== int*
 const int**q = &p;  // int**  <== const int**
 直接访问 a
 间接访问 *p **q

 

 int a = 10;
 int*const p = &a;  //  int* <== int*
 int**q = &p;      //   int** <==  int*const*
 直接访问 p
 间接访问 **q  在**中间加上const杜绝风险

 

 //int a = 10;
 //int* p = &a;//前面加上const
 //const int**q = &p;  // 不允许const int**  <== int**
 直接访问 a
 间接访问 **q , *(*q)  *q  p

 //int a = 10;
 //int* p = &a;
 //int*const*q = &p;
 直接访问 p
 间接访问 *q
 
 int a = 10;
 int* p = &a;
 int**const q = &p;
 直接访问 q
   没有间接访问

六、const和形参的结合

const 形参
 1.防止实参被修改
 2.接收临时量
 引用做形参
 1、引用实参的值
 2、引用不能引用立即数，部分实参无法调用

int getvalue（int a,int b）
//int getvalue（int& a,int& b）加上&可能会修改实参的值
//int getvalue（counst in&t a,counst int& b）防止实参被修改
{
     int tmp=a+b;
     return tmp; 
}

int getValue()
{
 int tmp = 20;
 return tmp;
}
int main()
{
//int& a = getValue();//int& a = eax; 指向寄存器的地址 不能引用常量错误
 //加上const把寄存器的值放到临时量中，用常引用引用临时量
 //int* p = &getValue();// int* p = &eax; 错误 寄存器不能取地址
 //int b = getValue();  //int a = eax;

 return 0;
}

int& getValue()
//返回该函数都有自动解引用的过程
{
 //不能返回局部变量的地址或引用
 static int tmp = 20;//static在数据段上可以取地址
 return tmp;
}
int main()
{
 int a = getValue();//getValue()==>eax(&tmp)==>*eax(tmp)系统自动解引用
 int&b = getValue();//getValue()==>eax(&tmp)==>*eax(tmp)
 int* p = &getValue();//getValue()==>eax(&tmp)==>*eax(tmp)==>&(*eax)==>&tmp
 return 0;
}

int* getValue()
{
 static int tmp = 20;
 return &tmp;
}
int main()
{
 int a = *getValue();//int a=*eax
 int&b = *getValue();//int &b=*eax=tmp
 int* p = getValue();//int *p=eax 值传递
 int*& pr = getValue();//int* &pr=eax 错误 引用一定要可以取地址，而寄存器不能取地址
 //int *后加上const
 return 0;
}