对于处理数组的函数,只能传递指针。为了防止修改数组,可以在函数形参声明中声明const关键字。但是这只是针对函数不能修改数组,原始数组的修改还要看声明时候的情况!

 

  1. #include<stdio.h> 
  2. #define SIZE 3 
  3. int sum(const int ar[],int n); 
  4.  
  5. int main(void){ 
  6.     int num[] = {1,2,3}; 
  7.     int answer = sum(num,sizeof(num)/sizeof(num[0])); 
  8.     printf("%d\n",answer); 
  9.     num[0] = 2;//可以修改,因为声明的时候不是const! 
  10.     printf("%d\n",num[0]); 
  11.     return 0; 
  12.  
  13. int sum(const int ar[],int n){ 
  14.     int result = 0; 
  15.     int index; 
  16.  
  17.     for(index=0;index<n;index++){ 
  18.         result += ar[index]; 
  19.     } 
  20.     //ar[0] = 2;会出错!不能更改const数组的元素的值 
  21.     return result; 

const关键字的作用

1.可以创建数组常量

2.可以创建指向常量的指针,该指针不能用于修改值,但是可以指向其他地址

3.可以创建常量指针,该指针不能指向其他地址,但是可以用于修改值

4.可以创建指向常量的常量指针,该指针既不能修改值,也不能指向其他地址

注意的规则

1.将常量或非常量数据的地址赋给指向常量的指针是合法的

2.只有非常量数据的地址才可以赋给普通指针

3.所以函数形参声明为const的指针,既可以接收普通数组,也可以接收常量数组,两种参数都可以赋给常量指针。反之没有声明为const的指针,只能接受普通数组,不能接受常量数组!

 

  1. #include<stdio.h> 
  2.  
  3. int main(void){ 
  4.     const int array1[] = {1,2,3};//声明一个常量数组 
  5.     int array2[] = {1,2,3} 
  6.  
  7.     //array1[0] = 2;编译错误,常量数组不能被修改; 
  8.  
  9.     const int *pd = array2;//指向常量的指针可以被赋予普通数组 
  10.     //*pd = 2;编译错误,指向常量的指针不能修改数组的值 
  11.     array2[0] = 2;//允许,因为array2不是常量数组 
  12.     pd++;//允许,pd不是常量指针,所以可以更改指向的对象 
  13.  
  14.     double rates[5] = {1,2,3,4,5}; 
  15.     const double locked[5] = {1,2,3,4,5}; 
  16.     const double *pc =rates;//普通数组可以赋值给指向常量的指针 
  17.     double *pnc = rates;//普通数组可以赋值给普通指针 
  18.     pc = locked;//常量数组可以赋值给指向常量的指针 
  19.     //pnc = locked;编译错误,常量数组不能赋值给普通指针 
  20.     double const *pncc = rates; 
  21.     *pncc = 2;//常量指针可以修改指向的内容 
  22.     pcnn++;//编译错误,常量指针不能改变指向 
  23.     const double const *pnccc = rates;//指向常量的常量指针既不能改变指向的内容,也不能改变指向