作业一
数组练习
-
选择题
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;
}
作业二
指针练习
-
选择题
1.1、若有下面的变量定义，以下语句中合法的是（ ）。
int i，a[10]，*p；
A） p=a+2; B） p=a[5];
C） p=a[2]+2; D） p=&(i+2);
解析：
A） p = a + 2;
这是合法的。a 是一个整型数组，a + 2 表示指向数组中第 3 个元素（索引为 2）的指针。p 可以正确地指向这个元素。
B） p = a[5];
这是不合法的。a[5] 表示数组中第 6 个元素的值（类型为 int），而 p 是一个整型指针，不能直接赋值一个 int 值。
C） p = a[2] + 2;
这是不合法的。a[2] 是数组中第 3 个元素的值（类型为 int），而 p 是指针，不能直接将一个 int 值加 2 后赋值给 p。
D） p = &(i + 2);
这是不合法的。&(i + 2) 表示 i + 2 的地址，但是 i + 2 是一个临时计算的值，不能取得地址。
解答：
A
1.2、有以下程序
main()
{
int a[3][3],*p,i;
p=&a[0][0];
for(i=0;i<9;i++)
p[i]=i;
for(i=0;i<3;i++)
printf("%d ",a[1][i]);
}
程序运行后的输出结果是 ____________
A）0 1 2
B）1 2 3
C）2 3 4
D）3 4 5
解析：
a[0][0] = 0
a[0][1] = 1
a[0][2] = 2
a[1][0] = 3
a[1][1] = 4
a[1][2] = 5
a[2][0] = 6
a[2][1] = 7
a[2][2] = 8
这里输出的是数组 a 的第二行，即 a[1][0]、a[1][1] 和 a[1][2]，对应的值是 3、4 和 5。
解答：
D
1.3、有以下程序
int main()
{ int a[3][2]={0}, (*ptr)[2],i,j;
for(i=0;i<2;i++)
{ ptr=a+i;
scanf("%d",*ptr);
*ptr++;
}
for(i=0;i<3;i++)
{
for(j=0;j<2;j++)
printf("%2d",a[i][j]);
printf("\n");
}
}
若运行时输入:1 2 3<回车>,则输出结果为 ___________
A）产生错误信息
B）1 0
2 0
0 0
C）1 2
3 0
0 0
D）1 0
2 0
3 0
解析：
用户输入 1 2 3（中间用空格分隔），这样在循环中会被逐个读取：
当 i = 0 时，输入 1，将其存储到 a[0][0]。
当 i = 1 时，输入 2，将其存储到 a[1][0]。
因为循环只运行了 2 次，所以 a[2] 不会被修改。
对于 i = 0，a[0] = {1, 0} 输出 1 0
对于 i = 1，a[1] = {2, 0} 输出 2 0
对于 i = 2，a[2] = {0, 0} 输出 0 0
解答：
C
1.4、有以下程序
main()
{ int a[]={1,2,3,4,5,6,7,8,9,0},*p;
for(p=a;p<a+10;p++)
printf("%d,",*p);
}
程序运行后的输出结果是 __________
A）1，2，3，4，5，6，7，8，9，0，
B）2，3，4，5，6，7，8，9，10，1，
C）0，1，2，3，4，5，6，7，8，9，
D）1，1，1，1，1，1，1，1，1，，1，
解析：
p = a 将指针 p 初始化为数组 a 的首地址。
p < a + 10 是循环的条件，表示只要 p 小于数组 a 的末尾地址（即 a 的第 10 个元素的地址），循环将继续执行。
*p 表示获取 p 指向的当前元素的值，并将其打印。
在循环中，指针 p 将依次指向数组 a 中的每个元素，输出顺序为：
第一次循环：*p 是 1
第二次循环：*p 是 2
第三次循环：*p 是 3
第四次循环：*p 是 4
第五次循环：*p 是 5
第六次循环：*p 是 6
第七次循环：*p 是 7
第八次循环：*p 是 8
第九次循环：*p 是 9
第十次循环：*p 是 0
解答：
A
1.5、有以下程序
main()
{
char s[]="159",*p;
p=s;
printf("%c",*p++);
printf("%c",*p++);
}
程序运行后的输出结果是________
A）1 5 B）1 6 C）1 2 D）5 9
解析：
第一次执行 printf("%c", *p++);：
*p 是指向当前字符 '1'，所以输出 '1'。
p++ 将指针 p 移动到下一个字符 '5'。
第二次执行 printf("%c", *p++);：
此时 p 指向字符 '5'，所以输出 '5'。
p++ 将指针 p 移动到下一个字符 '9'。
解答：
A
1.6、有以下程序
point(char *p)
{
p+=3;
}
int main()
{ char b[4]={'a','b','c','d'}, *p=b;
point(p); printf("%c\n",*p);
}
程序运行后的输出结果是 __________
A）a B）b C）c D）d
解析：
当调用
point(p);时，传递的是p的副本。因此，原始指针p在main函数中的值仍然指向字符数组b的第一个元素，即'a'。
解答：
A
1.7、设有如下定义语句 int m[ ]={2,4,6,8}, *k=m;
以下选项中，表达式的值为 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、设有以下语句：
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
