可以用数组名作函数参数，此时实参与形参都应用数组名（或指针变量）。
 
例2：有一个一维数组score，内放10个学生成绩，求平均成绩。
 
float average(float array[10]){
 
       
 
      int i;
 
      float aver,sum=array[0];    
 
           for(i=1; i<10; i++)sum=sum+array[i];
 
           aver=sum/10;
 
           return aver;
 
}
 
 
 
main(){
 
       
 
    float score[10],aver;      
 
         int i;
 
         printf("input 10 scores:/n");
 
         for(i=0; i<10; i++)scanf("%f",&score[i]);
 
         printf("/n");
 
         aver=average(score);//数组名作为函数参数
 
         printf("average score is %5.2f",aver);
 
}
 
 
 
 
 
说明：
 
l         用数组名称作函数参数，应该在主调函数和被调函数分别定义数组，本例中array是形参数组名，score是实参数组名，分别在其所在的函数中定义，不能只在一方定义。
 
l         实参数组与形参数组类型应该保持一致（这里都为float型），如不一致，结果将出错。
 
l         在被调用函数中声明了形参数组的大小为10，但在实际上，指定其大小是不起任何作用的，因为C编译器对形参数组大小不做检查，只是检查实参数组的首地址传给形参数组。因此，score[n]和array[n]指的是同一单元。
 
l         形参数组也可以不指定大小，在定义数组时在数组名后面跟一个空的方括号，有时为了在被调用函数中处理数组元素的需要，可以另设一个参数，传递需要处理的数组元素的个数，上例可以改写为下面的形式：
 
 
 
float average(float array[], int n){
 
      int i;
 
      float aver,sum=array[0];    
 
           for(i=1; i<n; i++)sum=sum+array[i];
 
           aver=sum/n;
 
           return aver;
 
}
 
 
 
main(){
 
    float score_1[5]={98.5,97,91.5,60,55};       
 
    float score_2[10]={67.5,89.5,99,69.5,77,89.5,76.5,54,60,99,5};       
 
         printf("the average of class A is %6.2f/n", average(score_1, 5));
 
         printf("the average of class B is %6.2f/n", average(score_2, 10));
 
}
 
 
 
可以看出，两次调用average函数时，需要处理的数组元素是不同的，在第一次调用时用一个实参5传递给形参n，表示求前面5个学生的平均分数。第二次调用时，求10个学生平均分。
 
 
 
l         最后应该说明一点：用数组名作为函数实参的时，不是吧数组元素的值传递给形参，而是把实参数组的起始地址传递给形参数组，这样两个数组就共占同一段内存单元。见下图：
 
 
 
 
 
    
 
     
起始地址1000
 
    
 
 
    a[0]              a[1]            a[2]          a[3]         a[4]           a[5]          a[6]         a[7]          a[8]       a[9]
 
 
 
 
2
 
 
4
 
 
6
 
 
8
 
 
10
 
 
12
 
 
14
 
 
16
 
 
18
 
 
20
 
 
 
          b[0]             b[1]             b[2]          b[3]         b[4]           b[5]          b[6]         b[7]         b[8]       b[9]
 
 
 
假如a的起始地址为1000，则b数组的起始地址也是1000，显然a和b同占一段内存单元，a[0]和b[0]同占一个内存单元……。由此，我们可以看到，形参数组中各个元素的值如果发生变化会使实参数组元素的值同时发生变化，从上图是很容易理解的。这一点与变量做函数参数的情况是不同的，务必注意！在程序设计中可以有意识地利用这一点，改变实参数组元素（如排序）。
 
最后，再给出一个例子：用选择排序法对数组中，10个整数按有小到大排序。所谓选择排序就是先将10个数中最小的数与a[0]对换；再将a[1]到a[9]中最小的数与a[1]对换……，每比较一轮，我们可以找出一个未经排序的数中最小的一个。共比较9论。
 
a[0]     a[1]   a[2]    a[3]    a[4]
 
                                    3        6        1         9       4
 
                                    1        6        3         9       4
 
                                    1        3        6         9       4
 
                                    1        3        4         9       6
 
                                    1        3        4         6       9
 
 
 
