广东计算机专升本计算机科目（C语言+数据结构）第一篇一文吃透广东计算机专升本计算机科目（C语言+数据结构）第一篇：考情全

`一文吃透广东计算机专升本计算机科目（C语言+数据结构）第一篇：考情全解析+C语言基础到核心语法体系`

在上一篇文章中，我们完整拆解了广东计算机专升本高等数学科目的全体系考点与备考全攻略，很多同学在评论区催更计算机专业综合课的内容。作为广东计算机专升本的核心拉分科目，省统考《计算机基础与程序设计》（C语言+数据结构）满分200分，占了专升本500分总分的40%，直接决定了你能否冲进公办本科院校，更是你未来计算机专业深造、入行开发、深耕人工智能/大数据/软件工程等方向的核心底层能力。

我知道，很多备考计算机专升本的同学，都面临着一模一样的困境：

零基础跨考，或者专科阶段只学了皮毛，对着C语言的指针、结构体望而生畏，完全不知道从何入手；
背了一堆语法规则，上课听懂了，一写代码就报错，一做题就卡壳，完全不知道怎么把语法转化为可运行的代码；
程序阅读题看着密密麻麻的代码，完全理不清执行逻辑，算不对最终结果，频频丢分；
编程题拿到需求，脑子一片空白，不知道怎么拆解问题、搭建代码框架，只能干瞪眼；
数据结构的算法更是像天书，线性表、二叉树、排序算法背了就忘，更别说手写代码实现了。

别担心，这个系列我将完全贴合2026年广东省普通专升本《计算机基础与程序设计》最新统考考纲，结合近10年广东专升本计算机统考真题的命题规律，针对计算机专业考生的备考痛点，把C语言+数据结构的全部考点做体系化的拆解，从基础概念到核心语法，从解题逻辑到代码实现，从真题考点到易错点避雷，分三篇文章给你讲得明明白白。

本系列三篇内容规划如下：

第一篇（本篇）：考情全拆解+C语言基础到核心语法体系（基础概念、数据类型、运算符、三大程序结构、数组与字符串）
第二篇：C语言进阶核心语法（函数、指针、结构体、文件操作）+数据结构基础与线性结构全考点
第三篇：数据结构非线性结构（树、图）+查找与排序全考点+全科目备考全攻略

无论你是零基础起步，还是已经进入强化刷题阶段，这篇文章都能帮你搭建起C语言的完整知识体系，精准抓住广东专升本的考试重点，扫清备考路上的所有障碍。

一、广东计算机专升本《计算机基础与程序设计》考情全拆解

在开始知识点拆解之前，我们必须先搞清楚：这门科目到底考什么？怎么考？只有吃透考情，备考才能有的放矢，不做无用功。

1. 考试性质与定位

广东省普通专升本《计算机基础与程序设计》（科目代码003），是广东省教育考试院组织的全省统考专业综合课，适用于计算机科学与技术、软件工程、人工智能、大数据技术与应用、网络工程、信息安全、物联网工程等所有计算机类本科专业，是计算机类专升本考生的必考科目。

本科目满分200分，考试时间150分钟，考试结果是本科院校录取的核心依据。从近3年的录取数据来看，广东计算机类专业是专升本的第一大热门赛道，公办院校报录比常年突破25:1，深圳大学、广东技术师范大学、东莞理工学院等热门公办院校的录取线，专业综合课平均分普遍在140分以上，哪怕是民办院校，专业综合课也需要达到100分以上才有录取把握。可以说，得专业综合课者，得计算机专升本的天下。

2. 试卷题型与分值分布

根据2026年最新考纲和近5年统考真题规律，广东专升本《计算机基础与程序设计》试卷题型和分值分布完全固定，具体如下：

题型	题量	单题分值	总分值	核心考查方向
单项选择题	20题	2分/题	40分	C语言基础概念、语法规则、细节辨析；数据结构基础概念、性质判定、算法逻辑与复杂度分析
填空题	10题	2分/题	20分	C语言语法细节、表达式计算结果、程序执行关键节点；数据结构核心术语、算法特性填空
程序阅读题	4题	5分/题	20分	C语言分支、循环、数组、函数、指针、结构体的程序执行结果计算，侧重语法综合应用与逻辑梳理
程序填空题	3题	6分/题	18分	C语言核心语法场景的代码补全，涵盖循环逻辑、数组操作、函数实现、指针应用、字符串处理、结构体操作
编程题	2题	16分/题	32分	C语言综合编程能力，常考数组与字符串处理、函数封装、排序查找、结构体应用、数学计算等场景
综合应用题	3题	20分/题	60分	数据结构核心算法与场景应用，涵盖线性表、栈与队列、树与二叉树、图、查找、排序六大模块，含算法分析、代码实现、场景设计与复杂度计算

从分值分布可以清晰看到：代码相关的题型（程序阅读、程序填空、编程、综合应用）占了130分，是考试的绝对核心。这就要求我们备考时，绝对不能只死记硬背语法概念，必须把“读代码、写代码、调代码”的能力放在第一位，不仅要懂语法，更要会用语法解决实际问题。而选择填空是必须拿满的基础分，侧重考查对语法细节和概念的精准理解，不能有丝毫模糊。

3. 考纲范围与模块分值占比

根据2026年最新考纲，本科目考试范围分为C语言程序设计、数据结构两大部分，结合历年真题的分值分布，我们可以清晰划分出核心重点、次重点和基础了解模块：

（1）C语言程序设计（90-100分，占比45%-50%）

C语言是数据结构的基础，也是整个科目备考的地基，所有代码实现都依赖C语言语法，是必须100%吃透的内容。

模块分类	具体模块	考查优先级
核心重点模块	指针、数组、函数、结构体、字符串	★★★★★
次重点模块	三大程序结构（顺序、分支、循环）、运算符与表达式、数据类型	★★★★☆
基础了解模块	编译预处理、文件操作、位运算	★★☆☆☆

（2）数据结构（100-110分，占比50%-55%）

数据结构是本门科目的拉分核心，综合应用题几乎全部出自数据结构，也是区分高分段和中分段的关键，更是计算机专业学生的核心竞争力。

模块分类	具体模块	考查优先级
核心重点模块	线性表、树与二叉树、排序算法、查找算法	★★★★★
次重点模块	栈与队列、图的存储与基本算法	★★★★☆
基础了解模块	串、广义表、文件结构	★★☆☆☆

4. 写给备考同学的真心话

很多同学会问：“我零基础，C语言从来没接触过，能学好吗？”“我专科阶段没好好学，现在备考来得及吗？”

答案是：完全可以。

广东专升本的C语言和数据结构考试，本质上是水平性考试，不是竞赛类考试，考点非常固定，命题规律极强，没有偏题怪题，所有考点都在考纲范围内，所有题型都有固定的解题逻辑和方法。哪怕你是零基础，只要按照体系化的路径，一步一个脚印，从基础语法到代码实现，从核心考点到真题刷题，完全可以在备考周期内拿到150+的高分。

更重要的是，对于计算机专业的你来说，学好C语言和数据结构，绝对不只是为了应付专升本考试。C语言是最贴近计算机底层的高级语言，学好C语言，你才能真正理解计算机的内存、CPU是怎么工作的，才能建立起真正的编程思维；而数据结构是所有软件开发的核心，无论是你未来做后端开发、游戏开发，还是深耕人工智能、大数据，本质上都是在做“数据结构的设计+算法的实现”。这两门课，是你计算机职业生涯的起点，而不是终点。

二、C语言全考点体系化拆解（上篇）

C语言的学习，绝对不是死记硬背语法规则，而是要理解“计算机怎么执行代码”，建立起“用代码解决问题”的编程思维。接下来，我们将完全贴合广东专升本考纲，从基础概念出发，对C语言的核心考点做体系化拆解，每个模块都包含考情定位、核心知识点、必备规则、高频考点真题例题、易错点避雷五大板块，帮你从本质上吃透C语言。

模块一：C语言基础概念与程序结构

考情定位

本模块是C语言的入门基础，每年必考4-6分，以单项选择题、填空题为主，难度极低，是必须拿满的“送分题”。核心考查C语言的基本特点、程序结构、标识符与关键字、编译执行过程，是所有C语言学习的地基。

核心知识点拆解

1. C语言的本质与核心特点

C语言是一门面向过程的结构化程序设计语言，同时也是一门编译型语言，兼具高级语言的可读性和低级语言的硬件操控能力，被称为“编程语言之母”。

针对广东专升本考试，你只需要记住C语言的6个核心考点特点：

