cout << "Hello" << endl; // 输出Hello后换行
cout << "World\n"; / / 输出World后换行
<<
编程基础
多类型值拼接输出：通过 依次连接不同类型（整数、浮点数、字符串等）。
输出： 数字：123，圆周率：3.14159
 printf 详细用法（C 风格，无需额外头文件）
printf 通过 格式控制符 + .n 直接设置精度（n 为非负整数，指定精度值），无需依赖其他工具，简洁高
效。
1. 核心格式控制符（重点）
C++基本框架
基础输出语法
输出单个值：
输出： Hello, C++!
输出后换行：用
输出形式
或 "\n"。
精度含义 适用类型 示例（输入 double num = 3.1415926）
格式控制
符
endl
#include <iostream>
using namespace std;
int main() {
}
return 0;
//头文件
//命名空间
//主函数
#include <iostream>
using namespace std;
int main() {
cout << "Hello, C++!"; // 输出字符串，无换行
return 0;
}
int num = 123; double pi
= 3.14159;
cout << "数字：" << num << "，圆周率：" << pi << endl;
3. 完整示例代码
小数形式（默认）
小数形式（规范）
科学计数法
自动择短
（%f/%e）
小数形式（规范）
小数点后位数
小数点后位数
小数点后位数
有效数字总位数
小数点后位数
float/double
double（推
荐）
float/double
float/double
double（推
荐）
printf("%.2f", num); → 输出 3.14
printf("%.5lf", num); → 输出 3.14159
printf("%.3e", num); → 输出 3.142e+00
printf("%.4g", num); → 输出 3.142（忽略末尾 0）
printf("%.5lf", num); → 输出 3.14159
%f
%lf
%e
%g
%lf
三、 cout + setprecision(n) 详细用法（C++ 风格，需 ）
cout 本身默认只保留 6 位有效数字，setprecision(n) 用于设置精度，但精度的含义需要配合 fixed 或
scientific 来确定，灵活性更高。
1. 核心流操纵符（必备）
生效范围
后续所有 cout 输出（直到重新设置）
全局生效（直到用 resetiosflags 取消）
作用
设置输出精度（n 为非负整数）
强制以小数形式输出，取消科学计数法
流操纵符
setprecision(n)
fixed
搭配 setprecision(n) 后的精度含义
无其他操纵符：有效数字总位数；
搭配 fixed/scientific：小数点后位数
小数点后位数
printf(" 保留5位有效数字：%.5g\n", num2); // 输出：0.0012345
return 0;
}
#include <cstdio> // printf 必备头文件
int main() {
double num1 = 3.1415926;
double num2 = 0.0012345;
double num3 = -9.8765;
// 1. 小数形式（%lf），不同精度
printf("1. 小数形式：\n");
printf(" 保留2位：%.2lf\n", num1); // 输出：3.14
printf(" 保留6位（默认）：%lf\n", num1); // 输出：3.141593
printf(" 负数保留3位：%.3lf\n", num3); // 输出：-9.877
// 2. 科学计数法（%e）
printf("\n2. 科学计数法：\n");
printf(" 保留3位小数：%.3e\n", num2); // 输出：1.235e-03
printf(" 保留4位小数：%.4e\n", num1); // 输出：3.1416e+00
// 3. 自动择短（%g），有效数字
printf("\n3. 自动择短（有效数字）：\n");
printf(" 保留4位有效数字：%.4g\n", num1); // 输出：3.142
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
●
●
●
仅单次输出有效
fixed 和 scientific 是「全局生效」的，设置后后续所有 cout 输出都会遵循该格式
示例：cout << setprecision(4) << 3.1415926; → 输出 3.142（4 位有效数字）。
setw(n) 仅对「下一个输出项」有效，且默认右对齐，不足宽度用空格填充（可配合 setfill 改为 0
填充）。
浮点数的精度限制：double 类型的有效数字约为 15-17 位，超过该范围会出现数值失真，设置过
高精度无意义。
3. 完整示例代码
setw(n) 设置输出宽度（仅对下一个输出有效） 无（辅助格式化）
cout << " 宽度5，填充0：" << setw(5) << num1 << endl; // 输出：03.14（宽度5，右对齐，补前导0）
cout << " 宽度8，填充0：" << setw(8) << num3 << endl; // 输出：00-9.88（宽度8，补前导0）
// 3. 切换为 scientific：科学计数法，小数点后位数
cout << "\n3. 配合 scientific（科学计数法）：" << endl;
cout << scientific; // 开启科学计数法（全局生效，覆盖 fixed）
cout << " 保留3位小数：" << setprecision(3) << num2 << endl; // 输出：1.235e-03
#include <iostream> // cout 必备头文件
cout << " 保留4位小数：" << setprecision(4) << num1 << endl; // 输出：3.1416e+00
// 4. 取消格式，恢复默认（有效数字）
cout << "\n4. 恢复默认格式（有效数字）：" << endl;
cout << resetiosflags(ios::scientific); // 取消科学计数法
cout << " 保留5位有效数字：" << setprecision(5) << num1 << endl; // 输出：3.1416
// 5. 辅助：setw + setfill（设置输出宽度和填充字符）
cout << "\n5. 辅助：setw + setfill（宽度和填充）：" << endl;
cout << fixed << setprecision(2); // 回到小数形式，2位小数
#include <iomanip> // setprecision、fixed 等必备头文件
cout << setfill('0'); // 填充字符设为 0（全局生效）
using namespace std;
int main() {
double num1 = 3.1415926;
double num2 = 0.0012345;
double num3 = -9.8765;
// 1. 单独使用 setprecision(n)：控制有效数字总位数
cout << "1. 单独使用 setprecision（有效数字）：" << endl;
cout << " 保留4位有效数字：" << setprecision(4) << num1 << endl; // 输出：3.142
cout << " 保留5位有效数字：" << setprecision(5) << num2 << endl; // 输出：0.0012345
cout << " 保留3位有效数字（负数）：" << setprecision(3) << num3 << endl; // 输出：-9.88
// 2. 配合 fixed：控制小数点后位数（最常用）
cout << "\n2. 配合 fixed（小数点后位数）：" << endl;
cout << fixed; // 开启小数形式强制输出（全局生效）
cout << " 保留2位小数：" << setprecision(2) << num1 << endl; // 输出：3.14
cout << " 保留6位小数：" << setprecision(6) << num1 << endl; // 输出：3.141593
cout << " 负数保留3位小数：" << setprecision(3) << num3 << endl; // 输出：-9.877
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
1.
变量定义、赋值及数据类型
常用基本数据类型
int age; // 定义int型变量age
age = 18; // 赋值为18
2. 变量定义与赋值
变量就是一个小盒子，需要定义名字和数据类型
先定义后赋值：
整数
长整数
双精度浮
点数
字符
布尔
含义
10, -5
12345678901
3.14, 1.2e5
'a', '$'
true, false
示例值
常）
4字节
8字节
8字节
1字节
1字节
内存（通
ASCII码范围（0~127）
仅真/假两个值
范围（简化）
int
long
long
double
char
bool
类型
1.
2. 运算符优先级
优先级：括号 () > 乘除取余（ *、 /、 %） > 加减（ +、 -）。
示例：
顺序执行流程
程序按代码书写顺序依次执行，每行执行完毕后进入下一行。
示例（计算长方形面积）：
算术表达式与顺序执行
竞赛常用算术运算符
定义时初始化：
自减
含义
加法
减法
乘法
除法
取余
（模）
含义
自增
--b（前减）
示例（ a=10,
b=3）
a + b
a - b
a * b
a / b
a % b
示例（ a=10,
b=3）
a++（后增）
b先变 2，
再取 2
结果
13
7
30
3
1
结果
先取 10，再
a=11
竞赛注意点
可用于整数、浮点数、字符串拼接（需特殊处
理）
整数相除取整（若需浮点数结果，至少一个操作
数为浮点数，如 10.0 / 3 ）
仅用于整数，竞赛中常用于判断奇偶、分组等
竞赛注意点
简化计数变量更新（如循环中i++）
--
运算
符
+
-
*
/
%
运算
符
++
double score = 95.5; // 定义并初始化double型score char
grade = 'A'; // 定义并初始化char型grade
int res = 10 + 3 * 2; // 先算`3*2=6`，再算`10+6=16` int
res2 = (10 + 3) * 2; // 先算括号内`13`，再算`13*2=26`
1.
2.
执行顺序：定义length →定 义 width →计 算 area →输出结果。
逻辑表达式与条件分支
关系与逻辑运算符
关系运算符：比较值的关系，结果为bool（ true / false）。
==（等于）、 !=（不等于）、 >（大于）、 <（小于）、 >=（大于等于）、 <=（小于等于）。
逻辑运算符：组合/取反布尔值，结果为bool。
&& （逻辑与）：左右都为true时，整体为true。
||（逻辑或）：左右至少一个true 时，整体为true 。
!（逻辑非）：取反， !true→ false， !false→ true。
优先级： 非(!) > 与(&&) > 或(||)
逻辑表达式示例
width = 3;
int area = length * width;
cout << "面积：" << area << endl;
int length = 5; int
int x = 5, y = 10;
bool cond1 = (x > 3) && (y < 20); // true && true → true bool cond2 =
(x > 10) || (y == 10); // false || true → true bool cond3 = !(x == y); //
!(false) → true
int num = 15; if
(num > 0) {
cout << "是正数" << endl;
}
int n = 7;
if (n % 2 == 0) {
cout << "偶数" << endl;
} else {
cout << "奇数" << endl;
}
3.
单分支（ if）：
示例（成绩分级）：
示例（判断正数）：
双分支（ if-else ）：
示例（判断奇偶）：
条件分支结构
多分支（ if-else if-else）：
if (条件) {
/ / 条件为true时执行的代码
}
if (条件) {
/ / 条件为true时执行
} else {
/ / 条件为false时执行
}
if (条件1) {
/ / 条件1为true时执行
} else if (条件2) {
/ / 条件1假、条件2真时执行
} else {
/ / 所有条件为假时执行
}
2. while
更新： i++（ i变为 2）
重复至条件为false（ i=6时，循环结束）
循环（未知循环次数，靠条件终止时常用）
语法： while (条件) { 循环体 }
示例（累加直到和>100）：
循环控制
for、 while、 do-while三种循环
1.
语法：
示例（输出1~5）：
执行流程：
初始化： i = 1
条件： i <= 5为 true，执行循环体（输出 1）
循环（已知循环次数时常用）
(score >= 90) {
cout << "优秀" << endl;
} else if (score >= 70) { cout << "良
好" << endl;
} else {
cout << "待提高" << endl;
}
int score = 85; if
for (初始化; 条件; 更新) {
循环体
}
for
for (int i = 1; i <= 5; i++) { cout << i << "
";
}
int sum = 0, i = 1; while (sum
<= 100) {
sum += i; i++;
}
cout << "累加和超100时，i的值：" << i << endl;
do-while
for (int i = 1; ; i++) { // 无限循环（条件省略）
if (i % 2 == 0) {
cout << "第一个偶数：" << i << endl;
break; // 跳出for循环
}
}
3.
1.
输出： 1 3 5
一维数组
数组是相同类型元素的连续存储空间，通过下标（索引，从0开始）访问元素。
数组的定义与初始化
语法： do { 循环体 } while (条件);
定义： 类型 数组名[长度]; （长度必须为常量）。
初始化：
全部初始化：
示例（至少输入一次合法值）：
循环控制语句
break：立即跳出当前所在
循环。示例（找第一个偶数）：
continue：跳过本次循环剩余代码，进入下一次循环判断。示
例（输出1~5中的奇数）：
循环（至少执行一次循环体）
int num;
do {
cout << "请输入1~10的数：";
cin >> num;
} while (num < 1 || num > 10); cout << "合
法输入：" << num << endl;
for (int i = 1; i <= 5; i++) { if (i % 2 ==
0) {
continue; / / 偶数时跳过后续输出，进入下一次循环
}
cout << i << " ";
}
int arr[5]; / / 定义能存5个int的数组，元素默认是随机值
1.
二维数组可理解为“数组的数组”，用于表示表格、矩阵等二维数据，通过行下标+列下标（均从0开始）访问元素。
二维数组的定义与初始化
定义： 类型 数组名[行数][列数]; （行数、列数需为常量）。
部分初始化（剩余元素为 0）：
省略长度（由初始化列表个数决定）：
数组元素的访问与修改
通 过 数组名[下标]访问/修改元素，下标范围 0 ~ 长度-1（下标越界会导致运行时错误）。示
例：
数组的遍历
用循环依次访问每个元素，常结合for循环。示
例（计算数组和）：
二维数组
int arr1[3] = {10, 20, 30}; // arr1[0]=10, arr1[1]=20, arr1[2]=30
int arr2[5] = {1, 2}; // arr2[0]=1, arr2[1]=2，其余为0
int arr3[] = {5, 6, 7}; // 数组长度自动为3
int arr[3] = {1, 2, 3};
cout << arr[0] << endl; // 输出第1个元素：1 arr[1] =
20; // 修改第2个元素为20
cout << arr[1] << endl; // 输出：20
int arr[5] = {1, 3, 5, 7, 9};
int sum = 0;
for (int i = 0; i < 5; i++) { // i从0到4（数组长度为5） sum += arr[i];
}
cout << "数组和：" << sum << endl; // 输出：25题型
int arr1[2][3] = {
{1, 2, 3}, / / 第0行：matrix1[0][0]=1, matrix1[0][1]=2, matrix1[0][2]=3
{4, 5, 6} / / 第1行：matrix1[1][0]=4, matrix1[1][1]=5, matrix1[1][2]=6
};
初始化：
全部初始化（按行填充）：
部分初始化（未赋值的元素为0）：
int arr1[3][4]; / / 定义3行4列的int型二维数组，元素默认随机值
int arr2[2][3] = { {1}, {4, 5} };
// 结果：
// 第0行：1, 0, 0
// 第1行：4, 5, 0
3.
示例（计算矩阵所有元素和）：
SAS
省略行数（列数不可省略，由初始化列表总行数决定）：
二维数组的访问与修改
通 过 数组名[行下标][列下标] 操作元素
下标范围：行 0 ~ 行数-1，列 0 ~ 列数-1。
二维数组的遍历
用双重循环（外层行、内层列）依次访问每个元素。
int arr3[][3] = { {1,2}, {3,4,5} }; // 自动推断行数为2
int matrix[2][3] = { {1,2,3}, {4,5,6} };
int sum = 0;
for (int i = 0; i < 2; i++) { // 遍历每一行
for (int j = 0; j < 3; j++) { // 遍历每一列
sum += matrix[i][j];
}
}
cout << "矩阵元素和：" << sum << endl; // 输出：21
提取文件名（找最后一个 . 分割后缀）：size_t dot = s.rfind('.'); string ext = s.substr(dot);
四、截取与替换
信奥场景示例
提取子串处理（如提取身份证前6位）：string area = id.substr(0, 6);
字符串修改（如将“123”替换为“456”）：s.replace(0, 3, "456");
五、插入与删除
在信息学奥赛（信奥）中，string 是处理字符串问题的核心工具。
一、基础属性与状态判断
二、元素访问与修改
字符串
三、查找与定位
信奥场景示例
分割字符串（找分隔符 ,）：size_t pos = s.find(','); while (pos != string::npos) { ... }
信奥场景示例
语法
s[i]
s.at(i)
s.push_back('a')
s.append("abc")
s.rfind("abc")
语法
s.find("abc", 0)
语法
s.size() / s.length()
s.empty()
语法
语法
s.substr(2, 3)
s.replace(2, 3, "xyz")
功能说明
访问第 i 个字符（索引从 0 开始，无越界检查）
访问第 i 个字符（有越界检查，会抛异常）
在字符串末尾添加字符 c
在字符串末尾添加字符串 str
从右向左查找子串 sub，返回最后一个匹配的起始索引
功能说明
从 pos 开始查找子串 sub，返回第一个匹配的起始索引；若未找到返回 string::npos
功能说明
功能说明
返回字符串长度（字符个数）
判断字符串是否为空（空返回 true）
功能说明
从 pos 开始截取长度为 len 的子串（len 省略则截取到末尾）
从 pos 开始，替换长度为 len 的子串为 str
rfind(sub, pos)
函数
substr(pos, len)
replace(pos, len, str)
函数
函数
size() / length()
empty()
函数
下标访问
at(i)
push_back(c)
append(str)
函数
find(sub, pos)
信奥场景示例
统计字符串中字符数量，判断是否为回文（如 s.size() % 2 == 0 则可能是偶数长度回文）
处理输入时，先判断字符串是否为空再进行后续操作（如 if (!s.empty()) { ... }）
信奥场景示例
遍历字符串统计特定字符出现次数：for (int i=0; i<s.size(); i++) if (s[i] == 'a') cnt++;
需严格确保索引合法时使用，避免数组越界错误
动态构造字符串（如拼接结果集）：string res; for (int i=0; i<5; i++) res.push_back('*');
拼接多个子串：s.append("def").append("ghi"); // 结果为 “abcdefghi”
示例2：统计子串出现次数
六、比较与转换
空字符串： string::npos
七、竞赛高频场景综合示例
示例1：字符串分割（按分隔符 , 分割）
信奥场景示例
字符串排序（如对多个字符串按字典序升序排列）：vector<string> vs; sort(vs.begin(), vs.end());
自定义排序规则（如忽略大小写比较）：需结合 tolower 手动实现，或用该函数辅助判断
调用 C 风格函数（如 printf("%s", s.c_str()); 或与文件操作函数交互）
构造特定格式字符串（如在数字前插前缀）：string num = "123"; num.insert(0, "NO."); // 结果 “NO.123”
去除字符串中的特定部分（如删除中间3个字符）：s.erase(1, 3);
语法
s1 == s2 / s1 > s2
s.compare("abc")
s.c_str()
s.insert(2, "abc")
s.erase(2, 3)
功能说明
直接比较字符串（按字典序）
按字典序比较，返回 0（相等）、正数（s 大）、负数（s 小）
返回 C 风格字符串（const char* 类型）
在 pos 位置插入字符串 str
从 pos 开始删除长度为 len 的子串（len 省略则删除到末尾）
insert(pos, str)
函数
比较运算符
compare(str)
c_str()
erase(pos, len)
parts.push_back(s); // 处理最后一段
// parts 结果：["a", "b", "c", "d"]
string s = "ababa";
string sub = "aba";
int cnt = 0;
size_t pos = 0;
while ((pos = s.find(sub, pos)) != string::npos) {
cnt++;
pos += 1; // 避免重复匹配（如“aba”在“ababa”中出现2次）
}
// cnt 结果：2
string s = "a,b,c,d";
vector<string> parts;
size_t pos = 0;
while ((pos = s.find(',')) != string::npos) {
parts.push_back(s.substr(0, pos));
s.erase(0, pos + 1); // 删去已处理的部分（包括分隔符）
}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
示例3：构造空心等腰三角形（结合字符串操作）
函数
pow(a,b);
3*3*3*3 2*2*2*2*2
pow(3,4) pow(2,5)
sqrt(81) sqrt(78)
?*?=81 ?*?=78
向上取整
2.1-->3 3.9--->4
ceil(2.1) ceil(3.9)
向下取整
2.1---->2 3.9---->4
掌握这些函数后，几乎可以解决信奥中所有字符串处理类问题（如字符串匹配、分割、构造、统计等）。
练习时注意结合具体场景，灵活运用这些函数的组合即可。
cin >> n;
for (int i = 1; i <= n; i++) {
string line;
// 前导空格
line.append(n - i, ' ');
// 第一个*
line.push_back('*');
// 实心行（第1行或最后一行）
if (i == 1 || i == n) {
line.append(2 * i - 2, '*');
} else { // 空心行
line.append(2 * i - 3, ' ');
line.push_back('*');
}
cout << line << endl;
}
1 int n;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1.
2.
3.
4.
5.
floor(2.1) floor(3.9)
和sum、求最大值maxn、判断素数is_prime）；
形参列表：函数的「输入数据」，格式类型+变量名，多个形参用逗号分隔，无参数则写空括号()
即可；
函数体：核心逻辑实现，是函数的主体；
绝对值
return：① 有返回值函数：return 变量/常量 必须与返回值类型一致；② void型函数：不需要
return语句。
-5---->5 6---->6
abs(-5) abs(6)
函数是一段完成特定独立功能的代码块，可被重复调用，执行后可选择性返回一个结果；
main()是程序的入口函数，所有程序都从main()开始执行，其他函数都需要被main()或其他函数调用才会
执行。
一、自定义函数
1. 自定义函数的【完整标准语法】（必须背会，语法严格）
语法说明（信奥易错点）
返回值类型：函数执行完要返回的结果类型，常见int/long long/double/char，无返回值时必须
写关键字 void；
函数名：符合C++命名规则（字母/数字/下划线，首字母非数字），见名知意（竞赛建议：比如求
// 格式：返回值类型 函数名( 形参列表 ) { 函数体; return 返回值; }
返回值类型 函数名(数据类型 形参1, 数据类型 形参2, ...) {
// 函数体：实现核心功能的代码
执行语句;
return 返回值; // 规则：有返回值必须写return，无返回值则无return
}
1
2
3
4
5
6
return 0;
// 自定义函数：打印分割线，无参数、无返回值
}
void printLine() {
#include <iostream>
cout << "-------------------------" << endl;
}
int main() {
printLine(); // 调用自定义函数
cout << "信奥C++函数知识点" << endl;
printLine(); // 重复调用，体现函数复用性
return 0;
}
#include <iostream>
using namespace std;
using namespace std;
// 自定义函数：打印n个*号，传入参数n，无返回值
void printStar(int n) {
for(int i=1; i<=n; i++) cout << "*";
cout << endl;
}
int main() {
printStar(5); // 调用：实参5传给形参n，打印5个*
printStar(10); // 调用：实参10传给形参n，打印10个*
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
●
●
3. 函数的调用：形参 & 实参
形参：定义函数时写的参数（如getMax(int a, int b)中的a、b），是「形式上的参数」，仅在函
数内部有效，相当于函数的局部变量；
实参：调用函数时传入的参数（如getMax(15,23)中的15、23），是「实际的数值/变量」，调用
for(int i=2; i*i<=x; i++) {
// 自定义函数：返回圆周率π，无参数，返回值为double类型
if(x%i == 0) return false;
}
return true;
}
int main() {
cout << "最大值：" << getMax(15,23) << endl; // 调用函数，输出23
int n = 29;
if(isPrime(n)) cout << n << "是素数" << endl;
return 0;
}
double getPI() {
#include <iostream>
return 3.1415926535;
}
int main() {
double r = 5;
double area = getPI() * r * r; // 调用函数获取π，计算圆面积
cout << "圆的面积：" << area << endl;
return 0;
}
#include <iostream>
using namespace std;
using namespace std;
// 例1：求两个整数的最大值（信奥基础题）
int getMax(int a, int b) {
if(a > b) return a;
else return b;
}
// 例2：判断一个数是否是素数（信奥高频必考！）
bool isPrime(int x) { // 返回值为bool型：true是素数，false不是
if(x <= 1) return false;
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
●
●
●
●
时会把实参的值传递给形参。
语法：形参前加&符号（引用符），格式void 函数名(数据类型 &形参)
核心原理：调用函数时，把实参的「副本」传给形参，形参和实参是两个独立的变量，在函数内部
修改形参的值，不会影响实参的值。
例题（经典反例：值传递无法交换两个数）：
4. 函数的两种传参方式
 方式1：值传递（默认传参方式，90%场景使用）
 方式2：地址传递（引用传递）
核心原理：调用函数时，把实参的内存地址传给形参，形参是实参的「别名」，在函数内部修改形
参的值，会直接修改实参的值。
#include <iostream>
using namespace std;
// 值传递：交换形参a和b，实参不会被修改
void swap_val(int a, int b) {
int temp = a;
a = b;
b = temp;
}
int main() {
int x=3, y=5;
swap_val(x,y); // 调用函数
cout << x << " " << y << endl; // 输出：3 5 （实参无变化！）
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
●
●
●
5. 函数的声明与定义分离（信奥规范写法，必考语法）
核心问题：C++编译器「从上到下」编译代码
如果自定义函数写在main()函数后面，编译器在编译main()时会找不到该函数，直接报错；
解决办法：函数声明（函数原型）
函数声明：告诉编译器「有这个函数存在」，语法是把函数的定义头写出来，末尾加分号，不写函
数体；
函数定义：函数的完整实现（有函数体）；
规范写法：声明写在main()前，定义写在main()后，这是信奥代码的标准格式，必须遵守！
例题（竞赛规范写法，必练）
// 地址传递（引用）：交换形参a和b，实参会被同步修改
void swap_ref(int &a, int &b) {
#include <iostream>
int temp = a;
a = b;
b = temp;
}
int main() {
int x=3, y=5;
swap_ref(x,y); // 调用函数
cout << x << " " << y << endl; // 输出：5 3 （实参成功交换！）
return 0;
}
using namespace std;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1.
2.
3.
数位分离
数位分离指将一个整数的每一位数字单独提取出来（如把 123拆为 1、 2、 3），核心思路是利用取余（ %）和整除
（ /）操作。
步骤：
对数字n取余 10，得到个位数字。
将 n整除 10（ n = n / 10），去掉个位，缩小数字范围。
重复步骤1-2，直到 n == 0（所有位已提取）。
示例（提取 1234的每一位并输出）：
输出： 4 3 2 1（注意：提取顺序是“从低位到高位”，若需“高位到低位”，可先存数组再逆序）。
必会题型
// 1. 函数声明（原型）：只写头，加分号，形参名可写可不写，类型必须写
int getSum(int a, int b);
#include <iostream>
bool isPrime(int); // 形参名省略，语法合法，竞赛常用
int main() {
cout << "和为：" << getSum(10,20) << endl; // 正常调用
cout << "17是否是素数：" << isPrime(17) << endl;
return 0;
}
// 2. 函数定义：完整实现，写在main后
int getSum(int a, int b) {
return a + b;
using namespace std;
}
bool isPrime(int x) {
if(x<=1) return false;
for(int i=2;i*i<=x;i++) if(x%i==0) return false;
return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int n = 1234; while
(n > 0) {
int digit = n % 10; // 取个位
cout << digit << " ";
n = n / 10; // 去掉个位
}
% 2
1.
2.
3.
奇数偶数判断
质数判断
质数（素数）是大于1且只能被1和自身整除的整数。
判断思路：验证 2 ~ n-1范围内是否有能整除n的数。步
骤：
若 n <= 1，直接判定为非质数。
若 n == 2，判定为质数。
若 n是偶数（ n % 2 == 0），判定为非质数。
通过取余运算 判断：若 n % 2 == 0则为偶数，否则为奇数。
int n; cin
>> n;
if (n % 2 == 0) {
cout << "偶数" << endl;
} else {
cout << "奇数" << endl;
}
4.
示例（判 断 n 是否为质数）：
遍 历 i从 3到 sqrt(n)，步长 2（只试奇数）：若 n % i == 0， 则 n是非质数；否则遍历结束后判定为质数。
#include <iostream> / / 需包含sqrt函数的头文件
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i <= n-1; i ++) { // 只试奇数
if (n % i == 0) {
return false; // 能被i整除，非质数
}
}
return true; // 遍历后无因子，是质数
}
int main() {
int n; cin
>> n;
if (isPrime(n)) {
cout << "是质数" << endl;
} else {
cout << "非质数" << endl;
}
return 0;
}