本帖最后由 科朗文化培训 于 2026-6-22 10:40 编辑
按考纲顺序整理，含核心语法、易错点、代码示例与考点提示）
一、IPO（输入/处理/输出）
IPO是程序的基础流程：输入（Input）→处理（Process）→输出（Output），是所有程序的核心骨架。 1. 输出语句 cout
- 语法格式：#include<iostream> // 必须包含的头文件 using namespace std; // 简化标准库调用 int main() { cout << "要输出的内容" << endl; // endl 表示换行 cout << "也可以不换行"; cout << "多个内容用 << 连接" << "，比如变量：" << 100; return 0; }
- 核心规则： cout 位于 std 命名空间，要么写 using namespace std;，要么写 std::cout。 可以直接输出字符串（用双引号包裹）、变量、表达式结果。 endl 等价于 \n（换行符），同时会强制刷新缓冲区，适合输出结果的末尾。
- 易错点：忘记加头文件、<< 写成 >>、字符串用单引号包裹（单引号只能存单个字符）。
2. 输入语句 cin
- 语法格式：int a, b; double c; char d; cin >> a >> b; // 连续读取两个整数，用空格/回车/制表符分隔 cin >> c; cin >> d;
- 核心规则： cin 会自动跳过输入中的空白（空格、回车、制表符），无需手动处理。 读取顺序与变量顺序一致，输入时按顺序输入即可。
- 易错点：>> 写成 <<、读取字符时被前面的回车/空格干扰（可使用 cin.ignore() 清除缓冲区）。
3. 变量命名规则
- 必须遵守： 只能由字母（a-z, A-Z）、数字（0-9）、下划线（_）组成。 不能以数字开头（比如 1a 非法，a1 合法）。 不能是C++关键字（比如 int、if、for、return 等）。
- 推荐习惯：见名知意（比如 score 表示分数，age 表示年龄），避免拼音缩写或无意义的 a/b/c。
4. 定义变量
- 语法格式：类型名 变量名;
- 示例：int age; // 声明一个整型变量age，未初始化 double score; // 声明一个双精度浮点型变量score char gender; // 声明一个字符型变量gender int a, b, c; // 同时声明多个同类型变量，用逗号分隔
- 核心规则：变量必须先声明，再使用（不能“先用后定义”）。
5. 变量赋值
- 语法格式：变量名 = 值;
- 示例：int a; a = 10; // 给变量a赋值10 int b = 20; // 声明的同时初始化（推荐写法，避免垃圾值） int c = a + b; // 用表达式结果赋值
- 易错点：赋值时类型不匹配（比如把字符串赋值给 int 变量）、= 写成 ==（前者是赋值，后者是判断相等）。
6. 基础数据类型
类型 | 关键字 | 取值范围/特点 | 示例 | 整型 | int | 通常占4字节，范围约±21亿 | int a = 100; | 双精度浮点型 | double | 占8字节，小数精度更高 | double pi = 3.14159; | 字符型 | char | 占1字节，存单个ASCII字符 | char c = 'A'; |
- 补充说明： 浮点型默认是 double，float 精度低，初赛不常用。 char 变量本质存的是ASCII码值，比如 '0' 的ASCII码是48，'A' 是65，'a' 是97。
7. 数据类型转换
- 自动转换（隐式转换）：编译器自动完成，从低精度到高精度 示例：int a = 10; double b = a; → b 的值是10.0 规则：char/short → int → long → float → double
- 强制转换（显式转换）：手动指定类型，格式：(目标类型)值 示例：double pi = 3.14; int a = (int)pi; → a 的值是3（直接截断小数部分，不是四舍五入）
- 易错点：强制转换可能导致数据丢失（比如把 double 转成 int 时小数部分消失）。
二、运算模块
1. 算术运算
- 运算符：+（加）、-（减）、*（乘）、/（除）、%（取模/取余）
- 核心规则： / 运算：如果两边都是整数，执行整数除法（只保留商的整数部分，比如 5/2=2，-5/2=-2）；如果有一边是小数，执行浮点除法（比如 5/2.0=2.5）。 % 运算：只能用于整数，结果的符号和被除数一致（比如 5%2=1，-5%2=-1，5%-2=1）。
- 优先级：* / % 高于 + -，同级从左到右计算。
- 易错点：整数除法忘记转浮点导致结果为0（比如 1/2 是0，1.0/2 才是0.5）。
2. 比较运算
- 运算符：>（大于）、<（小于）、>=（大于等于）、<=（小于等于）、==（等于）、!=（不等于）
- 核心规则： 运算结果是布尔值：true（真，用1表示）或 false（假，用0表示）。 == 是判断相等，= 是赋值，绝对不能写反！
- 示例：int a = 5, b = 3; cout << (a > b) << endl; // 输出1（true） cout << (a == b) << endl; // 输出0（false）
3. 逻辑运算
- 运算符：&&（逻辑与，且）、||（逻辑或，或）、!（逻辑非，取反）
- 核心规则： &&：两边都为真，结果才为真（短路运算：左边为假，右边不执行）。 ||：两边有一个为真，结果就为真（短路运算：左边为真，右边不执行）。 !：真变假，假变真（优先级最高）。
- 真值表： 表达式 结果 true && true true true && false false `true `false !true false
- 易错点：&& 和 || 写反、忘记短路运算导致的bug（比如 a>0 && (b=10)，如果 a<=0，b=10 不会执行）。
4. 复合运算符
- 运算符：+=、-=、*=、/=、%=
- 语法格式：变量 运算符= 表达式，等价于 变量 = 变量 运算符 表达式
- 示例：int a = 10; a += 5; // 等价于 a = a + 5 → a=15 a *= 2; // 等价于 a = a * 2 → a=30
- 考点提示：复合运算符优先级低，适合简化代码，初赛高频出现在循环中。
三、分支结构
1. 单分支：if 语句
- 语法格式：if (条件表达式) { // 条件为真时执行的代码块 }
- 示例：输入分数，判断是否及格（≥60分）int score; cin >> score; if (score >= 60) { cout << "及格" << endl; }
- 核心规则：条件表达式为真（非0）时，执行大括号内的代码；如果代码只有一行，可以省略大括号（但不推荐，容易出错）。
2. 双分支：if ... else ... 语句
- 语法格式：if (条件表达式) { // 条件为真时执行 } else { // 条件为假时执行 }
- 示例：同上的及格判断，输出“及格/不及格”if (score >= 60) { cout << "及格" << endl; } else { cout << "不及格" << endl; }
3. 多分支：if ... else if ... 多条件判断
- 语法格式：if (条件1) { // 条件1为真时执行 } else if (条件2) { // 条件1为假、条件2为真时执行 } else if (条件3) { // 条件1、2为假、条件3为真时执行 } else { // 所有条件都为假时执行 }
- 示例：根据分数输出等级（90+优秀，80-89良好，60-79及格，<60不及格）if (score >= 90) { cout << "优秀" << endl; } else if (score >= 80) { cout << "良好" << endl; } else if (score >= 60) { cout << "及格" << endl; } else { cout << "不及格" << endl; }
- 核心规则：条件按顺序判断，只要有一个条件为真，后面的所有分支都不会再执行。因此，条件顺序很重要（比如 score>=90 必须写在 score>=80 前面，否则会被提前匹配）。
4. 分支嵌套
- 概念：在 if/else 的代码块中，再写一层分支结构。
- 语法格式：if (外层条件) { if (内层条件1) { // 代码 } else { // 代码 } } else { // 代码 }
- 示例：判断年份是否为闰年（核心逻辑：能被4整除但不能被100整除，或能被400整除）int year; cin >> year; if (year % 4 == 0) { if (year % 100 == 0) { if (year % 400 == 0) { cout << "闰年" << endl; } else { cout << "平年" << endl; } } else { cout << "闰年" << endl; } } else { cout << "平年" << endl; }
- 易错点：大括号不匹配、嵌套层级过多导致逻辑混乱（可以用逻辑运算简化条件，比如 (year%4==0 && year%100!=0) || (year%400==0)）。
四、for 循环
for 循环适合已知循环次数的场景，结构清晰，初赛高频考点。 1. for 循环的标准写法
- 语法格式：for (初始化表达式; 条件表达式; 更新表达式) { // 循环体：条件为真时执行的代码 }
- 示例：输出1到10的所有整数for (int i = 1; i <= 10; i++) { cout << i << " "; }
2. for 循环的执行顺序（核心！必考）
- 初始化表达式：只执行1次（比如 int i=1，定义循环变量并赋初值）。
- 条件表达式：判断是否为真（比如 i<=10），为真则进入循环体，为假则直接结束循环。
- 执行循环体：大括号内的代码执行一次。
- 更新表达式：循环变量更新（比如 i++，i 自增1）。
- 回到步骤2，重复判断条件，直到条件为假。
3. 循环控制语句：break / continue
- **break**：立即终止当前所在的循环，跳出循环体，执行循环后面的代码。 示例：输出1到10，遇到5就停止for (int i=1; i<=10; i++) { if (i == 5) break; cout << i << " "; // 输出：1 2 3 4 }
- **continue**：跳过本次循环中 continue 后面的代码，直接执行更新表达式，进入下一次条件判断。 示例：输出1到10，跳过5for (int i=1; i<=10; i++) { if (i == 5) continue; cout << i << " "; // 输出：1 2 3 4 6 7 8 9 10 }
- 易错点：break 和 continue 只能作用于当前所在的循环，不能跳出外层循环；continue 不会终止循环，只是跳过本次迭代。
五、while 循环
while 循环适合循环次数不确定，只知道循环条件的场景。 1. while 循环的标准写法
- 语法格式：while (条件表达式) { // 循环体：条件为真时执行的代码 // 必须包含让条件趋近于假的语句（比如 i++），否则会变成死循环 }
- 示例：输出1到10的所有整数int i = 1; while (i <= 10) { cout << i << " "; i++; // 更新循环变量，避免死循环 }
2. while 循环的执行顺序
- 先判断条件表达式：为真则进入循环体，为假则直接结束循环。
- 执行循环体中的代码。
- 回到步骤1，重复判断条件，直到条件为假。
3. 数位拆分（while 循环高频应用）
- 核心逻辑：利用 %（取模）和 /（整除）提取整数的每一位数字。
- 示例：输入一个整数，输出它的每一位数字（比如输入1234，输出4 3 2 1）int n; cin >> n; while (n > 0) { int digit = n % 10; // 提取个位数字 cout << digit << " "; n = n / 10; // 去掉个位数字 }
- 拓展考点：数字反转（比如123→321）、求数字各位和（比如123→1+2+3=6）、判断回文数（比如121是回文数，123不是）。
六、循环嵌套
1. for 嵌套 for 的结构
外层 for 循环内部，包含一个完整的内层 for 循环，格式： for (外层初始化; 外层条件; 外层更新) {
for (内层初始化; 内层条件; 内层更新) {
// 内层循环体
}
}
2. for 嵌套 for 的执行顺序
外层循环每迭代一次，内层循环就完整执行一轮（从初始化到条件不成立）。 - 示例：打印3行4列的星号矩阵for (int i = 1; i <= 3; i++) { // 外层控制行数：3行 for (int j = 1; j <= 4; j++) { // 内层控制列数：4列 cout << "*"; } cout << endl; // 每行结束换行 }
- 输出结果：
- **易错点**：内外层循环变量名不能重复（比如都用 `i`），会导致逻辑混乱；内层循环的初始化必须写在 `for` 里，每次外层循环都会重置内层循环变量。
七、数学问题（高频考点汇总）
1. 偶数、奇数判断
- 核心方法：利用 `%` 运算判断是否能被2整除。
- 偶数：`n % 2 == 0`（能被2整除）
- 奇数：`n % 2 != 0` 或 `n % 2 == 1`（不能被2整除）
- 示例：输出1到10的所有偶数
```cpp
for (int i=1; i<=10; i++) {
if (i % 2 == 0) {
cout << i << " ";
}
}
2. 倍数、约数、质数
（1）倍数判断
- 核心方法：a % b == 0 → a 是 b 的倍数，b 是 a 的约数。
- 示例：输出100以内所有7的倍数for (int i=1; i<=100; i++) { if (i % 7 == 0) { cout << i << " "; } }
（2）求约数
- 核心方法：枚举从1到 n 的所有数，判断是否是 n 的约数。
- 示例：输出 n 的所有约数int n; cin >> n; for (int i=1; i<=n; i++) { if (n % i == 0) { cout << i << " "; } }
（3）质数判断（重点）
- 质数定义：大于1的自然数，除了1和它本身，没有其他约数。
- 核心方法：枚举从2到 sqrt(n)（或 n-1）的所有数，判断是否能整除 n。
- 示例：判断 n 是否为质数bool isPrime = true; int n; cin >> n; if (n <= 1) { // 1及以下不是质数 isPrime = false; } else { for (int i=2; i*i <= n; i++) { // 优化：只需要枚举到sqrt(n) if (n % i == 0) { isPrime = false; break; // 找到约数，直接跳出循环 } } } if (isPrime) { cout << "是质数" << endl; } else { cout << "不是质数" << endl; }
- 易错点：忘记处理 n<=1 的情况、循环条件写错（比如 i<=n 会导致效率极低）。
八、数组
数组是相同类型元素的有序集合，在内存中连续存储，适合批量处理数据。 1. 一维数组的定义
- 语法格式：类型 数组名[数组大小];
- 示例：int arr[10]; // 定义一个能存10个int元素的数组，下标范围0-9 double score[5]; // 定义一个能存5个double元素的数组 char name[20]; // 定义一个能存20个char元素的数组
- 核心规则：数组大小必须是常量（初赛中用固定数字即可，比如 10），不能用变量；数组下标从0开始，到 数组大小-1 结束（比如 arr[10] 的有效下标是0-9，访问 arr[10] 会越界报错）。
2. 一维数组的赋值
- 方式1：逐个赋值：通过下标给每个元素赋值int arr[5]; arr[0] = 10; arr[1] = 20; arr[2] = 30; arr[3] = 40; arr[4] = 50;
- 方式2：初始化列表赋值：定义时直接赋值int arr[5] = {10, 20, 30, 40, 50}; // 全部初始化 int arr2[5] = {1, 2}; // 前两个元素为1、2，后面自动初始化为0 int arr3[] = {1, 2, 3}; // 不写大小，编译器自动根据元素个数设置为3
3. 一维数组的元素查询
- 核心方法：通过下标访问元素，格式 数组名[下标]。
- 示例：cout << arr[0] << endl; // 输出数组第一个元素 int a = arr[2]; // 把数组第三个元素赋值给变量a
4. 一维数组的遍历
- 核心方法：用 for 循环配合下标，依次访问每个元素。
- 示例：遍历并输出数组所有元素int arr[5] = {10, 20, 30, 40, 50}; for (int i=0; i<5; i++) { // 下标从0到4 cout << arr << " "; }
5. 一维数组 + for + 分支综合应用
- 常见题型：求数组最大值/最小值、求和、求平均值、统计符合条件的元素个数（比如统计数组中偶数的个数）。
- 示例：求数组的最大值int arr[5] = {12, 45, 7, 89, 23}; int max_val = arr[0]; // 假设第一个元素为最大值 for (int i=1; i<5; i++) { if (arr > max_val) { max_val = arr; // 更新最大值 } } cout << "最大值：" << max_val << endl;
6. 二维数组及多维数组的简单用法
- 二维数组定义：类型 数组名[行数][列数];，可以理解为“行×列”的表格。
- 示例：定义并遍历一个2行3列的二维数组int arr[2][3] = {{1,2,3}, {4,5,6}}; // 遍历：外层循环控制行，内层循环控制列 for (int i=0; i<2; i++) { for (int j=0; j<3; j++) { cout << arr[j] << " "; } cout << endl; }
- 核心规则：二维数组的下标也是从0开始，初赛中只需掌握基础的定义、赋值和遍历即可。
九、字符串
1. 编码的概念
- 核心：计算机只能存储二进制数据，字符需要通过编码（比如ASCII码、GBK、UTF-8）转换成数字才能存储。
- 初赛考点：ASCII码的基本规律（'0'=48，'A'=65，'a'=97，小写字母比对应大写字母大32）。
- 示例：将大写字母转小写char c = 'A'; char lower_c = c + 32; // 等价于 'A' + 32 = 'a' cout << lower_c << endl; // 输出a
2. 字符串的用法
- C++字符串（string 类）：初赛推荐使用，操作简单，需包含头文件 <string>。 定义与赋值：[color=#576B95 !important][url=]#include[/url] <string> using namespace std; string s1 = "hello"; string s2; cin >> s2; // 读取字符串（遇到空格/回车停止） getline(cin, s2); // 读取整行字符串（包含空格，需注意前面的cin残留回车） 常用操作： 操作 示例 说明 求长度 s1.size() 或 s1.length() 返回字符串的字符个数 访问字符 s1[0] 访问第一个字符，下标从0开始 拼接 s1 + " world" 字符串拼接，返回新字符串 比较 s1 == "hello" 按字典序比较，返回布尔值
- 字符数组（char[]）：也可以存储字符串，末尾必须有 '\0'（字符串结束符），初赛中了解即可。char str[] = "hello"; // 等价于 {'h','e','l','l','o','\0'}
十、函数
1. 函数及过程抽象的概念
- 函数：一段封装好的、可重复调用的代码块，用来实现特定功能。
- 过程抽象：把复杂的问题拆分成多个小函数，每个函数只做一件事，简化主程序逻辑。
2. 函数的参数和返回值
- 参数：函数调用时传递给函数的数据，分为形参（定义时的参数）和实参（调用时的参数）。
- 返回值：函数执行结束后返回给调用者的数据，用 return 关键字返回。
3. 带参数的函数
- 语法格式：// 函数定义：返回值类型 函数名(参数列表) { 函数体 } void printSum(int a, int b) { // void表示无返回值 cout << a + b << endl; } // 调用：函数名(实参列表) int main() { printSum(3, 5); // 输出8 return 0; }
4. 有返回值的函数
- 语法格式：// 定义一个求两个数最大值的函数，返回int类型 int getMax(int a, int b) { if (a > b) { return a; // 返回最大值 } else { return b; } } // 调用 int main() { int max_val = getMax(10, 20); // max_val=20 cout << max_val << endl; return 0; }
- 核心规则： 函数必须先声明或定义，再调用（可以在主函数前定义，或在主函数前写函数声明）。 返回值类型必须和函数定义的类型一致，void 类型函数不能有 return 值。 参数列表的类型、个数、顺序必须和定义一致。
十一、算法
1. 模拟
- 概念：按照题目描述的步骤，用代码直接复现整个过程，不需要复杂的数学推导或优化。
- 适用场景：题目逻辑清晰、步骤明确，比如“模拟购物结账”“模拟字符串替换”“模拟进制转换”。
- 示例：模拟输入两个整数，按题目要求先加、再乘、再输出结果int a, b; cin >> a >> b; int sum = a + b; int product = sum * 2; cout << product << endl;
2. 枚举（穷举）
- 概念：使用循环遍历所有可能的情况，逐一判断是否满足题目条件，找到所有符合要求的答案。
- 适用场景：可能的情况数量不多，比如求100以内的质数、求满足条件的水仙花数、鸡兔同笼问题。
- 示例：求100-999之间的所有水仙花数（每个位的立方和等于它本身，比如153=1³+5³+3³）for (int i=100; i<=999; i++) { int bai = i / 100; // 百位 int shi = i / 10 % 10; // 十位 int ge = i % 10; // 个位 if (bai*bai*bai + shi*shi*shi + ge*ge*ge == i) { cout << i << " "; } }
- 核心思路：确定枚举范围 → 用循环遍历 → 用分支判断条件 → 输出符合条件的结果。
附录：初赛易错点清单
- 忘记加头文件（#include<iostream>/#include<string>）或 using namespace std;。
- = 和 == 写反，&& 和 || 混淆。
- 数组下标越界（比如访问 arr[10]，但数组大小只有10，下标范围是0-9）。
- for 循环条件写错（比如 i<=10 写成 i<10，导致少循环一次）。
- 整数除法忘记转浮点，导致结果为0（比如 1/2 写成 1.0/2）。
- 变量未初始化就使用，导致出现随机的“垃圾值”。
- 循环嵌套时，内外层循环变量名重复，或内层循环未重置。
- 字符串操作时，混淆 cin >> 和 getline（前者遇到空格停止，后者读取整行）。
- 函数调用时，参数类型、个数、顺序不匹配。
- 忘记 break/continue 的作用，导致循环逻辑错误。
|
发表于 
关注官方服务号