结构化程序设计：支持顺序、分支、循环三大基本结构，代码模块化，可读性强；
编译型语言：C语言代码必须经过“编译-链接”生成可执行文件，才能被计算机执行，和Python、JavaScript等解释型语言（逐行执行）有本质区别；
可移植性强：C语言代码可以在不同的操作系统（Windows、Linux、MacOS）和硬件平台上编译运行，仅需少量修改；
贴近硬件底层：可以直接操作内存地址、硬件寄存器，是操作系统、嵌入式开发的首选语言；
语法简洁灵活：核心关键字只有32个，代码量小，执行效率极高；
区分大小写：C语言严格区分大小写，int和Int是完全不同的两个标识符，这是选择题高频易错点。

2. C程序的基本结构

我们先通过一个最简单的C程序，搞懂C程序的核心结构，这是你写的所有C程序的基础模板：

#include <stdio.h>  // 预处理命令，头文件包含
#define PI 3.14159  // 宏定义，符号常量

// 主函数，程序执行的唯一入口
int main()
{
    // 代码主体，函数体，用{}包裹
    int a = 10;  // 变量定义
    printf("Hello World! a=%d\n", a);  // 输出语句
    return 0;  // 函数返回值，main函数正常结束返回0
}

针对这个模板，我们拆解C程序的核心考点：

main函数是程序执行的唯一入口：一个完整的C程序，有且仅有一个main函数，无论main函数写在代码的哪个位置，程序永远从main函数的第一行开始执行。这是选择题必考知识点，绝对不能记错。
预处理命令：以#开头的语句，比如#include <stdio.h>，在编译之前执行，#include <stdio.h>的作用是引入标准输入输出头文件，我们常用的printf、scanf函数都定义在这个头文件里，没有这个头文件，输入输出函数无法使用。
函数体：用{}包裹的代码块，所有可执行语句都必须写在函数体里，C语言的每条语句都必须以英文分号;结尾，分号是语句结束的标志，漏掉分号是新手最常见的编译错误。
注释：代码中的说明性文字，不会被编译执行，分为两种：
- 单行注释：// 注释内容，从//开始到行尾的内容都是注释
- 多行注释：/* 注释内容 */，包裹在中间的所有内容都是注释，不能嵌套使用注释的考点：注释不会被编译，不会影响程序执行结果，程序阅读题中可以直接忽略注释内容。
C程序的编译与执行过程（选择题高频考点）： C语言代码从.c源文件到可执行文件，必须经过4个步骤：
1. 预处理：处理所有#开头的预处理命令，比如头文件包含、宏替换、条件编译，生成.i文件；
2. 编译：将预处理后的文件编译成汇编语言，生成.s汇编文件；
3. 汇编：将汇编文件翻译成机器指令（二进制代码），生成.o目标文件；
4. 链接：将目标文件和用到的库文件链接在一起，生成可执行文件（Windows下为.exe，Linux下为.out）。

3. 标识符与关键字

标识符：程序员给变量、函数、数组、宏等起的名字，就是标识符。标识符的命名规则（选择题必考，必须100%记住）：
1. 只能由字母、数字、下划线三种字符组成；
2. 第一个字符必须是字母或下划线，绝对不能是数字；
3. 严格区分大小写；
4. 不能使用C语言的32个关键字作为标识符。举个例子：a、_num、student_name、Age都是合法的标识符；123a、a-b、int、$money都是非法的标识符。
关键字：C语言预先定义好的、具有特殊含义的单词，也叫保留字，不能作为标识符使用。 C语言标准的32个关键字，专升本常考的有：int、char、float、double、if、else、switch、case、break、continue、for、while、do、return、void、static、const、struct、typedef、sizeof，其余关键字仅需了解即可。

4. 结构化程序设计的三大基本结构

C语言是结构化程序设计语言，所有复杂的程序都可以拆解为三种基本结构：

顺序结构：代码从上到下依次执行，是最基础的程序结构；
选择结构（分支结构）：根据给定的条件，判断执行哪一段代码，比如if-else、switch语句；
循环结构：根据给定的条件，重复执行某一段代码，比如for、while、do-while语句。

高频考点真题例题

例1（2024年广东专升本真题·单选题） 以下合法的C语言标识符是（） A. 123abc B. abc_123 C. int D. a-b-c 解：正确答案是B。

A选项以数字开头，非法；
C选项是C语言关键字，不能作为标识符；
D选项包含非法字符-，非法。

例2（2023年广东专升本真题·单选题） 一个完整的C语言程序的执行入口是（） A. 程序中的第一个函数 B. main函数 C. 程序中的第一条语句 D. #include语句解：正确答案是B。C程序有且仅有一个main函数，是程序执行的唯一入口。

易错点避雷

C语言严格区分大小写，Int和int是完全不同的内容，int是关键字，Int是合法的标识符，选择题中极易混淆。
C语言的语句必须以英文分号结尾，中文分号会导致编译错误，新手写代码时一定要注意输入法切换。
标识符只能由字母、数字、下划线组成，不能包含$、-、空格等其他字符，也不能以数字开头。
注释不能嵌套使用，/* 注释1 /* 注释2 */ 注释1 */是非法的，会导致编译错误。

模块二：数据类型、常量与变量

考情定位

本模块是C语言数据处理的核心基础，每年必考6-8分，全题型均有涉及，是程序阅读题、表达式计算题的核心基础。所有的代码操作，本质上都是对数据的操作，而数据类型决定了数据的存储方式、取值范围和可执行的操作，是必须吃透的核心模块。

核心知识点拆解

1. 数据类型的本质

计算机的内存，就像一个巨大的酒店，每个内存单元就是一个酒店房间，每个房间都有唯一的门牌号（内存地址），而数据类型，就是给这个房间规定大小和用途。比如int类型是标间，占用4个字节的内存；double类型是套房，占用8个字节的内存。不同类型的数据，占用的内存大小不同，能存储的数值范围也不同，能执行的运算也不同。

C语言的数据类型分为四大类：基本类型、构造类型、指针类型、空类型void。本篇我们重点讲解基本类型，构造类型（数组、结构体等）、指针类型会在后续模块详细讲解。

C语言的基本数据类型分为三类：整型、字符型、实型（浮点型），我们针对专升本考点，逐一拆解。

2. 整型数据

整型数据用于存储整数，根据占用内存大小和取值范围，分为以下几种，专升本重点考查int类型，其余类型仅需了解：

类型名	32位系统占用字节数	取值范围	格式控制符（printf/scanf）
`int`（基本整型）	4字节	$-2^{31} \sim 2^{31}-1$ ，即-2147483648 ~ 2147483647	`%d`
`short`（短整型）	2字节	$-2^{15} \sim 2^{15}-1$ ，即-32768 ~ 32767	`%hd`
`long`（长整型）	4字节	和`int`一致	`%ld`
`long long`（双长整型）	8字节	$-2^{63} \sim 2^{63}-1$	`%lld`
`unsigned int`（无符号基本整型）	4字节	$0 \sim 2^{32}-1$ ，即0 ~ 4294967295	`%u`

核心考点：

无符号整型unsigned只能存储非负整数，取值范围的下限是0，上限比同字节的有符号整型高一倍，选择题高频考点。
整型常量在代码中可以用三种进制表示：
- 十进制：直接写数字，比如10、-25，最常用；
- 八进制：以数字0开头，比如012，对应十进制的10，只能包含0-7的数字；
- 十六进制：以0x或0X开头，比如0xA，对应十进制的10，包含0-9、a-f/A-F。这是选择题高频考点，比如018是非法的八进制数，因为八进制没有数字8。

3. 字符型数据

字符型数据用char表示，占用1个字节（8位）的内存，用于存储单个字符，本质上存储的是字符的ASCII码值，是一个整型数。

核心考点：

ASCII码表（必考）：C语言中，每个字符都对应一个0-127的ASCII码值，重点记住三个核心值：
- 字符'0'的ASCII码值是48；
- 字符'A'的ASCII码值是65；
- 字符'a'的ASCII码值是97。大写字母和小写字母的ASCII码值相差32，即'a' - 'A' = 32，这是程序阅读题的高频考点。
char类型的本质是整型，所以可以直接参与算术运算，比如'A' + 32的结果是97，也就是字符'a'的ASCII码值。
格式控制符：%c，用于输入输出单个字符。

4. 实型（浮点型）数据

实型数据用于存储小数，分为单精度浮点型float和双精度浮点型double，专升本重点考查double类型。

类型名	占用字节数	有效数字	格式控制符（printf）	格式控制符（scanf）
`float`（单精度）	4字节	6-7位	`%f`	`%f`
`double`（双精度）	8字节	15-16位	`%f`/`%lf`	`%lf`

核心考点（高频易错点）：

printf函数中，float和double类型都可以用%f输出；但scanf函数中，float必须用%f，double必须用%lf，这个细节是每年必考的易错点，很多同学在这里丢分。
浮点型常量有两种表示方式：
- 小数形式：比如3.14、-0.5、100.；
- 指数形式（科学计数法）：比如3.14e2表示 $3.14 \times 10^2$ ，即314；1.2e-3表示 $1.2 \times 10^{-3}$ ，即0.0012。注意：e/E前面必须有数字，后面必须是整数，e3、3.14e2.5都是非法的。

