作业一

数组练习

1. 选择题

1.1、若有定义语句：int a[3][6]; ，按在内存中的存放顺序，a 数组的第10个元素是

a[0][4]                   B) a[1][3]                     C)a[0][3]                D)a[1][4]

解析：

从 a[0][0] 开始，第一行有 6 个元素，分别是 a[0][0] 到 a[0][5]，即第 1 到第 6 个元素。

接着从 a[1][0] 开始，第二行前 4 个元素是 a[1][0] 到 a[1][3]，即第 7 到第 10 个元素。

所以，第 10 个元素是 a[1][3]

解答：

B

1.2、有数组 int   a[5] = {10，20，30，40，50},  以下表达式编译错误是____________。

A)   a ++ ;

B)   a[5] =  20  ;

C)    a + 20  ;

D)   (a-3，   a[3]) ;

解析：

A) a++ ;

错误：a++ 是不合法的。

原因：在 C 语言中，数组名 a 是一个指向数组第一个元素的指针常量，它的值不可改变。也就是说，数组名 a 不能被自增，因为它是一个 常量指针，指向数组首地址，不能通过 ++ 操作改变。

B) a[5] = 20 ;

错误：虽然语法上没有问题，但会导致 数组越界 错误。

原因：a[5] 实际上是访问数组的第 6 个元素，而 a[5] 数组只有 5 个元素，索引范围是 a[0] 到 a[4]。因此，访问 a[5] 会导致 越界访问，尽管某些编译器可能不会报错，但这是一个逻辑错误。

C) a + 20 ;

正确：这个表达式不会编译错误。

原因：a + 20 是一个合法的指针运算。它将指针 a 偏移 20 个元素的位置，虽然这样做的结果可能是非法的地址访问，但仅仅是表达式本身不会导致编译错误。

D) (a-3, a[3]) ;

正确：这个表达式不会编译错误。

原因：这是一个逗号表达式，先计算 a-3（虽然结果无实际意义），然后计算 a[3]，最终返回 a[3] 的值。语法上没有问题。

解答：

A

1.3、以下错误的定义语句是 _______   

A）int   x[][3]  =  {{0},{1},{1,2,3}};

B）int   x[4][3]  =  {{1,2,3},{1,2,3},{1,2,3},{1,2,3}};

C）int                  x[4][]  =   {{1,2,3},{1,2,3},{1,2,3},{1,2,3}};

D）int                 x[][3]  =   {1,2,3,4};

解析：

A) int x[][3] = {{0}, {1}, {1, 2, 3}};

正确：这是合法的定义。

原因：二维数组在定义时，必须指定列的大小（本例中的 [3]）。行数可以省略，编译器会根据初始化的内容推断行数。每行的元素少于 3 时，未指定的元素会自动填充为 0。因此，这个定义是合法的。

B) int x[4][3] = {{1,2,3},{1,2,3},{1,2,3},{1,2,3}};

正确：这是合法的定义。

原因：明确定义了 4 行 3 列的二维数组，并且每行都初始化了 3 个元素，符合数组初始化规则。

C) int x[4][] = {{1,2,3},{1,2,3},{1,2,3},{1,2,3}};

错误：这是非法的定义。

原因：在声明二维数组时，列的大小必须明确指定，但这个语句没有为列指定大小（即 [] 是空的）。编译器无法推断每行有多少个元素，因此会报错。

D) int x[][3] = {1, 2, 3, 4};

正确：这是合法的定义。

原因：这是二维数组的另一种初始化方式。虽然看起来像是一维数组的初始化，但编译器会将 1, 2, 3, 4 填充到 [3] 列的二维数组中。结果是 x[0][0] = 1, x[0][1] = 2, x[0][2] = 3, x[1][0] = 4，其余的未初始化元素将被自动填充为 0。因此，这个定义也是合法的。

解答：

C

1.4、设int i,x[3][3]={1,2,3,4,5,6,7,8,9};则下面语句

　    　for(i=0;i<3;i++)

　　    printf(″%d, ″,x[i][2-i]);

的输出结果是               

   A)1, 4, 7     B)1, 5, 9    C)3, 6, 9    D)3, 5, 7

解析：

这里 x[i][2-i] 表示：

当 i = 0 时，x[0][2-0] = x[0][2] = 3

当 i = 1 时，x[1][2-1] = x[1][1] = 5

当 i = 2 时，x[2][2-2] = x[2][0] = 7

解答：

D

1.5、表达式“sizeof(int [1][2])/sizeof(int)”的值为_____。

A)  2       B)  3      C)  4      D)  5

解析：

sizeof(int [1][2])：

这个数组包含 1 行 2 列，总共有 1 × 2 = 2 个 int 元素。

每个 int 占 4 字节，因此整个数组的大小为 2 × 4 = 8 字节。

sizeof(int)：

这是单个 int 类型的大小，在大多数系统上为 4 字节。

解答：

A

1.6有以下程序

#include main()

{ char s[]="012xy\07s34f4w2";  

int i,n=0;

for(i=0;s[i]!=0;i++)

if(s[i]>='0'&&s[i]<='9')

 n++;

printf("%d\n",n);

}

程序运行后的输出结果是____________

A)0       B)3      C)7         D)8

解析：

字符数组 s[] 的内容为 "012xy\07s34f4w2"：

"012xy\07s34f4w2" 是一个字符串常量。

\07 是一个八进制转义字符，对应的值是 7。

这个字符串的实际内容是："012xy\x07s34f4w2"，它的长度是 14 个字符（包括 \07）。

但在这个程序中，八进制字符不会影响字符串的解析，它仅仅是作为一个不可见的字符。

for 循环 遍历整个字符串，直到遇到空字符 '\0' 为止。

在 if (s[i] >= '0' && s[i] <= '9') 中，检查当前字符是否为数字字符 '0' 到 '9'。如果是数字字符，则计数器 n 增加。

字符串 "012xy\07s34f4w2" 中的数字字符为：

'0', '1', '2', '3', '4', '4', '2'

一共 7 个数字字符。

解答：

C

1.7、有以下程序

#include   <stdio.h>

 main(   )

{ char s[ ]=”wstuv”; printf(“%c\n”,*s+2); 

}

程序运行后的输出结果是

A）t       B)  tuv      C）y      D)出错

解析：

s 是一个字符数组，数组名 s 是指向第一个元素的指针。

*s 解引用 s，表示数组的第一个元素 s[0]，即字符 'w'。

表达式 *s + 2：

*s 取的是 s[0]，即字符 'w'。

'w' 在 ASCII 码中的值是 119。

*s + 2 相当于 119 + 2 = 121，ASCII 码值 121 对应的字符是 'y'。

printf("%c\n", *s + 2); 输出的就是字符 'y'。

解答：

C 

1.8  数组  int  a[5] = {10， 20， 30， 40，50}, 有以下语句，其输出_______

       printf(“%d\n”， *（&a +1)    );

   A)  20    B)  30    C)  随机值   D）编译报错

解析：

&a 的含义：

&a 是 数组 a 的地址，它的类型是 int (*)[5]，即指向一个大小为 5 的整型数组的指针。

注意，这与 a 的地址（指向数组第一个元素 a[0] 的地址）是不同的。a 作为数组名时相当于 &a[0]，是一个指向第一个元素的指针，而 &a 是整个数组的地址。

&a + 1 的含义：

&a + 1：这个表达式实际上是将 &a （数组 a 的地址）偏移一个数组的大小。因为 &a 是一个指向整个数组的指针，偏移 1 意味着它指向了数组 a 之后的地址。

也就是说，&a + 1 实际上指向的是数组 a[5] 后面的内存位置。

*( &a + 1 ) 的含义：

*( &a + 1 ) 试图 解引用 偏移后的地址。由于 &a + 1 指向数组 a 之外的内存，这意味着该表达式取出的值是数组 a 之后的内存中的内容。

这里访问的是超出数组范围的内存空间，会导致未定义行为。因此，输出的值是 随机的，也就是不可预测的。

解答：

C

1.9  有以下程序

    # include <stdio.h>

int  main()

{ int   s[12]={1,2,3,4,4,3,2,1,1,1,2,3},  c[5]={0,0,0,0,0},  i  ;

for(i=0;i<12;i++)          c[s[i]]++  ;

for(i=1;i<5;i++) printf(“%d，”,c[i]);  printf(“\n”);

}

A) 4 ，3， 3， 2        B) 2 ，   3， 4， 4    

  C)  1， 2， 3 ，4      D ) 4， 4， 2 ，3

解析：

数组 s[12] 的初始化为：{1, 2, 3, 4, 4, 3, 2, 1, 1, 1, 2, 3}。

这个数组包含 12 个元素。

数组 c[5] 的初始化为：{0, 0, 0, 0, 0}。

这是一个用于统计出现次数的数组，c[i] 表示整数 i 在数组 s 中出现的次数。

