C Primer Plus 第十章 课后答案

目录

 

复习题

1.下面的程序将打印什么内容

2.在复习题1中，ref有多少个元素

3.在复习题1中，ref的地址是什么？ref + 1是什么意思？++ref指向什么

4.在下面的代码中，*ptr和*(ptr + 2)的值分别是什么

a.

int *ptr; int torf[2][2] = {12, 14, 16};

ptr = torf[0];

b.

int * ptr;

int fort[2][2] = { {12}, {14,16} };

ptr = fort[0];

5.在下面的代码中，**ptr和**(ptr + 1)的值分别是什么？

a.

int (*ptr)[2];

int torf[2][2] = {12, 14, 16};

ptr = torf;

b.

int (*ptr)[2];

int fort[2][2] = { {12}, {14,16} };

ptr = fort;

6.假设有下面的声明：

int grid[30][100];

a.用1种写法表示grid[22][56]的地址

b.用2种写法表示grid[22][0] 的地址

c.用3种写法表示grid[0][0]的地址

7.正确声明以下各变量：

a.digits是一个内含10个int类型值的数组

b.rates是一个内含6个float类型值的数组

c.mat是一个内含3个元素的数组，每个元素都是内含5个整数的数组

d.psa是一个内含20个元素的数组，每个元素都是指向int的指针

e.pstr是一个指向数组的指针，该数组内含20个char类型的值

8.

a.声明一个内含6个int类型值的数组，并初始化各元素为1、2、4、8、16、32

b.用数组表示法表示a声明的数组的第3个元素（其值为4）

c.假设编译器支持C99/C11标准，声明一个内含100个int类型值的数组，并初始化最后一个元素为-1，其他元素不考虑

d.假设编译器支持C99/C11标准，声明一个内含100个int类型值的数组，并初始化下标为5、10、11、12、3的元素为101，其他元素不考虑

9.内含10个元素的数组下标范围是什么

10.假设有下面的声明：

float rootbeer[10], things[10][5], *pf, value = 2.2;

int i = 3;

判断以下各项是否有效：

a.rootbeer[2] = value;

b.scanf("%f", &rootbeer );

c.rootbeer = value;

d.printf("%f", rootbeer);

e.things[4][4] = rootbeer[3];

f.things[5] = rootbeer;

g.pf = value; h.pf = rootbeer;

11.声明一个800×600的int类型数组

12.下面声明了3个数组：

double trots[20];

short clops[10][30];

long shots[5][10][15];

a.分别以传统方式和以变长数组为参数的方式编写处理trots数组的void函数原型和函数调用 b.分别以传统方式和以变长数组为参数的方式编写处理clops数组的void函数原型和函数调用

c.分别以传统方式和以变长数组为参数的方式编写处理shots数组的void函数原型和函数调用

13.下面有两个函数原型：

void show(const double ar[], int n); // n是数组元素的个数

void show2(const double ar2[][3], int n); // n是二维数组的行数

a.编写一个函数调用，把一个内含8、3、9和2的复合字面量传递给show()函数。

b.编写一个函数调用，把一个2行3列的复合字面量（8、3、9作为第1行，5、4、1作为第2行）传递给show2()函数

编程练习

1.修改程序清单10.7的rain.c程序，用指针进行计算（仍然要声明并初始化数组）

2.编写一个程序，初始化一个double类型的数组，然后把该数组的内容拷贝至3个其他数组中（在main()中声明这4个数组）。使用带数组表示法的函数进行第1份拷贝。使用带指针表示法和指针递增的函数进行第2份拷贝。把目标数组名、源数组名和待拷贝的元素个数作为前两个函数的参数。第3个函数以目标数组名、源数组名和指向源数组最后一个元素后面的元素的指针。也就是说，给定以下声明，则函数调用如下所示：

double source[5] = {1.1, 2.2, 3.3, 4.4, 5.5};

double target1[5];

double target2[5];

double target3[5];

copy_arr(target1, source, 5);

copy_ptr(target2, source, 5);

copy_ptrs(target3, source, source + 5);

3.编写一个函数，返回储存在int类型数组中的最大值，并在一个简单的程序中测试该函数