5. 常量与变量

常量：程序运行过程中，值不能被改变的量，分为以下几类：
1. 整型常量：比如10、012、0xA；
2. 实型常量：比如3.14、1.2e3；
3. 字符常量：用单引号''包裹的单个字符，比如'a'、'5'、'\n'，重点注意：单引号里只能有一个字符，'ab'是非法的字符常量。
4. 字符串常量：用双引号""包裹的字符序列，比如"Hello World"、"a"，字符串常量的结尾会自动加上一个字符串结束标志'\0'（ASCII码值为0的空字符）。 ⚠️ 必考易错点：字符常量'a'和字符串常量"a"完全不同，'a'占用1个字节，存储的是字符a的ASCII码值；"a"占用2个字节，存储的是'a'和'\0'。
5. 符号常量：用#define定义的常量，比如#define PI 3.14159，定义后，代码中所有的PI都会在预处理阶段被替换成3.14159。符号常量的优点是可读性强、修改方便，定义时末尾不能加分号，这是易错点。
变量：程序运行过程中，值可以被改变的量，本质上是内存中一块有名字、有固定类型的存储空间。
1. 变量的定义格式：类型名变量名1, 变量名2, ...;，比如int a, b;、double score;。
2. 变量的初始化：定义变量的同时给变量赋值，比如int a = 10;，如果只定义不初始化，局部变量的值是随机的垃圾值，这是程序阅读题的高频考点。
3. 变量的使用规则：必须先定义，后使用，未定义的变量会导致编译错误。

6. 数据类型转换

C语言中，不同类型的数据可以混合运算，运算时会进行类型转换，分为自动类型转换（隐式转换）和强制类型转换（显式转换）。

自动类型转换（隐式转换）：由编译器自动完成，转换规则是向取值范围更大的类型转换，保证数据精度不丢失，转换优先级如下（从低到高）：
$char \rightarrow short \rightarrow int \rightarrow unsigned int \rightarrow long \rightarrow long long \rightarrow float \rightarrow double$
核心规则：
1. 所有char、short类型的数据，在运算时都会先自动转换为int类型；
2. 整型和浮点型混合运算时，整型会自动转换为浮点型；
3. 赋值运算时，右边表达式的类型会自动转换为左边变量的类型，精度丢失风险由程序员承担。
强制类型转换（显式转换）：程序员通过强制类型转换运算符，手动将数据转换为指定类型，格式为： $(目标类型) 表达式$ 比如(int)3.14，会将3.14强制转换为整型3，注意：强制类型转换只会得到一个转换后的临时值，不会改变原变量的类型和值。 ⚠️ 易错点：强制类型转换的括号不能少，(int)3.14和int 3.14完全不同，后者是非法的。

高频考点真题例题

例1（2025年广东专升本真题·单选题） 以下关于C语言字符常量和字符串常量的说法，正确的是（） A. 'a'和"a"占用的内存大小相同 B. 字符常量可以用单引号或双引号包裹 C. 字符串常量"abc"占用3个字节的内存 D. 字符常量'0'的ASCII码值是48 解：正确答案是D。

A选项：'a'占用1字节，"a"占用2字节，错误；
B选项：字符常量必须用单引号包裹，双引号是字符串常量，错误；
C选项："abc"占用4字节，包含'a'、'b'、'c'和结尾的'\0'，错误。

例2（2024年广东专升本真题·程序阅读题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    char c1 = 'A', c2 = 'a';
    int a = c2 - c1;
    printf("%d, %c\n", a, c1 + 3);
    return 0;
}

解：运行结果是32, D。

'a'的ASCII码是97，'A'是65，所以c2 - c1 = 97 - 65 = 32；
c1 + 3 = 65 + 3 = 68，对应ASCII码的字符'D'。

例3（类型转换考点） 写出以下表达式的结果：(int)(3.14 + 2.86) + 5.5 解：先计算括号内的3.14 + 2.86 = 6.0，强制转换为int类型得到6，6和5.5相加，6自动转换为6.0，最终结果是11.5。

易错点避雷

scanf函数中，double类型必须用%lf，不能用%f，而printf中两者都可以，这个细节每年都有考生丢分。
字符常量用单引号，字符串常量用双引号，绝对不能混用，单引号里只能有一个字符。
强制类型转换的括号必须包裹类型名，不能漏掉，比如(double)a是正确的，double a是定义变量，不是类型转换。
八进制常量以数字0开头，不是字母o，十六进制以0x开头，0后面的x可以大写也可以小写。
符号常量#define定义的末尾不能加分号，加了分号会把分号一起替换，导致编译错误。

模块三：运算符与表达式

考情定位

本模块是C语言程序逻辑的核心，每年必考8-10分，是程序阅读题的核心考查内容，几乎所有的程序逻辑都离不开运算符和表达式。本模块的考点非常细，陷阱很多，是考生的高频丢分点，必须吃透每个运算符的规则和优先级。

C语言中，用运算符将常量、变量、函数连接起来的、符合C语言语法规则的式子，称为表达式，每个表达式都有一个确定的运算结果，称为表达式的值。

核心知识点拆解

我们按照优先级从高到低，拆解专升本必考的运算符，同时给出完整的优先级与结合性规则。

1. 算术运算符

算术运算符用于数值的算术运算，是最基础的运算符，优先级仅次于括号。

运算符	含义	示例	运算规则
`+`	加法	`a + b`	两个数相加
`-`	减法/负号	`a - b`、`-a`	两个数相减，或取负数
`*`	乘法	`a * b`	两个数相乘
`/`	除法	`a / b`	两个数相除
`%`	取余（模运算）	`a % b`	求a除以b的余数

核心考点（必考）：

除法运算符/的整数除法规则：当/两边的操作数都是整数时，执行整数除法，结果只保留整数部分，直接舍弃小数部分，不是四舍五入。比如5 / 2的结果是2，不是2.5；-5 / 2的结果是-2，不是-3。只有当两边至少有一个是浮点数时，才会执行浮点数除法，比如5.0 / 2的结果是2.5。
取余运算符%的规则：%两边的操作数必须都是整型，不能是浮点数，否则会编译错误。取余结果的符号和被除数的符号一致，比如5 % 2 = 1，-5 % 2 = -1，5 % -2 = 1。

2. 自增自减运算符

自增++和自减--运算符是专升本必考的难点，也是程序阅读题的高频考点，用于将变量的值加1或减1。

核心规则：

前缀式（++a、--a）：先将变量的值加1/减1，再使用变量的值参与运算，即“先变后用”；
后缀式（a++、a--）：先使用变量原来的值参与运算，再将变量的值加1/减1，即“先用后变”。

举个例子：

int a = 10, b, c;
b = ++a;  // 前缀式：a先加1变成11，再赋值给b，结果a=11，b=11
c = a++;  // 后缀式：先把a的当前值11赋值给c，a再加1变成12，结果a=12，c=11

⚠️ 必考易错点：自增自减运算符只能作用于变量，不能作用于常量或表达式，比如5++、(a+b)++都是非法的，会导致编译错误。

3. 赋值运算符

赋值运算符用于给变量赋值，分为基本赋值运算符和复合赋值运算符。

基本赋值运算符=：将右边表达式的值赋值给左边的变量，格式为变量 = 表达式。核心考点：
1. 赋值运算符的左边必须是变量，不能是常量或表达式，比如5 = a、a + b = 10都是非法的；
2. 赋值表达式本身也有值，值就是赋值后左边变量的值，所以支持连续赋值，比如a = b = c = 10，执行顺序是从右到左，先给c赋值10，再把c的值赋值给b，再把b的值赋值给a。
复合赋值运算符：由算术运算符和赋值运算符组合而成，专升本常考的有+=、-=、*=、/=、%=。核心规则：a += b 等价于 a = a + b，其余复合赋值运算符以此类推。举个例子：int a = 10; a *= 2 + 3; 等价于 a = a * (2 + 3);，结果a=50，注意：复合赋值运算符的右边会被当成一个整体，先计算右边的表达式，再执行复合运算。

4. 关系运算符

关系运算符用于比较两个表达式的大小关系，运算结果是一个逻辑值：关系成立，结果为1（真）；关系不成立，结果为0（假）。C语言中没有专门的布尔类型，用非0表示真，0表示假。

运算符	含义	示例	结果（a=10, b=5）
`>`	大于	`a > b`	1（真）
`<`	小于	`a < b`	0（假）
`>=`	大于等于	`a >= 10`	1（真）
`<=`	小于等于	`b <= 3`	0（假）
`==`	等于	`a == b`	0（假）
`!=`	不等于	`a != b`	1（真）

⚠️ 必考高频易错点：等于运算符是==，不是=，=是赋值运算符。很多新手会把if(a == 10)写成if(a = 10)，这会导致逻辑完全错误：a = 10是赋值表达式，值是10，非0表示真，所以无论a原来的值是多少，这个if条件永远成立。这个错误是每年考试的高频陷阱，必须牢记。