for 循环统计元素出现次数：

c[s[i]]++ 根据数组 s[i] 的值，更新数组 c[] 的对应索引。

这意味着，数组 c 会记录数组 s 中数字 1 到 4 的出现次数。

数组 s 中每个数字的出现次数：

数字 1 出现了 4 次。

数字 2 出现了 3 次。

数字 3 出现了 3 次。

数字 4 出现了 2 次。

因此，数组 c 更新为：{0, 4, 3, 3, 2}。

输出部分：

for (i = 1; i < 5; i++) printf("%d，", c[i]);

该循环会打印数组 c[1] 到 c[4] 的值，也就是 4, 3, 3, 2。

解答：

 A

 1.10   有数组  int  a[3][4] = {10,20,30,40,50,60,70,80,90,100,110,120}，执行以下语句输出的是_______________

      printf(“%d\n”，  *(*a+2) + 3   );   

  A) 语句有错  B) 120     C)  30     D)  33

解析：

*a：

a 是一个二维数组，*a 代表 指向第一行的指针，也就是 a[0]，即地址 &a[0][0]，指向的是第一个元素 10。

*a + 2：

*a 是 a[0] 的首地址，即 &a[0][0]，加上 2 就是指向 a[0][2]，也就是 30 的地址。

*(*a + 2)：

这是对 a[0][2] 解引用，结果是 30。

*(*a + 2) + 3：

这一步是在 30 的基础上再加上 3，所以结果是 30 + 3 = 33

解答：

D

2、填空题

    2.1、有以下程序

#include   <stdio.h>

main(   )

{ int i,n[ ]={0,0,0,0,0};

for(i=1;i<=4;i++)

{n[i]=n[i-1]*3+1;

printf(“%d”,n[i]);}

}

程序运行后输出结果是 __________

解析：

当 i = 1：

n[1] = n[0] * 3 + 1 = 0 * 3 + 1 = 1

输出：1

当 i = 2：

n[2] = n[1] * 3 + 1 = 1 * 3 + 1 = 4

输出：4

当 i = 3：

n[3] = n[2] * 3 + 1 = 4 * 3 + 1 = 13

输出：13

当 i = 4：

n[4] = n[3] * 3 + 1 = 13 * 3 + 1 = 40

输出：40

解答：

141340

    2.2、执行以下程序的输出结果是_                   .

#include <stdio.h>

int  main()

{ int i,n[4]={1，0，0，0};

for(i=1;i<=3;i++)

{ n[i]=n[i-1]*2+1; printf("%d",n[i]); }

}

解析：

当 i = 1：

n[1] = n[0] * 2 + 1 = 1 * 2 + 1 = 3

输出：3

当 i = 2：

n[2] = n[1] * 2 + 1 = 3 * 2 + 1 = 7

输出：7

当 i = 3：

n[3] = n[2] * 2 + 1 = 7 * 2 + 1 = 15

输出：15

解答：

3715

2.3、下面程序运行的结果为_________。

       main（）

        {

           int  x[5]，i；

           x[0] = 1；x[1] = 2；

           for（i = 2；i<5；i++） x[i] = x[i-1] + x[i-2];

           for（i = 2；i<5；i++） printf（“%d”，x[i]）；

}

解析：

i = 2：

x[2] = x[1] + x[0] = 2 + 1 = 3

当 i = 3：

x[3] = x[2] + x[1] = 3 + 2 = 5

当 i = 4：

x[4] = x[3] + x[2] = 5 + 3 = 8

数组 x 的最终内容：

x[0] = 1

x[1] = 2

x[2] = 3

x[3] = 5

x[4] = 8

第二 for 循环：

再次循环从 i = 2 到 i < 5，输出 x[2], x[3], x[4] 的值。

输出：3, 5, 8

解答：

358

2.4、有以下程序

#include <sthio.h>

int  main()

{

int  arr[] = {1,3,5,7,2,4,6,8},  i,   start  ;

scanf(“%d”, &start);

 for(i=0,i<7,i+=2)

printf(“%d”,arr[(start+i)%5]);

}

若在程序运行时输入整数 10 <回车>，则输出结果为_______

解析：

当 i = 0：

arr[(start + i) % 5] = arr[(10 + 0) % 5] = arr[10 % 5] = arr[0]

输出：1

当 i = 2：

arr[(start + i) % 5] = arr[(10 + 2) % 5] = arr[12 % 5] = arr[2]

输出：5

当 i = 4：

arr[(start + i) % 5] = arr[(10 + 4) % 5] = arr[14 % 5] = arr[4]

输出：2

当 i = 6：

arr[(start + i) % 5] = arr[(10 + 6) % 5] = arr[16 % 5] = arr[1]

输出：3

解答：

1523

2.5下面程序运行的结果为_________。

#include "stdio.h"

      main()

      { int i,j,a[]={0,2,8,4,5};

        printf("\n");

         for(i=1;i<=5;i++)

        {  j=5-i;

          printf("%2d",a[j]);

         }

      }

解析：

当 i = 1：

j = 5 - 1 = 4

输出 a[4] = 5。

当 i = 2：

j = 5 - 2 = 3

输出 a[3] = 4。

当 i = 3：

j = 5 - 3 = 2

输出 a[2] = 8。

当 i = 4：

j = 5 - 4 = 1

输出 a[1] = 2。

当 i = 5：

j = 5 - 5 = 0

输出 a[0] = 0。

解答：

5 4 8 2 0

   2.6有以下程序

#include   <stdio.h>

int  main()

{ int n[2],i,j;

for(i=0;i<2;i++) n[i]=0; for(i=0;i<2;i++)

    for(j=0;j<2;j++) n[j]=n[i]+1;

printf(“%d\n”,n[1]);

}

程序运行后的输出结果是 【】

解析：

第一次for循环作用是对数组进行初始化全部赋值为0

第二个双层for循环外层是控制次数

第一次i=0时

j=0

n[0]=n[0]+1=0+1=1

j=1

n[1]=n[0]+1=1+1=2

第二次i=1时

j=0

n[0]=n[1]+1=2+1=3

j=1

n[1]=n[1]+1=2+1=3

输出n[1]为3

解答：

3

 3、编程题

3.1、 一个班10个学生的成绩，存放在一个一维数组中，要求找出其中成绩最高的学生的成绩和该生的序号。试编程。(试着用下标法和地址法两种方法表示数组)

代码解答：

下标法：

#include <stdio.h>int main() {int scores[10] = {85, 92, 78, 90, 88, 95, 82, 80, 91, 89}; // 假设的成绩int maxScore = scores[0]; // 假设第一个学生成绩为最高分int maxIndex = 0; // 最高分的序号（下标）// 找到最高分和对应的序号for (int i = 1; i < 10; i++) {if (scores[i] > maxScore) {maxScore = scores[i]; // 更新最高分maxIndex = i; // 更新最高分序号}}// 输出结果printf("最高成绩: %d\n", maxScore);printf("该生的序号: %d\n", maxIndex + 1); // 序号从 1 开始return 0;
}

地址法：

#include <stdio.h>int main() {int scores[10] = {85, 92, 78, 90, 88, 95, 82, 80, 91, 89}; // 假设的成绩int maxScore = *scores; // 假设第一个学生成绩为最高分int maxIndex = 0; // 最高分的序号（下标）// 找到最高分和对应的序号for (int i = 1; i < 10; i++) {if (*(scores + i) > maxScore) {maxScore = *(scores + i); // 更新最高分maxIndex = i; // 更新最高分序号}}// 输出结果printf("最高成绩: %d\n", maxScore);printf("该生的序号: %d\n", maxIndex + 1); // 序号从 1 开始return 0;
}

3.2、有5个学生上4门课程，要求输入全部学生的各门课程成绩，然后输出各门课程的平均成绩，并按照各个学生的平均成绩排序(成绩最高的学生排在数组最前面，最低学生排在数组最后面的行) (试着用下标法和地址法两种方法表示数组)。

代码解答：

下标法：

