大纲要求：C 程序的结构、main 函数、注释、标识符命名规则、程序的开发流程。

最小可运行的 C 程序（必须默写）

C#include <stdio.h>            /* 预处理命令：引入标准输入输出库 */

int main(void)                  /* main 函数：程序入口，有且仅有一个 */
{
    int a = 10, b = 20;         /* 变量：先定义，后使用 */
    int sum;
    sum = a + b;                /* 每条语句以分号结尾 */
    printf("sum = %d\n", sum);  /* 注释不参与编译 */
    return 0;
}

C 程序的开发流程（必背）

必懂概念清单

大纲要求：基本数据类型、常量与变量、运算符与表达式、类型转换。这是选择题出题密度最高的一章。

基本数据类型

常量的写法（易错点集中）

C/* 整型常量：三种进制，注意——没有二进制写法！ */
12        /* 十进制 */
012       /* 八进制：以 0 开头，等于十进制 10 */
0x12      /* 十六进制：以 0x 开头，等于十进制 18 */

/* 实型常量 */
3.14   .5   5.   1.2e3    /* e 前必须有数字，e 后必须是整数 */

/* 字符常量与字符串常量 */
'a'   '\n'   '\x41'       /* 占 1 字节 */
"abc"                     /* 占 4 字节：a b c \0 */

常用转义字符

运算符与优先级（速查）

类型转换

Cint i = 3.9;              /* 自动转换：舍去小数 → i = 3（不是四舍五入） */
double d = (double)5 / 2;  /* 强制转换 → 2.5 */
/* 自动提升方向：char/short → int → unsigned → long → float → double */

大纲要求：格式化输入输出、字符输入输出。printf 和 scanf 是操作题中出现率最高的库函数，格式符必须一一对应。

printf 格式符速查

附加格式：%5d 宽度 5 右对齐（左补空格）、%-5d 左对齐、%5.2f 宽度 5 精度 2。

scanf 注意事项（每年必考）

Cint a;  float x;  char s[20];

scanf("%d", &a);          /* 普通变量前必须加取地址符 & */
scanf("%d%f", &a, &x);    /* 输入时用空格分隔：12 3.5 */
scanf("%d,%d", &a, &b);   /* 格式串有逗号，输入也必须输逗号 */
scanf("%s", s);           /* 数组名本身就是地址，不加 & */

字符输入输出

Cchar c;
c = getchar();          /* 读一个字符（含回车） */
putchar(c);             /* 输出一个字符 */
gets(s);                /* 读一行字符串（可含空格） */
puts(s);                /* 输出字符串并换行 */

亲手试一试 · printf 格式符演示

大纲要求：if 语句的三种形式、嵌套 if、switch 语句、条件运算符。

Cif (score >= 90)       printf("A");
else if (score >= 80)  printf("B");
else                   printf("C");

/* 条件运算符（唯一的三目运算符） */
max = (a > b) ? a : b;

/* switch：表达式只能是整型或字符型 */
switch (grade) {
    case 'A': printf("优"); break;
    case 'B': printf("良"); break;
    default : printf("中");
}

大纲要求：for、while、do-while 三种循环，break 与 continue，循环嵌套。所有操作题都建立在循环之上。

三种循环对比

Cint i, sum = 0;
for (i = 1; i <= 100; i++)   /* 初值; 条件; 步进 */
    sum += i;                /* 1+2+…+100 = 5050 */

i = 1;
while (i <= 100) { sum += i; i++; }

do { sum += i; i++; } while (i <= 100);   /* 注意末尾分号！ */

break 与 continue

Cfor (i = 1; i <= 10; i++) {
    if (i % 2 == 0) continue;  /* 跳过本次循环体，进入下一次循环 */
    if (i > 7) break;          /* 终止整个循环 */
    printf("%d ", i);          /* 输出：1 3 5 7 */
}

经典必刷题型：判断素数

Cint isPrime(int n)
{
    int i;
    if (n < 2) return 0;
    for (i = 2; i * i <= n; i++)     /* 只需试除到 √n */
        if (n % i == 0) return 0;    /* 找到因数 → 不是素数 */
    return 1;                        /* 没有因数 → 是素数 */
}

其他必须会写的经典循环

大纲要求：一维数组、二维数组的定义/初始化/引用，数组与循环结合的常用算法（排序、查找、逆置、移动）。

定义与初始化

Cint a[5] = {1, 2, 3, 4, 5};   /* 下标范围 0 ~ 4 */
int b[5] = {1, 2};            /* 未初始化的元素自动为 0 */
int c[]  = {1, 2, 3};         /* 长度自动确定为 3 */

int m[2][3] = {{1,2,3},{4,5,6}};  /* 二维数组：按行存放 */
m[1][2] = 6;                      /* 第 2 行第 3 列 */

经典必刷：冒泡排序（填空题最爱）

Cvoid sort(int a[], int n)
{
    int i, j, t;
    for (i = 0; i < n - 1; i++)            /* 共 n-1 趟 */
        for (j = 0; j < n - 1 - i; j++)    /* 每趟少比一次 */
            if (a[j] > a[j + 1]) {         /* 前大后小则交换 */
                t = a[j]; a[j] = a[j+1]; a[j+1] = t;
            }
}

其他高频算法

• 求最值：if (a[i] > max) max = a[i];
• 数组逆置：首尾交换 for (i=0; i<n/2; i++) swap(a[i], a[n-1-i])
• 插入 / 删除元素、数组元素移动（操作题常客）
• 杨辉三角、矩阵转置（二维数组）

