👩‍💻博客主页：choice~的博客主页
✨欢迎关注🖱点赞🎀收藏⭐留言✒
🔮本文由choice~原创，csdn首发！
😘系列专栏：C语言进阶、数据结构与算法、牛客刷题训练营
👕参考网站：牛客网
💻首发时间：🎞2022年7月23日🎠
🎨你的收入跟你的不可替代成正比
🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦
💬给大家介绍一个求职刷题收割offer的地方👉点击进入网站

@[toc]

3.9 C/C++中的const

3.9.1 const概述

const单词字面意思为常数，不变的。它是c/c++中的一个关键字，是一个限定符，它用来限定一个变量不允许改变，它将一个对象转换成一个常量。

const int a = 10;

A = 100; //编译错误,const是一个常量，不可修改

const增强：我们看C代码，就算常量也可以通过指针找到对象地址更改它的值，为容易理解，叫做伪常量；

#include<stdio.h>

const m_A = 10;//受到保护，不可改
test07()
{
	//m_A = 100; //错误，必须是可需改的左值
	const int m_B = 20;//伪常量
	//m_B = 100;//错误,同上

	int *p = (int*)&m_B;//强制类型转换，int *”与“int”的间接级别不同
	*p = 200;
	printf("*p=%d \t m_B=%d \n\n", *p, m_B);
}

int main()
{
	test07();
	return 0;
}

const m_A = 10;定义在函数外部的为全局变量，是静态变量，更改不了，结果如下：

3.9.2 C/C++中const的区别

3.9.2.1 C中的const

常量的引进是在c++早期版本中，当时标准C规范正在制定。那时，尽管C委员会决定在C中引入const,但是，他们c中的const理解为”一个不能改变的普通变量”，也就是认为const应该是一个只读变量，既然是变量那么就会给const分配内存，并且在c中const是一个全局只读变量，c语言中const修饰的只读变量是外部连接的。

如果这么写:

const int arrSize = 10;
int arr[arrSize];

数组的下标不能用const常量

看似是一件合理的编码，但是这将得出一个错误。 因为arrSize占用某块内存，所以C编译器不知道它在编译时的值是多少？

3.8.2.1 C++中的const

而在C++中，它用指针方式也改变不了常量，数组下标可以用const常量，和c相反

原理如下：