#include <stdio.h>#define STUDENTS 5
#define SUBJECTS 4int main() {int scores[STUDENTS][SUBJECTS]; // 存储学生成绩float avgScores[STUDENTS]; // 存储每个学生的平均成绩float subjectAverages[SUBJECTS] = {0}; // 存储每门课程的平均成绩// 输入学生的成绩for (int i = 0; i < STUDENTS; i++) {printf("输入第 %d 个学生的4门课程成绩:\n", i + 1);for (int j = 0; j < SUBJECTS; j++) {printf("课程 %d: ", j + 1);scanf("%d", &scores[i][j]);}}// 计算每个学生的平均成绩for (int i = 0; i < STUDENTS; i++) {float total = 0;for (int j = 0; j < SUBJECTS; j++) {total += scores[i][j];}avgScores[i] = total / SUBJECTS;}// 计算每门课程的平均成绩for (int j = 0; j < SUBJECTS; j++) {float total = 0;for (int i = 0; i < STUDENTS; i++) {total += scores[i][j];}subjectAverages[j] = total / STUDENTS;}// 按照学生的平均成绩排序（简单选择排序）for (int i = 0; i < STUDENTS - 1; i++) {for (int j = i + 1; j < STUDENTS; j++) {if (avgScores[i] < avgScores[j]) {// 交换平均成绩float temp = avgScores[i];avgScores[i] = avgScores[j];avgScores[j] = temp;// 同时交换对应的成绩for (int k = 0; k < SUBJECTS; k++) {int tempScore = scores[i][k];scores[i][k] = scores[j][k];scores[j][k] = tempScore;}}}}// 输出每门课程的平均成绩printf("\n各门课程的平均成绩:\n");for (int j = 0; j < SUBJECTS; j++) {printf("课程 %d: %.2f\n", j + 1, subjectAverages[j]);}// 输出每个学生的成绩和平均成绩printf("\n学生的成绩及平均成绩:\n");for (int i = 0; i < STUDENTS; i++) {printf("第 %d 个学生成绩: ", i + 1);for (int j = 0; j < SUBJECTS; j++) {printf("%d ", scores[i][j]);}printf(" | 平均成绩: %.2f\n", avgScores[i]);}return 0;
}

地址法：

#include <stdio.h>#define STUDENTS 5
#define SUBJECTS 4int main() {int scores[STUDENTS][SUBJECTS]; // 存储学生成绩float avgScores[STUDENTS]; // 存储每个学生的平均成绩float subjectAverages[SUBJECTS] = {0}; // 存储每门课程的平均成绩// 输入学生的成绩for (int i = 0; i < STUDENTS; i++) {printf("输入第 %d 个学生的4门课程成绩:\n", i + 1);for (int j = 0; j < SUBJECTS; j++) {printf("课程 %d: ", j + 1);scanf("%d", (*(scores + i) + j)); // 地址法输入}}// 计算每个学生的平均成绩for (int i = 0; i < STUDENTS; i++) {float total = 0;for (int j = 0; j < SUBJECTS; j++) {total += *(*(scores + i) + j); // 地址法计算}avgScores[i] = total / SUBJECTS;}// 计算每门课程的平均成绩for (int j = 0; j < SUBJECTS; j++) {float total = 0;for (int i = 0; i < STUDENTS; i++) {total += *(*(scores + i) + j); // 地址法计算}subjectAverages[j] = total / STUDENTS;}// 按照学生的平均成绩排序（简单选择排序）for (int i = 0; i < STUDENTS - 1; i++) {for (int j = i + 1; j < STUDENTS; j++) {if (avgScores[i] < avgScores[j]) {// 交换平均成绩float temp = avgScores[i];avgScores[i] = avgScores[j];avgScores[j] = temp;// 同时交换对应的成绩for (int k = 0; k < SUBJECTS; k++) {int tempScore = *(*(scores + i) + k);*(*(scores + i) + k) = *(*(scores + j) + k);*(*(scores + j) + k) = tempScore;}}}}// 输出每门课程的平均成绩printf("\n各门课程的平均成绩:\n");for (int j = 0; j < SUBJECTS; j++) {printf("课程 %d: %.2f\n", j + 1, subjectAverages[j]);}// 输出每个学生的成绩和平均成绩printf("\n学生的成绩及平均成绩:\n");for (int i = 0; i < STUDENTS; i++) {printf("第 %d 个学生成绩: ", i + 1);for (int j = 0; j < SUBJECTS; j++) {printf("%d ", *(*(scores + i) + j)); // 地址法输出}printf(" | 平均成绩: %.2f\n", avgScores[i]);}return 0;
}

作业二

以下选项中，表达式的值为 6的是

A *(k+2)      B   k+2     C   *k+2     D *k+=2

解析：

A) *(k + 2)

k + 2 会指向 m[2]，也就是 6。

*(k + 2) 的值为 6。

结果： 是 6。

B) k + 2

k + 2 是指针运算，它会返回指向 m[2] 的地址。

这个表达式的值是指针，不是 6。

结果： 不是 6。

C) *k + 2

*k 是 m[0]，即 2。

*k + 2 的值为 2 + 2 = 4。

结果： 不是 6。

D) *k += 2

*k 是 m[0]，即 2。这个表达式会将 m[0] 的值更新为 4。

此时，该表达式的值是更新后的 4，而不是 6。

结果： 不是 6。

解答：

 A

1.8、若有定义语句：int year=2009，*p=&year；，以下不能使变量 year 中的值增至 2010 的语 句是(  )。

A)*p+=1；   B)( *p)++；   C)++(*p)；    D)*p++；

解析：

A) *p += 1;

这个语句会将 year 的值增加 1。

结果：year 变为 2010。

可以实现。

B) (*p)++;

这个语句会先返回 year 的值（2009），然后将 year 的值增加 1。

结果：year 变为 2010。

可以实现。

C) ++(*p);

这个语句会将 year 的值增加 1，等同于 *p += 1;。

结果：year 变为 2010。

可以实现。

D) *p++;

这个语句中的 *p++ 先返回 *p（即 year 的值 2009），然后 p 自增到指向下一个整型的位置。

这个操作不会改变 year 的值。

结果：year 仍然为 2009。

解答：

 D

1.9、设有定义：double x[10],*p=x;，以下能给数组 x 下标为 6 的元素读入数 据的正确语句是

A)scanf("%f",&x[6]);   B)scanf("%lf",*(x+6));

C)scanf("%lf",p+6);      D)scanf("%lf",p[6]);

解析：

A) scanf("%f", &x[6]);

%f 是用于读取 float 类型的格式符，而 x[6] 是 double 类型的。

这个语句是错误的，因为格式符与变量类型不匹配。

不正确。

B) scanf("%lf", *(x + 6));

*(x + 6) 表示访问 x[6] 的值，但这里不应该使用解引用操作符 *。

正确的方式是使用 & 来获取地址。

这个语句是错误的。

不正确。

C) scanf("%lf", p + 6);

p + 6 是指向 x[6] 的指针，而 %lf 是用于读取 double 类型的格式符。

这个语句是正确的，因为它可以直接将 x[6] 的地址传递给 scanf。

正确。

D) scanf("%lf", p[6]);

p[6] 等价于 *(p + 6)，表示访问 x[6] 的值，而不是地址。

因此，这个语句也是错误的，因为它尝试将一个值传递给 scanf，而 scanf 需要一个地址。

不正确。

解答：

 C

1.10、若有定义语句：char s[3][10],   (*k)[3],   *p; ，则以下赋值语句正确的是____

    A)p=s;       B)p=s[0];    C)p=k;     D)k=s;

解析：

A) p = s;

s 是 char 类型的二维数组，代表 char (*)[10]（指向包含 10 个字符的数组的指针）。

p 是 char *，无法直接赋值。

不正确。

B) p = s[0];

s[0] 是指向 s 的第一行的指针，类型是 char *。

这与 p 的类型相匹配，因此这个赋值是有效的。

正确。

C) p = k;

k 的类型是 char (*)[3]，指向包含 3 个字符的数组。

p 的类型是 char *，这两个类型不兼容。

不正确。

D) k = s;

s 的类型是 char (*)[10]（指向包含 10 个字符的数组的指针），与 k 的类型不匹配。

不正确。

解答：

 B

1.11、有定义语句：int *p[4]; 以下选项中与此语句等价的是

A）int p[4];    B)int **p;   C)int *(p[4]);    D)int (*p)[4];

解析：

int *p[4]; 定义了一个包含 4 个元素的数组 p，每个元素都是指向 int 的指针。也就是说，p 是一个指针数组，其中每个元素都指向一个 int 类型的值。

A) int p[4];

这定义了一个包含 4 个 int 类型元素的数组。与 int *p[4]; 不相同。

不等价。

B) int **p;

这定义了一个指向指针的指针，表示一个指向 int * 类型的指针。与 int *p[4]; 不相同。

不等价。

C) int *(p[4]);

这与 int *p[4]; 等价，因为它同样定义了一个包含 4 个 int * 类型元素的数组（虽然书写方式不同，但意义相同）。

等价。

D) int (*p)[4];

这定义了一个指向包含 4 个 int 元素的数组的指针，和 int *p[4]; 不同。

不等价。

解答：

 C

1.12、若有定义语句：int a[4][10], *p, *q[4]; 且 0≤i<4，则错误的赋值 是

A）p=a  B）q[i]=a[i]  C）p=a[i]  D）p=&a[2][1]

解析：

选项A：p = a

a 是一个二维数组 int a[4][10]，在 C 语言中，a 的类型是 int (*)[10]（指向包含 10 个整数的一维数组的指针）。

