对于处理数组的函数，只能传递指针。为了防止修改数组，可以在函数形参声明中声明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.  
  14. int sum(const int ar[],int n){ 
  15.     int result = 0; 
  16.     int index; 
  17.  
  18.     for(index=0;index<n;index++){ 
  19.         result += ar[index]; 
  20.     } 
  21.     //ar[0] = 2;会出错！不能更改const数组的元素的值 
  22.     return result; 
  23. } 
 
  
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;//指向常量的常量指针既不能改变指向的内容，也不能改变指向 
  24. }