C语言关键字const作用及其应用
2020/01/13 19:03:32 来源:cnblogs.com/HalfCircle 作者:半个圆

只要学过C语言的,都有知道const这个关键字,知道是用来定义常量的,如果一个变量被const修饰,那么它的值就不能再被改变,那么还有什么其他作用呢?

一、const常用作用


1.修饰局部变量

const int n=5;
int const n=5;/*二者是等价的,均表示变量n的值不能被改变了*/

注意:在使用const修饰变量时,一定要给变量初始化,否则之后就不能赋值了!

接下来看看const用于修饰常量静态字符串,例如:

const char* str="fdsafdsa";

如果没有const的修饰,我们可能会在后面有意无意的写str[4]=’x’这样的语句,这样会导致对只读内存区域的赋值,然后程序会立刻异常终止。有了const,这个错误就能在程序被编译的时候就立即检查出来,这就是const的好处。让逻辑错误在编译期被发现。

2. 常量指针与指针常量

常量指针是指针指向的内容是常量,可以有一下两种定义方式。

const int * n;
int const * n;

需要注意的是一下两点:

1、常量指针说的是不能通过这个指针改变变量的值,但是还是可以通过其他的引用来改变变量的值的。

int a=5;
const int* n=&a;
a=6;

2、常量指针指向的值不能改变,但是这并不是意味着指针本身不能改变,常量指针可以指向其他的地址。

int a=5;
int b=6;
const int* n=&a;
n=&b;

指针常量是指指针本身是个常量,不能在指向其他的地址,写法如下:

int *const n;/*指针常量*/

需要注意的是,指针常量指向的地址不能改变,但是地址中保存的数值是可以改变的,可以通过其他指向改地址的指针来修改。

int a=5;
int *p=&a;
int* const n=&a;
*p=8;

区分 常量指针和指针常量的关键就在于星号的位置,以星号为分界线

如果const在星号的左边,则为常量指针
如果const在星号的右边,则为指针常量

将星号读作‘指针’,将const读作‘常量’的话,内容正好符合。int const * n;是常量指针,int *const n;是指针常量。

int const *n;   /*是常量指针*/
int * const n;  /*是指针常量*/

指向常量的常指针

指针指向的位置不能改变且也不能通过这个指针改变变量的值。(但是仍然可以用其他的普通指针改变变量的值)

const int* const p;

3. const修饰函数的参数

1> 防止修改指针指向的内容,如:

void StringCopy(char *dst, const char *src);

2> 防止修改指针所指向的地址,如:

void swap(int * const p1, int * const p2);

4. 修饰函数的返回值

如果给以“指针传递”方式的函数返回值加 const 修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。
例如,若有如下函数:

const char* GetString(void);

当用以下语句来接收函数返回值时将出错:

char *str = GetString(); /*错误*/

应当改写为:

const char *str = GetString(); /*正确*/

二、const和#define区别

关键字const用来定义常量,如果一个变量被const修饰,那么它的值就不能再被改变,我想一定有人有这样的疑问,C语言中不是有#define吗,干嘛还要用const呢,我想事物的存在一定有它自己的道理,所以说const的存在一定有它的合理性,与预编译指令相比,const修饰符有以下的优点:

1、预编译指令只是对值进行简单的替换,不能进行类型检查

2、可以保护被修饰的东西,防止意外修改,增强程序的健壮性

3、编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

三、const面试题

1. const声明的变量只能被读

const int i=5;
int j=0;
...
i=j;   //非法,导致编译错误
j=i;   //合法

2.必须初始化

const int i=5;    //合法
const int j;      //非法,导致编译错误

3.如何在另一.c源文件中引用const常量

extern const int i;     //合法
extern const int j=10;  //非法,常量不可以被再次赋值

4. 可以进行类型检查

用const方法可以使编译器对处理内容有更多了解。

#define I=10
const long &i=10;
...
char h=I;      //没有错
char h=i;      //编译警告,可能由于数的截短带来错误赋值。

说明:由于编译器的优化,使得在const long i=10时,i不被分配内存,而是已10直接代入以后的引用中,以致在以后的代码中没有错误,为达到说教效果,特别地用&i明确地给出了i的内存分配。不过一旦你关闭所有优化措施,即使const long i=10也会引起后面的编译错误。

5.可以避免不必要的内存分配

#define STRING "abcdefghijklmn/n"
const char string[]="abcdefghijklm/n";
...
printf(STRING);   //为STRING分配了第一次内存
printf(string);   //为string一次分配了内存,以后不再分配
...
printf(STRING);   //为STRING分配了第二次内存
printf(string);
...

由于const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝。

6.可以通过函数对常量进行初始化

int value();
const int i=value();

假定对ROM编写程序时,由于目标代码的不可改写,本语句将会无效,不过可以变通一下:

const int &i=value();

只要令i的地址处于ROM之外,即可实现:i通过函数初始化,而其值有不会被修改。

7.是不是const的常量值一定不可以被修改呢?

const int i=0;
int *p=(int*)&i;
*p=100;

通过强制类型转换,将地址赋给变量,再作修改即可以改变const常量值。

8.如何分清数值常量和指针常量:

   int ii=0;
   const int i=0;            //i是常量,i的值不会被修改
   const int *p1i=&i;        //指针p1i所指内容是常量,可以不初始化
   int  * const p2i=ⅈ     //指针p2i是常量,所指内容可修改
   const int * const p3i=&i; //指针p3i是常量,所指内容也是常量
   p1i=ⅈ                  //合法
   *p2i=100;                 //合法

6

本栏最新