四：const基础

const是定义常量==》const意味着只读

Const好处

//合理的利用const，

//1指针做函数参数，可以有效的提高代码可读性，减少bug；

//2清楚的分清参数的输入和输出特性

int setTeacher_err( const Teacher *p)

Const修改形参的时候，在利用形参不能修改指针所向的内存空间

1：const基础

#include<iostream>

using namespace std;

struct Teacher
{
	char name[64];
	int age;
};
//const 修饰的是PT这个变量，pT这个变量所代表的哪个房间（01号或者02号）被不能被修改
//但是房间里的数据可以修改
int opreatorTeacher( Teacher * const pT)
{
	pT->age = 10;//正确的
	//pT = NULL;//报错error C3892: “pT”: 不能给常量赋值
	return 0;
}
//const修饰的是*pt,代表房间里的数据不能被修改。
int opreatorTeacher01(const Teacher *pT)
{
	//pT->age = 10;//错误-----指针所指向的内存空间，不能被修改
	return 0;
}
//房间号和房间的数据都不能被修改
int opreatorTeacher02( const Teacher * const pT)//pT不能被修改
{
	//pT->age = 10;//正确的
	//pT = NULL;报错
	printf("age:%d\n",pT->age);
	return 0;
}

int main()
{
	//	const int a;
	//	int const b;//一样的

	//	const int *c;//const修饰的是指针所指向的内存空间，不能被修改
	Teacher t1;
	t1.age = 33;
	opreatorTeacher02(&t1);

	const int a = 10;
	int *p = NULL;
	//CONST
	p = (int *)&a;

	*p = 20;

	printf("a:%d\n",a);//c++当中打印的是10 ；c中打印的是20 ；
	printf("*p:%d\n",*p);//	执行这句话之后p = (int *)&a;重新给变量a分配了内存
	system("pause");
	return 0;
}

2：const分配内存的时机，编译器在编译期间分配

#include<iostream>

using namespace std;

struct Teacher
{
	char name[64];
	int age;
};
//const 修饰的是PT这个变量，pT这个变量所代表的哪个房间（01号或者02号）被不能被修改
//但是房间里的数据可以修改
int opreatorTeacher( Teacher * const pT)
{
	pT->age = 10;//正确的
	//pT = NULL;//报错error C3892: “pT”: 不能给常量赋值
	return 0;
}
//const修饰的是*pt,代表房间里的数据不能被修改。
int opreatorTeacher01(const Teacher *pT)
{
	//pT->age = 10;//错误-----指针所指向的内存空间，不能被修改
	return 0;
}
//房间号和房间的数据都不能被修改
int opreatorTeacher02( const Teacher * const pT)//pT不能被修改
{
	//pT->age = 10;//正确的
	//pT = NULL;报错
	printf("age:%d\n",pT->age);
	return 0;
}
//CONST分配内存的时机，编译器在编译期间分配
int main()
{
	int a;
	const int b = 10 ;
	int c ;
	printf(" &a:%d\n &b:%d\n &c:%d\n",&a,&b,&c);

	system("pause");
	return 0;
}

//04:const和#define的相同之处---编译预处理阶段处理
//#define 编译预处理阶段处理
//const常量是由编译器处理的，提供类型检查和作用域检查 

#include<iostream>

using namespace std;

struct Teacher
{
	char name[64];
	int age;
};
//const 修饰的是PT这个变量，pT这个变量所代表的哪个房间（01号或者02号）被不能被修改
//但是房间里的数据可以修改
int opreatorTeacher( Teacher * const pT)
{
	pT->age = 10;//正确的
	//pT = NULL;//报错error C3892: “pT”: 不能给常量赋值
	return 0;
}
//const修饰的是*pt,代表房间里的数据不能被修改。
int opreatorTeacher01(const Teacher *pT)
{
	//pT->age = 10;//错误-----指针所指向的内存空间，不能被修改
	return 0;
}
//房间号和房间的数据都不能被修改
int opreatorTeacher02( const Teacher * const pT)//pT不能被修改
{
	//pT->age = 10;//正确的
	//pT = NULL;报错
	printf("age:%d\n",pT->age);
	return 0;
}

//04:const和#define的相同之处---编译预处理阶段处理
//#define 编译预处理阶段处理
//const常量是由编译器处理的，提供类型检查和作用域检查 

#define e 20

