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
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指向什么
- 该数组的第一个元素的地址
- 该数组第二个元素的地址
- ++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
#include
#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
#include
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
#include
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
#include
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
#include
#include
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
#include
#include
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
#include
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
#include
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
#include
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
#include
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
#include
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
#include
#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
#include
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
#include
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;
}