我们可以看到在执行函数调用语句sort（a，10）；之前和之后，a数组各元素的值是不一样的。原来是无序的，执行sort（a，10）之后是有序的。这也就是所谓的形参数组改变也可以使实参数组随之改变。
 
 
 
现在，我们已经知道了，当用数组名作函数参数时，如果形参数组中各元素的值发生了变化，实参数组元素的值也随之变化。那么这是为什么呢？如果你学过指针，这个问题就很容易来回答。
 
我们先看数组元素做实参时的情况。如果已经定义了一个函数，其原型为：
 
Void swap(int x, int y);
 
假设函数的作用是将两个形参（x，y）的值进行交换，现在我们这样调用这个函数：
 
Swap(a[1], a[2]);
 
用数组元素a[1], a[2]做实参的情况与变量做实参时一样，是“值传递”方式，我们将a[1], a[2]的值单向传递给x，y。当x和y的值改变时a[1], a[2]的值并不改变。
 
我们现再看用数组名作函数参数的情况。前面已经介绍，实参数组名代表该数组首元素的地址。而形参是用来接收从实参传递过来的数组首元素的地址。因此形参应该是一个指针变量。实际上，C编译器都是将形参数组名作为指针变量来处理的。例如：
 
我们定义一个被调函数f(int arr[], int n);，实际上，编译器是把arr按照指针变量来处理的，这相当于将函数f的首地址写成：f（int *arr，int n）。以上两种写法是等价的。
 
实际上，我们经常用这种方法调用一个函数来改变实参数组的值。
 
这里，给出一个表格，用于比较变量名作为函数参数和数组名作为函数参数。
 
 
 
 
 
 
实参类型
 
 
变量名
 
 
数组名
 
 
要求形参的类型
 
 
变量名
 
 
数组名或指针变量
 
 
传递的信息
 
 
变量的值
 
 
实参数组首元素的地址
 
 
通过函数调用能否改变实参的值
 
 
不能
 
 
能
 
 
 
 
 
注意：
 
l         在用数组名做函数实参的时候，既然实际上相应的形参是指针变量，为什么还允许使用形参数组的形式呢？
 
这是因为在C语言中，用下标法和指针法都可以访问一个数组，而且用下标法比较直观，便于理解。因此许多人愿意用数组名做形参，以便与实参数组对应。但从应用的角度讲，用户可以认为有一个形参数组，从实参数组那里得到起始地址，因此形参数组与实参数组共占一段内存单元，在调用函数期间，如果改变了形参数组的值，也就改变了实参数组的值。当然，在主调函数中我们可以使用这些改变了的值。实际上，对C语言比较熟悉的专业人士，往往比较喜欢用指针变量做形参。
 
l         再强调一点：实参数组名代表一个固定的地址，或者说是一个指针型常量，而形参数组并不代表一个固定的地址值。作为指针变量，在函数调用开始时，它的值等于实参数组起始地址，但在函数执行期间，它可以再被赋值。例如：
 
    f(arr[], int n){
 
   printf("%d/n", *arr);  //输出array[0]的值
 
   arr=arr+3; 
 
   printf("%d/n", *arr);  //输出array[3]的值
 
}

 
 
 

 
 
 
1、数组初始化：
 
 
数组元素的个数可以显示或隐式指定
 




 
  
int main()
  
{
  
int a[10] = {1,2};//其他没初始化元素，编译器默认帮你初始化为0
  
        int b[] = {1, 2};//编译器隐式指定长度为两个元素
  
        int c[20] = {0};
  
        for (i=0; i<10; i++)
  
        {
  
                  printf("%d ", a[i]);
  
        }
  
        memset(a, 0, sizeof(a));
  
        getchar();
  
}
  
 
 
 
 
2、数组名理解难点
 




 
  
