本文系统梳理了 C++ 一级 GESP 考试的核心知识点，包括编程环境搭建、数据类型与变量、运算符、输入输出、流程控制、函数基础、数组及简单算法。通过概念解析、代码示例和易错点提醒，帮助学习者掌握 C++ 语法与逻辑思维，并提供模拟试题辅助备考。
GESP（图形教育能力测评）是由中国计算机学会（CCF）主办的面向青少年的编程能力认证考试，旨在考察编程基础能力与应用思维。C++ 一级是 GESP 的入门级别，重点考察C++ 基础语法、逻辑控制、简单算法等核心能力。本文以 GESP 一级考试大纲为基准，结合零基础学习需求，系统梳理所有知识点，包含概念解析、代码示例、易错点提醒、真题模拟四大模块，助你高效备考！
C++ 是一种高效、通用、面向对象的编程语言，广泛应用于游戏开发、操作系统、嵌入式设备等领域。GESP 一级选择 C++ 作为考试语言，是因为其语法简洁、逻辑清晰，适合培养编程思维。
要编写 C++ 程序，需先安装编译器（将代码转为计算机能执行的二进制文件）。常用工具：
验证安装：新建文件 hello.cpp，输入以下代码并运行，若输出 Hello GESP！ 则环境正常。
#include <iostream>
using namespace std;
int main() {
cout << "Hello GESP！" << endl;
return 0;
}
#include <iostream>：告诉编译器引入'输入输出流'相关的函数（如 cout、cin）。using namespace std;：'std'是 C++ 标准库的命名空间，避免重复命名（例如 cout 实际是 std::cout）。注意：新手建议保留 using namespace std;，避免每次写 std::cout 的麻烦；熟练后可指定具体命名空间（如 using std::cout;）。
一个 C++ 程序由预处理指令、全局变量、函数组成，其中 main() 函数是程序执行的起点（必须存在且唯一）。
// 预处理指令（如 #include）
#include <iostream>
using namespace std;
// 全局变量（不推荐新手使用，易引发冲突）
int global_num = 10;
// 自定义函数（可放在 main() 前或后，若放后面需声明）
void print_num() {
cout << "全局变量值：" << global_num << endl;
}
// 主函数（程序从这里开始执行）
int main() {
print_num(); // 调用自定义函数
int local_num = 20; // 局部变量（仅在 main() 内有效）
cout << "局部变量值：" << local_num << endl;
return 0;
}
输出结果：
全局变量值：10 局部变量值：20
计算机只能处理二进制，但人类需要处理数字、文字、符号等。数据类型定义了数据的存储大小、取值范围、可进行的操作。整数可以做除法，但结果是整数。
GESP 一级主要考察以下 5 种基本数据类型：
| 类型名 | 关键字 | 存储大小（字节） | 取值范围 | 说明 |
|---|---|---|---|---|
| 整型 | int | 4 | -2^31 ~ 2^31-1（约 -21 亿~21 亿） | 最常用的整数类型 |
| 短整型 | short | 2 | -2^15 ~ 2^15-1（约 -3 万~3 万） | 范围小，节省空间 |
| 长整型 | long | 4（32 位系统）或 8（64 位） | 同 int 或更大 | 兼容不同系统的整数 |
| 长长整型 | long long | 8 | -2^63 ~ 2^63-1（约 -9e18~9e18） | 超大整数 |
| 单精度浮点型 | float | 4 | ±3.4e-38 ~ ±3.4e38 | 小数，精度约 6-7 位有效数字 |
| 双精度浮点型 | double | 8 | ±1.7e-308 ~ ±1.7e-308 | 小数，精度约 15-17 位有效数字 |
| 字符型 | char | 1 | -128 ~ 127（或 0~255） | 存储单个字符（如'a'、'5'） |
| 布尔型 | bool | 1 | true（1）或 false（0） | 逻辑值，表示'真'或'假' |
0.1 无法精确表示），计算时可能存在精度误差。'a' 对应 97，'0' 对应 48）。变量是程序中存储数据的'容器'，使用前需声明类型和名称。
声明语法：
数据类型 变量名 [= 初始值]; // 方括号表示可选（初始化非必须，但强烈建议！）
示例：
int age; // 声明一个整型变量 age（未初始化，值不确定）
double score = 90.5; // 声明并初始化一个双精度浮点型变量 score
char grade = 'A'; // 声明并初始化一个字符型变量 grade
bool is_pass = true; // 声明并初始化一个布尔型变量 is_pass
命名规则（必须遵守！）：
_）。123abc 非法，abc123 合法）。int、main、if 等，详见附录）。student_age 表示学生年龄，避免 a、b 等无意义名称）。常量是程序中值固定不变的数据，常用两种方式定义：
10、3.14、'a'、"hello"）。const 修饰的常量：声明时用 const 限定，不可修改。示例：
const double PI = 3.14159; // 圆周率，不可修改
const int MAX_STUDENTS = 50; // 最大学生数
cout << PI * 2 * 2 << endl; // 输出半径为 2 的圆周长（12.56636）
// PI = 3.14; // 错误！const 常量不可修改
当不同类型的数据参与运算时，C++ 会自动转换类型（隐式转换），但可能丢失精度。
小范围类型 → 大范围类型（安全）：
char/short → int → long → long long → float → double
示例：
char c = 'A'; // ASCII 码 65
int i = c; // 隐式转换为 int（65）
double d = i; // 隐式转换为 double（65.0）
大范围类型 → 小范围类型（可能丢失数据，需谨慎）：
语法：(目标类型) 表达式 或 目标类型 (表达式)
示例：
double pi = 3.14159;
int int_pi = (int)pi; // 结果为 3（截断小数部分）
cout << int_pi << endl; // 输出 3
int num = 100;
char ch = char(num); // 结果为'd'（ASCII 码 100 对应'd'）
运算符是连接数据并产生新数据的符号，GESP 一级重点考察算术、赋值、关系、逻辑、条件、自增自减六大类运算符。
用于数值计算，包括：+（加）、-（减）、*（乘）、/（除）、%（取余）、++（自增）、--（自减）。
/：整数相除结果为整数（舍去小数部分），浮点数相除结果为浮点数。%：仅适用于整数，结果是两数相除的余数（符号与被除数一致）。示例：
int a = 10, b = 3;
cout << a + b << endl; // 13
cout << a - b << endl; // 7
cout << a * b << endl; // 30
cout << a / b << endl; // 3（10/3=3.333…，取整为 3）
cout << a % b << endl; // 1（10=3*3+1）
double c = 10.5, d = 3.2;
cout << c / d << endl; // 3.28125（浮点数除法）
// cout << c % d << endl; // 错误！% 不能用于浮点数
i++（后置自增）：先使用 i 的值，再自增 1。++i（前置自增）：先自增 1，再使用 i 的值。示例：
int i = 5;
cout << i++ << endl; // 输出 5（先使用 i=5，再 i=6）
cout << i << endl; // 输出 6
int j = 5;
cout << ++j << endl; // 输出 6（先 j=6，再使用 j）
cout << j << endl; // 输出 6
将右侧表达式的值赋给左侧变量，包括基本赋值（=）和复合赋值（+=、-=、*=、/=、%=）。
示例：
int x = 10;
x = x + 5; // 等价于 x += 5 → x=15
x -= 3; // 等价于 x = x - 3 → x=12
x *= 2; // 等价于 x = x * 2 → x=24
x /= 4; // 等价于 x = x / 4 → x=6
x %= 4; // 等价于 x = x % 4 → x=2（6 除以 4 余 2）
用于比较两个值的大小，结果为布尔型（true或false），包括：>（大于）、<（小于）、>=（大于等于）、<=（小于等于）、==（等于）、!=（不等于）。
示例：
int a = 10, b = 20;
cout << (a > b) << endl; // 0（false）
cout << (a < b) << endl; // 1（true）
cout << (a == b) << endl; // 0（false）
cout << (a != b) << endl; // 1（true）
注意：=是赋值，==是比较，新手易混淆！
用于组合布尔表达式，结果为布尔型，包括：&&（逻辑与）、||（逻辑或）、!（逻辑非）。
| 运算符 | 名称 | 规则（P 和 Q 为布尔值） | 短路特性 |
|---|---|---|---|
&& | 逻辑与 | P 为 false 时，结果必为 false（不再计算 Q） | 左操作数为 false 时，右操作数不执行 |
| ` | ` | 逻辑或 | |
! | 逻辑非 | 取反（true→false，false→true） | 无 |
示例：
int age = 15;
bool is_student = true;
// 逻辑与：age>=6 && age<=18 → 15 在 6~18 之间 → true
cout << (age >= 6 && age <= 18) << endl; // 1（true）
// 逻辑或：is_student || age>60 → 已有一个为 true → true
cout << (is_student || age > 60) << endl; // 1（true）
// 逻辑非：!(age==20) → age=15≠20 → true
cout << !(age == 20) << endl; // 1（true）
唯一的三目运算符，语法：表达式 1 ? 表达式 2 : 表达式 3。
true，执行表达式 2 并返回结果；false，执行表达式 3 并返回结果。示例：
int a = 10, b = 20;
int max_num = (a > b) ? a : b; // 比较 a 和 b，取较大值
cout << max_num << endl; // 输出 20
当表达式中有多个运算符时，需按优先级确定计算顺序；优先级相同则按结合性（左结合或右结合）。
常见运算符优先级（从高到低）：
()、自增 ++/自减 --（后置）- 取负、!）*///% → +/->/</>=/<= → ==/!=! → && → ||?:=/+= 等示例：
int x = 2 + 3 * 4; // 先乘后加 → 2+12=14
int y = (2 + 3) * 4; // 括号改变优先级 → 5*4=20
int z = -3 * 2; // 单目负号优先级高于乘 → -(3*2)=-6
输入（读取外部数据）和输出（显示程序结果）是程序与用户交互的核心，GESP 一级主要考察 cin（输入）和 cout（输出）。
cout（控制台输出）用于将数据打印到屏幕，语法：
cout << 表达式 1 << 表达式 2 << ... << endl;
endl：输出换行符并刷新缓冲区（可选，也可用换行）。示例：
int age = 12;
double score = 95.5;
char grade = 'A';
// 输出整数、浮点数、字符，用空格分隔
cout << "年龄：" << age << " 分数：" << score << " 等级：" << grade << endl;
// 输出：年龄：12 分数：95.5 等级：A
// 用 \n 换行
cout << "第一行" << '\n' << "第二行" << endl;
// 输出：
// 第一行
// 第二行
cin（控制台输入）用于从键盘读取数据到变量，语法：
cin >> 变量 1 >> 变量 2 >> ...;
cin 会自动匹配变量类型。示例：
int a, b;
double c;
char d;
cout << "输入两个整数和一个浮点数：" << endl;
cin >> a >> b >> c; // 输入：5 8 3.14（空格分隔）
cout << "输入一个字符：" << endl;
cin >> d; // 输入：X（换行或空格不影响）
cout << "a=" << a << " b=" << b << " c=" << c << " d=" << d << endl;
// 输出：a=5 b=8 c=3.14 d=X
默认情况下，cout 输出浮点数会保留 6 位有效数字，整数为十进制。可通过 iomanip 库中的函数格式化输出。
常用格式化操作：
| 功能 | 代码示例 | 说明 |
|---|---|---|
| 设置浮点数精度 | cout << fixed << setprecision(2); | 固定小数位数（如 2 位） |
| 设置宽度和填充 | cout << setw(10) << setfill('*'); | 宽度为 10，不足用 * 填充 |
| 切换进制（十进制/八进制/十六进制） | cout << hex;（十六进制） | 八进制 oct，十进制 dec（默认） |
示例：
#include <iomanip> // 需包含格式化库
int main() {
int num = 255;
double pi = 3.1415926;
cout << "十进制：" << num << endl; // 255
cout << "十六进制：" << hex << num << endl; // ff（小写）
cout << "八进制：" << oct << num << endl; // 377
cout << fixed << setprecision(2); // 保留 2 位小数
cout << "π≈" << pi << endl; // 3.14
cout << "填充示例：" << setw(10) << setfill('*') << 123 << endl; // *******123（总宽度 10）
return 0;
}
流程控制决定了程序的执行顺序，GESP 一级重点考察**顺序、分支（if-else、switch-case）、循环（for、while、do-while）**三大结构。
程序默认按代码编写顺序逐行执行（从上到下，从左到右），是最基本的流程。
分支结构用于判断条件是否成立，决定执行哪段代码。
语法：
if (条件表达式) {
// 条件为 true 时执行的代码
}
示例：判断是否及格（分数≥60 及格）
int score = 75;
if (score >= 60) {
cout << "及格！" << endl; // 输出：及格！
}
语法：
if (条件表达式) {
// 条件为 true 时执行
} else {
// 条件为 false 时执行
}
示例：判断是否及格
int score = 55;
if (score >= 60) {
cout << "及格！" << endl;
} else {
cout << "不及格！" << endl; // 输出：不及格！
}
语法：
if (条件 1) {
// 条件 1 为 true 时执行
} else if (条件 2) {
// 条件 1 为 false，条件 2 为 true 时执行
} else {
// 所有条件为 false 时执行
}
示例：根据分数输出等级（A:90+, B:80-89, C:70-79, D:60-69, F:＜60）
int score = 85;
if (score >= 90) {
cout << "等级：A" << endl;
} else if (score >= 80) { // 等价于 score <90 && score >=80
cout << "等级：B" << endl; // 输出：等级：B
} else if (score >= 70) {
cout << "等级：C" << endl;
} else if (score >= 60) {
cout << "等级：D" << endl;
} else {
cout << "等级：F" << endl;
}
适用于条件为固定值的场景（如星期几、月份），语法：
switch (表达式) {
// 表达式结果必须是整型、字符型或枚举型
case 常量 1:
// 表达式等于常量 1 时执行
break; // 跳出 switch，避免穿透
case 常量 2:
// 表达式等于常量 2 时执行
break;
default:
// 所有 case 都不匹配时执行（可选）
}
示例：根据月份输出天数（不考虑闰年）
int month = 2;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
cout << "31 天" << endl;
break;
case 4:
case 6:
case 9:
case 11:
cout << "30 天" << endl;
break;
case 2:
cout << "28 天" << endl; // 输出：28 天
break;
default:
cout << "无效月份！" << endl;
}
注意：
case 后必须是常量值（如 1、'a'），不能是变量或表达式。break，会发生'穿透'（执行下一个 case 的代码），需谨慎使用。循环结构用于重复执行某段代码，直到条件不满足。
语法：
while (条件表达式) {
// 条件为 true 时重复执行
}
执行流程：先判断条件，若为 true 则执行循环体，执行完后再次判断，直到条件为 false。
示例：打印 1~5 的整数
int i = 1;
while (i <= 5) {
cout << i << " ";
i++; // 关键！否则死循环（i 一直是 1）
}
// 输出：1 2 3 4 5
语法：
do {
// 至少执行一次循环体
} while (条件表达式);
执行流程：先执行一次循环体，再判断条件，若为 true 则继续循环，否则退出。
示例：用户输入验证（直到输入合法值）
int num;
do {
cout << "请输入 1~10 的数：" << endl;
cin >> num;
} while (num < 1 || num > 10); // 输入合法时退出循环
cout << "输入成功：" << num << endl;
语法：
for (初始化表达式; 条件表达式; 更新表达式) {
// 循环体
}
执行流程：
true 则执行循环体；i++）；false。示例：打印 1~5 的整数（等价于 while 循环）
for (int i = 1; i <= 5; i++) {
cout << i << " ";
}
// 输出：1 2 3 4 5
循环内部包含另一个循环（如打印乘法表），外层循环每执行一次，内层循环执行全部次数。
示例：打印 9×9 乘法表
for (int i = 1; i <= 9; i++) { // 外层循环控制行数（1~9）
for (int j = 1; j <= i; j++) { // 内层循环控制列数（1~i）
cout << j << "×" << i << "=" << i * j << "\t"; // \t 制表符对齐
}
cout << endl; // 每一行结束后换行
}
输出结果（部分）：
1×1=1 1×2=2 2×2=4 1×3=3 2×3=6 3×3=9 ...（省略后续行）
break：终止当前循环，跳出循环体（不再执行后续迭代）。continue：跳过当前迭代的剩余代码，直接进入下一次循环判断。示例：用 break 找第一个偶数
int nums[] = {1, 3, 5, 7, 8, 9};
for (int i = 0; i < 6; i++) {
if (nums[i] % 2 == 0) {
cout << "第一个偶数：" << nums[i] << endl;
break; // 找到后退出循环
}
}
// 输出：第一个偶数：8
示例：用 continue 跳过奇数
for (int i = 1; i <= 5; i++) {
if (i % 2 == 1) {
continue; // 跳过奇数，不执行后续 cout
}
cout << i << " "; // 只输出偶数
}
// 输出：2 4
函数是程序的'模块'，用于封装重复代码，提高复用性。GESP 一级考察函数的定义、声明、调用及参数传递。
函数由返回类型、函数名、参数列表、函数体组成，语法：
返回类型 函数名 (参数列表) {
// 函数体（执行的代码）
return 返回值; // 若返回类型为 void，可省略 return
}
cout、cin 属于 iostream 库）。示例：计算两个数的和
// 函数声明（放在 main() 前或头文件中）
int add(int a, int b);
int main() {
int x = 3, y = 5;
int sum = add(x, y); // 函数调用
cout << "和为：" << sum << endl; // 输出：和为 8
return 0;
}
// 函数定义（放在 main() 后或其他文件中）
int add(int a, int b) {
return a + b; // 返回 a 和 b 的和
}
GESP 一级只考察值传递：函数接收的是参数的'副本'，修改形参不影响实参。
示例：尝试修改形参的值
void swap(int a, int b) { // 形参 a、b 是实参的副本
int temp = a; a = b; b = temp;
}
int main() {
int x = 10, y = 20;
swap(x, y); // 调用 swap 函数
cout << "x=" << x << " y=" << y << endl; // 输出：x=10 y=20（未改变）
return 0;
}
函数可以没有参数（用空括号 () 表示），也可以没有返回值（返回类型为 void）。
示例：打印问候语
void say_hello() {
cout << "Hello, GESP！" << endl;
}
int main() {
say_hello(); // 调用无参函数
say_hello(); // 再次调用
return 0;
}
// 输出：
// Hello, GESP！
// Hello, GESP！
数组是存储同类型、连续内存的一组变量，用于批量处理数据。GESP 一级考察一维数组的定义、初始化、访问及基本操作。
语法：
数据类型 数组名 [数组长度]; // 数组长度必须是常量（C++11 前）或常量表达式
示例：
int scores[5]; // 定义一个整型数组，长度 5（索引 0~4）
double temps[10]; // 定义一个双精度浮点型数组，长度 10
// char chars['A']; // 错误！数组长度必须是常量（'A'是字符，不是常量）
const int N = 3;
int arr[N]; // 正确！N 是 const 常量
数组初始化时可为元素赋初值，未显式赋值的元素会被初始化为 0（整型）、0.0（浮点型）、（字符型）或不确定值（全局数组默认初始化为 0）。
示例：
int a[3] = {1, 2, 3}; // 全部初始化：a[0]=1, a[1]=2, a[2]=3
int b[5] = {4, 5}; // 部分初始化：b[0]=4, b[1]=5，其余为 0
int c[] = {6, 7, 8, 9}; // 省略长度：长度自动推断为 4
int d[3] = {}; // 全部初始化为 0：d[0]=d[1]=d[2]=0
通过索引（从 0 开始）访问数组元素，语法：数组名 [索引]。
示例：
int nums[5] = {10, 20, 30, 40, 50};
cout << nums[0] << endl; // 输出第一个元素：10
cout << nums[3] << endl; // 输出第四个元素：40
nums[1] = 200; // 修改第二个元素为 200
cout << nums[1] << endl; // 输出：200
通过循环访问数组的所有元素（最常用 for 循环）。
示例：计算数组元素的和
int arr[5] = {1, 2, 3, 4, 5};
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += arr[i]; // 累加每个元素
}
cout << "和为：" << sum << endl; // 输出：15
int find_max(int arr[], int len) {
// 参数：数组名（指针）、长度
int max_val = arr[0]; // 假设第一个元素是最大值
for (int i = 1; i < len; i++) {
if (arr[i] > max_val) {
max_val = arr[i];
}
}
return max_val;
}
int main() {
int scores[5] = {85, 92, 78, 95, 88};
int max_score = find_max(scores, 5);
cout << "最高分：" << max_score << endl; // 输出：95
return 0;
}
void reverse_arr(int arr[], int len) {
for (int i = 0; i < len / 2; i++) {
int temp = arr[i];
arr[i] = arr[len - 1 - i]; // 交换 i 和 len-1-i 位置的元素
arr[len - 1 - i] = temp;
}
}
int main() {
int nums[5] = {1, 2, 3, 4, 5};
reverse_arr(nums, 5);
for (int i = 0; i < 5; i++) {
cout << nums[i] << " "; // 输出：5 4 3 2 1
}
return 0;
}
arr1 = arr2; 错误）。算法是解决问题的步骤和方法，GESP 一级重点考察枚举、排序、查找三大基础算法。
思想：根据问题的条件，逐一列举所有可能的情况，筛选出符合条件的解。
示例：百钱买百鸡（公鸡 5 元/只，母鸡 3 元/只，小鸡 1 元/3 只，用 100 元买 100 只鸡）
int main() {
int rooster, hen, chick; // 公鸡、母鸡、小鸡数量
for (rooster = 0; rooster <= 20; rooster++) { // 公鸡最多 20 只（5*20=100 元）
for (hen = 0; hen <= 33; hen++) { // 母鸡最多 33 只（3*33=99 元）
chick = 100 - rooster - hen; // 小鸡数量=总数 - 公鸡 - 母鸡
if (chick % 3 == 0 && 5 * rooster + 3 * hen + chick / 3 == 100) {
cout << "公鸡：" << rooster << " 母鸡：" << hen << " 小鸡：" << chick << endl;
}
}
}
return 0;
}
输出结果（部分）：
公鸡：0 母鸡：25 小鸡：75 公鸡：4 母鸡：18 小鸡：78 公鸡：8 母鸡：11 小鸡：81 公鸡：12 母鸡：4 小鸡：84
思想：重复遍历数组，比较相邻元素，若顺序错误则交换，直到所有元素有序（升序/降序）。
示例：升序排列数组 {5, 3, 8, 1, 2}
void bubble_sort(int arr[], int len) {
for (int i = 0; i < len - 1; i++) { // 外层循环：控制排序轮数（n-1 轮）
for (int j = 0; j < len - 1 - i; j++) { // 内层循环：比较相邻元素（每轮减少 i 次）
if (arr[j] > arr[j + 1]) { // 升序：前一个＞后一个则交换
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int nums[5] = {5, 3, 8, 1, 2};
bubble_sort(nums, 5);
for (int i = 0; i < 5; i++) {
cout << nums[i] << " "; // 输出：1 2 3 5 8
}
return 0;
}
思想：从数组第一个元素开始，逐个比较，直到找到目标值或遍历完数组。
示例：在数组中查找值为 7 的元素
int linear_search(int arr[], int len, int target) {
for (int i = 0; i < len; i++) {
if (arr[i] == target) {
return i; // 找到目标，返回索引
}
}
return -1; // 未找到，返回 -1（约定俗成的无效索引）
}
int main() {
int data[6] = {2, 5, 7, 9, 1, 4};
int target = 7;
int index = linear_search(data, 6, target);
if (index != -1) {
cout << "目标值" << target << "在索引" << index << "处" << endl; // 输出：索引 2
} else {
cout << "未找到目标值" << endl;
}
return 0;
}
// 单行注释，/* */ 多行注释）。student_name、total_score），避免 a、b 等无意义名称。a = b + c; 而非 a=b+c;），逗号后加空格（如 func(a, b);）。K&R 风格（左大括号不换行，右大括号单独换行）。良好示例：
// 计算两个数的最大公约数（欧几里得算法）
int gcd(int a, int b) {
while (b != 0) {
int temp = a % b;
a = b;
b = temp;
}
return a;
}
;、括号不匹配、未声明的变量），编译器会提示具体位置。
cout << "hello"（缺少 endl 或，但不报错，只是输出不换行）。cout << "i=" << i << endl;）。if 是关键字，main 是函数名，printf 是 C 语言函数，include 是预处理指令）。执行以下代码，输出结果是？（ ）
int x = 5;
cout << x++ << ++x << endl;
A. 56 B. 57 C. 67 D. 66
答案：B（x++ 输出 5，x 变为 6；++x 输出 7，x 变为 7）。
3 > 5 && 8 < 4 的结果是______（填 true 或 false）。
答案：false（两个条件都不成立）。pi 并初始化为 3.14159 的语句是______。
答案：double pi = 3.14159;。编写程序，输入 10 个学生的数学成绩，计算平均分并输出最高分和最低分。 参考代码：
#include <iostream>
using namespace std;
int main() {
int scores[10];
int sum = 0, max_score = -1, min_score = 101;
cout << "请输入 10 个数学成绩（0~100）：" << endl;
for (int i = 0; i < 10; i++) {
cin >> scores[i];
sum += scores[i];
if (scores[i] > max_score) {
max_score = scores[i];
}
if (scores[i] < min_score) {
min_score = scores[i];
}
}
double average = sum / 10.0;
cout << "平均分：" << average << endl;
cout << "最高分：" << max_score << endl;
cout << "最低分：" << min_score << endl;
return 0;
}
编写程序，输入一个整数 n（1≤n≤100），输出其所有因数（如 n=6，输出 1 2 3 6）。
参考代码：
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << "n 的因数有：";
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
cout << i << " ";
}
}
cout << endl;
return 0;
}
GESP 一级是编程学习的起点，重点在于掌握基础语法、逻辑思维和算法思想。本文覆盖了所有核心知识点，建议结合示例代码动手练习，多做模拟试题巩固。遇到问题时，善用调试工具和搜索引擎，逐步提升编程能力！
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online