const的使用

在C/C++中关键字const用来定义一个只读的变量或者对象，有如下优点

（1）便于类型检查，如函数的函数 fun（const int a） a的值不允许变，这样便于保护实参。

（2）功能类似与宏定义，方便参数的修改和调整。如 const int max = 100；

（3）节省空间，如果再定义a = max,b=max...就不用在为max分配空间了，而用宏定义的话就一直进行宏替换并为变量分配空间

（4）为函数重载提供参考

而C/C++中常把指针和常量混合起来使用，其最大的用途就是作为函数的形式参数，保证实参在被调函数中的不可改变的特性，那到底常量指针和指针常量有什么区别呢？
下面通过一个例子来解析 常量指针 和 指针常量，我们先总结一下 常量指针 和 指针常量 的区别
首先一定要明白哪种定义方式是常量指针，哪种是指针常量，这里可以记住三句话加深记忆：
*（指针）和 const（常量） 谁在前先读谁 ；*象征着地址，const象征着内容；谁在前面谁就不允许改变。

好吧，让我们来看这个例子:

int a =3;  
int b = 1;  
int c = 2;  
int const *p1 = &b;//const 在前，定义为常量指针  
int *const p2 = &c;//*在前，定义为指针常量   

常量指针p1：指向的地址可以变，但内容不可以重新赋值，内容的改变只能通过修改地址指向后变换。   
    p1 = &a是正确的，但 *p1 = a是错误的。
指针常量p2：指向的地址不可以重新赋值，但内容可以改变，必须初始化，地址跟随一生。

    p2= &a是错误的，而*p2 = a 是正确的。

测试代码：

//常量指针：const int* p,p指向的地址可以读但是不能写，不能*p进行赋值。
//指针常量：int* const p,p指向的地址跟随p一生。

#include <stdio.h>
#include <stdlib.h>

void main2mianshiti7()
{
	//const int x=3;
	//int b = 10;
	//int c = 20;

	//const int* a1 = &b;
	//int* const a2 = &b;
	//const int* const a3 = &b;

	//x = 2;

	//a1 = &c;
	//*a1 = 1;

	//a2 = &c;
	//*a2 = 1;

	//a3 = &c;
	//*a3 = 1;


	/


	//const int x = 3;
	//int b = 10;
	//int c = 20;
	//printf("%p",&c);

	// int* a1 = &b;
	// *a1 = 15;
	// *a1 = &c;
	// a1 = 99;
	// *a1 = &x;
	// a1 = 80;


	system("pause");
}

可以尝试一下分别把注释的放开会报什么错误！

这就是常量指针与指针常量的区别：

常量指针是指 const 类型*这种写法，指针指向为常量。指针指向的内容无法修改。

指针常量是指 类型 *const这种写发，指针本身为常量。指针本身无法修改。

对const关键字的总结：

const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。
const关键字的作用主要有以下几点：
（1）可以定义const常量，具有不可变性。 例如： 
const int Max=100; int Array[Max]; 
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改； 
（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如： 
void f(const int i) { i=10;//error! } 
（5） 为函数重载提供了一个参考。 
class A { ...... 
void f(int i) {......} //一个函数 
void f(int i) const {......} //上一个函数的重载 ...... 
}; 
（6） 可以节省空间，避免不必要的内存分配。 例如： 
#define PI 3.14159 //常量宏 
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ...... 
double i=Pi; //此时为Pi分配内存，以后不再分配！ 
double I=PI; //编译期间进行宏替换，分配内存 
double j=Pi; //没有内存分配 
double J=PI; //再进行宏替换，又一次分配内存！ 
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。 
（7） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。