int a[10]={1,2};
  
   printf("&a:%d,a:%d\n",&a,a);
  
   printf("&a+1:%d,a+1:%d\n", &a+1, a+1);
 
 
 
 
 数组首元素地址与数组地址：数组名a代表元素首地址,&a代表数组地址。
 
 
 数组首元素地址=数组地址即：a=&a
 
 
 &a+1代表的是加一个数组长度sizeof(a)，a+1代表的是加一个数组元素长度sizeof(a[0])
 
 
 一维数组名是一个指针常量
 
 
 二维数组名是一个数组指针,多维数组名也是一个数组指针,是指向一个低维数组的指针
 
 




 
  
char array[10][30];
  
        (array+i)          //相当于第i行的首地址      //二级指针
  
        （*(array+i)）    //一维数组的首地址          //一级指针
  
        *(array+i)+j    //相当于第i行第j列的地址  &array[i][j]
  
        *(*(array+i)+j)  //相当于第i行第j列的地址  array[i][j]
 
 
 
6、多维数组在物理内存中是线性存储的，只是编译器帮我们优化了
 




 
 
 
 
 
 
 
 
 
2、初学者数组类型三大难题
 
 
数组类型
 
 
数组指针：数组是一个指针，该指针是指向一个数组的指针（数组类型和数组指针的关系）
 
 
指针数组：指针是数组元素，也就是数组元素中存储的都是指针
 
 
 
 
 
1、       数组类型
 
 
C语言中的数组有自己特定的类型，数组的类型由元素类型和数组大小共同决定
 
 
1、定义一个数组类型：用数组定义变量
 




 
  
void main12()
  
{
  
        int i = 0;
  
        //定义一个数组类型
  
        typedef int MyArrayType[5];    //int 
  
        MyArrayType myArray;        //int myArray[5];
  
        for (i=0; i<5; i++)
  
        {
  
                  myArray[i] = i +1;
  
        }
  
        for (i=0; i<5; i++)
  
        {
  
                  printf("%d \n", myArray[i]);
  
        }
  
        system("pause");
  
}
 
 
 
2、定义一个数组类型，用数组顶一个数组类型的指针
 




 
  
void main13()
  
{
  
        int i = 0;    
  
        typedef int MyArrayType[5];   //定义一个数组类型 
  
MyArrayType *pArray = NULL; //定义了一个数组类型的指针
  
Int a[5]={0};
  
pArray = &a;
  
for (i=0; i<5; i++)          //我通过数组指针的方式来操作a[5]这块内存
  
        {
  
                  (*pArray)[i] = i+1;       //a[i] = i+1;
  
        }
  
        for (i=0; i<5; i++)
  
        {
  
                  printf("%d \n", (*pArray)[i]);
  
        }        
  
        system("pause");
  
}
 
 
 
 
 
 
2、       数组指针
 
 
定义数组指针
 







 
  
int i = 0;
  
        //这个是定义了一个类型，这个类型是数组类型
  
        typedef int MyArrayType[5]; //int 
  
//这个是定义了一个类型，定义了一个指针类型，定义了一个指向数组的指针类型。。。。
  
        typedef int (*MyPArrType)[5] ; //数组指针
  
        MyPArrType myPoint;        //
  
int b[5]; 
  
myPoint = &b;             //变量取地址给指针赋值
  
        for (i=0; i<5; i++)
  
        {
  
                  (*myPoint)[i] = i+1;
  
        }
  
        for (i=0; i<5; i++)
  
        {
  
                  printf("%d  ", (*myPoint)[i]);
  
        }        
  
        system("pause");
  
}
 
  
 
  
        1）：typedef int MyArrayType[5];    //定义一个数组类型
  
                  MyArrayType *pArray = NULL;   //定义了一个数组类型的指针
  
//这个是定义了一个类型，定义了一个指针类型，定义了一个指向数组的指针类型
  
        2）：typedef int (*MyPArrType)[5] ; //数组指针
  
                  MyPArrType myPoint; //int b[5]; 
  
        3）：int (*myArrayPoint)[5] ;   //告诉编译给我开辟四个字节内存
 
 
 
 
 
 
5、指针数组
 
 
1、指针数组与数组指针容易混淆
 




 
  