4.编写一个函数，返回储存在double类型数组中最大值的下标，并在一个简单的程序中测试该函数

5.编写一个函数，返回储存在double类型数组中最大值和最小值的差值，并在一个简单的程序中测试该函数

6.编写一个函数，把double类型数组中的数据倒序排列，并在一个简单的程序中测试该函数

7.编写一个程序，初始化一个double类型的二维数组，使用编程练习2中的一个拷贝函数把该数组中的数据拷贝至另一个二维数组中（因为二维数组是数组的数组，所以可以使用处理一维数组的拷贝函数来处理数组中的每个子数组）

8.使用编程练习2中的拷贝函数，把一个内含7个元素的数组中第3～第5个元素拷贝至内含3个元素的数组中。该函数本身不需要修改，只需要选择合适的实际参数（实际参数不需要是数组名和数组大小，只需要是数组元素的地址和待处理元素的个数）

9.编写一个程序，初始化一个double类型的3×5二维数组，使用一个处理变长数组的函数将其拷贝至另一个二维数组中。还要编写一个以变长数组为形参的函数以显示两个数组的内容。这两个函数应该能处理任意N×M数组（如果编译器不支持变长数组，就使用传统C函数处理N×5的数组）

10.编写一个函数，把两个数组中相对应的元素相加，然后把结果储存到第 3 个数组中。也就是说，如果数组1中包含的值是2、4、5、8，数组2中包含的值是1、0、4、6，那么该函数把3、4、9、14赋给第3个数组。函数接受3个数组名和一个数组大小。在一个简单的程序中测试该函数

11.编写一个程序，声明一个int类型的3×5二维数组，并用合适的值初始化它。该程序打印数组中的值，然后各值翻倍（即是原值的2倍），并显示出各元素的新值。编写一个函数显示数组的内容，再编写一个函数把各元素的值翻倍。这两个函数都以数组名和行数作为参数

12.重写程序清单10.7的rain.c程序，把main()中的主要任务都改成用函数来完成

13.编写一个程序，提示用户输入3组数，每组数包含5个double类型的数（假设用户都正确地响应，不会输入非数值数据）。该程序应完成下列任务。

a.把用户输入的数据储存在3×5的数组中

b.计算每组（5个）数据的平均值

c.计算所有数据的平均值

d.找出这15个数据中的最大值

e.打印结果 每个任务都要用单独的函数来完成（使用传统C处理数组的方式）。

完成任务b，要编写一个计算并返回一维数组平均值的函数，利用循环调用该函数3次。对于处理其他任务的函数，应该把整个数组作为参数，完成任务c和d的函数应把结果返回主调函数

14.以变长数组作为函数形参，完成编程练习13

---

复习题

1.下面的程序将打印什么内容

#include　<stdio.h> 
int　main(void)
{ 
    int　ref[]　=　{　8,　4,　0,　2　}; 
    int *ptr; 
    int　index; 
    for　(index　=　0,　ptr　=　ref;　index　<　4;　index++,　ptr++) 
        printf("%d %d\n", ref[index], *ptr); 
    return　0; 
}

8 8

4 4

0 0

2 2

2.在复习题1中，ref有多少个元素

4

3.在复习题1中，ref的地址是什么？ref + 1是什么意思？++ref指向什么

1. 该数组的第一个元素的地址
2. 该数组第二个元素的地址
3. ++ref不是个有效的表达式，ref是常量，不是变量

4.在下面的代码中，*ptr和*(ptr + 2)的值分别是什么

a.

int *ptr; int torf[2][2] = {12, 14, 16};

ptr = torf[0];

b.

int * ptr;

int fort[2][2] = { {12}, {14,16} };

ptr = fort[0];

a.

12  16

b.

12  14//多维数组是按连续的存储空间存储的

5.在下面的代码中，**ptr和**(ptr + 1)的值分别是什么？

a.

int (*ptr)[2];

int torf[2][2] = {12, 14, 16};

ptr = torf;

b.

int (*ptr)[2];

int fort[2][2] = { {12}, {14,16} };

ptr = fort;

a.

12  16

b.

12  14

6.假设有下面的声明：