p 是一个 int * 类型的指针。

在这种情况下，p = a 的赋值是 不合法 的，因为：

a 是一个指向一维数组的指针，不能直接赋值给一个指向单个 int 的指针 p。这种赋值会导致类型不匹配。

正确的赋值应该是 p = &a[0][0]，这样 p 才会指向数组的第一个元素。

解答：

A

1.13、若有以下定义

int x[10],*pt=x;

则对 x 数组元素的正确应用是

A）*&x[10]    B）*（x+3）

3C）*（pt+10） D）pt+3

解析：

A）*&x[10]

x[10] 超出了数组的有效范围（合法索引为 0 到 9），因此访问 x[10] 是不合法的。

结果：不合法

B）*(x + 3)

x + 3 指向数组 x 的第四个元素（索引为 3）。

*(x + 3) 访问这个元素的值。

结果：合法，返回 x[3] 的值。

C）*(pt + 10)

pt + 10 超出了数组的有效范围（合法索引为 0 到 9），所以访问 *(pt + 10) 是不合法的。

结果：不合法

D）pt + 3

pt + 3 指向 x 数组的第四个元素（索引为 3），但此表达式本身不访问元素的值，只是计算地址。

结果：不合法，不直接返回数组元素的值。

解答：

B

1.14、有以下程序

#include <stdio.h>

main()

{ int a[ ]={1,2,3,4},y,*p=&a[3];

--p; y=*p; printf(“y=%d\n”,y);

}

程序的运行结果是

A）y=0   B）y=1    C）y=2   D）y=3

解析：

数组 a 的定义为 {1, 2, 3, 4}，索引从 0 到 3。

a[0] = 1

a[1] = 2

a[2] = 3

a[3] = 4

指针 p 初始化为指向 a[3]，即 p 的值为 &a[3]（地址值指向元素 4）。

执行 --p;，指针 p 现在指向 a[2]，即元素值 3。

y = *p; 解引用 p 得到 a[2] 的值，赋值给 y。所以 y = 3。

最后，printf("y=%d\n", y); 打印 y 的值。

解答：

D

1.15、设char  *s = “\ta\017bc”；则指针变量s指向的字符串所占的字节数是_______

   A)  6   B)  2   C)   5   D) 9

解析：

\t 表示一个制表符（Tab），占用 1 个字节。

a 是一个普通字符，占用 1 个字节。

\017 是一个八进制数，表示字符 \017，对应的十进制值为 15，实际上是控制字符，占用 1 个字节。

b 是一个普通字符，占用 1 个字节。

c 是一个普通字符，占用 1 个字节。

字符串的结束符 \0，占用 1 个字节。

解答：

A

1.16、  若有定义语句：char s[3][10],  (*k)[3],   *p;，则以下赋值语句正确的是 A)p=s; B)p=k; C)p=s[0]; D)k=s;

解析：

A) p = s;

s 是 char 类型的二维数组，代表 char (*)[10]（指向包含 10 个字符的数组的指针）。

p 是 char *，无法直接赋值。

不正确。

C) p = s[0];

s[0] 是指向 s 的第一行的指针，类型是 char *。

这与 p 的类型相匹配，因此这个赋值是有效的。

正确。

B) p = k;

k 的类型是 char (*)[3]，指向包含 3 个字符的数组。

p 的类型是 char *，这两个类型不兼容。

不正确。

D) k = s;

s 的类型是 char (*)[10]（指向包含 10 个字符的数组的指针），与 k 的类型不匹配。

不正确。

解答：

C

2、填空题

2.1以下程序的输出结果是_______

#include<stdio.h>

main()

{ int a[5]={2,4,6,8,10}, *p;

p=a+2;

printf(“%d”,*p++);

}

解析：

数组初始化：

int a[5] = {2, 4, 6, 8, 10};：数组 a 被初始化为 2, 4, 6, 8, 10。

指针赋值：

p = a + 2;：指针 p 指向数组 a 的第三个元素（a[2]），即 6。

打印输出：

printf("%d", *p++);：

*p 取出 p 指向的值（即 6）。

p++ 后缀自增，指针 p 将指向下一个元素（a[3]，值为 8）。

因此，输出 6。

解答：

6

2.2、以下程序段的定义语句中，x[1]的初值是_____,程序运行后输出的内容是_______

#include<stdio.h>

 main()

{ int x[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16},*p[4],i;

for(i=0;i<4;i++)

{ p[i]=&x[2*i+1]; printf(“%d ”,p[i][0]);

}

printf(“\n”);

}

解析：

数组 x 的初始化：

x 被初始化为 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16。

x[1] 的初值：

因此，x[1] 的初值是 2。

在 for 循环中，指针 p[i] 被赋值为 &x[2*i + 1]：

当 i = 0：

p[0] = &x[2*0 + 1] = &x[1]，此时 p[0] 指向 x[1]（值为 2）。

输出 p[0][0]，即 *p[0]，结果为 2。

当 i = 1：

p[1] = &x[2*1 + 1] = &x[3]，此时 p[1] 指向 x[3]（值为 4）。

输出 p[1][0]，即 *p[1]，结果为 4。

当 i = 2：

p[2] = &x[2*2 + 1] = &x[5]，此时 p[2] 指向 x[5]（值为 6）。

输出 p[2][0]，即 *p[2]，结果为 6。

当 i = 3：

p[3] = &x[2*3 + 1] = &x[7]，此时 p[3] 指向 x[7]（值为 8）。

输出 p[3][0]，即 *p[3]，结果为 8。

解答：

2        2468

    2.3  以下程序段的输出结果是( )

#include <sthio.h>

mian()

{ char *ch[4]={“red”,”green”,”blue”}; int  i=0;

while(ch[i]);

{   putchar(ch[i][0];    i++;   }

}

解析：

字符指针数组 ch：

char *ch[4] = {"red", "green", "blue", NULL}; 这是一个字符指针数组，存储了三个字符串和一个 NULL 指针，用于标识数组的结束。

while (ch[i]) 循环：

循环的条件是 ch[i]，它会检查 ch[i] 是否为 NULL。如果不是，则继续执行循环。

输出 putchar(ch[i][0])：

ch[i][0] 获取字符串 ch[i] 的第一个字符。

对于字符串数组中的每个字符串，输出其首字符：

当 i = 0 时，ch[0] 是 "red"，输出 r。

当 i = 1 时，ch[1] 是 "green"，输出 g。

当 i = 2 时，ch[2] 是 "blue"，输出 b。

当 i = 3 时，ch[3] 是 NULL，循环结束。

解答：

rgb

       2.4、以下程序的功能是：借助指针变量找出数组元素中最大值所在的位置并输出该最大值。 请在输出语句中填写代表最大值的输出项。

#include   <stdio.h> 

int   main()

{ int a[10], *p, *s;

for(p=a; p-a<10; p++)

scanf(“%d”,  p);

for(p=a,s=a;p-a<10;p++)

if(*p>*s) s=p;

printf(“max=%d,  序号:%d\n” , ___________ );

}

解析：

输入数组：使用 scanf 输入 10 个整数。

查找最大值：

使用两个指针 p 和 s，其中 s 初始化为指向数组的起始位置，p 遍历整个数组。

在循环中，如果当前指针 p 所指向的值大于 s 所指向的值，则更新 s，使其指向当前更大的值。

输出最大值和序号：

*s：表示最大值。

s - a：表示最大值在数组中的索引位置。

解答：

*s，s-a

2.5 有以下程序，输出结果为_________

      main()

{ 

int a[5]={1,2,3,4,5};   

int *ptr=(int *)(&a+1);   

printf("%d,%d",*(a+1),*(ptr-1));

}  

解析：

数组定义：

int a[5] = {1, 2, 3, 4, 5}; 定义了一个包含五个整数的数组 a。

指针定义：

int *ptr = (int *)(&a + 1);

&a 是数组 a 的地址，其类型是 int (*)[5]（指向数组的指针）。

&a + 1 的效果是获取 a 数组之后的内存地址，这个地址是 a 的末尾加上整个数组的大小（即 5 个 int 的大小，通常是 20 字节，假设 int 是 4 字节）。

由于 &a + 1 结果是一个指向 int[5] 的指针，因此在进行强制类型转换后，ptr 实际指向的是 a 数组之后的第一个 int（即 a[5]）。

打印输出：

*(a + 1)：

这个表达式指向 a 数组的第二个元素，值是 2。

*(ptr - 1)：

ptr - 1 实际上是指向 a[4]（数组的最后一个元素），值是 5。

解答：

2，5

2.6  以下程序的功能是：借助指针变量找出数组元素中最大值所在的位置并输出该最大值。 请在输出语句中填写代表最大值的输出项。

#include <stdio.h>

int main( )

{ int a[10], *p, *s;

for(p=a;p-a<10; p++)

scanf(“%d”,p);

 for(p=a,s=a;p-a<10;p++)

 if(*p>*s) s=p;

printf(“max=%d\n” ,  ______ );

解析：

输入数组：使用 scanf 输入 10 个整数。

查找最大值：

使用两个指针 p 和 s，其中 s 初始化为指向数组的起始位置，p 遍历整个数组。

在循环中，如果当前指针 p 所指向的值大于 s 所指向的值，则更新 s，使其指向当前更大的值。

输出最大值和序号：

*s：表示最大值。

s - a：表示最大值在数组中的索引位置。

解答：

*s，s-a

3、编程题

3.1、 有一个整型数组int [10] = {10,20,30,40,50,60,70,80,90,100}；标准输入一个整型数值m(0<m<10) ,使前面10-m个数值向后移动m个位置，最后m个数变成前面的m个数

代码解答： 

#include <stdio.h>int main() {int arr[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};int m;// 输入m的值，确保0 < m < 10printf("请输入一个整数 m (0 < m < 10): ");scanf("%d", &m);// 检查输入的合法性if (m <= 0 || m >= 10) {printf("输入不合法！m的值必须在0到10之间。\n");return 1; // 结束程序}// 移动数组// 从后往前移动for (int i = 9; i >= m; i--) {arr[i] = arr[i - m];}// 将最后m个数变成前面的m个数for (int i = 0; i < m; i++) {arr[i] = 10 * (i + 1); // 将前m个数设为10, 20, 30, ...}// 输出结果printf("移动后的数组为：");for (int i = 0; i < 10; i++) {printf("%d ", arr[i]);}printf("\n");return 0;
}

                     

作业三

结构体共用体练习

1. 选择题

   1.1、设有以下语句：

typedef struct REC

{

           char c;

           int a[4];

}REC1；

则下面叙述中正确的是____________。

A）可以用REC定义结构体变量

B）REC1是struct REC类型的变量

C）REC是struct 类型的变量。

D）可以用REC1定义结构体变量

解析：

A）可以用 REC 定义结构体变量

错误。REC 是结构体的标签名，而不是类型名。你需要使用 struct REC 来定义结构体变量。

B）REC1 是 struct REC 类型的变量

错误。REC1 是 struct REC 的别名，不是变量。它是一个类型名。

C）REC 是 struct 类型的变量

错误。REC 是结构体的标签名，不是变量。结构体变量需要显式地定义，比如 struct REC myVar;。

D）可以用 REC1 定义结构体变量

正确。因为 REC1 是 struct REC 的别名，所以你可以使用 REC1 来定义结构体变量，如 REC1 myVar;。

解答 ：

D

1.2、下列关于结构的说法错误的是______.

A)结构是由用户自定义的一种数据类型。

