半角🌙输入
第41题
给定程序中，函数fun的功能是用函数指针指向要调用的函数，并进行调用。规定在__2__处使fa指向函数f1，在__3__处使fb指向函数f2。当调用正确时，程序输出：
x1=5.000000，x2=3.000000，x1*x1+x1*x2=40.000000
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK.C中。
不得增行或删行，也不得更改程序的结构！
给定源程序：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
|
1.
正确答案： double
2.
正确答案： f1
3.
正确答案： f2
第42题
给定程序MODI1.C是建立一个带头结点的单向链表，并用随机函数为各结点赋值。函数fun的功能是将单向链表结点（不包括头结点）数据域为偶数的值累加起来，并且作为函数值返回。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
给定源程序：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
|
1.
正确答案： h->next
2.
正确答案： p-> next
共 18 分
假设链表结构为：
头结点（9000） → 节点1（2） → 节点2（5） → 节点3（8） → NULL
-
空1填
h->next后：p指向节点1（跳过头结点的9000）- 检查
2是偶数 → 累加到sum
-
空2填
p->next后：p移动到节点2（值为5，不是偶数 → 不累加）- 再次移动 → 到节点3（值为8，累加到
sum） - 最终
sum=2+8=10
请编写函数fun，函数的功能是：判断字符串是否为回文？若是，函数返回1，主函数中输出：YES；否则返回0，主函数中输出NO，回文是指顺读和倒读都一样的字符串。
例如，字符串LEVEL是回文，而字符串123312就不是回文。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 80
int fun(char *str)
{
int i,n=0,fg=1;
char *p=str;
while(①)
{
②
③
}
for（i=0;i<n/2;i++）
{
if(④)
{
⑤
⑥
}
}
return fg;
}
main()
{
char s[N];
void NONO();
printf("Enter a string：");
gets(s);
printf("\n");
puts(s);
if(fun(s))
{
printf("YES\n");
}
else
{
printf("NO\n");
}
NONO();
system("pause");
}
void NONO()
{/* 请在此函数内打开文件，输入测试数据，
调用函数，输出数据，关闭文件。 */
FILE *rf, *wf;
int i;
char s[N];
rf=fopen("in.dat","r");
wf=fopen("out.dat","w");
for(i=0; i<8; i++)
{
fscanf(rf, "%s", s);
if(fun(s))
{
fprintf(wf, "%s YES\n", s);
}
else
{
fprintf(wf, "%s NO\n", s);
}
}
fclose(rf);
fclose(wf);
}
1.
正确答案： *p
2.
正确答案： n++;
3.
正确答案： p++;
4.
正确答案： str[i]!=str[n-1-i]
5.
正确答案： fg=0
6.
正确答案： break;
代码整体结构说明
c
int fun(char *str) {
int i, n=0, fg=1; // n统计长度，fg标记是否是回文（1是，0否）
char *p = str; // 指针p从字符串开头开始
// 步骤1：计算字符串长度
while(*p) { // 循环直到遇到字符串结尾符'\0'
n++; // 每循环一次，长度+1
p++; // 指针移动到下一个字符
}
// 步骤2：对称比较字符
for(i=0; i<n/2; i++) { // 比较前一半字符（如长度5则比较前2个）
if(str[i] != str[n-1-i]) { // 比较第i个和倒数第i个字符
fg = 0; // 发现不相等，标记为非回文
break; // 提前终止循环，无需继续比较
}
}
return fg; // 返回结果（1是回文，0不是）
}逐句解释代码逻辑
1. 初始化变量
c
int i, n=0, fg=1;
char *p = str;- 作用：准备统计字符串长度和比较字符。
- 通俗解释：
n=0：用来记录字符串有多长（比如"LEVEL"是5个字符）。fg=1：假设字符串是回文，后面发现不匹配再改为0。p = str：让指针p指向字符串的第一个字符（如str是"LEVEL"，p先指向'L'）。
2. 计算字符串长度
c
while(*p) {
n++;
p++;
}- 作用：遍历整个字符串，统计字符数量。
- 通俗解释：
while(*p)：只要p指向的字符不是结尾符\0（比如字符串末尾的结束标志），就一直循环。n++：每循环一次，长度加1（比如遍历"LEVEL"时，n从0增加到5）。p++：让指针p移动到下一个字符（比如从'L'→'E'→'V'...直到结尾）。
3. 对称比较字符
c
for(i=0; i<n/2; i++) {
if(str[i] != str[n-1-i]) {
fg = 0;
break;
}
}- 作用：检查字符串是否对称。
- 通俗解释：
i<n/2：只需比较前一半字符（比如长度5，比较前2个；长度6，比较前3个）。str[i]：第i个字符（从前往后数）。str[n-1-i]：倒数第i个字符（从后往前数）。- 示例：
- 字符串"LEVEL"（长度5）：
i=0：比较str[0]='L'和str[4]='L'✅i=1：比较str[1]='E'和str[3]='E'✅
- 字符串"123312"（长度6）：
i=0：比较str[0]='1'和str[5]='2'❌ → 直接标记fg=0并终止循环。
- 字符串"LEVEL"（长度5）：
4. 返回结果
c
return fg;- 作用：返回判断结果。
- 通俗解释：
- 如果所有对称字符都相等，
fg保持1，返回"是回文"。 - 只要有一对不相等，
fg变为0，返回"不是回文"。
- 如果所有对称字符都相等，
给定程序中，函数fun的功能是将不带头结点的单向链表逆置。即若原链表中从头至尾结点数据域依次为：2、4、6、8、10，逆置后，从头至尾结点数据域依次为：10、8、6、4、2.
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
注意：源程序存放在考生文件夹下的BLANK.C中。
不得增行或删行，也不得更改程序的结构！
给定源程序：
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node {
int data;
struct node *next;
} NODE;
/**********found**********/
__1__ fun(NODE *h)
{NODE *p, *q, *r;
p = h;
if (p == NULL)
return NULL;
q = p->next;
p->next = NULL;
while (q)
{
/**********found**********/
r = q->__2__;
q->next = p;
p = q;
/**********found**********/
q = __3__ ;
}
return p;
}
NODE *creatlist(int a[])
{NODE *h,*p,*q; int i;
h=NULL;
for(i=0; i<N; i++)
{q=(NODE *)malloc(sizeof(NODE));
q->data=a[i];
q->next = NULL;
if (h == NULL) h = p = q;
else {p->next = q; p = q;}
}
return h;
}
void outlist(NODE *h)
{NODE *p;
p=h;
if (p==NULL) printf("The list is NULL!\n");
else
{printf("\nHead ");
do
{printf("->%d", p->data); p=p->next;}
while(p!=NULL);
printf("->End\n");
}
}
main()
{NODE *head;
int a[N]={2,4,6,8,10};
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
head=fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
}
1.
正确答案： NODE *
2.
正确答案： next
3.
正确答案： r
共 18 分
题目1：链表逆置
目标：把链表顺序倒过来（如2→4→6→8→10变成10→8→6→4→2）。
空1：NODE *
- 作用：告诉程序这个函数会返回一个链表的新头节点。
- 比喻：就像写“我给你的是一本书的封面”，这里的
NODE *就是告诉程序“封面在哪”。
空2：next
- 作用：保存当前节点的下一个节点地址。
- 比喻：翻书时先记住下一页的位置，否则翻过去就找不到后面的内容了。
- 代码逻辑：
r = q->next（记下q后面是谁，避免断开后丢失）。
空3：r
- 作用：移动到下一个待处理的节点。
- 比喻：翻到下一页继续操作（
q移动到之前保存的r的位置）。 - 代码逻辑：处理完当前节点后，让
q指向下一个节点继续循环。
第42题
给定程序MODI1.C中函数fun的功能是：将s所指字符串中位于奇数位置的字符或ASCII码为偶数的字符放入t所指数组中（规定第一个字符放在第0位中）。
例如，字符串中的数据为：AABBCCDDEEFF，则输出应当是ABBCDDEFF。
请改正程序中的错误，使它能得出正确结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
给定源程序：
#include <stdio.h>
#include <string.h>
#define N 80
void fun(char *s, char t[])
{int i, j=0;
for(i=0; i<(int)strlen(s); i++)
/***********found**********/
if(__1__)
t[j++]=s[i];
/***********found**********/
__2__;
}
main()
{char s[N], t[N];
printf("\n Please enter string s : "); gets(s);
fun(s, t);
printf("\nThe result is : %s\n",t);
}
1.
正确答案： i%2||s[i]%2==0 或 i%2!=0||s[i]%2==0
2.
正确答案： t[j]='\0' 或 t[j]=0
共 18 分
题目2：字符串筛选
目标：筛选出奇数位置或ASCII码为偶数的字符（如AABBCCDDEEFF变成ABBCDDEFF）。
填空思路
-
空1：
i%2 || s[i]%2 == 0- 作用：判断当前字符是否满足条件。
- 通俗解释：
i%2：位置是奇数（如第1、3、5位）。s[i]%2 == 0：字符的ASCII码是偶数（如B的ASCII码66是偶数）。
- 示例：第1位
A（ASCII 65，奇数位置满足条件），第2位A（ASCII 65不满足）。
-
空2：
t[j] = '\0'- 作用：在结果字符串末尾添加结束符。
- 比喻：写完一封信后写上“完”字，否则程序不知道哪里结束。
- 代码逻辑：
t[j] = '\0'（标记字符串结束）。
代码结构通俗解释
- 遍历字符串：逐个检查每个字符的位置和ASCII码。
- 条件筛选：符合条件则存入
t数组。 - 结束处理：最后添加
\0，避免输出时包含垃圾数据。
第43题请编写函数fun，函数的功能是：将M行N列的二维数组中的数据，按列的顺序依次放到一维数组中。
例如，二维数组中的数据为：
33 33 33 33
44 44 44 44
55 55 55 55
则一维数组中的内容应该是：
33 44 55 33 44 55 33 44 55 33 44 55。
注意：部分源程序在文件PROG1.C中。
请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
给定源程序：
#include <stdio.h>
void fun(int s[][10], int b[], int *n, int mm, int nn)
{
__1__;
for(j=0;j<nn;j++)
for(__2__)
{
b[*n]=__3__;
__4__;
}
}
main()
{int w[10][10]={{33,33,33,33},{44,44,44,44},{55,55, 55,55}},i,j;
int a[100]={0}, n=0;void NONO ();
printf("The matrix:\n");
for(i=0; i<3; i++)
{for(j=0;j<4; j++)printf("%3d",w[i][j]);
printf("\n"); }
fun(w,a,&n,3,4);
printf("The A array:\n");
for(i=0;i<n;i++)printf("%3d",a[i]);printf("\n\n");
NONO();
}
void NONO ()
{/* 请在此函数内打开文件，输入测试数据，调用 fun 函数，输出数据，关闭文件。 */
FILE *rf, *wf ; int i, j, k ;
int w[10][10], a[100], n = 0, mm, nn ;
rf = fopen("in.dat","r");
wf = fopen("out.dat","w");
for(k = 0 ; k < 5 ; k++) {
fscanf(rf, "%d %d", &mm, &nn);
for(i = 0 ; i < mm ; i++)
for(j = 0 ; j < nn ; j++) fscanf(rf, "%d", &w[i][j]);
fun(w, a, &n, mm, nn);
for(i = 0 ; i < n ; i++) fprintf(wf, "%3d", a[i]); fprintf(wf, "\n");
}
fclose(rf); fclose(wf);
}
1.
正确答案： int i,j
2.
正确答案： i=0;i<mm;i++
3.
正确答案： *(*(s+i)+j)
4.
正确答案： *n=*n+1
题目3：二维数组按列转一维
目标：按列顺序将二维数组存入一维数组（如3行4列转成33,44,55,33,44,55...）。
填空思路
-
空1：
int i, j- 作用：声明循环变量，用于遍历行和列。
- 比喻：准备两个计数器，一个数行，一个数列。
-
空2：
i = 0; i < mm; i++- 作用：按行遍历每一列。
- 通俗解释：固定一列（如第0列），从上到下取每一行的数据。
-
空3：
*(*(s + i) + j)- 作用：获取二维数组第
i行第j列的元素。 - 比喻：用坐标（行, 列）定位数据，类似Excel表格的单元格。
- 作用：获取二维数组第
-
空4：
*n = *n + 1- 作用：每存一个数据，计数器加1。
- 比喻：每放一个东西到箱子里，就在本子上记一笔，方便知道总数。
代码结构通俗解释
- 按列遍历：外层循环控制列，内层循环控制行。
- 逐行读取：对每一列，从上到下读取所有行的数据。
- 存入一维数组：将读取的数据依次放入一维数组，并更新计数器。
参考逻辑：类似整理书架，先按列从上到下取书，再移到下一列重复操作
题目1：链表逆置（完整代码注释）
c
NODE* fun(NODE *h) { // 填空①：返回逆置后的新链表头（类似新书的封面）
NODE *p, *q, *r;
p = h; // p指向原链表头（原书第一页）
if (p == NULL) return NULL;
q = p->next; // q指向第二个节点（原书第二页）
p->next = NULL; // 断开原头节点，变成新链表的末尾（把第一页撕下来放一边）
while (q) { // 循环处理所有节点（一页一页翻转）
r = q->next; // 填空②：保存q的下一个节点（先记住下一页的位置）
q->next = p; // 将q的指针指向p（把当前页钉到新书最前面）
p = q; // 移动p到当前节点（新书的封面更新为当前页）
q = r; // 填空③：q移动到下一个节点（翻到下一页继续操作）
}
return p; // 最终p是新链表的头（整本书倒过来了）
}题目2：字符串筛选（完整代码注释）
c
void fun(char *s, char t[]) {
int i, j=0;
for(i=0; i<strlen(s); i++) {
// 填空①：判断条件（要么是奇数位置，要么是ASCII码为偶数的字符）
if(i%2 || s[i]%2==0) { // 类似“挑出第1/3/5页，或页上画了偶数图案的书页”
t[j++] = s[i]; // 符合条件的字符存入t数组
}
}
t[j] = '\0'; // 填空②：添加结束符（在筛选后的字符串末尾写“完”字）
}题目3：二维数组转一维（完整代码注释）
c
void fun(int s[][10], int b[], int *n, int mm, int nn) {
int i,j; // 填空①：声明行(i)和列(j)的计数器
for(j=0; j<nn; j++) { // 外层循环控制列（先处理第0列，再第1列...）
for(i=0; i<mm; i++) { // 填空②：内层循环按行遍历当前列（从上到下扫描一列）
b[*n] = s[i][j]; // 填空③：取第i行第j列的数据（类似Excel表格的单元格）
(*n)++; // 填空④：计数器+1（每存一个数，本子上记一笔总数）
}
}
}函数fun()的功能是：在有n个元素的结构体数组std中，查找有不及格科目的学生，找到后输出学生的学号；函数的返回值是有不及格科目的学生人数。例如，主函数中给出了4名学生的数据，则程序运行的结果为：
学号：N1002 学号：N1006
共有2位学生有不及格科目
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
|
1.
正确答案： STU
2.
正确答案： ||
3.
正确答案： k
第一个空：STU
正确答案：STU
解析：
此处需要定义结构体类型的别名。根据代码中typedef struct { ... }的语法，结构体别名应填写在最后。参考结构体定义：
typedef struct {
char num[10];
double s;
} STREC; 题目中结构体的别名应为STU，因此填空处应为STU。
2. 第二个空：||
正确答案：||
解析：
此处需要判断学生是否有任意一科不及格（即分数低于60）。C语言中逻辑“或”运算符为||，表示两个条件满足其一即可。
例如，判断分数是否等于最高分时，使用了if (p[i].s == max)的条件判断，但本题需要判断两个科目中任意一科是否低于60，因此应使用逻辑或运算符||。
3. 第三个空：k
正确答案：k
解析：
变量k在函数中记录了不及格学生的人数，最终需通过return返回该值。fun函数中通过形参*n传回人数，而本题直接通过函数返回值传递，因此应返回k。
函数fun()的功能是：判断整数n是否是“完数”。当一个数的因子之和恰好等于这个数本身时，就称这个数为“完数"。例如：6的因子包括1、2、3，而6=1+2+3，所以6是完数。如果是完数，函数返回值为1，否则函数返回值为0。
数组a中存放的是找到的因子，变量k中存放的是因子的个数。请改正函数fun中指定部位的错误，使它能得出正确的结果。
注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
|
1.
正确答案： *k=m;
2.
正确答案： if(t==0)
#include <stdio.h>
#include <stdlib.h>
int fun(int n, int a[], int *k) {
int m = 0, i, t = n;
for (i = 1; i < n; i++) { // 遍历1到n-1找因子
if (n % i == 0) {
a[m] = i; // 存储因子到数组a
m++;
t -= i; // 用t累减所有因子
}
}
*k = m; // 错误1修正：通过指针返回因子个数
return (t == 0); // 错误2修正：判断t是否为0（即因子和等于n）
}
int main() {
int n, a[10], flag, i, k;
printf("请输入一个整数：");
scanf("%d", &n);
flag = fun(n, a, &k);
if (flag) {
printf("%d是完数，其因子是：", n);
for (i = 0; i < k; i++) printf(" %d ", a[i]);
} else printf("%d不是完数\n", n);
system("pause");
return 0;
}请编写函数fun()，其功能是：在形参指针所指的4个整数中找出最大值和最小值，最大的放在a中，最小的放在d中。
注意：请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括中的标号处填入所编写的若干语句。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
|
1.
正确答案： *a<*b
2.
正确答案： t=*a
3.
正确答案： *a=*b
4.
正确答案： *b=t
5.
正确答案： *a<*c
6.
正确答案： t=*a
7.
正确答案： *a=*c
8.
正确答案： *c=t
9.
正确答案： *a<*d
10.
正确答案： t=*a
11.
正确答案： *a=*d
12.
正确答案： *d=t
13.
正确答案： *b<*c
14.
正确答案： t=*a
15.
正确答案： *a=*d
16.
正确答案： *d=t
17.
正确答案： *a<*d
18.
正确答案： t=*a
19.
正确答案： *a=*d
20.
正确答案： *d=t
21.
正确答案： *b<*c
22.
正确答案： t=*b
23.
正确答案： *b=*c
24.
正确答案： *c=t
#include <stdio.h>
#include <stdlib.h>
void NONO();
void fun(int *a,int *b,int *c,int *d)
{
int t;
// 比较 *a 和 *b，如果 *a 小于 *b，则交换它们的值
if(*a<*b)
{
t=*a;
*a=*b;
*b=t;
}
// 比较 *a 和 *c，如果 *a 小于 *c，则交换它们的值
if(*a<*c)
{
t=*a;
*a=*c;
*c=t;
}
// 比较 *a 和 *d，如果 *a 小于 *d，则交换它们的值
if(*a<*d)
{
t=*a;
*a=*d;
*d=t;
}
// 比较 *b 和 *c，如果 *b 小于 *c，则交换它们的值
if(*b<*c)
{
t=*b;
*b=*c;
*c=t;
}
// 比较 *b 和 *d，如果 *b 小于 *d，则交换它们的值
if(*b<*d)
{
t=*b;
*b=*d;
*d=t;
}
// 比较 *c 和 *d，如果 *c 小于 *d，则交换它们的值
if(*c<*d)
{
t=*c;
*c=*d;
*d=t;
}
}
main()
{
int a, b, c, d;
printf("请输入4个整数：");
scanf("%d %d %d %d",&a,&b,&c,&d);
printf("原始顺序：%d,%d,%d,%d\n",a,b,c,d);
fun(&a,&b,&c,&d);
printf("处理后顺序：%d,%d,%d,%d\n",a,b,c,d);
NONO();
}
void NONO()
{/*本函数用于打开文件，输入数据，
调用函数，输出数据，关闭文件。*/
FILE *rf,*wf;
int i, a, b, c, d;
rf=fopen("in.dat","r");
wf=fopen("out.dat","w");
for(i=0; i<8; i++)
{
fscanf(rf,"%d %d %d %d",&a,&b,&c,&d);
fun(&a,&b,&c,&d);
fprintf(wf,"a=%d,d=%d\n",a,d);
}
fclose(rf);
fclose(wf);
system("pause");
}编程填空题设计及解析（基于完数、质数等常见考点）
题目1：质数判断函数填空
c
// 判断n是否为质数，返回1是质数，0不是
int isPrime(int n) {
if (n <= 1) return 0;
for (int i = 2; i < n; i++) { // 填空1：循环条件优化
if (______) return 0; // 填空2：判断是否为非质数
}
return 1;
}答案与解析
- 填空1：
i <= sqrt(n)或i * i <= n
质数判断只需检查到√n即可，否则效率低下8
9
。 - 填空2：
n % i == 0
若存在因子，则不是质数。
题目2：水仙花数填空
c
// 判断n是否为水仙花数（三位数，各位立方和等于自身）
int isNarcissistic(int n) {
int sum = 0, temp = n;
while (temp > 0) {
int digit = ______; // 填空1：取个位数字
sum += ______; // 填空2：计算立方和
temp /= 10;
}
return sum == n;
}答案与解析
- 填空1：
temp % 10
分离各位数字需用取余操作9
。 - 填空2：
digit * digit * digit
水仙花数要求各位立方和等于自身10
。
题目3：回文数填空
c
// 判断n是否为回文数（如121）
int isPalindrome(int n) {
int reversed = 0, original = n;
while (n > 0) {
reversed = reversed * 10 + ______; // 填空1：构造翻转数
n = ______; // 填空2：去除已处理位
}
return reversed == original;
}答案与解析
- 填空1：
n % 10
取当前最低位数字添加到翻转数中9
。 - 填空2：
n / 10
每次循环去掉已处理的最低位10
。
题目4：亲和数判断填空
c
// 判断a和b是否为亲和数（彼此因子和相等）
int sumDivisors(int num) {
int sum = 0;
for (int i = 1; i < num; i++) {
if (______) sum += i; // 填空1：累加因子
}
return sum;
}
int areAmicable(int a, int b) {
return ______ && ______; // 填空2：判断条件
}答案与解析
- 填空1：
num % i == 0
因子需满足整除条件9
。 - 填空2：
sumDivisors(a) == b和sumDivisors(b) == a
亲和数需彼此因子和相等10
。
常见考点总结与突击技巧
-
指针传参错误
- 错误示例：
k = m（未解引用） - 修正：
*k = m1
5
- 技巧：指针参数需用
*操作符修改外部变量值。
- 错误示例：
-
逻辑条件错误
- 错误示例：
if (t = 0)（赋值非判断） - 修正：
if (t == 0)5
7
- 技巧：注意
=和==的区别，编译时开启警告（如-Wall）。
- 错误示例：
-
循环范围优化
- 质数优化：
i <= sqrt(n)代替i < n8
9
。 - 完数优化：遍历到
n/2即可5
。
- 质数优化：
-
动态内存与字符串处理
- 字符串结束符：
str[j] = '\0'3
9
。 - 文件操作：
fgetc和fputc需检查EOF5
7
。
- 字符串结束符：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