int grid[30][100];

a.用1种写法表示grid[22][56]的地址

b.用2种写法表示grid[22][0] 的地址

c.用3种写法表示grid[0][0]的地址

a.

&grid[22][56]

b.

grid[22]

&grid[22][0]

c.

grid

grid[0]

&grid[0][0]

7.正确声明以下各变量：

a.digits是一个内含10个int类型值的数组

b.rates是一个内含6个float类型值的数组

c.mat是一个内含3个元素的数组，每个元素都是内含5个整数的数组

d.psa是一个内含20个元素的数组，每个元素都是指向int的指针

e.pstr是一个指向数组的指针，该数组内含20个char类型的值

a. int gigits[10];

b. float rates[6];

c. int mat[3][5];

d. int *pas[20];

e. char (*pstr)[20];

8.

a.声明一个内含6个int类型值的数组，并初始化各元素为1、2、4、8、16、32

b.用数组表示法表示a声明的数组的第3个元素（其值为4）

c.假设编译器支持C99/C11标准，声明一个内含100个int类型值的数组，并初始化最后一个元素为-1，其他元素不考虑

d.假设编译器支持C99/C11标准，声明一个内含100个int类型值的数组，并初始化下标为5、10、11、12、3的元素为101，其他元素不考虑

a. int a[] = {1, 2, 4, 8, 16, 32};

b. a[2]

c. int a[]={[99] = -1};//可以指明或不指明数组大小，不指明默认100，指明比100小编译器报错

d. int a[100] = {[5] = 101, [10] = 101, 101, 101, [3] = 101};//不能写成[5] = [10] = ... = 101

9.内含10个元素的数组下标范围是什么

0-9

10.假设有下面的声明：

float rootbeer[10], things[10][5], *pf, value = 2.2;

int i = 3;

判断以下各项是否有效：

a.rootbeer[2] = value;

b.scanf("%f", &rootbeer );

c.rootbeer = value;

d.printf("%f", rootbeer);

e.things[4][4] = rootbeer[3];

f.things[5] = rootbeer;

g.pf = value; h.pf = rootbeer;

a. o        b. x        c. x        d. x        e. o        f. x      g. x

11.声明一个800×600的int类型数组

int a[800][600];

12.下面声明了3个数组：

double trots[20];

short clops[10][30];

long shots[5][10][15];

a.分别以传统方式和以变长数组为参数的方式编写处理trots数组的void函数原型和函数调用 b.分别以传统方式和以变长数组为参数的方式编写处理clops数组的void函数原型和函数调用

c.分别以传统方式和以变长数组为参数的方式编写处理shots数组的void函数原型和函数调用

a.
void func(double []);
void func(int, double [*]);

/*
题目说的是调用- -自闭
void func(double a[]){}
void func(int a, double b[a]){}
*/
func(trots);
func(20, trots);

b.
void func(short [][30]);
void func(int, int, short [*][*]);

/*
void func(short a[][30]){}
void func(int a, int b, short c[a][b]){}
*/
func(clops);
func(10, 30, clops);

c.
void func(long [][10][15]);
void func(int, int, int, long[*][*][*]);

/*
void func(long a[][10][15]){}
void func(int a, int b, int c, long d[a][b][c]){}
*/
func(shots);
func(5, 10, 15, shots);

13.下面有两个函数原型：

void show(const double ar[], int n); // n是数组元素的个数

void show2(const double ar2[][3], int n); // n是二维数组的行数

a.编写一个函数调用，把一个内含8、3、9和2的复合字面量传递给show()函数。

b.编写一个函数调用，把一个2行3列的复合字面量（8、3、9作为第1行，5、4、1作为第2行）传递给show2()函数

a.
void show((double []){8, 3, 9, 2}, 4);
b.
void show((double [][3]){{8, 3, 9},{5, 4, 1}}, 6);//二维里的3不能落下

编程练习

1.修改程序清单10.7的rain.c程序，用指针进行计算（仍然要声明并初始化数组）

#include <stdio.h>
#include <stdlib.h>