B)结构中可设定若干个不同数据类型的成员。

C)结构中成员的数据类型可以是另一个已定义的结构

D)在定义结构时，可以为成员设置默认值。

解析：

A) 结构是由用户自定义的一种数据类型。

正确。结构确实是用户定义的一种数据类型，可以包含多个成员。

B) 结构中可设定若干个不同数据类型的成员。

正确。结构的成员可以是不同的数据类型，例如整型、字符型、浮点型等。

C) 结构中成员的数据类型可以是另一个已定义的结构。

正确。结构的成员可以是其他结构类型，这样可以实现嵌套结构。

D) 在定义结构时，可以为成员设置默认值。

错误。在 C 语言中，不能直接在结构定义时为成员设置默认值。需要在定义结构变量后，通过赋值来设置成员的值。

解答 ：

D

1.3、以下结构体类型说明和变量定义中，正确的是______。

A)  struct SS                             B)  struct

{                                                  {

              char flag;                                         char flag;

              float x;                                             float x;

}                                                }SS;

                         struct SS  a, b;

C)  struct ss                              D)typedef

{                                                         {

       char flag;                                                char flag;

              float x;                                                 float x

};                                                        }SS;

               struct  ss  a，b;             SS a,b;

解析：

A）在定义结构体时少了个`;`

B）struct 关键字后面缺少结构体的名称。正确的写法应该是 struct SS

C）正确

D）typedef 语句的写法不正确。typedef 后面需要跟 struct 类型的完整定义，且结构体变量的定义也有错误，正确写法应该是 typedef struct { ... } SS;，然后可以用 SS a, b; 来声明变量。

解答 ：

C

1.4、设有以下说明语句：

struct stu

{

            int a;

            float b;

}stutype;

则下面的叙述不正确的是____________。

A)struct是结构体类型的关键字

B)struct stu是用户定义的结构体类型名

C)stutype 是用户定义的结构体类型名

D)a 和b 都是结构体成员名

解析：

A) 正确。struct 确实是结构体类型的关键字。

B) 正确。struct stu 是结构体类型的声明，其中 stu 是用户定义的结构体类型名。

C) 错误。stutype 是结构体的类型定义，并不是用户定义的结构体类型名。实际上，stutype 是该结构体类型的一个别名。

D) 正确。a 和 b 确实是结构体成员名

解答 ：

C

1.5、根据下面的定义，能打印出字母M的语句是____________。

struct person

{

              char name[9];

              int age;

};

struct person class[10] = {“John”,17,”Paul”,19,”Mary”,18,”adam”,16};

A)  printf(“%c\n”,class[3].name);

B)  printf(“%c\n”,class[3].name[1]);

C)  printf(“%c\n”,class[2].name[1]);

D)  printf(“%c\n”,class[2].name[0]);

解析：

A) printf(“%c\n”,class[3].name);

这将尝试打印 class[3].name，这是一个字符串（字符数组），会导致类型不匹配错误。

B) printf(“%c\n”,class[3].name[1]);

class[3].name 对应的字符串是 "adam"，name[1] 是 'd'，因此不会打印出 M。

C) printf(“%c\n”,class[2].name[1]);

class[2].name 对应的字符串是 "Mary"，name[1] 是 'a'，因此不会打印出 M。

D) printf(“%c\n”,class[2].name[0]);

class[2].name 对应的字符串是 "Mary"，name[0] 是 'M'，所以这条语句将打印出字母 M。

解答 ：

D

1.6、若有如下定义：

struct person

{

      int id;

          char name[10];

}per,*s = &per;

则以下对结构体成员的引用中错误的是____________。

A) per.name                  B) s->name[0]

C) (*per).name[8]         D) (*s).id

解析：

A) per.name

这是一个正确的引用，直接访问 per 的 name 成员。

B) s->name[0]

这是一个正确的引用，使用箭头运算符（->）访问指针 s 指向的结构体的 name 成员。

C) (*per).name[8]

这是错误的引用。这里的 per 是一个结构体变量，而不是指针，因此不能使用解引用操作符 *。正确的写法应为 (*s).name[8] 或 s->name[8]。

D) (*s).id

这是一个正确的引用，使用解引用操作符访问指针 s 指向的结构体的 id 成员。

解答 ：

C

1.7、下面程序的运行结构是____________。

main()

{

          struct cmplx{int x;

                                   int y;

                     }cnum[2] = {1,3,2,7};

printf(“%d\n”,cnum[0].y/cnum[0].x*cnum[1].x);

}

A)0     B)1    C)3        D)6

解析：

结构体初始化：

cnum[0] 初始化为 {1, 3}，即 cnum[0].x = 1 和 cnum[0].y = 3。

cnum[1] 初始化为 {2, 7}，即 cnum[1].x = 2 和 cnum[1].y = 7。

计算表达式：

首先计算 cnum[0].y / cnum[0].x：

cnum[0].y/cnum[0].x=3/1=3

cnum[0].y/cnum[0].x=3/1=3

然后乘以 cnum[1].x：

3∗cnum[1].x=3∗2=6

3∗cnum[1].x=3∗2=6

输出结果：

程序输出 6。

解答 ：

D

1.8、若有以下定义和语句：

struct student

{

          int age;

          int num;

};

struct student stu[3] = {{1001,20},{1002,19},{1003,21}};

main( )

{

          sturct student *p;

          p = stu;

          …

}

则以下不正确的引用形式是____________。

A)  (p++) ->num               B)  p++

C)  (*p).num                      D)  p = &stu.age

解析：

A) (p++) -> num

合法：这个表达式首先访问指针 p 指向的 num 成员，然后将 p 增加到下一个 student 结构体（这通常是有效的，尽管需要注意这种用法在某些情况下会导致未定义行为）。

B) p++

合法：这个表达式增加指针 p，将其指向下一个 student 结构体。

C) (*p).num

合法：这个表达式解引用指针 p 并访问 num 成员。

D) p = &stu.age

不合法：stu 是一个结构体数组，stu.age 不是有效的表达式。结构体数组的成员必须通过索引来访问。例如，应该使用 stu[0].age 来获取第一个结构体的 age 成员的地址

解答 ：