Char *p1[] = {“123”,”456”,”789”};
  
[]优先级高，先与p结合成为一个数组，再由char*说明这是一个字符型指针数组
  
//这是一个指针数组、数组3*4、三个一维数组的首地址存放在以指针作为元素的数组中
  
Char (*p2)[] = {“123”,”456”,”789”};
  
//编译器只分配4个字节，是一个指针，编译不通过、错误的方式
 
 
 
2、指针数组做函数参数退化
 




 
  
int printfArray(char *buf [30]);
  
int printfArray(char *buf[]);
  
int printfArray(char **buf);
 
 
 
 
 指针数组的两种用途
 
 菜单
 
       命令行
 
 
 指针数组自我结束的三种方法
 
 




 
  
  char*   c_keyword[] = {   "while", "case","static","do",'\0'};
  
char*  c_keyword[] = {"while", "case","static","do",0};
  
char*  c_keyword[] = {"while", "case","static","do",NULL};
 
 
 
 
 
 
 
 
 
 
 
 
6、当多维数组当做函数参数的话的时候会退化为指针
 













 
  
退化原因的本质是因为程序员眼中的二维内存，在物理内存上是线性存储
  
//总结：函数调用的时候，把数组首地址和有效数据长度传给被调用函数才是最正确的做法
 
  
一维数组做函数参数退化过程
  
//int a[10] -=-->int a[] ---->int *a
  
//数组做函数形参的时候，如果在形参中定义int a[10]语句，
  
//c/c++编译器会做优化，技术推演如下
  
//int a[10] -=-->int a[] ---->int *a
  
 
 
  
一维数组做函数参数退化过程
  
char buf[10][30])—》char buf[][30])----》char (*buf)[30])
  
 
 
  
int printfArray(char buf[10][30]);
  
int printfArray(char buf[][30]);
  
int printfArray(char (*buf)[30]);
  
这三者效果是一样的，也就验证了数组做函数参数退化为指针
 
 
 
第一种做法
 










 
  
int printfArray(int a[])
  
{
  
        int i = 0;
  
        printf("排序之前\n ");
  
        for (i=0; i<10; i++)
  
        {
  
                  printf("%d ", a[i]);
  
        }
  
        return 0;
  
}
 
  
第二种写法
 
  
int printfArray04(int *a, int num)
  
{
  
 
  
        int i = 0;
  
        printf("排序之前\n ");
  
        for (i=0; i<num; i++)
  
        {
  
                  printf("%d ", a[i]);
  
        }
  
        return 0;
  
}                                                              
 
 
 
 
 

























 
  
1、 C语言中只会以机械式的值拷贝的方式传递参数（实参把值传给形参）
 
  
int fun(char a[20], size_t b)
 {
    printf("%d\t%d",b,sizeof(a));
 }
 
  
原因1：高效
 
  
原因2：
 C语言处理a[n]的时候，它没有办法知道n是几，它只知道&a[0]是多少，它的值作为参数传递进去了
 虽然c语言可以做到直接int fun(char a[20])，然后函数能得到20这个数字，但是，C没有这么做。
 
  
2、二维数组参数同样存在退化的问题
 
  
二维数组可以看做是一维数组
  
二维数组中的每个元素是一维数组
  
二维数组参数中第一维的参数可以省略
  
void f(int a[5]) ====》void f(int a[]); ===》 void f(int* a);
  
void g(int a[3][3])====》 void g(int a[][3]); ====》 void g(int (*a)[3]);
 
  
3、等价关系
 
  
        
  
        数组参数                                              等效的指针参数
  
        
  
一维数组 char a[30]                                  指针 char*
  
指针数组 char *a[30]                               指针的指针 char **a
  
二维数组 char a[10][30]                          数组的指针 char(*a)[30]
 
 
 
 
 
 
 
 
 
 
 
 
7、数组操作基础以及中括号本质
 
 
//c语言里面没有字符串这种类型。通过字符数组来模拟字符串
 
 
//C风格字符串是以零结尾的字符串
 
 
//操作数组的方法:下标法和指针法
 
 
 
 







 
  