5. 逻辑运算符

逻辑运算符用于连接多个关系表达式，实现复杂的逻辑判断，运算结果也是1（真）或0（假），是选择结构、循环结构的核心。

运算符	含义	运算规则	示例
`!`	逻辑非（取反）	真变假，假变真	`!a`，a为真时结果为0，a为假时结果为1
`&&`	逻辑与（并且）	两边都为真，结果才为真；只要有一个为假，结果就为假	`a && b`，a和b都为真时结果为1
`		`	逻辑或（或者）	两边只要有一个为真，结果就为真；两边都为假，结果才为假	`a	b`，a和b有一个为真时结果为1

核心考点：短路求值规则（必考难点） 逻辑与&&和逻辑或||有一个非常重要的特性：短路求值，即当运算符左边的表达式已经能确定整个逻辑表达式的结果时，右边的表达式就不会再执行了。

逻辑与&&的短路：表达式1 && 表达式2，当表达式1的结果为假（0）时，已经能确定整个表达式的结果为假，所以表达式2不会被执行，直接短路。
逻辑或||的短路：表达式1 || 表达式2，当表达式1的结果为真（非0）时，已经能确定整个表达式的结果为真，所以表达式2不会被执行，直接短路。

举个例子，这是专升本的高频真题考点：

int a = 5, b = 0, c = 3;
int res1 = a < 0 && ++b;  // a<0的结果是0，逻辑与短路，++b不会执行，b还是0
int res2 = a > 0 || ++c;  // a>0的结果是1，逻辑或短路，++c不会执行，c还是3

6. 条件运算符（三目运算符）

条件运算符是C语言中唯一的三目运算符，需要三个操作数，用于实现简单的分支逻辑，格式为：

表达式1 ? 表达式2 : 表达式3

执行规则：

先计算表达式1的值，判断真假；
如果表达式1为真，执行表达式2，整个条件表达式的值就是表达式2的值；
如果表达式1为假，执行表达式3，整个条件表达式的值就是表达式3的值。

举个例子：int max = a > b ? a : b;，这个表达式的作用是求a和b中的最大值，等价于一个简单的if-else分支。

7. 逗号运算符

逗号运算符用于将多个表达式连接起来，格式为：

表达式1, 表达式2, 表达式3, ..., 表达式n

执行规则：从左到右依次计算每个表达式的值，整个逗号表达式的值是最后一个表达式的值。举个例子：

int a = 10, b;
b = (a += 5, a * 2, a - 3);  // 先执行a+=5，a变成15；再执行a*2，结果30；最后执行a-3，结果12
// 整个逗号表达式的值是最后一个表达式的结果12，所以b=12

⚠️ 考点：逗号运算符的优先级是所有运算符中最低的，所以上面的例子中，括号不能省略，否则赋值运算符会先执行。

8. 运算符优先级与结合性

运算符的优先级决定了表达式中运算的先后顺序，优先级高的先运算，优先级低的后运算；结合性决定了相同优先级的运算符的运算方向。

专升本必考的运算符优先级排序（从高到低）：

括号()
单目运算符：!、++、--、-（负号）、强制类型转换(类型)
算术运算符：*、/、% > +、-
关系运算符：>、<、>=、<= > ==、!=
逻辑运算符：&& > ||
条件运算符?:
赋值运算符：=、+=、-=、*=、/=、%=
逗号运算符,

结合性规则：

单目运算符、条件运算符、赋值运算符：从右到左结合；
其余运算符：从左到右结合。

高频考点真题例题

例1（2025年广东专升本真题·程序阅读题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int a = 3, b = 4, c = 5;
    int res = a++ < b && ++c > b;
    printf("a=%d, b=%d, c=%d, res=%d\n", a, b, c, res);
    return 0;
}

解：运行结果是a=4, b=4, c=6, res=1。

先计算a++ < b：a++是后缀式，先用a的原值3和b=4比较，3<4成立，结果为1，然后a加1变成4；
逻辑与&&左边结果为1，不能短路，继续执行右边的++c > b：c先加1变成6，6>4成立，结果为1；
整个逻辑表达式的结果是1，所以res=1。

例2（2024年广东专升本真题·单选题） 以下表达式的结果为1的是（） A. 5 / 2 B. 5 % 2 C. !5 D. 5 > 2 && 2 > 5 解：正确答案是B。

A选项：5/2是整数除法，结果是2；
B选项：5%2是取余，结果是1；
C选项：!5是逻辑非，5是非0为真，取反后结果是0；
D选项：2>5不成立，结果为0，整个逻辑与的结果是0。

例3（自增自减考点） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int x = 10, y;
    y = x++ + ++x;
    printf("x=%d, y=%d\n", x, y);
    return 0;
}

解：运行结果是x=12, y=22。

先计算x++：后缀式，取x的原值10参与运算，x加1变成11；
再计算++x：前缀式，x先加1变成12，取12参与运算；
相加结果是10+12=22，所以y=22，最终x=12。

易错点避雷

整数除法/的结果只保留整数部分，直接舍弃小数，不是四舍五入，这是最常见的计算错误。
等于运算符是==，赋值运算符是=，绝对不能混用，if条件中尤其要注意。
自增自减运算符的前缀和后缀的区别，一定要分清“先变后用”和“先用后变”，程序阅读题中极易出错。
逻辑与&&和逻辑或||的短路求值规则，一定要记住：左边能确定结果，右边就不会执行，不会改变右边变量的值。
逗号表达式的结果是最后一个表达式的值，优先级是所有运算符中最低的，赋值时一定要加括号。

模块四：顺序结构程序设计

考情定位

本模块是C语言程序设计的基础，每年必考3-5分，以程序填空题、简单程序阅读题为主，难度较低，核心考查数据的输入与输出函数的用法，是所有程序设计的基础。

顺序结构是最简单的程序结构，代码从上到下依次执行，没有分支，没有循环，核心就是数据的输入、处理、输出三个步骤。

核心知识点拆解

C语言没有内置的输入输出语句，所有的输入输出功能都是通过标准库函数实现的，我们重点考查printf（格式化输出函数）和scanf（格式化输入函数），这两个函数是C语言中最常用的输入输出函数，也是必考知识点。

1. 格式化输出函数`printf`

printf函数用于将数据按照指定的格式输出到屏幕上，定义在<stdio.h>头文件中。

基本格式：printf("格式控制字符串", 输出列表);
两个组成部分：
1. 格式控制字符串：用双引号包裹，包含两种内容：
  - 普通字符：原样输出到屏幕上的字符，比如"a=%d\n"中的a=、换行符\n；
  - 格式说明符：以%开头，后面跟格式字符，用于指定输出数据的类型和格式，比如%d、%f、%c。
2. 输出列表：需要输出的数据，可以是常量、变量、表达式，数量和类型必须和格式控制字符串中的格式说明符一一对应。

2. 常用格式说明符（必考）

格式说明符	适用数据类型	功能
`%d`	int、short	输出十进制有符号整数
`%u`	unsigned int	输出十进制无符号整数
`%c`	char	输出单个字符
`%s`	字符数组/字符串	输出字符串
`%f`	float、double	输出十进制浮点数，默认保留6位小数
`%lf`	double	输出双精度浮点数，printf中和%f通用
`%x`/`%X`	整型	输出十六进制整数，小写/大写
`%o`	整型	输出八进制整数
`%%`	无	输出一个百分号%本身

3. 格式控制符的附加修饰符

我们可以在%和格式字符之间加上修饰符，控制输出的宽度、精度、对齐方式等，专升本常考的修饰符有：

宽度修饰符：比如%5d，表示输出的整数至少占用5个字符的宽度，如果数据的长度小于5，左边用空格补齐；如果大于5，按实际长度输出。示例：printf("%5d", 123); 输出结果是 123（前面有2个空格）。
左对齐修饰符-：默认是右对齐，加上-后变为左对齐，比如%-5d，数据不足5位时，右边用空格补齐。
精度修饰符.n：
- 对于浮点数：%.2f表示保留2位小数，四舍五入，比如printf("%.2f", 3.14159); 输出3.14；
- 对于字符串：%.3s表示只输出字符串的前3个字符。

4. 格式化输入函数`scanf`

scanf函数用于从键盘读取用户输入的数据，按照指定的格式存储到对应的变量中，定义在<stdio.h>头文件中。

基本格式：scanf("格式控制字符串", 地址列表);
核心考点（必考易错点）：scanf的第二个参数是地址列表，必须是变量的内存地址，不能直接写变量名。普通变量的地址需要用取地址符&获取，比如int a; scanf("%d", &a);，这里的&a就是变量a的内存地址，绝对不能漏掉&，否则会导致程序崩溃，这是新手最常见的错误，也是考试的高频陷阱。

5. `scanf`的格式说明符

