背景介绍

C语言中函数参数传递的两种方式（“引用传递做函数参数”是C++的特性，C语言不支持。）
（1）传值，就是把你的变量的值传递给函数的形式参数，实际就是用变量的值来新生成一个形式参数，因而在函数里对形参的改变不会影响到函数外的变量的值。
（2）传址，就是传变量的地址赋给函数里形式参数的指针，使指针指向真实的变量的地址，因为对指针所指地址的内容的改变能反映到函数外，也就是能改变函数外的变量的值。一般有变量地址作为参数、数组名作为参数、指针作为参数。

1. 数组名作为参数时，传递的是数组的首地址，实参数组和形参数组共用了一段内存空间。所以当用数组名做参数时，实参和形参共享了一个数组，形参数组的改变也就是实参数组的改变。
2. 指针作为参数和数组名作参数类似，传递的也是结构体数组的首地址，但是此时不是共享一个数组，而是共享一个变量的地址，也就是实参指针和形参指针共同指向同一个变量，共享同一个变量地址。

示例demo

下面的demo中：
test函数以结构体数组名为形参；
test1函数以结构体数组的首地址和数组大小作为形参；
test2函数是把结构体数组的首地址传入，然后以数组的形式遍历；

#include <stdio.h>
#include <string.h>

#define MAXNUM (2)

typedef struct tagNumber
{
    int i;
    int j;
    int k;
}TNum;

typedef struct tagNumbers
{
    TNum atNum[MAXNUM];
}TNums;


// 结构体数组名
void test (TNums atNums1[])
{
    printf("atNums1 ptr:%p\r\n",atNums1);
    
    int idx = 0; 
    int idx1 = 0;
    
    for(idx = 0; idx < MAXNUM; idx++)
    {
        for(idx1 = 0; idx1 < MAXNUM; idx1++)
        {
            printf("i:%d\n",atNums1[idx].atNum[idx1].i);
            printf("j:%d\n",atNums1[idx].atNum[idx1].j);
            printf("k:%d\n",atNums1[idx].atNum[idx1].k);
        }
    }
}

//结构体指针1.0
void test1(TNums *ptNum,int num)
{
    printf("ptNum ptr:%p\r\n",ptNum);
    int idx = 0; 
    int idx1 = 0;
    
    for(idx = 0; idx < num; idx++)
    {
        for(idx1 = 0; idx1 < num; idx1++)
        {
            printf("i:%d\n",(ptNum + idx)->atNum[idx1].i);
            printf("j:%d\n",(ptNum + idx)->atNum[idx1].j);
            printf("k:%d\n",(ptNum + idx)->atNum[idx1].k);
        }
    }
}

//结构体指针1.1
void test2(TNums *ptNum)
{
    printf("ptNum ptr:%p\r\n",ptNum);
    int idx = 0; 
    int idx1 = 0;
    
    for(idx = 0; idx < MAXNUM; idx++)
    {
        for(idx1 = 0; idx1 < MAXNUM; idx1++)
        {
            printf("i:%d\n",ptNum[idx].atNum[idx1].i);
            printf("j:%d\n",ptNum[idx].atNum[idx1].j);
            printf("k:%d\n",ptNum[idx].atNum[idx1].k);
        }
    }
}

int main() {

    TNums atNums[MAXNUM];
    memset(atNums, 0, sizeof(atNums));
    
    int idx = 0; 
    int idx1 = 0;
    for(idx = 0; idx < MAXNUM; idx++)
    {
        for(idx1 = 0; idx1 < MAXNUM; idx1++)
        {
            atNums[idx].atNum[idx1].i = 1+idx;
            atNums[idx].atNum[idx1].j = 2+idx;
            atNums[idx].atNum[idx1].k = 3+idx;
        }
    }
    
    printf("atNums ptr:%p\r\n",atNums);
    
    printf("func 1:\r\n");
    test(atNums);
    
    printf("func 2:\r\n");
    test1(atNums, MAXNUM);
    
    
    printf("func 3:\r\n");
    test2(atNums);
    return 0;
}

打印信息：

atNums ptr:0x7fff87dba270
func 1:
atNums1 ptr:0x7fff87dba270
i:1
j:2
k:3
i:1
j:2
k:3
i:2
j:3
k:4
i:2
j:3
k:4
func 2:
ptNum ptr:0x7fff87dba270
i:1
j:2
k:3
i:1
j:2
k:3
i:2
j:3
k:4
i:2
j:3
k:4
func 3:
ptNum ptr:0x7fff87dba270
i:1
j:2
k:3
i:1
j:2
k:3
i:2
j:3
k:4
i:2
j:3
k:4

引经据典

http://www.oh100.com/kaoshi/c/536660.html

结构体变量名代表的是整个集合本身，作为函数参数时传递的整个集合，也就是所有成员，而不是像数组一样被编译器转换成一个指针。（结构体变量传递给函数与基本变量传递给函数类似，可参考c函数传值调用和引用调用）

如果结构体成员较多，尤其是成员为数组时，传送的时间和空间开销会很大，影响程序的运行效率。所以最好的办法就是使用结构体指针，这时由实参传向形参的只是一个地址，非常快速。（结构体数组传递给函数与数组传递给函数类似）

一 形式参数

形式参数是一个结构体指针

void average(struct stu *ps, int len)

{...}

二 调用方式

结构体数组名是一个指向结构体数组中第一个元素的常量指针，将结构体数组名（常量指针）传递给函数

average(stus, len);

三 案列展示

#include <stdio.h>
struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在小组
    float score;  //成绩
}stus[] = {
    {"Li ping", 5, 18, 'C', 145.0},
    {"Zhang ping", 4, 19, 'A', 130.5},
    {"He fang", 1, 18, 'A', 148.5},
    {"Cheng ling", 2, 17, 'F', 139.0},
    {"Wang ming", 3, 17, 'B', 144.5}
};
void average(struct stu *ps, int len);
int main(){
    int len = sizeof(stus) / sizeof(struct stu);
    average(stus, len);
    return 0;
}
void average(struct stu *ps, int len){
    int i, num_140 = 0;
    float average, sum = 0;
    for(i=0; i<len; i++){
        sum += (ps + i) -> score;
        if((ps + i)->score < 140) num_140++;
    }
    printf("sum=%.2f\naverage=%.2f\nnum_140=%d\n", sum, sum/5, num_140);
}