void main()
  
{
  
        int i = 0;
  
        char *p = NULL;
  
        //通过字符串初始化字符数组并且追加\0
  
        char buf4[] = "abcd";        
  
        for (i=0; i<strlen(buf4); i++)
  
        {
  
                  printf("%c", buf4[i]); //p[]
  
        }        
  
        //[] *的本质到底是什么？
  
        //*p 是我们程序员手工的（显示）去利用间接赋值
  
        //[] 只不过是，c/c++编译器帮我们做了一个*p的操作。。。。。。
  
        // buf4[i]======> buf4[0+i] ====>  *(buf4+i)
  
        //===*(buf4+i)   --> bu4[i];
  
        printf("\n");
  
        p = buf4;
  
        for (i=0; i<strlen(buf4); i++)
  
        {
  
                  printf("%c", *(p+i)); //*p 
  
        }
  
        system("pause");
  
}
 
  
void main12()
  
{
  
        //字符数组初始化
  
        //指定长度如果定义的长度剩余部分补充0
  
        char buf1[100] = {'a', 'b', 'c'};
  
        //不指定长度
  
        char buf2[] = {'a', 'b', 'c'};
  
        char buf3[] = {'a', 'b', 'c','\0'};
  
        //通过字符串初始化字符数组并且追加\0
  
        char buf4[] = "abcd";
  
        printf("%s\n", buf4 );
  
        printf("sizeof(buf4): %d\n ", sizeof(buf4)); 
  
//注意sizeof是对数据类型进行大小测量也就是数组类型包括了\0
  
        printf("strlen(buf4): %d \n", strlen(buf4));//strlen是求字符串的长度不包括\0
  
 
  
        system("pause");
  
}
 
 

 9.5.4  数组名作为函数的参数（1）
 
 在前面章节介绍函数时，曾介绍过用数组名作函数的实参和形参的情况。在学习指针变量之后，可以从指针角度对这种参数的传递进行理解。
 
 数组名就是数组的首地址，当实参向形参传送数组名时，实际上就是传送数组的地址，形参得到该地址后就与主调函数中的实参指向同一数组。这样，在被调函数中对数组元素的值进行修改返回主调函数后，通过实参同样可以访问到。这就解决了C函数只能使用return语句返回一个值的问题。当函数需要返回多个值给主调函数时，可使用数组作为函数的形参。
 
 同样，指针变量的值也是地址。在调用形参为数组的函数时，也可将指针作为实参传递给函数。
 
 1．一维数组作参数
 
 当向函数传递一维数组作实参时，只需要将数组名填入函数的形参部分即可。例如，编写一个函数，用于向屏幕中显示一个字符串。
 
 【程序9-15】
 
 
#include <stdio.h>  //头文件  
#include <stdlib.h> 
 
int main()  
{  
    void puts1(char s[]);  
    char s1[]="Hello,C Programer!";  
 
    puts1(s1);      //输出字符串  
    putchar('\n');  //输出换行符  
 
    system("pause");  
    return 0;  
}  
 
void puts1(char *s) //自定义函数  
{  
     for(i=0;s[i]!='\0';i++)  
         putchar(*s++);  
} 
 
 编译执行这段程序，得到如下结果，如图9-30所示。
 
  
 图9-30  执行结果
 
 在该程序中，编写自定义函数puts1()，用来输出一个字符串。在puts1()函数的定义部分，定义了该函数的形参为一个一维数组，该一维数组中保存着一个字符串。在函数中使用putchar()库函数逐个输出数组中的字符，直到字符串结束为止。字符串的最后一个字符为'\0'，所以第14行的循环以s[i]!='\0'作为条件。
 
 在main()函数中，调用puts()函数，将字符数组名s1作为实参传给函数，参数的传递过程相当于一个赋值语句
 
 
 
s=s1; 
 
 即将main()函数中的数组名s1（数组的首地址）传给形参中的数组名s。前面介绍过，数组名是一个指针常量，不允许修改其值。在C语言中，当函数的形参设置为数组时，C编译器会将其转换为指针。例如，本例中函数puts1()的函数头中将形参定义为数组s，实质是函数头与以下形式等价：
 
 