scanf的格式说明符和printf基本一致，核心区别是：

float类型必须用%f，double类型必须用%lf，不能混用，这是和printf最大的区别，也是每年必考的易错点。
格式控制字符串中的普通字符，必须原样输入。比如scanf("a=%d", &a);，用户输入时必须输入a=10，才能正确读取10到变量a中，如果只输入10，会读取失败。
scanf读取数据时，默认以空格、回车、Tab键作为数据的分隔符，输入多个数据时，用空格、回车分隔即可。

6. 字符输入输出函数

除了printf和scanf，C语言还提供了专门的单个字符输入输出函数，定义在<stdio.h>头文件中：

putchar函数：输出单个字符，格式为putchar(字符变量/字符常量/ASCII码值);，比如putchar('A'); 会输出字符A。
getchar函数：从键盘读取单个字符，格式为char c = getchar();，getchar函数会读取键盘输入的第一个字符，包括回车、空格等控制字符。 ⚠️ 考点：getchar会读取缓冲区中的残留字符，比如scanf输入后按下的回车，会被后续的getchar读取，这是程序阅读题的高频考点。

高频考点真题例题

例1（2025年广东专升本真题·程序填空题） 以下程序的功能是从键盘输入两个整数，输出它们的和，请补全代码：

#include <stdio.h>
int main()
{
    int a, b, sum;
    scanf("%d%d", _______);
    sum = a + b;
    printf("sum=%d\n", sum);
    return 0;
}

解：补全内容为&a, &b，scanf必须传入变量的地址，需要用取地址符&。

例2（格式控制考点） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    double num = 3.1415926;
    printf("%.2f, %8.3f\n", num, num);
    return 0;
}

解：运行结果是3.14, 3.142。

%.2f保留2位小数，四舍五入后是3.14；
%8.3f总宽度8个字符，保留3位小数，3.142占5个字符，左边补3个空格。

例3（2024年广东专升本真题·单选题） 以下关于scanf函数的说法，正确的是（） A. scanf函数的格式控制符%f可以用于输入double类型的数据 B. scanf函数的参数列表中，变量名前可以省略取地址符& C. scanf("a=%d", &a); 输入时必须输入a=10才能正确读取数据 D. scanf函数不能读取字符类型的数据解：正确答案是C。

A选项：double类型必须用%lf，错误；
B选项：普通变量必须加&，错误；
D选项：scanf可以用%c读取字符，错误。

易错点避雷

scanf函数的普通变量前必须加取地址符&，绝对不能漏掉，这是最常见的编译错误和逻辑错误。
scanf中，double类型必须用%lf，float类型必须用%f，不能混用，和printf的规则不同。
scanf格式控制字符串中的普通字符，必须原样输入，否则会读取失败。
printf的格式说明符和输出列表的数量、类型必须一一对应，否则会导致输出错误。
getchar会读取回车、空格等控制字符，注意输入缓冲区的残留字符问题。

模块五：选择结构程序设计

考情定位

本模块是C语言程序逻辑的核心，每年必考8-10分，全题型覆盖，程序阅读题、程序填空题、编程题都会涉及，是实现程序分支逻辑的核心。选择结构的本质是“根据条件判断，决定执行哪一段代码”，是编程中最基础的逻辑控制结构。

广东专升本重点考查两种选择结构语句：if-else语句和switch语句。

核心知识点拆解

1. if语句的三种形式

if语句的核心是：先判断条件表达式的真假，再决定是否执行对应的代码块。C语言中，非0即为真，0即为假，条件表达式可以是任意表达式，只要结果非0，就认为条件成立。

（1）单分支if语句

基本格式：

if(条件表达式)
{
    语句块;  // 条件成立时执行的代码
}

执行流程：先计算条件表达式的值，如果为真（非0），执行大括号内的语句块；如果为假（0），跳过语句块，执行if后面的代码。
注意：如果语句块只有一条语句，可以省略大括号{}，但为了代码可读性和避免逻辑错误，建议永远加上大括号。

（2）双分支if-else语句

基本格式：

if(条件表达式)
{
    语句块1;  // 条件成立时执行
}
else
{
    语句块2;  // 条件不成立时执行
}

执行流程：条件成立，执行语句块1；条件不成立，执行语句块2，两个分支只会执行其中一个。

（3）多分支if-else if-else语句

用于处理多个条件的分支判断，比如成绩分级、分段函数计算等场景。

基本格式：

if(条件表达式1)
{
    语句块1;
}
else if(条件表达式2)
{
    语句块2;
}
else if(条件表达式3)
{
    语句块3;
}
// 可以有多个else if
else
{
    语句块n;  // 所有条件都不成立时执行
}

执行流程：从上到下依次判断条件表达式，遇到第一个成立的条件，执行对应的语句块，执行完后直接跳出整个if-else if结构，后面的条件不会再判断；如果所有条件都不成立，执行else中的语句块。

2. if语句的嵌套

if语句的大括号内，可以再写if语句，称为if语句的嵌套，用于处理更复杂的分支逻辑。

核心考点：悬空else问题（必考易错点） C语言规定：else永远和离它最近的、没有匹配else的if配对，和代码的缩进无关。举个例子，这是专升本的高频陷阱题：

int a = 1, b = 2;
if(a > 0)
    if(b > 3)
        printf("A\n");
else
    printf("B\n");

很多同学会以为else和第一个if配对，条件a>0成立，b>3不成立，所以输出B。但实际上，else和离它最近的第二个if配对，第一个if的条件成立，进入第二个if，b>3不成立，所以else也不会执行，最终什么都不会输出。

解决悬空else问题的方法：永远用大括号{}包裹if和else的语句块，明确配对关系，避免逻辑错误。

3. switch语句

switch语句是多分支选择语句，适用于条件是多个固定值的场景，比如菜单选择、星期几判断等，比if-else if结构更清晰，可读性更强。

基本格式：

switch(表达式)
{
    case 常量表达式1:
        语句块1;
        break;
    case 常量表达式2:
        语句块2;
        break;
    // 可以有多个case
    default:
        语句块n;
        break;
}

核心考点与执行规则（必考）：
1. switch后面的表达式，只能是整型、字符型、枚举型，不能是实型（float、double），也不能是字符串，这是选择题高频考点。
2. case后面的必须是常量表达式，不能是变量，而且所有case的常量值不能重复，否则会编译错误。
3. 执行流程：先计算switch表达式的值，然后从上到下和case的常量值比较，找到匹配的case，就从该case的语句块开始执行，直到遇到break语句，或者switch语句结束。
4. break语句的作用：跳出整个switch语句，终止case的执行。如果case后面没有break，会发生case穿透：执行完当前case的语句后，会继续执行后面所有case的语句，直到遇到break或switch结束，这是程序阅读题的高频考点。
5. default子句：用于处理所有case都不匹配的情况，相当于if-else中的else，可以写在switch的任意位置，通常写在最后，也可以省略。

高频考点真题例题

例1（2025年广东专升本真题·程序阅读题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int score = 85;
    if(score >= 90)
        printf("优秀\n");
    else if(score >= 80)
        printf("良好\n");
    else if(score >= 60)
        printf("及格\n");
    else
        printf("不及格\n");
    return 0;
}

解：运行结果是良好。score=85，第一个条件>=90不成立，第二个条件>=80成立，执行对应的printf，执行完后跳出整个if-else if结构。

例2（case穿透考点·2024年广东专升本真题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int num = 2;
    switch(num)
    {
        case 1: printf("A");
        case 2: printf("B");
        case 3: printf("C"); break;
        case 4: printf("D");
        default: printf("E");
    }
    return 0;
}

解：运行结果是BC。num=2，匹配case 2，执行printf("B")，case 2后面没有break，发生case穿透，继续执行case 3的printf("C")，遇到break，跳出switch语句。

例3（编程题基础） 编写程序，输入一个整数，判断它是奇数还是偶数，输出对应的结果。解：

#include <stdio.h>
int main()
{
    int num;
    printf("请输入一个整数：");
    scanf("%d", &num);
    if(num % 2 == 0)
    {
        printf("%d是偶数\n", num);
    }
    else
    {
        printf("%d是奇数\n", num);
    }
    return 0;
}

易错点避雷

if语句的条件表达式中，不要把==写成=，赋值表达式的值非0时，条件永远成立，会导致逻辑完全错误。
else永远和离它最近的、没有匹配else的if配对，和代码缩进无关，一定要用大括号明确配对关系，避免悬空else问题。
switch语句的表达式只能是整型、字符型，不能是浮点型，case后面必须是常量，不能是变量。
case后面如果没有break，会发生case穿透，继续执行后面的case语句，这是考试的高频陷阱，一定要注意break的使用。
if语句的条件表达式后面，不要加分号，比如if(a > 0);，分号会被当成空语句，后面的大括号和if无关，无论条件是否成立，都会执行大括号里的代码。