#define MONTHS 12   // 一年的月份数
#define YEARS  5    // 年数
int main(void)
{ // 用2010～2014年的降水量数据初始化数组
    const float rain[YEARS][MONTHS] =
    {
        { 4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.4, 3.5, 6.6 },
        { 8.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9, 0.3, 0.9, 1.4, 7.3 },
        { 9.1, 8.5, 6.7, 4.3, 2.1, 0.8, 0.2, 0.2, 1.1, 2.3, 6.1, 8.4 },
        { 7.2, 9.9, 8.4, 3.3, 1.2, 0.8, 0.4, 0.0, 0.6, 1.7, 4.3, 6.2 },
        { 7.6, 5.6, 3.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2 }
    };
    int year, month;
    float subtot, total;
    printf(" YEAR   RAINFALL  (inches)\n");
    for (year = 0, total = 0; year < YEARS; year++)
    {             // 每一年，各月的降水量总和
        for (month = 0, subtot = 0; month < MONTHS; month++)
            subtot += *(*(rain + year) + month);
        printf("%5d %15.1f\n", 2010 + year, subtot);
        total += subtot;  // 5年的总降水量
    }
    printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);
    printf("MONTHLY AVERAGES:\n\n");
    printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct ");
    printf(" Nov  Dec\n");
    for (month = 0; month < MONTHS; month++)
    {             // 每个月，5年的总降水量
        for (year = 0, subtot = 0; year < YEARS; year++)
            subtot += *(*(rain + year) + month);
        printf("%4.1f ", subtot / YEARS);
    }
    printf("\n");
    return 0;
}

2.编写一个程序，初始化一个double类型的数组，然后把该数组的内容拷贝至3个其他数组中（在main()中声明这4个数组）。使用带数组表示法的函数进行第1份拷贝。使用带指针表示法和指针递增的函数进行第2份拷贝。把目标数组名、源数组名和待拷贝的元素个数作为前两个函数的参数。第3个函数以目标数组名、源数组名和指向源数组最后一个元素后面的元素的指针。也就是说，给定以下声明，则函数调用如下所示：

double source[5] = {1.1, 2.2, 3.3, 4.4, 5.5};

double target1[5];

double target2[5];

double target3[5];

copy_arr(target1, source, 5);

copy_ptr(target2, source, 5);

copy_ptrs(target3, source, source + 5);

#include <stdio.h>
#include <stdlib.h>

void copy_arr(double *target1, double *source, int n)
{
    for(int i = 0; i < n; i++)
    {
        target1[i] = source[i];
    }
}
void copy_ptr(double *target2, double *source, int n)
{
    for(int i = 0; i < n; i++)
    {
        *(target2 + i) =  *(source + i);
    }
}
void copy_ptrs(double *target3, double *source1, double *source2)
{
    double *i;
    int j;
    for(i = source1, j = 0; i < source2; i++, j++)
    {
        *(target3 + j) = *i;
    }
}

void xxx(double a[])
{
    for(int i = 0; i < 5; i++)
    {
        printf("%.1lf ", a[i]);
    }
    printf("\n");
}