int main()
{
	int a1 = 10 ;
	int b = 10;
	//int array[a1+b];//变量不能做下标，linux内核里成立，GCC支持
	//C/C++编译器不支持----报错
	const int c = 10 ;
	const int d = 10;
	int array[c+d];//可以编译通过

	int array01[c+e];//#define一样可以通过

	system("pause");
	return 0;
}

//const定义的变量 由编译器处理的，提供类型检查和作用域检查

#include<iostream>

using namespace std;

struct Teacher
{
	char name[64];
	int age;
};
//const 修饰的是PT这个变量，pT这个变量所代表的哪个房间（01号或者02号）被不能被修改
//但是房间里的数据可以修改
int opreatorTeacher( Teacher * const pT)
{
	pT->age = 10;//正确的
	//pT = NULL;//报错error C3892: “pT”: 不能给常量赋值
	return 0;
}
//const修饰的是*pt,代表房间里的数据不能被修改。
int opreatorTeacher01(const Teacher *pT)
{
	//pT->age = 10;//错误-----指针所指向的内存空间，不能被修改
	return 0;
}
//房间号和房间的数据都不能被修改
int opreatorTeacher02( const Teacher * const pT)//pT不能被修改
{
	//pT->age = 10;//正确的
	//pT = NULL;报错
	printf("age:%d\n",pT->age);
	return 0;
}

//const定义的变量 由编译器处理的，提供类型检查和作用域检查 
void fun1()
{
#define a 10
	const int b = 20;
	//#undef a //如果有这条语句函数fun2就没有办法使用a;
	//# undef// 宏定义卸载
}

void fun2()
{
	printf("a = %d\n", a);
	//printf("b = %d\n", b);//不能够用b const有作用域
}

int main()
{
	fun1();
	fun2();
	return 0;
}

3：C语言中的冒牌货

#include<iostream>
using namespace std;


int main()
{
	
	const int a = 10;
	int *p = (int*)&a; 
	printf("a===>%d\n", a);
	*p =20;
	printf("a===>%d\n", a);
	printf("*p====>%d\n",*p);//此处证明20的存在
	printf("Hello......\n");
	
	system("pause");
	return 0;
}

打印的结果为10

同样的代码C编译器当中打印出来是20 ；C++编译器打印出来是10

为什么会出现这种现象呢？

C++编译器对const常量的处理；

C++的常量是放在符号表当中的。

当碰见常量声明时，在符号表中放入常量 

那么问题是：那又如何解释取地址

       编译过程中若发现使用常量则直接以符号表中的值替换

       编译过程中若发现对const使用了extern或者&操作符，则给对应的常量分配存储空间（兼容C）

C++中const符号表原理图

1：c++编译器会把常量a放到一个符号表中，key处放a; value处放10 

2：当使用a的时候，编译器就把a从符号表中拿出来   例如执行语句printf("a:%d\n",a);

3：当对a取地址的时候（也就是执行p=(int *)&a时）编译器为a单独的开辟一块内存空间，执行这句话后指针p指向了

      新分配的内存空间。不管怎么该，不会改变符号表中的值。

注意：

C++编译器虽然可能为const常量分配空间，但不会使用其存储空间中的值。

结论：

C语言中的const变量

C语言中const变量是只读变量，有自己的存储空间

C++中的const常量

可能分配存储空间,也可能不分配存储空间

两种分配的情况 

1）当const常量为全局，并且需要在其它文件中使用

2）当使用&操作符取const常量的地址

4：const 和define的相同之处

int main()
{
    const int a = 1; //如果此处写成#define a 1
    const int b = 2; //如果此处写成#define b 2,下边的语句就不能编译通过
    int array[a + b ] = {0}
    int i = 0; 
    
    for(i=0; i<(a+b); i++)
    {
        printf("array[%d] = %d\n", i, array[i]);
    }
    
    
    getchar();
    
    return 0;
}

C++中的const修饰的，是一个真正的常量，而不是C中变量（只读）。在const修饰的常量编译期间，就已经确定下来了。

5：const 和define的不相同之处

对比加深

C++中的const常量类似于宏定义

const int c = 5; ≈ #define c 5

C++中的const常量与宏定义不同

const常量是由编译器处理的，提供类型检查和作用域检查

宏定义由预处理器处理，单纯的文本替换

最后的 结论
1）C 语言中的 const 变量

         C语言中const变量是只读变量，有自己的存储空间

2）C++ 中的 const 常量

可能分配存储空间,也可能不分配存储空间 
当const常量为全局，并且需要在其它文件中使用，会分配存储空间
当使用&操作符，取const常量的地址时，会分配存储空间
当const int &a = 10; const修饰引用时，也会分配存储空间