c语言中 const 的作用

Const 的作用

const 修饰变量，这个被修饰的变量被称为常数变量

特性：

不能被修改，本质上还是变量

用法：（2类，指针类型有2小类）

第一类：const + 普通变量
第二类：const + 指针变量（分为2小类）

• 方便起见我用 int * 类型举例

  第一小类：const int * p (const 在 * 左边)

  有2种情况：

  1. 不加 const
  2. 加 const

  1. 对指针解引用
  2. 直接使用指针地址

  第二小类：int * const p (const 在 * 右边)

  有2种情况：

  1. 不加 const
  2. 加 const

  1. 对指针解引用
  2. 直接使用指针地址

先说结论：

无论哪一种类型，其主要作用都是让一个被修饰的变量只能被读取，不能被写入，只要写入就报错
第一小类：const int * p (const 在 * 左边) 结论：指针指向的 值 不可被修改
第二小类：int * const p (const 在 * 右边) 结论：指针指向的 地址 不可被修改

例子：

第一类： const + 普通变量

程序（不加 const）

#include <stdio.h>
int main()
{
	int num = 10;
	num = 20;//对num写入（赋值）20
	printf("%d\n", num);//打印num的值
	return 0;
}

num 的值可以被修改
运行结果为 20
程序（加 const）

#include <stdio.h>
int main()
{
	const int num = 10;
	num = 20;//对num写入（赋值）20
	printf("%d\n", num);//打印num的值
	return 0;
}

报了一个错误

意思就是说 num 的值是不可以被改变的
由于 num 的值不可以被修改，得出结论：在 “第一类： const + 普通变量” 中，被修饰的变量只能被读取，不能被写入，只要写入就报错

---

第二类：const + 指针变量（分为2小类）

第一小类：const int * p (const 在 * 左边)
程序（不加 const）

#include <stdio.h>
int main() 
{
	int num = 10;
	int *p = &num;//申请一个指针，让他获得num的地址
	*p = 20;//解引用p，修改被指向变量的值，也就是num的值
	printf("%d\n", num);//打印num的值
	return 0;
}

输出：20

程序（加 const ，有两种情况）
情况一：对指针解引用

#include <stdio.h>
int main() 
{
	int num = 10;
	const int *p = &num;//申请一个指针，让他获得num的地址，此时 const 修饰的是 *p， 也就是说这个 *p 是一个常量指针变量 
	*p = 20;//解引用p，修改被指向变量的值，也就是num的值
	printf("%d\n", num);
	return 0;
}

报错
第5行 const 修饰了 *p， 也就是说这个 *p 是一个常量指针变量，由于常量指针变量也属于常量变量，而常量变量又不可以被赋值所以，第6行 我对 *p 进行解引用赋值操作，报错了
得出结论：在 “第二类：const + 指针变量，第一小类：const int * p (const 在 * 左边)”，情况一：对指针解引用 中，被修饰的变量只能被读取，不能被写入，只要写入就报错

程序（加 const ，有两种情况）
情况二：直接使用指针地址

#include <stdio.h>
int main()
{
	int num = 10;
	const int* p = &num;//申请一个指针，让他获得num的地址
	int num1 = 20;//新建一个int型变量
	p = &num1;//让 指针p 读取num1的地址
	printf("%d\n", num);
	return 0;
}

通过监视可以看出来 指针p 已经得到了num1 的地址

运行结果：打印 num 的值，没问题
前面已经说过了，第5行 const 修饰了 *p， 也就是说这个 *p 是一个常量指针变量，由于常量指针变量也属于常量变量，而常量变量又不可以被赋值所以，第6行 我对 p 进行赋值操作跟*p 没有关系，改 p 的地址没问题

第二小类：int * const p (const 在 * 右边)
程序（不加 const）

#include <stdio.h>
int main() 
{
	int num = 10;
	int *p = &num;//申请一个指针，让他获得num的地址
	*p = 20;//解引用p，修改被指向变量的值，也就是num的值
	printf("%d\n", num);//打印num的值
	return 0;
}

输出：20

程序（加 const ，有两种情况）
情况一：对指针解引用

#include <stdio.h>
int main() 
{
	int num = 10;
	int * const p = &num;//申请一个指针，让他获得num的地址，此时 const 修饰的是 p， 也就是说这个 p 是一个常量指针变量，我不可以对 p 赋值  
	*p = 20;//解引用p，修改被指向变量的值，也就是num的值
	printf("%d\n", num);
	return 0;
}

正常运行第5行 const 修饰了 p， 也就是说这个 p 是一个常量指针变量，由于常量指针变量也属于常量变量，而常量变量又不可以被赋值所以，第6行 我对 *p 进行解引用赋值操作，没问题

程序（加 const ，有两种情况）
情况二：直接使用指针地址

#include <stdio.h>
int main()
{
	int num = 10;
	int* const p = &num;//申请一个指针，让他获得num的地址，此时 const 修饰的是 p， 也就是说这个 p 是一个常量指针变量，我不可以对 p 赋值
	int num1 = 20;//新建一个int型变量
	p = &num1;//让 指针p 读取num1的地址
	printf("%d\n", num);
	return 0;
}

报错

前面已经说过了，第5行 const 修饰了 p， 也就是说这个 p 是一个常量指针变量，由于常量指针变量也属于常量变量，而常量变量又不可以被赋值所以，第6行 我对 p 进行赋值操作，报错了
得出结论：在 “第二类：const + 指针变量，第二小类：int * const p (const 在 * 右边)，情况二：直接使用指针地址，被修饰的变量只能被读取，不能被写入，只要写入就报错

故得出结论：

无论哪一种类型，其主要作用都是让一个被修饰的变量只能被读取，不能被写入，只要写入就报错