int main(void)
{
    double source[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
    double target1[5];
    double target2[5];
    double target3[5];
    xxx(source);
    copy_arr(target1, source, 5);
    copy_ptr(target2, source, 5);
    copy_ptrs(target3, source, source + 5);
    xxx(target1);
    xxx(target2);
    xxx(target3);
    return 0;
}

3.编写一个函数，返回储存在int类型数组中的最大值，并在一个简单的程序中测试该函数

#include <stdio.h>
#include <stdlib.h>

int maxa(int a[], int n)
{
    /*
    不能写 sizeof(a) / sizeof(int), a是指针，大小和int一样, 把形参改为a[10]也不行
    int x = sizeof(a) / sizeof(int);
    printf("%d\n", x);
    */
    int num = 0;
    while(n--)
    {
        num = num > a[n] ? num : a[n];
        //不知道为什么，写成 num = num > a[n] ? : a[n] 的话，在a[4]那里返回值会让num变成1
    }
    return num;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    int a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    printf("%d\n", maxa(a, n));
    return 0;
}
/*
测试数据
10
4 3 2 1 0 9 8 7 6 5
*/

4.编写一个函数，返回储存在double类型数组中最大值的下标，并在一个简单的程序中测试该函数

#include <stdio.h>
#include <stdlib.h>

double maxa(double a[], int n)
{
    double num = 0;
    while(n--)
    {
        num = num > a[n] ? num : a[n];
    }
    return num;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    double a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    printf("%lf\n", maxa(a, n));
    return 0;
}
/*
测试数据
10
4 3 2 1 0 9 8 7 6 5
*/

5.编写一个函数，返回储存在double类型数组中最大值和最小值的差值，并在一个简单的程序中测试该函数

#include <stdio.h>
#include <stdlib.h>
#include <float.h>

double maxsmin(double a[], int n)
{
    double num1 = 0;
    double num2 = DBL_MAX;
    while(n--)
    {
        num1 = num1 > a[n] ? num1 : a[n];
        num2 = num2 > a[n] ? a[n] : num2;
    }
    return num1 - num2;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    double a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    printf("%lf\n", maxsmin(a, n));
    return 0;
}
/*
测试数据
10
4 3 2 1 0 9 8 7 6 5
*/

6.编写一个函数，把double类型数组中的数据倒序排列，并在一个简单的程序中测试该函数

/*顺便复习了下快排- -，打印了交换过程*/
#include <stdio.h>
#include <stdlib.h>
#include <float.h>

void func(double a[])
{
    for(int i = 0; i < 10; i++)
    {
        printf("%.0lf ", a[i]);
    }
    printf(" | ");
}

int xx(double a[], int s, int e)
{
    double t = a[s];
    double x = a[s];
    while(s < e)
    {
        while(s < e && a[e] <= x)
        {
            e--;
        }
        a[s] = a[e];
        func(a);
        printf("%d %d s = %.0lf\n", s, e, a[s]);
        while(s < e && a[s] >= x)
        {
            s++;
        }
        a[e] = a[s];
        func(a);
        printf("%d %d e = %.0lf\n", s, e, a[e]);
    }
    a[s] = t;
    return s;
}

void sortd(double a[], int s, int e)
{
    if(s < e)
    {
        int x = xx(a, s, e);
        printf("-------------------------------\n");
        sortd(a, s, x - 1);
        sortd(a, x + 1, e);
    }
}

int main(void)
{
    int n;
    scanf("%d", &n);
    double a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    sortd(a, 0, n - 1);
    for(int i = 0; i < n; i++)
    {
        printf("%.1lf ", a[i]);
    }
    printf("\n");
    return 0;
}
/*
测试数据
10
4 3 5 1 0 9 2 7 6 8
*/

7.编写一个程序，初始化一个double类型的二维数组，使用编程练习2中的一个拷贝函数把该数组中的数据拷贝至另一个二维数组中（因为二维数组是数组的数组，所以可以使用处理一维数组的拷贝函数来处理数组中的每个子数组）

#include <stdio.h>
#include <stdlib.h>

void copy_ptrs(double *target3, double *source1, double *source2)
{
    double *i;
    int j;
    for(i = source1, j = 0; i < source2; i++, j++)
    {
        *(target3 + j) = *i;
    }
}

int main(void) {
    //double a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    double a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    double b[3][3];//不能写成b[][3];
    //不能写成copy_ptrs(b, a, a + 9), b的类型是(double*)[3], a同理
    for (int i = 0; i < 3; i++)
    {
        copy_ptrs(b[i], a[i], a[i] + 3);
    }
    /*
    for(int i = 0; i < 9; i++)
    {
        printf("%.0lf ", *(*b + i));//不能写成*(b + i), 只有int型元素可以通过控制地址位置取值，b是数组的指针,即(double*)[3]，*b才是元素的指针
    }
    printf("\n");
    printf("%p %p\n", b, *b);              000000000061FDA0 000000000061FDA0
    printf("%p %p\n", b + 1, *b + 1);      000000000061FDB8 000000000061FDA8
    */
    for (int j = 0; j < 3; ++j)
    {
        for (int i = 0; i < 3; ++i)
        {
            printf("%.0lf ", b[j][i]);
        }
        printf("\n");
    }
    return 0;
}

8.使用编程练习2中的拷贝函数，把一个内含7个元素的数组中第3～第5个元素拷贝至内含3个元素的数组中。该函数本身不需要修改，只需要选择合适的实际参数（实际参数不需要是数组名和数组大小，只需要是数组元素的地址和待处理元素的个数）

#include <stdio.h>
#include <stdlib.h>

void copy_ptrs(double *target3, double *source1, double *source2)
{
    double *i;
    int j;
    for(i = source1, j = 0; i < source2; i++, j++)
    {
        *(target3 + j) = *i;
    }
}

int main(void)
{
    double a[] = {1, 2, 3, 4, 5, 6, 7};
    double b[3];
    copy_ptrs(b, a + 2, a + 5);
    for (int i = 0; i < 3; ++i) {
        printf("%.0lf ", b[i]);
    }
    return 0;
}

9.编写一个程序，初始化一个double类型的3×5二维数组，使用一个处理变长数组的函数将其拷贝至另一个二维数组中。还要编写一个以变长数组为形参的函数以显示两个数组的内容。这两个函数应该能处理任意N×M数组（如果编译器不支持变长数组，就使用传统C函数处理N×5的数组）

#include <stdio.h>
#include <stdlib.h>

void xx(int a, int b, double c[a][b], double d[a][b])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            d[i][j] = c[i][j];
        }
    }
}