D

1.9、设有以下定义和语句，以下引用形式不合法的是____________。

struct s

{

           int il;

           struct s *i2;

char  *i0;

};

   static struct s a[3] = {2,&a[1],'\0',4,&a[2], ‘\0’ , 6 ,&a[1], ‘\0’  },*ptr;

ptr = a;

A)  ptr->i1++    B)  *ptr->i2     C) ++ptr->i0     D)  *ptr->i1

解析：

A) ptr->i1++

合法：这个表达式对 ptr 所指向的结构体的 i1 成员进行自增操作。

B) *ptr->i2

合法：ptr->i2 返回指向另一个 struct s 的指针，*ptr->i2 解引用该指针。

C) ++ptr->i0

合法：ptr->i0 是一个指向字符的指针，因此可以对其进行自增操作，指向下一个字符。

D) *ptr->i1

不合法：ptr->i1 是一个 int 类型的成员，不能解引用。解引用只能用于指针类型。

解答 ：

D

1.10、设有如下定义：

struct sk

{

             int n;

             float x;

}data,*p;

若要使p指向data中的n域，则正确的赋值语句是____________。

A) p = &data.n;                   B) *p = data.n;

C) p =(struct sk *)&data.n;     D) p = (struct sk *)data.n;

解析：

A) p = &data.n;

不合法：&data.n 是一个指向 int 的指针，但 p 是指向 struct sk 的指针。

B) *p = data.n;

不合法：*p 期望一个 struct sk 类型的值，但 data.n 是 int 类型，类型不匹配。

C) p =(struct sk *)&data.n;

合法：&data.n 是一个指向 int 的指针，强制转换为 struct sk * 是合适的，因为它们的类型不同。

D) p = (struct sk *)data.n;

不合法：data.n 是 int 类型，强制转换为 struct sk * 不合适，可能会导致不正确的内存访问。

解答 ：

C

1.11、若有以下程序段：

struct dent

{

       int n;

       int *m;

};

int a = 1,b = 2,c = 3;

struct dent s[3] = {{101,&a},{102,&b},{103,&c}};

main()

{

  struct dent *p;

           p =s;

          …

}

则以下表达式中值为2的是____________。

A)  (++p)->m         B)  *(p++)->m

C)  (*p).m               D)  *(++p)->m

解析：

A) (++p)->m

p 指向 s[0]，执行 ++p 后，p 指向 s[1]。

p->m 是 s[1].m，即 &b，其值为 2。

值为 2。

B) *(p++)->m

p 指向 s[0]，首先解引用 p，p->m 是 s[0].m，即 &a，其值为 1。

然后 p++ 会使 p 指向 s[1]。所以这个表达式返回的是 *(&a) 的值，结果为 1。

值为 1。

C) (*p).m

此时 p 指向 s[0]，(*p).m 是 s[0].m，即 &a，值为 1。

值为 1。

D) *(++p)->m

p 指向 s[0]，执行 ++p 后，p 指向 s[1]。

*(p->m) 是 *(s[1].m)，即 *(&b)，值为 2。

值为 2。

解答 ：

AD

1.12、若有以下说明和语句，则对pup中sex域的正确引用方式是____________

struct pupil

{

            char name[20];

            int sex;

}pup,*p;

p = &pup;

A)  p.pup.sex              B)  p->pup.sex

C)  (*p).pup.sex         D)  (*p).sex

解析：

A) p.pup.sex

p 是指针，不能用点运算符（.）直接引用。此写法不合法。

错误。

B) p->pup.sex

p 是指向 pup 的指针，p->pup 表示对 pup 的引用，但 pup 是结构体变量而不是结构体成员。这个表达式是不合法的。

错误。

C) (*p).pup.sex

(*p) 是 pup 的引用，但同样 (*p).pup 是不合法的，因为 pup 是结构体变量而不是结构体成员。

错误。

D) (*p).sex

(*p) 解引用指针 p，得到 pup 结构体，然后可以直接访问 sex 域。

这是合法且正确的引用方式。

正确。

解答 ：

D

1.13、以下程序的输出结果是____________。

struct stu

{

       int x;

              int *y;

}*p;

int dt[4] = {10,20,30,40};

struct stu a[4] = {50,&dt[0],60,&dt[1],70,&dt[2],80,&dt[3]};

main( )

{

            p = a;

            printf(“%d,”,++p->x);

            printf(“%d”,(++p)->x);

            printf(“%d”,++(*p->y));

}

A)10,20,20                    B)50,60,21

C)51,60,21                    D)60,70,31

解析：

第一行: printf("%d,", ++p->x);

p 最初指向 a[0]，即 x = 50。

++p->x 会先将 p->x（即 a[0].x）加 1，然后输出 51。

此时 a[0].x 的值变为 51。

输出: 51

第二行: printf("%d", (++p)->x);

++p 将 p 移动到 a[1]，即 x = 60。

输出 60。

输出: 60

第三行: printf("%d", ++(*p->y));

此时 p 仍然指向 a[1]。

p->y 指向 dt[1]，即 y = 20。

++(*p->y) 将 dt[1] 的值加 1，变为 21。

输出: 21

解答 ：

C

1.14、若有以下说明和语句，则下面表达式中值为1002的是____________。

struct   student

{

            int age;

            int num;

};

struct student stu[3] = {{1001,20},{1002,19},{1003,21}};

struct student  *p;

p = stu;

A)  (p++)->num                     B)  (p++)->age

C)  (*p).num                           D)  (*++p).age

解析：

A) (p++)->num

p++ 先使用 p 的当前值（stu[0]），然后将 p 指向 stu[1]。

p->num 为 20（stu[0].num），所以输出是 20，不是 1002。

B) (p++)->age

同样，p++ 先使用 stu[0]，然后将 p 指向 stu[1]。

p->age 为 1001（stu[0].age），所以输出是 1001，不是 1002。

C) (*p).num

此时 p 仍然指向 stu[0]，所以 (*p).num 为 20，不是 1002。

D) (*++p).age

++p 将 p 移动到 stu[1]。

(*p).age 为 1002（stu[1].age），所以输出是 1002。

解答 ：

D

1.15、以下对结构体变量stu1中成员age的非法引用是____________。

struct student

{

            int age;

            int num;

}stu1,*p;

p = &stu1;

A) stu1.age                          B) student.age

C) p ->age                              D) (*p).age

解析：

A) stu1.age

这是合法的引用，直接访问 stu1 中的 age 成员。

B) student.age

这是非法的引用。student 是结构体类型名，而不是变量名。不能直接通过结构体类型名访问结构体成员。

C) p->age

这是合法的引用。指针 p 指向 stu1，通过箭头运算符可以访问 age 成员。

D) (*p).age

这是合法的引用。解引用指针 p 后可以通过点运算符访问 age 成员

解答 ：

B

1.16、 设有以下说明和定义语句，则下面表达式中值为3的是____________

struct s

{

             int il;

             struct s *i2;

};

static struct s a[3] = {1,&a[1],2,&a[2],3,&a[0]},*ptr;

ptr = &a[1];

A)ptr->il++                              B)ptr++->il

C)(ptr++)->il                                      D)++ptr->il

解析：

A) ptr->il++

ptr->il 的当前值为 2，执行 ptr->il++ 后，值变为 3，并且返回的值是 2。所以这个表达式的结果不是 3。

B) ptr++->il

先计算 ptr->il，此时 ptr 指向 a[1]，所以返回值为 2，然后 ptr 移动到下一个元素（指向 a[2]）。所以返回值不是 3。

C) (ptr++)->il

这个表达式与选项 B 类似，首先返回 ptr->il 的值，即 2，然后再进行指针自增。返回值不是 3。

D) ++ptr->il

这个表达式会首先对 ptr->il 进行自增，ptr 指向 a[1]，ptr->il 从 2 自增到 3，并返回自增后的值 3。

解答 ：

D

1.17、若有以下定义和语句：

union data

{

     int i;

              char c;

              float f;

}a;

int n;

则以下语句正确的是____________。

A)a = 5;                                      B)a.f = 1.2

C)printf(“%d\n”,a);      D)n =a;

解析：

A) a = 5;

这是错误的，因为 a 是一个联合体，无法直接赋值为一个整数。正确的写法应该是使用 a.i = 5;。

B) a.f = 1.2;

这是正确的，虽然可能会引起类型问题（由于不同数据类型共用同一内存位置），但语法上是合法的。

C) printf(“%d\n”, a);

这是错误的，因为 a 是一个联合体，不能直接作为 %d 的参数。你需要使用 a.i 来打印 int 类型的值，例如 printf("%d\n", a.i);。

D) n = a;

这是错误的，因为不能将一个联合体直接赋值给一个整数变量。需要使用 n = a.i;。

解答 ：

B

1.18、以下程序在32位操作系统的运行结果是____________。