模块六：循环结构程序设计

考情定位

本模块是C语言的核心中的核心，每年必考10-15分，全题型覆盖，程序阅读题、程序填空题、编程题都会重点考查，几乎所有的编程题都离不开循环结构。循环结构的本质是“根据条件，重复执行某一段代码”，是计算机最核心的能力，也是编程思维的核心体现。

广东专升本重点考查三种循环语句：while循环、do-while循环、for循环，其中for循环是最常用、最灵活的，是考查的重中之重。同时，循环的嵌套、break和continue语句也是必考考点。

核心知识点拆解

1. while循环

while循环是最基础的循环语句，属于“先判断，后执行”的循环，当条件成立时，重复执行循环体。

基本格式：

while(条件表达式)
{
    循环体语句;  // 重复执行的代码
}

执行流程：
1. 先计算条件表达式的值，判断真假；
2. 如果为真（非0），执行循环体语句；
3. 执行完循环体后，回到第一步，再次判断条件表达式；
4. 如果条件为假（0），跳出循环，执行while后面的代码。
核心注意点：
1. while循环的循环体如果有多条语句，必须用大括号{}包裹，否则只有第一条语句属于循环体。
2. 循环体内必须有能改变条件表达式的语句，否则条件永远成立，会导致死循环，比如while(1)就是死循环。

2. do-while循环

do-while循环属于“先执行，后判断”的循环，无论条件是否成立，循环体至少会执行一次。

基本格式：

do
{
    循环体语句;
}while(条件表达式);  // 注意：这里的分号绝对不能漏掉

执行流程：
1. 先执行一次循环体语句；
2. 计算条件表达式的值，判断真假；
3. 如果为真，再次执行循环体；
4. 如果为假，跳出循环。
核心考点：do-while循环的循环体至少执行一次，而while循环可能一次都不执行，这是两者的核心区别，是选择题的高频考点。
易错点：while(条件表达式)后面的分号绝对不能漏掉，否则会编译错误。

3. for循环

for循环是C语言中最灵活、最常用的循环语句，功能最强大，几乎可以实现所有的循环场景，是专升本考试的重中之重。

基本格式：
```
for(表达式1; 表达式2; 表达式3)
{
    循环体语句;
}
```
三个表达式的作用：
1. 表达式1：循环初始化语句，用于给循环变量赋初值，在整个循环中只执行一次；
2. 表达式2：循环条件表达式，用于判断循环是否继续执行，每次循环前都会判断，和while的条件表达式作用一致；
3. 表达式3：循环变量更新语句，用于改变循环变量的值，每次循环体执行完后执行。
执行流程：
1. 执行表达式1，完成循环初始化，只执行一次；
2. 执行表达式2，判断循环条件是否成立；
3. 如果条件成立，执行循环体语句；如果不成立，跳出循环；
4. 循环体执行完后，执行表达式3，更新循环变量；
5. 回到第2步，再次判断循环条件。
最常用的for循环格式：
```
for(int i = 0; i < n; i++)  // i是循环变量，n是循环次数
{
    循环体语句;
}
```
这个格式用于固定次数的循环，是编程中最常用的格式，必须熟练掌握。
核心考点：for循环的三个表达式都可以省略，但分号绝对不能省略。
1. 省略表达式1：循环初始化放在for循环之前，比如int i=0; for(; i<10; i++)；
2. 省略表达式2：循环条件永远为真，变成死循环，需要在循环体内用break跳出；
3. 省略表达式3：循环变量更新放在循环体内，比如for(int i=0; i<10; ) { i++; }；
4. 三个表达式都省略：for(;;)，等价于while(1)，是死循环。

4. 循环的嵌套

在一个循环的循环体内，再写另一个循环，称为循环的嵌套，也叫多重循环。专升本重点考查双重循环，三重及以上循环几乎不考。

双重循环的执行规则：外层循环执行一次，内层循环完整执行一遍。举个例子，最常用的双重循环格式：

for(int i = 0; i < 3; i++)  // 外层循环，执行3次
{
    for(int j = 0; j < 2; j++)  // 内层循环，执行2次
    {
        printf("i=%d, j=%d\n", i, j);
    }
}

这个程序中，外层循环执行3次，每次外层循环，内层循环都执行2次，总共执行3*2=6次printf语句。

双重循环的高频应用场景：打印图形、矩阵运算、排序算法（冒泡排序、选择排序）等，是编程题的高频考点。

5. 循环控制语句：break和continue

break和continue语句用于控制循环的执行流程，是考试的高频考点，必须分清两者的区别。

（1）break语句

break语句有两个作用：

在switch语句中，跳出switch结构；
在循环语句中，立即跳出当前所在的循环，终止循环的执行，执行循环后面的代码。

注意：break语句只能跳出一层循环，如果是双重循环，内层循环的break只能跳出内层循环，不能跳出外层循环。

（2）continue语句

continue语句只能用在循环语句中，作用是：跳过本次循环中continue后面的语句，直接进入下一次循环的条件判断。

核心区别：

break：终止整个循环，直接跳出；
continue：只跳过本次循环的剩余代码，继续下一次循环，循环不会终止。

举个例子，对比两者的区别：

// break示例
for(int i = 1; i <= 5; i++)
{
    if(i == 3)
        break;  // i=3时，跳出整个循环
    printf("%d ", i);
}
// 输出结果：1 2

// continue示例
for(int i = 1; i <= 5; i++)
{
    if(i == 3)
        continue;  // i=3时，跳过后面的printf，进入下一次循环
    printf("%d ", i);
}
// 输出结果：1 2 4 5

6. 算法的时间复杂度基础

时间复杂度是衡量算法执行效率的核心指标，是数据结构的基础，也是专升本选择题的必考考点。

定义：时间复杂度是算法中基本操作的执行次数，用大O符号表示，记作 $T(n) = O(f(n))$ ，其中n是问题的规模。
计算规则：
1. 只保留最高阶项，忽略低阶项和常数项；
2. 忽略最高阶项的系数。
专升本常考的时间复杂度：
1. 常数阶： $O(1)$ ，基本操作执行次数是固定的，和n无关；
2. 线性阶： $O(n)$ ，单层循环，循环次数和n成正比；
3. 平方阶： $O(n^2)$ ，双重循环，循环次数和n的平方成正比；
4. 对数阶： $O(\log n)$ ，二分查找等算法的时间复杂度。

举个例子：

单层for循环for(int i=0; i<n; i++)，时间复杂度是 $O(n)$ ；
双重for循环for(int i=0; i<n; i++) for(int j=0; j<n; j++)，时间复杂度是 $O(n^2)$ 。

高频考点真题例题

例1（2025年广东专升本真题·程序阅读题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int i = 1, sum = 0;
    while(i <= 10)
    {
        sum += i;
        i++;
    }
    printf("sum=%d\n", sum);
    return 0;
}

解：运行结果是sum=55。这个程序的功能是计算1到10的累加和，1+2+3+...+10=55。