**在c++中，一个const不必创建内存空间，而在c中，一个const总是需要一块内存空间。**在c++中，是否为const常量分配内存空间依赖于如何使用。一般说来，如果一个const仅仅用来把一个名字用一个值代替(就像使用#define一样)，那么该存储局空间就不必创建。

如果存储空间没有分配内存的话，在进行完数据类型检查后，为了代码更加有效，值也许会折叠到代码中。

不过，取一个const地址, 或者把它定义为extern,则会为该const创建内存空间。

在c++中，出现在所有函数之外的const作用于整个文件(也就是说它在该文件外不可见)，默认为内部连接，c++中其他的标识符一般默认为外部连接。

3.8.2.3 C/C++中const异同总结

• c语言全局const会被存储到只读数据段。c++中全局const当声明extern或者对变量取地址时，编译器会分配存储地址，变量存储在只读数据段。两个都受到了只读数据段的保护，不可修改。

 const int constA = 10;
      int main(){
           int* p = (int*)&constA;
           *p = 200;
     }

以上代码在c/c++中编译通过，在运行期，修改constA的值时，发生写入错误。原因是修改只读数据段的数据。

• c语言中局部const存储在堆栈区，只是不能通过变量直接修改const只读变量的值，但是可以跳过编译器的检查，通过指针间接修改const值。

	const int constA = 10;
	int* p = (int*)&constA;
	*p = 300;
	printf("constA:%d\n",constA);
	printf("*p:%d\n", *p);

运行结果：

c语言中，通过指针间接赋值修改了constA的值。

c++中对于局部的const变量要区别对待：

1. 对于基础数据类型，也就是const int a = 10这种，编译器会把它放到符号表中，不分配内存，当对其取地址时，会分配内存。

   const int constA = 10;
   	int* p = (int*)&constA;
   	*p = 300;
   	cout << "constA:" << constA << endl;
   	cout << "*p:" << *p << endl;
   

运行结果：

constA在符号表中，当我们对constA取地址，这个时候为constA分配了新的空间，*p操作的是分配的空间，而constA是从符号表获得的值。

2. 对于基础数据类型，如果用一个变量初始化const变量，如果const int a = b,那么也是会给a分配内存。

int b = 10;
	const int constA = b;//会分配空间
	int* p = (int*)&constA;
	*p = 300;
	cout << "constA:" << constA << endl;
	cout << "*p:" << *p << endl;

运行结果：

constA 分配了内存，所以我们可以修改constA内存中的值。

3. 对于自定数据类型，比如类对象，那么也会分配内存。

    const Person person; //未初始化age
	//person.age = 50; //不可修改
	Person* pPerson = (Person*)&person;
	//指针间接修改
	pPerson->age = 100;
	cout << "pPerson->age:" << pPerson->age << endl;
	pPerson->age = 200;
	cout << "pPerson->age:" << pPerson->age << endl;

运行结果：

为person分配了内存，所以我们可以通过指针的间接赋值修改person对象。

• c中const默认为外部连接，c++中const默认为内部连接.当c语言两个文件中都有const int a的时候，编译器会报重定义的错误。而在c++中，则不会，因为c++中的const默认是内部连接的。如果想让c++中的const具有外部连接，必须显示声明为: extern const int a = 10;

const由c++采用，并加进标准c中，尽管他们很不一样。在c中，编译器对待const如同对待变量一样，只不过带有一个特殊的标记，意思是”你不能改变我”。在c++中定义const时，编译器为它创建空间，所以如果在两个不同文件定义多个同名的const，链接器将发生链接错误。简而言之,const在c++中用的更好。

了解: 能否用变量定义数组:

在支持c99标准的编译器中，可以使用变量定义数组。
1. 微软官方描述vs2013编译器不支持c99.：
Microsoft C conforms to the standard for the C language as set forth in the 9899:1990 edition of the ANSI C standard. 
2. 以下代码在Linux GCC支持c99编译器编译通过
-----------------------------------
int a = 10;
int arr[a];
int i = 0;
for(;i<10;i++) 
	arr[i] = i;
i = 0;
for(;i<10;i++)
	printf("%d\n",arr[i]);

3.9.3 尽量以const替换#define

在旧版本C中，如果想建立一个常量，必须使用预处理器”

#define MAX 1024;

我们定义的宏MAX从未被编译器看到过，因为在预处理阶段，所有的MAX已经被替换为了1024，于是MAX并没有将其加入到符号表中。但我们使用这个常量获得一个编译错误信息时，可能会带来一些困惑，因为这个信息可能会提到1024，但是并没有提到MAX.如果MAX被定义在一个不是你写的头文件中，你可能并不知道1024代表什么，也许解决这个问题要花费很长时间。

解决办法就是用一个常量替换上面的宏。

const int max= 1024;

const和#define区别总结:

1. const有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查.

2. const有作用域，而#define不重视作用域，默认定义处到文件结尾.如果定义在指定作用域下有效的常量，那么#define就不能用。

1. 宏常量没有类型，所以调用了int类型重载的函数。const有类型，所以调用希望的short类型函数？

#define PARAM 128
const short param = 128;

void func(short a){
	cout << "short!" << endl;
}
void func(int a){
	cout << "int" << endl;
}

2. 宏常量不重视作用域.

void func1(){
	const int a = 10;
	#define A 20 
    //#undef A  //卸载宏常量A
}
void func2(){
	//cout << "a:" << a << endl; //不可访问，超出了const int a作用域
	cout << "A:" << A << endl; //#define作用域从定义到文件结束或者到#undef，可访问
}
int main(){
	func2();
	return EXIT_SUCCESS;
}

问题: 宏常量可以有命名空间吗？

namespace MySpace{
	#define num 1024
}
void test(){
	//cout << MySpace::NUM << endl; //错误
	//int num = 100; //命名冲突
	cout << num << endl;
}

到这里就结束了，大家可以去牛客找些关于const试题做，巩固前面知识，都是干货，用时间换效率的方法直达链接查看

重点回顾

5.7 const增强
5.7.1 C语言中const是伪常量，可以通过指针修改
5.7.2 C++中const会放入到符号表中
5.7.3 C语言中const默认是外部链接，C++中const默认是内部链接
5.7.4 const分配内存情况
5.7.4.1 对变量取地址，会分配临时内存
5.7.4.2 extern关键字下的const会分配内存
5.7.4.3 用普通变量初始化const变量
5.7.4.4 自定义数据类型会分配内存
5.7.5 尽量用const代替define
5.7.5.1 define宏没有作用域概念
5.7.5.2 define宏常量没有类型