#include <stdio.h>

main( )

{

                  union{

                         long a;

                          int b;

                          char c;

               }m;

printf(“%d\n”,sizeof(m));

}

A) 2              B)4        C) 6              D)8

解析：

long 类型：在32位操作系统上，通常为4字节。

int 类型：在32位操作系统上，通常为4字节。

char 类型：大小为1字节。

由于联合体的大小取决于其最大成员的大小，且在32位系统上 long 和 int 的大小都是4字节，因此联合体 m 的大小将是4字节。

解答 ：

B

1.19、以下程序的运行结果是____________

#include <stdio.h>

union pw

{

       int i;

       char ch[2];

}a;

main( )

{

            a.ch[0] = 13;

a.ch[1] = '0';

printf(“%d\n”,a.i);

}

A) 12301             B)4813         C) 208          D) 209

解析：

内存布局分析

a.ch[0] 被赋值为 13，其十六进制表示为 0x0D。

a.ch[1] 被赋值为字符 '0'，其 ASCII 值为 48，十六进制表示为 0x30。

联合体的内存结构通常是按照小端字节序（little-endian）存储的：

a.ch[0]（低位字节）存储在地址的低位，即 0x0D。

a.ch[1]（高位字节）存储在地址的高位，即 0x30。

计算 a.i

在小端字节序下，a.i 的内存布局如下：

低位（ch[0]）：0x0D (13)

高位（ch[1]）：0x30 (48)

将这两个字节合并为一个整数 i：

a.i=0x30×256+0x0D=48×256+13=12288+13=12201

解答 ：

A

1.20、下面对typedef的叙述中不正确的是____________

A) 用typedef可以定义各种类型名，但不能用来定义变量

B) 用typedef可以增加新类型

C) 用typedef只是将已存在的类型用一个新的标识符来代表

D) 使用typedef有利于程序的通用和移植

解析：

A) 用typedef可以定义各种类型名，但不能用来定义变量

正确。typedef 用于为现有类型创建别名，不能直接用于定义变量。

B) 用typedef可以增加新类型

不正确。typedef 不能创建新的数据类型，它只是为现有类型提供新的名称。

C) 用typedef只是将已存在的类型用一个新的标识符来代表

正确。typedef 创建的只是类型的别名，实际上没有创建新的类型。

D) 使用typedef有利于程序的通用和移植

正确。通过使用 typedef，可以使代码更易读并增强移植性，因为可以在不同的平台上使用不同的类型实现。

解答 ：

B

1.21、下面程序在64位操作系统的运行结果是____________。

typedef union {  long a[2];

                                      int b[4];

                                      char c[8];

}TY;

TY our;

main()

{

            printf(“%d\n”,sizeof(our));

}

A) 32            B)16                    C) 8              D)24

解析：

在这个程序中，TY 是一个 union，其成员包括：

一个包含 2 个 long 类型元素的数组 a[2]。

一个包含 4 个 int 类型元素的数组 b[4]。

一个包含 8 个 char 类型元素的数组 c[8]。

union 的大小由其最大成员决定。在 64 位操作系统中：

一个 long 类型通常占用 8 字节，因此 a[2] 占用 16 字节。

一个 int 类型通常占用 4 字节，因此 b[4] 占用 16 字节。

一个 char 类型占用 1 字节，因此 c[8] 占用 8 字节。

因此，union TY 的大小取决于其最大成员 a[2]，即 16 字节。因此，sizeof(our) 将返回 16。

解答 ：

B

二、填空题

2.1、有结构体

 struct ST

{

           int a;

           float b;

           sturct ST *c;

           double x[3];

}st1;

请填空，完成以下对数组s的定义，使其每个元素均为上述结构体类型。

____________ s[10];   

解析：

要定义一个包含结构体 ST 类型元素的数组 s，需要将结构体 ST 的定义放在数组定义之前

解答 ：

struct ST

2.2、 以下程序的运行结果是____________。

struct n

{  int x;

           char c;

};

main( )

{

           struct n a = {10,'x'};

           func(a);

           printf(“%d,%c”,a.x,a.c);

}

func(struct n b)

{

            b.x = 20;

            b.c = 'y';

}

解析：

没传地址，所以原变量不变

解答 :

10 x

2.3、以下程序的运行结果是_____

main()

{

           struct EXAMPLE

            {

                  struct{ int x;

                               int y;

                               }in;

                  int a;

                  int b;

            }e;

e.a = 1;  e.b = 2;

e.in.x = e.a*e.b;

e.in.y = e.a +e.b;

printf(“%d,%d”,e.in.x,e.in.y);

}

解析：

e.in.x 被赋值为 e.a 和 e.b 的乘积，即 1 * 2 = 2。

e.in.y 被赋值为 e.a 和 e.b 的和，即 1 + 2 = 3。

解答 ：

2，3

2.4、 以下程序的输出结果是____________。

#include <stdio.h>

struct abc

{

          char c;

          float v;

};

void fun1(strcut abc b)

{

          b.c = 'A';

          b.v = 80.7;

}

void fun2(struct abc *b)

{

      (*b).c = 'C';

           (*b).v = 92.5;

}

int main()

{

    struct abc a = {'B',98.5};

          fun1(a);

          printf(“%c,%4.1f\n”,a.c,a.v);

          fun2(&a);

           printf(“%c,%4.1f\n”,a.c,a.v);

}

解析：

fun1是值传送，原变量不变，fun2是地址传送原变量发生改变

解答 ：

B, 98.5
C, 92.5

2.8、若已定义：

struct num

{

          int a;

          int b;

          float f;

} n = {1,3,5.0}

struct num *pn = &n;

则表达式pn->b/n.a*++pn->b的值是【1】,表达式(*pn).a + pn->f的值是【2】。

解析：

初始状态：

n.a = 1

n.b = 3

n.f = 5.0

pn 指向 n。

解析：

pn->b 当前值为 3。

n.a 的值为 1。

++pn->b 将 pn->b 先自增，然后使用新值。自增操作会使 n.b 从 3 变为 4。

因此：

pn->b 变为 4（自增后）。

pn->b / n.a 计算为 4 / 1 = 4。

最终表达式的值为 4 * 4 = 16。

2. 表达式 (*pn).a + pn->f

解析：

(*pn).a 是 n.a 的值，等于 1。

pn->f 是 n.f 的值，等于 5.0。

因此：

这个表达式计算为 1 + 5.0 = 6.0。

总结

第一个表达式 pn->b / n.a * ++pn->b 的值是 16。

第二个表达式 (*pn).a + pn->f 的值是 6.0。

解答 ：

16，6.0

2.9、以下程序的运行结果是____________。

struct ks

{

          int a;

          int *b;

} s[4],*p;

main()

{

          int n = 1,i;

          printf(“\n”);

          for(i = 0;i < 4;i++)

           {

                  s[i].a = n;

                  s[i].b = &s[i].a;

                  n = n+2;

            }

p = &s[0];

p++;

printf（“%d,%d\n”，（++p)->a,     (p++)->a   )  ;

}

解析：

在 for 循环中：

s[0].a = 1

s[1].a = 3

s[2].a = 5

s[3].a = 7

对应的指针 b 均指向各自的 a 成员。 ++p 使 p 指向 s[2]，然后访问 s[2].a 的值，即 5。

(p++)->a 先访问当前 p 指向的 s[2] 的 a 的值（即 5），然后 p 自增到 s[3]。

因此，printf 的输出将是：

第一个 %d 输出 5（来自 s[2].a）。

第二个 %d 输出 5（来自 s[2].a，因为 p++ 操作在这一步之后才改变 p 的指向）。

解答 ：

5，5

2.10、以下程序的运行结果为____________

struct s

{

           int a;

           float b;

           char *c;

}

main( )

{

             static struct s x = {19,83.5,”zhang”};

             struct s *px = &x;

             printf(“%d%.1f%s\n”,x.a,x.b,x.c);

             printf(“%d%.1f%s\n”,px->a,(*px).b,px->c);

             printf(“%c%s\n”,*px->c-1,&px->c[1]);

}

解析：

第一个 printf 语句

x.a 输出 19。

x.b 输出 83.5，使用 .1f 格式输出，显示为 83.5。

x.c 输出字符串 "zhang"

第二个 printf 语句：

px->a 输出 19（和 x.a 一样）。

(*px).b 输出 83.5（和 x.b 一样）。

px->c 输出字符串 "zhang"（和 x.c 一样）

第三个 printf 语句

*px->c 访问的是 x.c 的第一个字符，即 'z'，然后减去 1，得到字符 'y'。

&px->c[1] 指向字符串 "zhang" 的第二个字符，即 "hang"

解答 ：

19 83.5zhang
19 83.5zhang
yhang

2.11、设有以下定义和语句，请在printf语句的【】中天上能够正确输出的变量及相应的格式说明。