void xxx(int a, int b, double c[a][b])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            printf("%-2.0lf ", c[i][j]);
        }
        printf("\n");
    }
}

int main(void)
{
    double a[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    double b[3][5];
    xx(3, 5, a, b);
    xxx(3, 5, a);
    xxx(3, 5, b);
    return 0;
}

10.编写一个函数，把两个数组中相对应的元素相加，然后把结果储存到第 3 个数组中。也就是说，如果数组1中包含的值是2、4、5、8，数组2中包含的值是1、0、4、6，那么该函数把3、4、9、14赋给第3个数组。函数接受3个数组名和一个数组大小。在一个简单的程序中测试该函数

#include <stdio.h>
#include <stdlib.h>

void xxx(int a, int b[a], int c[a], int d[a])
{
    for (int i = 0; i < a; ++i) {
        d[i] = b[i] + c[i];
    }
}

int main(void)
{
    int a;
    scanf("%d", &a);
    int b[a], c[a], d[a];
    for (int i = 0; i < a; ++i) {
        scanf("%d", b + i);
    }
    for (int i = 0; i < a; ++i) {
        scanf("%d", c + i);
    }
    xxx(a, b, c, d);
    for (int i = 0; i < a; ++i) {
        printf("%d ", d[i]);
    }
    return 0;
}

11.编写一个程序，声明一个int类型的3×5二维数组，并用合适的值初始化它。该程序打印数组中的值，然后各值翻倍（即是原值的2倍），并显示出各元素的新值。编写一个函数显示数组的内容，再编写一个函数把各元素的值翻倍。这两个函数都以数组名和行数作为参数

#include <stdio.h>
#include <stdlib.h>

void xxx(int a, int b[][5])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < 5; ++j) {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
}

void xx(int a, int b[][5])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < 5; ++j) {
            b[i][j] *= 2;
        }
    }
}

int main(void)
{
    int a[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    xxx(3, a);
    xx(3, a);
    xxx(3, a);
    return 0;
}

12.重写程序清单10.7的rain.c程序，把main()中的主要任务都改成用函数来完成

#include <stdio.h>
#include <stdlib.h>

#define MONTHS 12   // 一年的月份数
#define YEARS  5    // 年数

void yearaver(const float rain[YEARS][MONTHS])
    {
    int year, month;
    float subtot, total;
    printf(" YEAR   RAINFALL  (inches)\n");
    for (year = 0, total = 0; year < YEARS; year++)
    {             // 每一年，各月的降水量总和
        for (month = 0, subtot = 0; month < MONTHS; month++)
            subtot += *(*(rain + year) + month);
        printf("%5d %15.1f\n", 2010 + year, subtot);
        total += subtot;  // 5年的总降水量
    }
    printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);
}

