C/C++：const常量，常变量

---

常变量

• const 变量类型 变量名

C语言：const修饰只能为常变量，且不能做左值

• 具有常量属性，将变量变为只读，变量值不能直接修改，且必须进行初始化；

  int a = 10;//可读可写
  int b;
  b =  a;//使用a的读权限
  a =  20;//使用a的写权限，左值：放在赋值符号的左边
  
  const int c = 10;//等价于 int const c = 10;
  int d = c;//c可读
  //c = 20;//error，c不可写
  
  //int arr[c];//error，c为常变量，不能作为数组长度使用

  const int e;//error,未初始化，局部变量默认随机值
  

• 通过指针强转类型修改常变量的值

#include <stdio.h>

int main()
{
    const int a = 10;//a为变常量
	const int* p = &a;
	int* p1 = (int*)p;//可以通过指针强转类型修改a的值
	*p1 = 20;
	
	printf("%d,%d\n", a, *p);//20,20
	
	return 0;
}

C++：const修饰可以常量或常变量

• 使用常量初始化，就是常量，
  • 指针无法修改常量的值
  • 可以作为数组长度使用
• 使用变量初始化，为常变量

#include<iostream>
using namespace std;

int main()
{
    const int a = 10;//a为常量
	const int* p = &a;
	int* p1 = (int*)p;
	*p1 = 20;
	cout << a << endl;//10,编译期直接替换a的值，指针无法修改常量的值
	cout << *p << endl;//20

	int arr[a];//a为常量

	const int b;//error，b必须初始化

	int c = 10;
	const int d = c;//使用变量初始化，d为常变量
	
	return 0;
}

const修饰指针

• const对于数据类型是透明的，
• const仅修饰变量，与数据类型位置无关。
• 即：const int* p等价于int const* p

const int* p
此时，const修饰* p，即 * p的值具有常量属性，也就是说指针p指向的地址所保存的值不能被修改。
但是指针p保存的地址，即指针p的指向是可以被修改的。

int* const p
此时，const修饰p，即指针p具有常量属性，也就是说指针p保存的地址不能被修改，也就是说指针p的指向是固定的。
但是指针p指向的地址所保存的值是可以被修改的。

  const int* p1 = &a;
  //等价于 int const* p1 = &a;
  p1 = &b;
  //*p1 = 200;//error,const修饰*p1
  
  int* const p2 = &a;
  //p2 = &b;//error,const修饰p2
  *p2 = 200;
  
  const int* const p3 = &a;
  //p3 = &b;//error,const修饰p3
  //*p3 = 200;//error,const修饰*p3
  

const类型值的传递

• 具有相同读、写权限的变量可以进行传递，
  可读可写权限可以传递给可读不可写权限，
  可读不可写权限不能传递给可读可写权限。

定义时，只考虑右边的读权限
涉及到指针，还需要考虑解引用权限和右边具体值的写权限

const int* p：p可读可写，*p不可写
int* const p：p可读不可写，*p不可写

  int a = 10;//&a可读,a可写
  int b = 20;//&b可读,b可写
  const int ca = 10;//&ca可读,ca不可写
  const int cb = 20;//&cb可读，cb不可写
  
  int* p = &a;//*p可写 <—— &a可读,a可写
  p = &b;//p可写，*p可写 <—— &b可读,b可写
  
  //p = &ca;//p可写，*p可写 —— &ca可读,ca不可写
            //ca不可写权限无法传递给 *p可写权限，
            //*p可以解引用进行修改，而ca的值不能改写
            
  const int* p1 = &a;//*p1不可写 <—— &a可读,a可写
  p1 = &ca;//p可写，*p1不可写 <—— &cb可读，cb不可写
           //ca不可写权限传递给 *p1不可写权限
           //const修饰*p1，无法解引用进行修改
           
  int* const p2 = &a;//*p2可写 <—— &a可读,a可写
  //p2 = &b;//p2不可写 —— &b可读
          //const修饰p3，即p3的指向不能改变，但是*p3可以解引用进行修改
          
  //int* const p3 = &ca;//*p3可写 —— &ca可读,ca不可写
                        //此处ca不可写权限无法传递给 *p3可写权限
                        

C++中可解释为：常量的地址不能泄露给变量

    int c = 10;
    
	int* p1 = &c;
	const int* p2 = &c;//*p2常量
	int const* p3 = &c;//*p3常量
	int* const p4 = &c;//p4常量

	int* q1 = &c;
	const int* q2 = &c;//*q2常量
	int const* q3 = &c;//*q3常量
	int* const q4 = &c;//q4常量

	p1 = q1;
	//p1 = q2;//常量的地址不能泄露给变量
	//p1 = q3;//error
	p1 = q4;

	p2 = q1;
	p2 = q2;
	p2 = q3;
	p2 = q4;

	//常量无法修改
	//p4 = q1;
	//p4 = q2;
	//p4 = q3;
	//p4 = q4;