目录
- C语言的const
- 1.const关键字
- 2.const修饰的只读变量
- 3.节省空间，避免不必要的内存分配，同时提高效率
- 4.使用cosnt修饰
- 4.1修饰一般变量
- 4.2修饰数组
- 4.3修饰指针
- 4.4修饰函数的参数
- 4.5修饰函数的返回值
- C与C++中cosnt的区别
- 1.在C语言中
- 2.在C++语言中
- 3.cosnt修饰指针
- 3.1常量指针
- 3.2指针常量
- 3.3指向常量的指针常量
- 4.cosnt修饰二级指针
- 5.cosnt指针练习
- 总结
C语言的const 注：c语言部分cosnt引用自《c语言深度剖析》一书。
1. const关键字
const 是 constant 的缩写，是恒定不变的意思，也翻译为常量、常数等。很不幸，正是因为这一点，很多人都认为被 const 修饰的值是常量。这是不精确的，精确的说应该是只读的变量，其值在编译时不能被使用，因为编译器在编译时不知道其存储的内容。或许当初这个关键字应该被替换为 readonly。那么这个关键字有什么用处和意义呢？
const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。我们看看它与 define 宏的区别。 （很多人误以为 define 是关键字，然而并不是）。在C和C++中都有const关键字，但是他们的各自表示的意义是有所差别的。
2. const 修饰的只读变量
定义 const 只读变量，具有不可变性。
例如：
const int Max=100;
intArray[Max];
这里请在 Visual C++6.0 里分别创建.c 文件和.cpp 文件测试一下。你会发现在.c 文件中，编译器会提示出错，而在.cpp 文件中则顺利运行。为什么呢？我们知道定义一个数组必须指定其元素的个数。这也从侧面证实在 C 语言中， const 修饰的 Max 仍然是变量，只不过是只读属性罢了；而在 C++里，扩展了 const 的含义，我们在后面讨论。注意： const 修饰的只读变量必须在定义的同时初始化，想想为什么？
答：只读，不可写。因此定义后不可再次赋值。
留一个问题： case 语句后面是否可以是 const 修饰的只读变量呢？请动手测试一下。
答：case后面只能跟整形或者字符型的常量或常量表达式；因此，在C语言中不可以，C++中可以。void select(int a){ const int b = 10; switch (a) { caseb: cout < < "hello" < < endl; break; default:break; }}int main(){ select(10); return 0; }
3. 节省空间，避免不必要的内存分配，同时提高效率
编译器通常不为普通 const 只读变量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的值，没有了存储与读内存的操作，使得它的效率也很高。
例如：
#define M 3 //宏常量const int N=5; //此时并未将 N 放入内存中......int i=N; //此时为 N 分配内存，以后不再分配！int I=M; //预编译期间进行宏替换，分配内存int j=N; //没有内存分配// 注：取第一次分配时的地址给 jint J=M; //再进行宏替换，又一次分配内存！
const 定义的只读变量从汇编的角度来看， 只是给出了对应的内存地址， 而不是象#define一样给出的是立即数，所以， const 定义的只读变量在程序运行过程中只有一份拷贝（因为它是全局的只读变量，存放在静态区），而#define 定义的宏常量在内存中有若干个拷贝。
#define 宏是在预编译阶段进行替换，而 const 修饰的只读变量是在编译的时候确定其值。
#define 宏没有类型，而 const 修饰的只读变量具有特定的类型。
4. 使用cosnt修饰
4.1 修饰一般变量 一般常量是指简单类型的只读变量。这种只读变量在定义时，修饰符 const 可以用在类型说明符前，也可以用在类型说明符后。例如：
int const i=2;
或 const int i=2;
4.2 修饰数组 定义或说明一个只读数组可采用如下格式：
int const a[5]={1, 2, 3, 4, 5};
或const int a[5]={1, 2, 3, 4, 5};
4.3 修饰指针
const int *p; // p 可变， p 指向的对象不可变int const *p; // p 可变， p 指向的对象不可变int *const p; // p 不可变， p 指向的对象可变const int *const p; //指针 p 和 p 指向的对象都不可变
先忽略类型名（编译器解析的时候也是忽略类型名），我们看 const 离哪个近。 “近水楼台先得月”，离谁近就修饰谁。
const int *p; //const 修饰*p,p 是指针， *p 是指针指向的对象，不可变int const *p; //const 修饰*p,p 是指针， *p 是指针指向的对象，不可变int *const p; //const 修饰 p， p 不可变， p 指向的对象可变const int *const p; //前一个 const 修饰*p,后一个 const 修饰 p，指针 p 和 p 指向的对象都不可变
4.4 修饰函数的参数 const 修饰符也可以修饰函数的参数，当不希望这个参数值被函数体内意外改变时使用。例如：
void Fun(const int i);
告诉编译器 i 在函数体中的不能改变， 从而防止了使用者的一些无意的或错误的修改。
注：void Fun(int i) 在 void Fun(const int i)在C++中是一个函数，不会被认为是重载。可使用 typeid(i).name() 函数查看类型都为 int 类型
4.5 修饰函数的返回值 const 修饰符也可以修饰函数的返回值，返回值不可被改变。例如：
const int Fun (void);
在另一连接文件中引用 const 只读变量：
extern const int i;
//正确的声明extern const int j=10;
//错误！只读变量的值不能改变。注意这里是声明不是定义，注意声明和定义的区别。
C与C++中cosnt的区别 首先，const的作用表示，使用const修饰的变量不能作左值。在初始化完成后不能被修改。
1. 在C语言中
1.const修饰的量，可以不用初始化（测试得）。
2.cosnt修饰的量，称之为常变量，不可以用来初始化数组长度。
3.cosnt修饰的量，无法直接修改，但可以通过指针或汇编指令等方式修改。
在
.c 文件中const int b; // 无初始化， ok const int a = 10; //int arr[a] = {}; // 初始化数组长度 ，error int* p = (int*)&a; *p = 30; // 30 30 30 printf("%d %d %d \n", a, *p, *(&a));
2. 在C++语言中
1.const修饰的量，必须初始化。
2.cosnt修饰的量，称之为常量，预编译阶段全部替换，可以用来初始化数组长度。
3.cosnt修饰的量，无法修改。
在
.cpp 文件中//const int b; // error const int a = 10; int arr[a] = {}; int* p = (int*)&a; *p = 30; // 10 30 10 printf("%d %d %d \n", a, *p, *(&a)); // 注，这里的 a 和 *(&a) ，以及int arr[a]中的常量a在与编译阶段都被替换成10.
关于C++中通过指针修改常量这一点，可参考博客：C++中如何修改const变量
特殊情况：常量退化为常变量
int b = 20; const int a = b;
3. cosnt修饰指针
3.1 常量指针 常量指针，即指向常量的指针。
const int *p;
int const *p;
// const 与 int 不分先后，意义相同。此类指针我们称之为常量指针。顾名思义，指针指向的值是一个常量（语法上的，编译器认为该值不可通过指针修改）。
记忆方法：const修饰的 （*p），*p解引用后就是指针所指向的值。则const直接修饰该值，该值为常量。所以常量指针修饰的值为常量（不可做左值被修改）。
示例代码：
{int a = 10; const int* p = &a; int *q = p; // 此语句错误的，int*<==const int*的指向赋值，普通指针存在修改常量的风险，编译器报错。}
3.2 指针常量 指针常量。即指针本身是一个常量。
int* const p;
指针是常量，即不可改变指针的指向。而指针指向的内容任然是可修改的。
特点：指针常量本身任然是一个指针，也就是说 int* const p 与 int p 的类型都是 "int "类型指针。因此，我们可以认为指针常量是一个限定了指向的指针。
记忆方法：const 修饰了 （p），p是一个指针，也就是说const限制的p不能改变指向。
示例代码：
{int a = 10; int* const p = &a; int *q = p; // 此语句正确，本质上是指针的int*<==int*的指向赋值}
3.3 指向常量的指针常量 不可改变指向，且不可修改内容的指针。
const int* const p = &a;
4. cosnt修饰二级指针
const修饰一级指针：
int a; const int* p1 = &a; int const* p2 = &a; int* const p2 = &a;
const修饰二级指针：
int a; int* p = &a; const int* p1 = &a; /*cosnt无修饰类型 */ int**pp0 = &p; int** const pp1 = &p; /*cosnt修饰一级指针 */ int* const* pp2 = &p; /*cosnt修饰二级指针 */ int const** pp3 = &p1; // int const** pp31 = &p; // 无法从“int * *”转换为“const int** ” const int** pp4 = &p1; // const int** pp41 = &p; // .. /*cosnt修饰一级和二级指针 */const int* const* pp5 = &p; int const* const* pp6 = &p;
5. cosnt指针练习
题目一：下列表达式语句赋值错误的是？
int a = 10; const int* p = &a; int* q = p; int a = 10; int* const p = &a; int* q = p; int a = 10; int* const p = &a; int* const q = p; int a = 10; int* const p = &a; const int* q = p;
题目二：下列表达式语句错误的有。
// 选项Aint a = 10; int* p1 = &a; const int** q1 = &p1; // 选项Bint a = 10; int* p2 = &a; int* const* q2 = &p2; // 选项Cint a = 10; int* p3 = &a; int** const q3 = &p3; // 选项Dint a = 10; int* const p4 = &a; int** q4 = &p4; // 选项Eint a = 10; const int* p5 = &a; int* const* q5 = &p5;
题目解析请参看博客 练习题：C++指针练习 。
总结 【初识C++的const关键字|初识C++的const关键字,常量与常变量】本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容!