union

{

            int n;

            double x;

}num;

num.n = 10;

num.x = 10.5;

printf(“【1】”，【2】);

解析：

输出 num.n

如果我们尝试输出 num.n，我们会得到一个未定义的结果，因为 num.x 被赋值为 10.5，并且 num.n 的值是不可预知的。

输出 num.x

输出 num.x 是有效的，因为 num.x 是最近赋值的成员。

解答 ：

printf("%f", num.x);

2.12、以下程序的运行结果是____________。

main()

{

           struct EXAMPLE

            {

                  union

                  {

                        int x;

                        int y;

                   }in;

                 int a;

                 int b;

            }e;

            e.a = 1; e.b = 2;

            e.in.x = e.a *e.b;

            e.in.y = e.a +e.b;

            printf(“%d,%d”,e.in.x,e.in.y);

}

解析：

联合体的所有成员共享同一块内存，这意味着在联合体中赋值的最后一个成员会覆盖之前赋值的成员。

在这里，当我们执行 e.in.y = e.a + e.b; 时，由于 in 是一个联合体，e.in.y 的赋值将覆盖 e.in.x 的值。虽然 e.in.x 被赋值为 2，但在下一行代码中，e.in.y 被赋值为 3，此时 e.in.x 的值实际上是 3。

解答 ：

3，3

2.13、以下程序的运行结果是____________。

union ks

{

             int a;

             int b;

};

union ks s[4];

union ks *p;

main( )

{

int n = 1,i;

printf(“\n”);

for(i = 0;i < 4;i++)

           {

                 s[i].a = n;

                 s[i].b = s[i].a + i;

                 n = n+2;

            }

p = &s[2];

printf(“%d,”,p++->a);

printf(“%d”,++p->a);

}

解析：

联合体数组初始化：

s[0]：

s[0].a = 1

s[0].b = 1 + 0 = 1（s[0].b 取值是 1，覆盖了 s[0].a）

s[1]：

s[1].a = 3

s[1].b = 3 + 1 = 4（s[1].b 取值是 4，覆盖了 s[1].a）

s[2]：

s[2].a = 5

s[2].b = 5 + 2 = 7（s[2].b 取值是 7，覆盖了 s[2].a）

s[3]：

s[3].a = 7

s[3].b = 7 + 3 = 10（s[3].b 取值是 10，覆盖了 s[3].a）

最终状态：

s[0]：a = 1, b = 1

s[1]：a = 4, b = 4

s[2]：a = 7, b = 7

s[3]：a = 10, b = 10

指针操作：

p = &s[2];，指向 s[2]（p->a 为 7）。

解答 ：

7，11

2.14、以下程序的运行结果是____________

main( )

{

            union EXAMPLE

              {

                  struct

                        {

                             int x;

                             int y;

                         }in

                    int a;

                    int b;

               }e;

e.a = 1;

e.b = 2;

e.in.x = e.a * e.b;

e.in.y = e.a +e.b;

printf(“%d %d”,e.in.x,e.in.y);

}

解析：

定义和初始化联合体：

联合体 EXAMPLE 中有一个结构体 in，包含两个整数 x 和 y，以及两个整数 a 和 b。

由于这是一个联合体，a、b、in.x 和 in.y 共用同一块内存。

赋值操作：

e.a = 1;：设置 e.a 为 1。此时 e.b 和结构体成员 in 的内容不确定，因为联合体的成员共享内存。

e.b = 2;：设置 e.b 为 2。由于 a 和 b 是联合体的成员，所以此时 e.a 的值可能会被覆盖，但在这一点上我们关注的是后面的计算。

e.in.x = e.a * e.b;：这里的计算中，e.a 和 e.b 的值都分别为 1 和 2。所以 e.in.x 的值为 1 * 2 = 2。

e.in.y = e.a + e.b;：这里的计算中，e.a 和 e.b 的值都分别为 1 和 2。所以 e.in.y 的值为 1 + 2 = 3。

联合体内存重用：

由于 in 结构体和 a、b 共享内存，后面的赋值可能会影响值。在这个过程中，in.x 和 in.y 被赋值，但实际上因为是联合体，只有最后一个写入的值有效。即使我们在赋值之前对 e.a 和 e.b 进行了操作，实际上 e.in.y 在这里并不会被赋值为 3，而是被 e.in.x 所覆盖。

打印输出：

printf("%d %d", e.in.x, e.in.y); 在这里可能会输出 4 和 8，原因在于内存共享导致后面的值覆盖了之前的值。

最后，由于 in.x 和 in.y 共享内存，它们最终可能会取到我们未预见的值（具体依赖于编译器、内存对齐等）。

解答 ：

4，8

2.15、以下程序的运行结果为____________。

#include <stdio.h>

struct w

{

           char low;

           char high;

};

union u

{

           struct w byte;

           int word;

}uu;

int  main( )

{

            uu.word = 0x1234;

            printf(“Word value:%04x\n”,uu.word);

            printf(“High value:%02x\n”,uu.byte.high);

            printf(“Low value:%02x\n”,uu.byte.low);

            uu.byte.low = oxff;

             printf(“Word value: %04x\n”,uu.word);

}

解析：

联合体的定义：

struct w 定义了一个结构体，包含两个 char 类型的成员 low 和 high。

union u 定义了一个联合体，包含 struct w 和一个 int 类型的 word。联合体的所有成员共享同一块内存。

将值赋给联合体

uu.word = 0x1234; 将 0x1234（十六进制数，等于4660）存入联合体的 word 成员。

在大端字节序（big-endian）系统中，0x1234 将存储为：

high: 0x12

low: 0x34

打印输出：

printf("Word value:%04x\n", uu.word); 输出 Word value:1234。

printf("High value:%02x\n", uu.byte.high); 输出高字节，结果为 12。

printf("Low value:%02x\n", uu.byte.low); 输出低字节，结果为 34。

修改低字节：

uu.byte.low = 0xff; 将联合体中的低字节设置为 0xff。在内存中，word 的值将被更新为：

高字节仍然为 0x12，低字节现在为 0xff。

所以现在 word 的值为 0x12ff。

最后输出：

printf("Word value: %04x\n", uu.word); 输出 Word value:12ff。

解答 ：

1234
12
34
12ff

2.16、以下程序的输出结果为____________

enum coin{ penny, nickel, dime, quarter,  half_dollar, dollar };

char *name[] =

 {“penny”,”nickel”,”dime”,”quarter”,”half_dollar”,”dollar”};

main( )

{

            enum coin money1,money2;

money1 = dime;

money2 = dollar;

printf(“%d %d\n”,meney1,money2)

printf(“%s %s\n”,name[(int)money1],name[(int)money2]);

}

解析：

枚举类型定义

在这里定义了一个枚举类型 coin，枚举的值分别是：

penny = 0

nickel = 1

dime = 2

quarter = 3

half_dollar = 4

dollar = 5

字符指针数组定义

这里定义了一个字符指针数组 name，用于存储对应的枚举名称。

枚举变量赋值

将 money1 设置为 dime，值为 2；将 money2 设置为 dollar，值为 5

打印输出

输出 money1 和 money2 的整数值，结果为 2 5

访问字符串数组

name[(int)money1]：(int)money1 的值是 2，因此输出 name[2]，对应的字符串为 "dime"。

name[(int)money2]：(int)money2 的值是 5，因此输出 name[5]，对应的字符串为 "dollar"。

解答 ：

2 5
dime dollar
 

2.17、以下程序的输出结果是____________。

#include <stdio.h>

typedef   int   INT;

int  main()

{

   INT a,b;

   a = 5;

         b = 6;

        printf("a = %d\tb = %d\n",a,b);

         {

          float   INT;

           INT = 3.0;

          printf("2*INT = %.2f\n",2*INT);

         }

}

解析：

类型定义：

typedef int INT;

使用 typedef 定义了一个新类型 INT，它是 int 的别名。因此，在程序中使用 INT 等价于使用 int。

变量声明和赋值：

INT a, b;

a = 5; 

b = 6;

这里定义了两个 INT 类型的变量 a 和 b，并将它们赋值为 5 和 6。

打印变量值：

printf("a = %d\tb = %d\n", a, b); 

输出为：

a = 5 b = 6

进入新作用域：

{ 

float INT; 

INT = 3.0; 

在这个新作用域中，INT 被重新定义为 float 类型。这会遮蔽前面的 typedef 定义，所以在这个作用域中 INT 不再是 int 的别名，而是一个 float 类型的变量。

计算并打印：

printf("2*INT = %.2f\n", 2 * INT); // 计算 2 * INT 的值，并打印

这里 INT 是 float 类型，并且被赋值为 3.0。因此，2 * INT 的计算结果是 6.0。输出为：

2*INT = 6.00

解答 ：

a = 5      b = 6
2*INT = 6.00