大纲要求：函数定义/声明/调用、参数传递、递归、变量的作用域与生存期。操作题的三大题型全部围绕"函数"展开。

定义、声明与调用

Cint add(int x, int y)     /* 形参 */
{
    return x + y;
}

int main(void)
{
    int s = add(3, 5);      /* 实参：把 3、5 的值复制给形参 */
    return 0;
}

递归（选择题年年考）

Clong fac(int n)                 /* n 的阶乘 */
{
    if (n <= 1) return 1;       /* 递归出口：必须有！ */
    return n * fac(n - 1);      /* 自己调用自己 */
}
/* fac(4) = 4*fac(3) = 4*3*fac(2) = 4*3*2*fac(1) = 24 */

变量的作用域与生存期

大纲要求：指针的定义与引用、指针与数组、指针作函数参数。指针是二级 C 区分度最大的考点，操作题离不开它。

基本用法

Cint a = 10;
int *p = &a;         /* p 存放 a 的地址；此处 * 表示"指针" */

*p = 20;             /* 此处 * 表示"解引用"，等价于 a = 20 */
printf("%d %d", a, *p);   /* 输出 20 20 */

指针与数组（核心中的核心）

Cint a[5] = {1,2,3,4,5}, *p;
p = a;                    /* 等价于 p = &a[0]，数组名 = 首地址 */

/* 以下四种写法完全等价，都表示 a[2] */
a[2]      *(a + 2)        p[2]        *(p + 2)

传地址：让函数真正改变外面的变量

Cvoid swap(int *x, int *y)
{
    int t = *x;
    *x = *y;
    *y = t;
}
/* 调用：swap(&a, &b); —— 传地址，a、b 真正交换 */
/* 错误：swap(a, b);   —— 传值，只交换了形参 */

大纲要求：字符数组与字符串的关系、字符串结束标志、常用字符串处理函数、手动实现字符串算法。

字符串的存储（结束标志 '\0'）

Cchar s[10] = "hello";   /* 总共占 10 字节，有效 5 + \0 */
char t[]  = "hello";    /* 长度自动为 6（含 \0） */

常用字符串函数（需 #include <string.h>）

手动实现（操作题高频）

Cint myLen(char s[])            /* 求字符串长度 */
{
    int i = 0;
    while (s[i] != '\0') i++;
    return i;
}

void reverse(char s[])          /* 字符串逆置 */
{
    int i = 0, j = myLen(s) - 1;
    char t;
    while (i < j) {
        t = s[i]; s[i] = s[j]; s[j] = t;
        i++;  j--;
    }
}

大纲要求：结构体类型的定义与使用、typedef、链表概念、共用体、文件的基本读写操作。

结构体

Cstruct Student {
    int    num;
    char   name[20];
    float  score;
};

struct Student s1 = {1001, "Tom", 90.5};
struct Student *p = &s1;

s1.num        /* 结构体变量用 . 访问成员 */
p->num        /* 指针用 -> 访问，等价 (*p).num */

typedef struct Student STU;   /* 类型别名 */
STU s2;

链表结点（了解结构即可）

Cstruct Node {
    int data;
    struct Node *next;    /* 指向下一个结点 */
};
/* 删除 head 之后的结点：head->next = head->next->next; */

文件操作

CFILE *fp;
fp = fopen("data.txt", "r");   /* 打开失败返回 NULL */
if (fp == NULL) return;
/* …… 读写 …… */
fclose(fp);                      /* 用完必须关闭 */

常用读写函数

大纲要求：宏定义（不带参 / 带参）、文件包含。预处理在编译之前进行纯文本替换。

C#define PI 3.14159              /* 不带参宏：末尾不写分号！ */
#define S(x) ((x) * (x))         /* 带参宏：参数和整体都要加括号 */

#include <stdio.h>                /* 尖括号：到系统目录找 */
#include "myfun.h"                /* 双引号：先到用户当前目录找 */

printf("%f", S(3));               /* 编译前替换为 ((3)*(3)) → 9.000000 */

虽然只有 10 分，但属于系统复习后比较容易拿到的分数，不要忽略。

收录 2021–2024 年考生回忆版真题、2025 年官方样题，以及依据最新大纲编写的 2026 模拟预测题。 选择题点击选项立即判分；操作题点击「查看参考答案」展开解析。

Cdouble fun(int n)
{
    double f = ___(1)___;      /* 填：1（或 1.0） */
    int i;
    for (i = 1; ___(2)___; i++)  /* 填：i <= n */
        ___(3)___;               /* 填：f *= i （或 f = f * i） */
    return f;
}

Cdouble fun(int n)
{
    double s = 0.0;
    int i;
    for (i = 1; i < n; i++)        /* found：应改为 i <= n */
        s = s + 1 / i;             /* found：应改为 1.0 / i */
    return s;
}

Cvoid fun(int a, int b, long *c)
{
    *c = (a / 10) * 1000      /* a 的十位 → 千位 */
       + (b / 10) * 100       /* b 的十位 → 百位 */
       + (a % 10) * 10        /* a 的个位 → 十位 */
       + (b % 10);            /* b 的个位 → 个位 */
}

Cvoid fun(int a[], int *n)
{
    int i, k = 0;
    for (i = 1; i <= 1000; i++)
        if ((i % 7 == 0 || i % 11 == 0) && i % 77 != 0)
            a[k++] = i;
    *n = k;
}

Cint fun(int m)
{
    int k;
    for (k = 2; k <= m - 1; k++)
        if (m % k = 0)       /* found：应改为 m % k == 0 */
            return 0;
    return;                  /* found：应改为 return 1; */
}