void monthaver(const float rain[YEARS][MONTHS])
{
    int year, month;
    float subtot, total;
    printf("MONTHLY AVERAGES:\n\n");
    printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct ");
    printf(" Nov  Dec\n");
    for (month = 0; month < MONTHS; month++)
    {             // 每个月，5年的总降水量
        for (year = 0, subtot = 0; year < YEARS; year++)
            subtot += *(*(rain + year) + month);
        printf("%4.1f ", subtot / YEARS);
    }
    printf("\n");
}

int main(void)
{ // 用2010～2014年的降水量数据初始化数组
    const float rain[YEARS][MONTHS] =
            {
                    { 4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.4, 3.5, 6.6 },
                    { 8.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9, 0.3, 0.9, 1.4, 7.3 },
                    { 9.1, 8.5, 6.7, 4.3, 2.1, 0.8, 0.2, 0.2, 1.1, 2.3, 6.1, 8.4 },
                    { 7.2, 9.9, 8.4, 3.3, 1.2, 0.8, 0.4, 0.0, 0.6, 1.7, 4.3, 6.2 },
                    { 7.6, 5.6, 3.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2 }
            };
    yearaver(rain);
    monthaver(rain);
    return 0;
}

13.编写一个程序，提示用户输入3组数，每组数包含5个double类型的数（假设用户都正确地响应，不会输入非数值数据）。该程序应完成下列任务。

a.把用户输入的数据储存在3×5的数组中

b.计算每组（5个）数据的平均值

c.计算所有数据的平均值

d.找出这15个数据中的最大值

e.打印结果 每个任务都要用单独的函数来完成（使用传统C处理数组的方式）。

完成任务b，要编写一个计算并返回一维数组平均值的函数，利用循环调用该函数3次。对于处理其他任务的函数，应该把整个数组作为参数，完成任务c和d的函数应把结果返回主调函数

#include <stdio.h>
#include <stdlib.h>

double aver(double a[5])
{
    double sum = 0;
    for (int i = 0; i < 5; ++i) {
        sum += a[i];
    }
    return sum / 5;
}

double allaver(double a[3][5])
{
    double sum = 0;
    for (int i = 0; i < 3; ++i) {
        sum += aver(a[i]);
    }
    return sum / 3;
}

double maxx(double* a, double* b)
{
    double max = 0;
    for(;a < b; a++)
    {
        max = max > *a ? max : *a;
    }
    return max;
}

int main(void)
{
    double a[3][5];
    for (int i = 0; i < 3; ++i)
    {
        printf("input a sequence of 5 number:");
        for (int j = 0; j < 5; ++j) {
            scanf("%lf", &a[i][j]);
        }
    }
    double sum = 0;
    for (int k = 0; k < 3; ++k) {
        printf("%.2lf ", aver(a[k]));
    }
    printf("\n");
    printf("%.2lf\n", allaver(a));
    printf("%.2lf\n", maxx(*a, *a + 15));
    return 0;
}

14.以变长数组作为函数形参，完成编程练习13

#include <stdio.h>
#include <stdlib.h>

double aver(int a, double b[a])
{
    double sum = 0;
    for (int i = 0; i < a; ++i) {
        sum += b[i];
    }
    return sum / 5;
}

double allaver(int b, int c, double a[b][c])
{
    double sum = 0;
    for (int i = 0; i < b; ++i) {
        sum += aver(c, a[i]);
    }
    return sum / 3;
}

double maxx(int a, int b, double c[a][b])
{
    double max = 0;
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            max = max > c[i][j] ? max : c[i][j];
        }
    }
    return max;
}

int main(void)
{
    double a[3][5];
    for (int i = 0; i < 3; ++i)
    {
        printf("input a sequence of 5 number:");
        for (int j = 0; j < 5; ++j) {
            scanf("%lf", &a[i][j]);
        }
    }
    double sum = 0;
    for (int k = 0; k < 3; ++k) {
        printf("%.2lf ", aver(5, a[k]));
    }
    printf("\n");
    printf("%.2lf\n", allaver(3, 5, a));
    printf("%.2lf\n", maxx(3, 5, a));
    return 0;
}