例2（for循环考点·2024年广东专升本真题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int i, j;
    for(i = 1; i <= 3; i++)
    {
        for(j = 1; j <= i; j++)
        {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

解：运行结果是：

*
**
***

外层循环i从1到3，执行3次；内层循环j从1到i，每次外层循环，内层循环执行i次，打印i个*，然后换行。

例3（break和continue考点） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int i;
    for(i = 1; i <= 10; i++)
    {
        if(i % 2 == 0)
            continue;
        if(i % 7 == 0)
            break;
        printf("%d ", i);
    }
    return 0;
}

解：运行结果是1 3 5。

i=1：不是偶数，不是7的倍数，打印1；
i=2：是偶数，执行continue，跳过打印；
i=3：不是偶数，不是7的倍数，打印3；
i=4：是偶数，continue；
i=5：不是偶数，不是7的倍数，打印5；
i=6：是偶数，continue；
i=7：不是偶数，是7的倍数，执行break，跳出整个循环。

例4（编程题） 编写程序，输出100以内的所有素数（质数）。解：素数是指大于1的自然数，除了1和它本身，不能被其他自然数整除的数。

#include <stdio.h>
#include <math.h>
int main()
{
    int i, j, is_prime;
    // 遍历2到100的所有数
    for(i = 2; i <= 100; i++)
    {
        is_prime = 1;  // 假设当前数是素数
        // 判断i是否能被2到sqrt(i)之间的数整除
        for(j = 2; j <= sqrt(i); j++)
        {
            if(i % j == 0)
            {
                is_prime = 0;  // 能被整除，不是素数
                break;  // 跳出内层循环
            }
        }
        if(is_prime == 1)
        {
            printf("%d ", i);
        }
    }
    return 0;
}

易错点避雷

do-while循环的while(条件表达式)后面必须加分号，绝对不能漏掉，否则会编译错误。
for循环的三个表达式之间用分号分隔，即使省略表达式，分号也不能省略，for(;;)是正确的，for()是非法的。
break语句只能跳出当前所在的一层循环，不能跳出多层循环；continue语句只能跳过本次循环，不能终止循环，两者的作用不能混淆。
循环体内必须有能改变循环条件的语句，否则会导致死循环，考试中程序阅读题的死循环陷阱要注意。
循环体的多条语句必须用大括号{}包裹，否则只有第一条语句属于循环体，会导致逻辑错误。

模块七：数组与字符串

考情定位

本模块是C语言的核心重点，每年必考12-15分，全题型覆盖，程序阅读题、程序填空题、编程题都会重点考查，是专升本C语言部分的拉分核心。数组是C语言中最常用的构造类型，是批量处理数据的核心工具，也是后续学习指针、数据结构的基础，更是编程题的高频出题点。

广东专升本重点考查一维数组、二维数组、字符数组与字符串，其中一维数组和字符串是考查的重中之重。

核心知识点拆解

1. 数组的本质

数组是相同类型的若干个数据，按照一定的顺序排列而成的集合。数组中的每个数据称为数组元素，所有元素在内存中占用连续的存储空间，每个元素都有唯一的编号，称为数组下标，通过下标可以访问数组中的任意元素。

数组的核心特点：

数组中的所有元素，数据类型必须完全相同；
数组在内存中占用连续的存储空间；
数组下标从0开始，不是从1开始，这是高频易错点；
数组名本质上是数组首元素的内存地址，是一个地址常量，不能被赋值，这是后续指针模块的核心基础。

2. 一维数组

一维数组是最简单的数组，用于存储一组相同类型的数据，比如一组学生的成绩、一组整数等。

（1）一维数组的定义

定义格式：类型名数组名[数组长度];
格式说明：
1. 类型名：数组中每个元素的数据类型，可以是int、char、double等基本类型，也可以是构造类型；
2. 数组名：遵循C语言标识符的命名规则；
3. 数组长度：必须是整型常量表达式，不能是变量，指定数组中元素的个数，也就是数组的大小。
示例：int score[10]; 定义了一个名为score的一维数组，数组中有10个int类型的元素，下标从0到9，分别是score[0]、score[1]、...、score[9]。

⚠️ 必考易错点：数组长度必须是常量表达式，不能是变量。比如int n=10; int a[n]; 是非法的（C99标准支持变长数组，但广东专升本考试不认可，认为是非法的），必须用常量定义数组长度。

（2）一维数组的初始化

数组的初始化，就是在定义数组的同时，给数组元素赋初值，有以下几种常用方式：

全部元素初始化：int a[5] = {1, 2, 3, 4, 5}; 大括号中的值依次赋给a[0]到a[4]。
部分元素初始化：int a[5] = {1, 2, 3}; 只给前3个元素赋值，后面的元素自动初始化为0。
省略数组长度的初始化：int a[] = {1, 2, 3, 4, 5}; 数组长度由大括号中的初始值个数决定，这里数组长度是5。
全部元素初始化为0：int a[5] = {0}; 第一个元素赋值为0，后面的元素自动初始化为0，这是最常用的数组清零方式。

（3）一维数组的引用

数组必须先定义，后使用，C语言只能逐个引用数组元素，不能一次性引用整个数组。

引用格式：数组名[下标]
下标可以是整型常量、整型变量或整型表达式，取值范围是0到数组长度-1，超出范围会导致数组越界，这是C语言中最常见的严重错误，会导致程序崩溃，也是考试的高频陷阱。

（4）一维数组的遍历

数组的遍历就是依次访问数组中的每个元素，通常用for循环实现，这是数组最基础的操作，必须熟练掌握。示例：遍历输出数组中的所有元素

int a[5] = {1, 2, 3, 4, 5};
for(int i = 0; i < 5; i++)  // i是数组下标，从0到4
{
    printf("%d ", a[i]);
}

（5）一维数组的高频应用（编程题必考）

一维数组的应用场景非常广泛，专升本编程题高频考查的有：

求数组的最大值、最小值、平均值、总和；
数组的逆序输出；
数组的排序（冒泡排序、选择排序）；
数组的查找（顺序查找、二分查找）；
数组元素的插入、删除。

3. 二维数组

二维数组本质上是“数组的数组”，也就是一维数组中的每个元素都是一个一维数组，通常用于处理表格、矩阵等二维数据，比如学生的多门课程成绩、数学中的矩阵。

（1）二维数组的定义

定义格式：类型名数组名[行数][列数];
示例：int matrix[3][4]; 定义了一个3行4列的二维数组，共有3*4=12个int类型的元素，行下标从0到2，列下标从0到3。

（2）二维数组的初始化

二维数组的初始化有以下几种常用方式：

按行初始化：int a[2][3] = {{1,2,3}, {4,5,6}}; 第一对大括号的值赋给第一行，第二对赋给第二行，最清晰，推荐使用。
线性初始化：int a[2][3] = {1,2,3,4,5,6}; 按数组在内存中的存储顺序，依次赋值，第一行赋值完后赋值第二行。
部分元素初始化：int a[3][4] = {{1}, {2,3}}; 未赋值的元素自动初始化为0。
省略行数的初始化：int a[][3] = {1,2,3,4,5,6}; 列数不能省略，行数由初始值的个数和列数自动计算，这里行数是2。

⚠️ 必考考点：二维数组初始化时，列数绝对不能省略，行数可以省略，这是选择题的高频考点。

（3）二维数组的存储方式

二维数组在内存中是按行优先顺序存储的，先存储第一行的所有元素，再存储第二行的所有元素，以此类推，整个数组在内存中是连续的存储空间。比如int a[2][3]的存储顺序是：a[0][0] → a[0][1] → a[0][2] → a[1][0] → a[1][1] → a[1][2]。

（4）二维数组的引用与遍历

引用格式：数组名[行下标][列下标]

二维数组的遍历通常用双重for循环实现，外层循环控制行，内层循环控制列：

int a[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
for(int i = 0; i < 3; i++)  // 外层循环，遍历行
{
    for(int j = 0; j < 4; j++)  // 内层循环，遍历列
    {
        printf("%d ", a[i][j]);
    }
    printf("\n");  // 每行结束换行
}

4. 字符数组与字符串

C语言中没有专门的字符串类型，字符串是用字符数组来存储的，字符串的本质是以'\0'（ASCII码值为0的空字符）结尾的字符数组，这是C语言字符串的核心定义，必须牢记。

（1）字符数组的定义与初始化

定义格式：char 数组名[数组长度];
初始化方式：
1. 逐个字符初始化：char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; 必须手动加上字符串结束标志'\0'，才能成为字符串。
2. 用字符串常量初始化：char str[] = "Hello"; 这是最常用的方式，编译器会自动在字符串末尾加上'\0'，数组长度自动为6（5个字符+1个'\0'）。
3. 注意：char str[5] = "Hello"; 是非法的，因为"Hello"需要6个字节的存储空间（包含'\0'），数组长度不够。

⚠️ 必考易错点：字符数组和字符串的核心区别是有没有结尾的'\0'，没有'\0'的字符数组只是普通的字符数组，不能当成字符串使用，否则会导致输出乱码、程序崩溃。

（2）字符串的输入与输出

用printf和scanf输入输出：
- 输出：用%s格式说明符，printf("%s\n", str);，从str的首地址开始输出，直到遇到'\0'结束，不会输出'\0'。
- 输入：用%s格式说明符，scanf("%s", str);，注意：数组名str本身就是首元素的地址，不需要加取地址符&。scanf读取字符串时，以空格、回车、Tab作为分隔符，所以不能读取包含空格的字符串。
用gets和puts函数输入输出：
- puts函数：输出字符串，自动在末尾加上换行符，格式为puts(str);。
- gets函数：从键盘读取一行字符串，包括空格，直到遇到回车结束，自动将回车替换为'\0'，格式为gets(str);。注意：gets函数不检查数组长度，会导致缓冲区溢出，安全性低，但专升本考试中仍会考查。

（3）字符串处理函数（必考）

C语言的标准库<string.h>中提供了大量的字符串处理函数，专升本重点考查以下4个，是程序阅读题、编程题的高频考点，必须熟练掌握。

strlen函数：求字符串长度
- 函数原型：size_t strlen(const char *str);
- 功能：计算字符串str的长度，即从首地址开始，到'\0'为止的字符个数，不包含'\0'本身。
- 示例：char str[] = "Hello"; printf("%d", strlen(str)); 输出结果是5，不是6。
- ⚠️ 必考易错点：strlen和sizeof的区别：sizeof计算的是数组占用的总字节数，包含'\0'；strlen计算的是字符串的有效字符个数，不包含'\0'。比如上面的例子，sizeof(str)的结果是6，strlen(str)的结果是5。
strcpy函数：字符串复制
- 函数原型：char *strcpy(char *dest, const char *src);
- 功能：将src字符串的内容（包括结尾的'\0'）复制到dest字符数组中，返回dest的首地址。
- 注意：dest数组的长度必须足够大，能容纳src的所有内容，包括'\0'；dest必须是字符数组，不能是字符串常量。
- 示例：
```
char dest[10];
char src[] = "Hello";
strcpy(dest, src);  // dest中的内容变为"Hello"
```
strcat函数：字符串拼接
- 函数原型：char *strcat(char *dest, const char *src);
- 功能：将src字符串的内容拼接到dest字符串的末尾，覆盖dest末尾的'\0'，并在新字符串的末尾加上'\0'，返回dest的首地址。
- 注意：dest数组的长度必须足够大，能容纳拼接后的所有内容；dest必须以'\0'结尾。
- 示例：
```
char dest[20] = "Hello ";
char src[] = "World";
strcat(dest, src);  // dest中的内容变为"Hello World"
```
strcmp函数：字符串比较
- 函数原型：int strcmp(const char *str1, const char *str2);
- 功能：按照ASCII码值，从左到右逐个比较两个字符串的字符，直到出现不同的字符或遇到'\0'为止，返回比较结果：
  1. 如果str1 == str2，返回0；
  2. 如果str1 > str2，返回一个正整数；
  3. 如果str1 < str2，返回一个负整数。
- ⚠️ 必考易错点：两个字符串的比较不能用==，必须用strcmp函数。if(str1 == str2)比较的是两个字符串的首地址，不是字符串的内容，这是高频错误。
- 示例：strcmp("abc", "abd") 返回负整数，因为'c'的ASCII码值小于'd'；strcmp("abc", "abc") 返回0。

高频考点真题例题

例1（2025年广东专升本真题·程序阅读题） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int a[] = {1, 3, 5, 7, 9};
    int sum = 0;
    for(int i = 0; i < 5; i++)
    {
        if(i % 2 == 0)
            sum += a[i];
    }
    printf("sum=%d\n", sum);
    return 0;
}

解：运行结果是sum=15。程序遍历数组，累加下标为偶数的元素，即a[0]=1、a[2]=5、a[4]=9，总和是1+5+9=15。

例2（strlen与sizeof考点·2024年广东专升本真题） 写出以下程序的运行结果：

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "Hello\nWorld";
    printf("%d, %d\n", sizeof(str), strlen(str));
    return 0;
}