void puts1(char *s) 
 
 为了检验这种情况，可将函数puts1()代码改写为以下形式：
 
 
void puts1(char s[])  
{  
     for(;*s!='\0';)  
         putchar(*s++);  
} 
 
 在函数头部分，形参仍然采用数组形式，但在函数体的代码中，即可以使用s++来修改数组首地址，逐个输出其值。如果数组s不是函数的形参，而是函数内部定义的数组，则不允许使用这种方式。
 
 其实，在C语言程序设计中，程序员更喜欢用指针方式编写这类程序。例如，将puts1()函数改写为以下形式，应该更易读易懂。
 
 
 
void puts1(char *s)  
{  
     while(*s!='\0')  
         putchar(*s++);  
} 
 
 而表达式*s!= '\0'更可以精简为*s，因为当*s的值为'\0'时，表达式的值也就为0，循环结束；当*s的值不为0时，循环继续执行。在C语言中，类似这样的比较运算都可简写，省去关系表达式运算的环节，可提高程序的效率，同时使程序更简洁。修改后的程序如下：
 
 
 
void puts1(char *s)  
{  
     while(*s)  putchar(*s++);  
} 
 
 修改后的函数与程序9-15中函数完成相同的功能，main()函数不需要进行任何修改，即可得到同样的结果。
 
 2．二维数组作参数
 
 一维数组作为参数时比较简单，上面的例子演示了其使用方法。在使用一维数组作为参数时，也可使用指针的方式访问数组中的数据。
 
 也可根据需要向函数传递二维数组作为实参，有两种方法：一是使用指向数组元素的指针变量，其本质就是将二维数组作为一维数组来使用；二是使用指向一维（行）数组的指针变量。
 
 下面的程序演示使用指向一维数组的指针变量传递参数的形式。该程序让用户输入一个矩阵，然后计算矩阵对角线数据之和。
 
 【程序9-16】
 
 
#include <stdio.h>  //头文件  
#include <stdlib.h> 
 
#define M 4  
 
void read(int a[][M],int n);  
int sum(int a[][M],int n);  
 
int main()  
{  
    int a[M][M];  
 
    read(a,M);  
    printf("矩阵对角线元素之和为：%d\n",sum(a,M));  
 
    system("pause");  
    return 0;  
}  
 
void read(int a[][M],int n)  
{  
     int i,j;  
     for(i=0;i<n;i++)  
     {  
         printf("请输入矩阵第%d行的%d个数据:",i+1,n);  
         for(j=0;j<n;j++)  
             scanf("%d",&a[i][j]);  
      }  
}  
 
int sum(int a[][M],int n)  
{  
     int i,s=0;  
     for(i=0;i<n;i++)  
         s+=a[i][i];  
     return s;  
 } 
 
 

 
若用数组名作为函数调用时的实参，则实际上传递给形参的是数组首地址。
 
数组首地址数组第一个元素的地址。数组名字本身就是一个指针，它是一个指针常量，指向的地址不变。
 
比如定义了一个数组变量，编译器就会在内存中划分了一块地址空间给它，数组名这个指针常量就指向了这块内存空间的首地址，而数组首元素就存在这段内存空间的首地址处，即这段内存空间的首地址跟数组首元素的内存地址是一样的。
 

 
扩展资料：
 
形参的作用是实现主调函数与被调函数之间的联系，通常将函数所处理的数据，影响函数功能的因素或者函数处理的结果作为形参。
 
没有形参的函数在形参表的位置应该写void.main 函数也可以有形参和返回值，其形参也称为命令行参数，由操作系统在启动程序时初始化，其返回值传递给操作系统。
 
两者关系：
 
在一般传值调用的机制中只能把实参传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参值发生改变，而实参中的值不会变化。而在引用调用的机制当中是将实参引用的地址传递给了形参，所以任何发生在形参上的改变实际上也发生在实参变量上。