解：运行结果是13, 11。

字符串"Hello\nWorld"中，\n是一个转义字符，算1个字符，有效字符个数是11，所以strlen的结果是11；
sizeof计算数组的总字节数，包含结尾的'\0'，所以是11+1=12？不对，等一下："Hello\nWorld"的字符是：H e l l o \n W o r l d，一共11个字符，加上'\0'，数组长度是12？哦，我算错了，Hello是5个，\n是1个，World是5个，5+1+5=11，加'\0'是12，所以sizeof是12，strlen是11。刚才的错误要修正。哦，对，Hello是5个字母，\n是1个，World是5个，总共5+1+5=11个有效字符，strlen是11，sizeof是11+1=12，所以正确结果是12, 11。

例3（二维数组考点） 写出以下程序的运行结果：

#include <stdio.h>
int main()
{
    int a[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};
    int sum = 0;
    for(int i = 0; i < 3; i++)
    {
        sum += a[i][2-i];
    }
    printf("sum=%d\n", sum);
    return 0;
}

解：运行结果是sum=15。程序累加的是矩阵的副对角线元素：a[0][2]=3、a[1][1]=5、a[2][0]=7，总和是3+5+7=15。

例4（编程题） 编写程序，输入一个字符串，统计字符串中大写字母、小写字母、数字字符的个数。解：

#include <stdio.h>
#include <string.h>
int main()
{
    char str[100];
    int upper = 0, lower = 0, digit = 0;
    printf("请输入一个字符串：");
    gets(str);  // 读取包含空格的字符串
    // 遍历字符串，直到遇到'\0'结束
    for(int i = 0; str[i] != '\0'; i++)
    {
        if(str[i] >= 'A' && str[i] <= 'Z')
        {
            upper++;  // 大写字母
        }
        else if(str[i] >= 'a' && str[i] <= 'z')
        {
            lower++;  // 小写字母
        }
        else if(str[i] >= '0' && str[i] <= '9')
        {
            digit++;  // 数字字符
        }
    }
    printf("大写字母：%d个\n", upper);
    printf("小写字母：%d个\n", lower);
    printf("数字字符：%d个\n", digit);
    return 0;
}

易错点避雷

数组下标从0开始，不是从1开始，数组的最后一个元素的下标是数组长度-1，超出范围会导致数组越界，这是最常见的错误。
数组长度必须是常量表达式，不能用变量定义数组长度，考试中认为变长数组是非法的。
二维数组初始化时，列数绝对不能省略，行数可以省略，选择题中极易混淆。
字符串必须以'\0'结尾，没有'\0'的字符数组不能当成字符串使用，否则会导致输出乱码、程序崩溃。
strlen函数计算的是字符串的有效字符个数，不包含'\0'；sizeof计算的是数组的总字节数，包含'\0'，两者的区别是必考的高频陷阱。
两个字符串的比较必须用strcmp函数，不能用==直接比较，==比较的是地址，不是字符串的内容。

三、写在最后

本篇文章，我们完整拆解了广东计算机专升本《计算机基础与程序设计》的考情，以及C语言从基础概念到数组与字符串的全体系核心考点，覆盖了考试中70%的C语言分值，是你C语言备考的核心基础。

C语言的学习，从来都不是死记硬背语法，而是要多写代码、多调代码，只有亲手把代码敲出来，运行出结果，你才能真正理解语法的本质，建立起编程思维。很多同学看着代码觉得懂了，一写就错，本质上就是练得太少，没有真正把知识转化为自己的能力。

在本系列的第二篇文章中，我们将继续拆解C语言的进阶核心考点：函数、指针、结构体、文件操作，这些是C语言的难点，也是考试的拉分重点；同时，我们会开启数据结构模块的讲解，从数据结构的基础概念，到线性表、栈与队列的全考点拆解，帮你一站式搞定专升本计算机科目的进阶内容。

如果你在C语言备考中有任何不懂的知识点，或者踩过哪些语法坑，都可以在评论区留言，我会一一为你解答。你也可以说说，你最头疼的是C语言的哪个模块，我会在下一篇中重点拆解。

广东计算机专升本计算机科目（C语言+数据结构）第一篇

一文吃透广东计算机专升本计算机科目（C语言+数据结构）第一篇：考情全解析+C语言基础到核心语法体系

一、广东计算机专升本《计算机基础与程序设计》考情全拆解

1. 考试性质与定位

2. 试卷题型与分值分布

3. 考纲范围与模块分值占比

（1）C语言程序设计（90-100分，占比45%-50%）

（2）数据结构（100-110分，占比50%-55%）

4. 写给备考同学的真心话

二、C语言全考点体系化拆解（上篇）

模块一：C语言基础概念与程序结构

考情定位

核心知识点拆解

1. C语言的本质与核心特点

2. C程序的基本结构

3. 标识符与关键字

4. 结构化程序设计的三大基本结构

高频考点真题例题

易错点避雷

模块二：数据类型、常量与变量

考情定位

核心知识点拆解

1. 数据类型的本质

2. 整型数据

3. 字符型数据

4. 实型（浮点型）数据

5. 常量与变量

6. 数据类型转换

高频考点真题例题

易错点避雷

模块三：运算符与表达式

考情定位

核心知识点拆解

1. 算术运算符

2. 自增自减运算符

3. 赋值运算符

4. 关系运算符

5. 逻辑运算符

6. 条件运算符（三目运算符）

7. 逗号运算符

8. 运算符优先级与结合性

高频考点真题例题

易错点避雷

模块四：顺序结构程序设计

考情定位

核心知识点拆解

1. 格式化输出函数printf

2. 常用格式说明符（必考）

3. 格式控制符的附加修饰符

4. 格式化输入函数scanf

5. scanf的格式说明符

6. 字符输入输出函数

高频考点真题例题

易错点避雷

模块五：选择结构程序设计

考情定位

核心知识点拆解

1. if语句的三种形式

（1）单分支if语句

（2）双分支if-else语句

（3）多分支if-else if-else语句

2. if语句的嵌套

3. switch语句

高频考点真题例题

易错点避雷

模块六：循环结构程序设计

考情定位

核心知识点拆解

1. while循环

2. do-while循环

3. for循环

4. 循环的嵌套

5. 循环控制语句：break和continue

（1）break语句

（2）continue语句

6. 算法的时间复杂度基础

高频考点真题例题

易错点避雷

模块七：数组与字符串

考情定位

`一文吃透广东计算机专升本计算机科目（C语言+数据结构）第一篇：考情全解析+C语言基础到核心语法体系`

1. 格式化输出函数`printf`

4. 格式化输入函数`scanf`

5. `scanf`的格式说明符