一、进制转换（必考考点）

1. 基本概念

进制 特点 前缀 示例
十进制 0-9数字组成 无 123
二进制 0/1组成 0b 0b1010
八进制 0-7数字组成 0 014
十六进制 0-9,A-F组成 0x 0xA3
操纵符 (Manipulator) 作用 头文件
std::dec 设置后续整数的输入 / 输出为十进制 (默认) <iostream>
std::hex 设置后续整数的输入 / 输出为十六进制 <iostream>
std::oct 设置后续整数的输入 / 输出为八进制 <iostream>
std::setbase(n) 设置后续整数的输入 / 输出为 n 进制 (n 只能是 8, 10, 16) <iomanip>
std::showbase 在输出时显示进制前缀 (例如 0x for hex, 0 for oct) <iostream>
std::uppercase 在十六进制输出时使用大写字母 (A-F) <iostream>
std::nouppercase 在十六进制输出时使用小写字母 (a-f) (默认) <iostream>

2. 位运算

运算符

功能

示例

&（与）

全1则1

5(101)&6(110)=4(100)

|（或）

有1则1

5(101)|6(110)=7(111)

^（异或）

不同则1

5(101)^6(110)=3(011)

~（非）

取反

~5(00000101)=11111010(-6补码)

<<（左移）

左移n位=×2ⁿ

8<<2=32(1000→100000)

>>（右移）

右移n位=÷2ⁿ

9>>1=4(1001→100)

（1）运算符优先级（从高到低）

~（取反）→ <</>>（移位）→ &（与）→ ^（异或）→ |（或）

  • 判断奇偶：n&1 == 1为奇数
  • 交换两数：a=a^b; b=a^b; a=a^b（无需临时变量）
  • （左移和右移）只有在 无符号整数 或 有符号整数且左移不会导致溢出 的情况下，(a<<2>>2) 才等于 a。对于可能导致溢出的有符号整数，结果可能会改变。无符号整数是 (unsigned int) 有符号整数 左移可能会溢出 比如： 
    int a = 1073741824;
a 的二进制：01000000 00000000 00000000 00000000
a << 2：00000000 00000000 00000000 00000000 (左移后符号位变化，高位丢失)

在真题24年9月的判断题中 考的就是前缀

0b1010是二进制数,&运算没有影响

01100以0开头，是八进制数转换为十进制的方法是 “按位加权求和”：

从右到左，每一位的权重是8^位索引（索引从 0 开始）：01100 = 1×8⁴ + 1×8³ + 0×8² + 0×8¹ + 0×8⁰ = 4096 + 512 + 0 + 0 + 0 = 4608

即 b = 4608。

b = 4608 的二进制：00000000 00000000 00010010 00000000  我这里是用32位为例（int是4个字节，一个字节等于8位）通过下面的计算得出的结果是 0 所以 答案是错误。 

a: 00000000 00000000 00000000 00001010
b: 00000000 00000000 00010010 00000000
&: 00000000 00000000 00000000 00000000

现在做一点真题（判断题）

1.

2.

3.

4.

5.

选择题

答案： X  X   √  √  X  

            B  A  B  C  B

二、 转换方法总结

（1）R进制转十进制

        R进制→十进制：按权展开求和（如二进制101=1×2²+0×2¹+1×2⁰=5）

整数部分案例

1. 二进制 (R=2)
二进制数 按权展开计算过程 十进制结果
1011 1×2³ + 0×2² + 1×2¹ + 1×2⁰ = 8 + 0 + 2 + 1 11
11001 1×2⁴ + 1×2³ + 0×2² + 0×2¹ + 1×2⁰ = 16 + 8 + 0 + 0 + 1 25
2. 八进制 (R=8)
八进制数 按权展开计算过程 十进制结果
24 2×8¹ + 4×8⁰ = 16 + 4 20
173 1×8² + 7×8¹ + 3×8⁰ = 64 + 56 + 3 123
3. 十六进制 (R=16)
十六进制数 按权展开计算过程 十进制结果
B7 11×16¹ + 7×16⁰ = 176 + 7 183
2A.F (整数部分)2×16¹ + 10×16⁰ = 32 + 10 42

小数部分案例

1. 二进制小数 (R=2)
二进制小数 按权展开计算过程 十进制结果
0.101 1×2⁻¹ + 0×2⁻² + 1×2⁻³ = 1/2 + 0 + 1/8 = 0.5 + 0 + 0.125 0.625
0.1101 1×2⁻¹ + 1×2⁻² + 0×2⁻³ + 1×2⁻⁴ = 1/2 + 1/4 + 0 + 1/16 = 0.5 + 0.25 + 0.0625 0.8125
2. 八进制小数 (R=8)
八进制小数 按权展开计算过程 十进制结果
0.5 5×8⁻¹ = 5/8 0.625
0.12 1×8⁻¹ + 2×8⁻² = 1/8 + 2/64 = 0.125 + 0.03125 0.15625
3. 十六进制小数 (R=16)
十六进制小数 按权展开计算过程 十进制结果
0.A 10×16⁻¹ = 10/16 0.625
0.3C 3×16⁻¹ + 12×16⁻² = 3/16 + 12/256 = 0.1875 + 0.046875 0.234375

混合数（整数 + 小数）案例

这是最常见的情况，我们只需将 整数部分 和 小数部分 的计算结果 相加 即可。

1. 二进制混合数 101.101 (R=2)
  • 整数部分 101：1×2² + 0×2¹ + 1×2⁰ = 4 + 0 + 1 = 5
  • 小数部分 0.101：1×2⁻¹ + 0×2⁻² + 1×2⁻³ = 0.5 + 0 + 0.125 = 0.625
  • 合并结果：5 + 0.625 = 5.625
  • 结论：(101.101)₂ = (5.625)₁₀
2. 八进制混合数 23.4 (R=8)
  • 整数部分 23：2×8¹ + 3×8⁰ = 16 + 3 = 19
  • 小数部分 0.4：4×8⁻¹ = 4/8 = 0.5
  • 合并结果：19 + 0.5 = 19.5
  • 结论：(23.4)₈ = (19.5)₁₀
3. 十六进制混合数 1A.8 (R=16)
  • 整数部分 1A：1×16¹ + 10×16⁰ = 16 + 10 = 26
  • 小数部分 0.8：8×16⁻¹ = 8/16 = 0.5
  • 合并结果：26 + 0.5 = 26.5
  • 结论：(1A.8)₁₆ = (26.5)₁₀
4. 特殊进制混合数 12.3 (R=5)
  • 整数部分 12：1×5¹ + 2×5⁰ = 5 + 2 = 7
  • 小数部分 0.3：3×5⁻¹ = 3/5 = 0.6
  • 合并结果：7 + 0.6 = 7.6
  • 结论：(12.3)₅ = (7.6)₁₀

（2）十进制转R进制

        十进制→R进制：除R取余，倒序输出

整数部分：除R取余，逆序排列

整数部分（除 R 取余法）

1. 十进制 → 二进制

  • 29 → 二进制

  • 29 ÷ 2 = 14 余 1

  • 14 ÷ 2 = 7 余 0

  • 7 ÷ 2 = 3 余 1

  • 3 ÷ 2 = 1 余 1

  • 1 ÷ 2 = 0 余 1

  • 倒序余数：11101 → (29)₁₀ = (11101)₂

  • 45 → 二进制45 ÷ 2 = 22 余 1

  • 22 ÷ 2 = 11 余 0

  • 11 ÷ 2 = 5 余 1

  • 5 ÷ 2 = 2 余 1

  • 2 ÷ 2 = 1 余 0

  • 1 ÷ 2 = 0 余 1

  • 倒序余数：101101 → (45)₁₀ = (101101)₂

2. 十进制 → 八进制

  • 100 → 八进制

  • 100 ÷ 8 = 12 余 4

  • 12 ÷ 8 = 1 余 4

  • 1 ÷ 8 = 0 余 1

  • 倒序余数：144 → (100)₁₀ = (144)₈

  • 127 → 八进制

  • 127 ÷ 8 = 15 余 7

  • 15 ÷ 8 = 1 余 7

  • 1 ÷ 8 = 0 余 1

  • 倒序余数：177 → (127)₁₀ = (177)₈

3. 十进制 → 十六进制

  • 255 → 十六进制

  • 255 ÷ 16 = 15 余 15(F)

  • 15 ÷ 16 = 0 余 15(F)

  • 倒序余数：FF → (255)₁₀ = (FF)₁₆

  • 300 → 十六进制

  • 300 ÷ 16 = 18 余 12-----用（c） 表示

  • 18 ÷ 16 = 1 余 2

  • 1 ÷ 16 = 0 余 1

  • 倒序余数：12C → (300)₁₀ = (12C)₁₆

4. 十进制 → 三进制

  • 40 → 三进制
  • 40 ÷ 3 = 13 余 1
  • 13 ÷ 3 = 4 余 1
  • 4 ÷ 3 = 1 余 1
  • 1 ÷ 3 = 0 余 1
  • 倒序余数：1111 → (40)₁₀ = (1111)₃

小数部分（乘 R 取整法）

1. 十进制小数 → 二进制

  • 0.625 → 二进制

  • 0.625 × 2 = 1.25 取整 1，余 0.25

  • 0.25 × 2 = 0.5 取整 0，余 0.5

  • 0.5 × 2 = 1.0 取整 1，余 0.0

  • 顺序取整：101 → (0.625)₁₀ = (0.101)₂

  • 0.8125 → 二进制0.8125 × 2 = 1.625 取整 1，余 0.625

  • 0.625 × 2 = 1.25 取整 1，余 0.25

  • 0.25 × 2 = 0.5 取整 0，余 0.5

  • 0.5 × 2 = 1.0 取整 1，余 0.0

  • 顺序取整：1101 → (0.8125)₁₀ = (0.1101)₂

2. 十进制小数 → 八进制

  • 0.125 → 八进制
  • 0.125 × 8 = 1.0 取整 1，余 0.0
  • 顺序取整：1 → (0.125)₁₀ = (0.1)₈

3. 十进制小数 → 十六进制

  • 0.0625 → 十六进制
  • 0.0625 × 16 = 1.0 取整 1，余 0.0
  • 顺序取整：1 → (0.0625)₁₀ = (0.1)₁₆

整数 + 小数混合

  • (10.625)₁₀ → 二进制

  • 整数 10 → (1010)₂

  • 小数 0.625 → (0.101)₂

  • 合并 → (1010.101)₂

  • (25.25)₁₀ → 十六进制

  • 整数 25 → (19)₁₆

  • 小数 0.25 × 16 = 4.0 取整 4 → (0.4)₁₆

  • 合并 → (19.4)₁₆

（3）二进制与十六进制八进制互转

转换方向 口诀 核心操作
二进制 → 十六进制 四合一 从右往左，每 4 位一组，不足补 0，再查表转换。
十六进制 → 二进制 一分四 每位十六进制数，都转换为 4 位二进制数，然后合并。
二进制 → 八进制 三合一 从右往左，每 3 位一组，不足补 0，再查表转换。
八进制 → 二进制 一分三 每位八进制数，都转换为 3 位二进制数，然后合并。

二进制 ↔ 十六进制

二进制 → 十六进制：4 位一组，不足补 0

二进制输入 分组 (从右到左) 十六进制输出
10100100 1010 0100 0xA4
1111 1111 0xF
11011 0001 1011 0x1B
101101101 0101 1011 0101 0x5B5
111000111 0001 1100 0111 0x1C7
100110101011 1001 1010 1011 0x9AB

十六进制 → 二进制：1 位拆 4 位

十六进制输入 拆分与转换 二进制输出
0x3F 3→0011, F→1111 00111111
0xA A→1010 1010
0x12 1→0001, 2→0010 00010010
0xB4 B→1011, 4→0100 10110100
0x7D0 7→0111, D→1101, 0→0000 011111010000
0xFF F→1111, F→1111 11111111

二进制 ↔ 八进制

二进制 → 八进制：3 位一组，不足补 0

二进制输入 分组 (从右到左) 八进制输出
10100100 10 100 100 0o244
111 111 0o7
11011 1 101 1 0o151
101101101 101 101 101 0o555
111000111 111 000 111 0o707
100110101011 10 011 010 101 1 0o23251

八进制 → 二进制：1 位拆 3 位

八进制输入 拆分与转换 二进制输出
0o37 3→011, 7→111 011111
0o5 5→101 101
0o12 1→001, 2→010 001010
0o74 7→111, 4→100 111100
0o650 6→110, 5→101, 0→000 110101000
0o10 1→001, 0→000 001000

练习题：

  1. 11110000 (二进制) = ? (十六进制)
  2. D7 (十六进制) = ? (二进制)
  3. 1010101 (二进制) = ? (八进制)
  4. 146 (八进制) = ? (二进制)

参考答案：

  1. F0
  2. 11010111
  3. 125
  4. 001100110 (或 1100110)

真题练习 

答案  C  D  C  A  D 

          A   A   A

二、数据表示（核心难点）

1. 原码、反码、补码

类型 正数规则 负数规则（以8位为例）
原码 符号位0+数值位 符号位1+数值位（如 -1 → 10000001）
反码 与原码相同 符号位不变，数值位取反（如 -1 → 11111110）
补码 与原码相同 反码+1（如 -1 → 11111111）
一、 核心概念

  1. 真值

    • 我们眼中的数：带正负号的实际数值。

    • 例子：+14, -21, +7

  2. 机器码

    • 计算机眼中的数：在内存中存储的纯二进制序列。

    • 例子：00001110, 11101011

二、 三种重要的编码方式

规则：计算机内部一律使用补码进行存储和运算！

编码名称 如何表示一个数 优点 缺点
原码 符号位 + 数值位
- 符号位：0为正，1为负
- 数值位：绝对值的二进制		 非常直观，容易理解 1. 有+0和-0两个零
2. 加减法规则复杂，硬件实现麻烦
反码 正数：和原码一样
负数：原码的符号位不变，数值位全部取反		 可以将减法转化为加法 1. 仍有+0和-0两个零
2. 加法时可能需要处理“循环进位”
补码 正数：和原码一样
负数：反码 + 1		 1. 只有一个零
2. 加减法规则统一，硬件设计简单
3. 表示范围比原码和反码大		 -
三、 快速转换技巧（重点！）

已知一个数，求它的补码：

  • 正数：直接转换成二进制，前面补0到指定位数即可。

    • 例：+14 -> 00001110

  • 负数：口诀：绝对值取反加一

    1. 先写出其绝对值的二进制原码。 (14 -> 00001110)

    2. 将所有位按位取反（0变1，1变0）。 (00001110 -> 11110001)

    3. 将取反后的结果加1。 (11110001 + 1 = 11110010)

    • 例：-14的补码是 11110010

已知一个补码，求它的真值：

  • 看最高位（符号位）：

    • 如果是0：是正数。直接转换成十进制。

    • 如果是1：是负数。口诀：减一取反

      1. 将补码减1。 (11110010 - 1 = 11110001)

      2. 将结果所有位取反（符号位也取反）。 (11110001 -> 00001110)

      3. 转换成十进制，加上负号。 (00001110 -> 14 -> -14)

四、 实战案例：14 + (-21) = ?

计算机内部是这样做的：

  1. 将真值转为补码

    • 14 是正数，补码为：00001110

    • -21 是负数：

      • 21的原码：00010101

      • 按位取反：11101010

      • 加1：11101011

  2. 补码相加

      00001110  (14的补码)
+ 11101011  (-21的补码)
------------
  11111001  (计算结果的补码)

  3. 将结果补码转换回真值

    • 结果 11111001 最高位是1，所以是负数。

    • 减一：11111001 - 1 = 11111000

    • 取反：11111000 -> 00000111 (即 7)

    • 所以真值是 -7。

结论：14 + (-21) = -7。计算正确！

真题训练

判断题

1.

2.

3.

答案： B  A  C  B   D  B  B

           √   √  √  √  √   √

三、字符串操作（代码题重点）

1. 常用函数（#include <string>）

函数 功能 示例
size()/length() 返回长度 str.size()
substr(pos, len) 截取子串 str.substr(2,3)（从下标2取3个字符）
find(str) 查找子串位置 str.find("abc")（返回首位置或npos）
replace(pos, len, newstr) 替换子串 str.replace(2,3,"xyz")
sort(s.begin(), s.end()) 排序（需#include <algorithm>） sort(str.begin(), str.end())
功能  C++ std::string 方法 C 语言风格函数 (用于 char[]) 备注 (Notes)
定义 string s; char s[100]; C++ string 更安全、更灵活
求长度

s.length() 

 s.size()

 strlen(s) strlen 不计算\0，sizeof计算数组总大小
输入

cin >> s;

带空格的输入

getline(cin, s);

cin >> s; 

cin.getline(s,n); 

scanf("%s", s);

 getline 可以读取空格
拼接 s1 + s2 / s1.append(s2) strcat(s1, s2) C++ 的+更直观安全
比较 s1 == s2 / s1 < s2 等 strcmp(s1, s2) C++ 的比较符更直观
查找 s.find(sub) strstr(s, sub) / strchr(s, ch) 返回值类型不同，C++ 返回size_t
截取 s.substr(pos, len) strncpy(dest, s+pos, len) C++ 更直接
替换 s.replace(pos, len, sub) 手动实现或使用strncpy组合 C++ 功能强大
插入 s.insert(pos, sub) 手动实现，较为复杂 C++ 功能强大
删除

s.erase(pos,len) 

或 s.erase(it)

 手动实现，较为复杂 C++ 功能强大 
#include <bits/stdc++.h> // 包含所有标准头文件，方便演示
using namespace std;

int main() {
    // --- 1. 字符串定义与初始化 ---
    // <string>
    string str1; // 定义一个空字符串
    string str2 = "Hello World"; // 用字符串字面量初始化
    string str3(str2); // 用另一个字符串初始化
    char c_str1[100]; // C风格字符数组

    cout << "--- 1. 定义与初始化 ---" << endl;
    cout << "str2: " << str2 << endl;
    cout << "str3: " << str3 << endl;
    cout << endl;


    // --- 2. 求长度 ---
    // <string> for string::length() / size()
    // <cstring> for strlen()
    cout << "--- 2. 求长度 ---" << endl;
    cout << "str2 的长度 (length): " << str2.length() << endl;
    cout << "str2 的长度 (size): " << str2.size() << endl;

    char c_str2[] = "C-style string";
    cout << "c_str2 的长度 (strlen): " << strlen(c_str2) << endl;
    cout << endl;


    // --- 3. 输入字符串 ---
    // <iostream> for cin, getline
    // <cstdio> for scanf
    cout << "--- 3. 输入字符串 (请依次输入: 'Test Input', 'Hello', 'World') ---" << endl;
    
    string input_line;
    cout << "使用 getline(cin, str) 读取一行 (含空格): ";
    getline(cin, input_line); // 读取一整行，包括空格

    string input_word;
    cout << "使用 cin >> str 读取一个单词 (遇空格结束): ";
    cin >> input_word;

    char c_input[50];
    cout << "使用 scanf(\"%s\", ...) 读取一个单词到字符数组: ";
    scanf("%s", c_input); // 注意：scanf不需要&，因为数组名本身就是地址

    cout << "\n输入结果: " << endl;
    cout << "getline 读取: \"" << input_line << "\"" << endl;
    cout << "cin >> 读取: \"" << input_word << "\"" << endl;
    cout << "scanf 读取: \"" << c_input << "\"" << endl;
    cout << endl;


    // --- 4. 分割截取 substr() ---
    // <string>
    cout << "--- 4. 分割截取 substr() ---" << endl;
    string original = "Programming in C++";
    string sub1 = original.substr(11); // 从下标11开始，截取到末尾
    string sub2 = original.substr(0, 11); // 从下标0开始，截取长度为11的子串

    cout << "原始字符串: " << original << endl;
    cout << "substr(11): " << sub1 << endl; // 输出 "in C++"
    cout << "substr(0, 11): " << sub2 << endl; // 输出 "Programming"
    cout << endl;


    // --- 5. 查找指定子字符串 find() ---
    // <string>
    cout << "--- 5. 查找 find() ---" << endl;
    string text = "Hello, welcome to the world of C++.";
    size_t pos = text.find("world"); // 查找第一次出现的位置

    if (pos != string::npos) { // 检查是否找到 (npos代表"not found")
        cout << "在 \"" << text << "\" 中找到了 \"world\"，位置在: " << pos << endl;
    } else {
        cout << "未找到子字符串" << endl;
    }

    size_t pos_not_found = text.find("Java");
    if (pos_not_found == string::npos) {
        cout << "在 \"" << text << "\" 中未找到 \"Java\"" << endl;
    }
    cout << endl;


    // --- 6. 替换字符串 replace() ---
    // <string>
    cout << "--- 6. 替换 replace() ---" << endl;
    string greeting = "Hello World";
    cout << "替换前: " << greeting << endl;
    greeting.replace(6, 5, "Universe"); // 从下标6开始，替换长度为5的字符为"Universe"
    cout << "替换后: " << greeting << endl; // 输出 "Hello Universe"
    cout << endl;


    // --- 7. 插入字符串 insert() ---
    // <string>
    cout << "--- 7. 插入 insert() ---" << endl;
    string sentence = "I love C++";
    cout << "插入前: " << sentence << endl;
    sentence.insert(2, "really "); // 在下标2处插入 "really "
    cout << "插入后: " << sentence << endl; // 输出 "I really love C++"
    cout << endl;


    // --- 8. 复制字符串 ---
    // <string>
    cout << "--- 8. 复制字符串 ---" << endl;
    string source = "Copy me";
    string dest1(source); // 方法1: 通过构造函数
    string dest2;
    dest2 = source; // 方法2: 通过赋值运算符

    cout << "源字符串: " << source << endl;
    cout << "复制到 dest1: " << dest1 << endl;
    cout << "复制到 dest2: " << dest2 << endl;
    cout << endl;


    // --- 9. 排序 sort() ---
    // <algorithm>
    cout << "--- 9. 排序 sort() ---" << endl;
    string unsorted = "12sklhfsabfskfb,a aghs 1425416 27638";
    cout << "排序前: " << unsorted << endl;
    sort(unsorted.begin(), unsorted.end()); // 对字符串内的字符进行排序
    cout << "排序后: " << unsorted << endl;
    cout << endl;


    // --- 10. 删除 erase() ---
    // <string>
    cout << "--- 10. 删除 erase() ---" << endl;
    string numbers = "12345678";
    cout << "删除前: " << numbers << endl;
    numbers.erase(numbers.begin() + 3); // 删除下标为3的字符 ('4')
    cout << "删除后: " << numbers << endl; // 输出 "1235678"
    cout << endl;


    // --- 11. 添加字符 push_back() ---
    // <string>
    cout << "--- 11. 添加字符 push_back() ---" << endl;
    string message = "Hi";
    cout << "添加前: " << message << endl;
    message.push_back('!'); // 在字符串末尾添加一个字符 '!'
    cout << "添加后: " << message << endl; // 输出 "Hi!"
    cout << endl;


    // --- 12. 大小写转换 tolower() / toupper() ---
    // <cctype>
    cout << "--- 12. 大小写转换 ---" << endl;
    string mixed_case = "Hello World!";
    cout << "原始字符串: " << mixed_case << endl;

    // 转换为小写
    for (char &c : mixed_case) { // 使用范围for循环更简洁
        c = tolower(c);
    }
    cout << "转换为小写: " << mixed_case << endl;

    // 转换为大写
    for (char &c : mixed_case) {
        c = toupper(c);
    }
    cout << "转换为大写: " << mixed_case << endl;
    cout << endl;


    // --- C语言风格字符串函数在C++中的使用 ---
    // <cstring>
    cout << "--- C语言风格字符串函数 ---" << endl;
    string cpp_str = "This is a C++ string";
    
    // 必须先将 std::string 转换为 C风格字符串 const char*
    const char* c_str_from_cpp = cpp_str.c_str();
    cout << "从C++ string转换来的C风格字符串: " << c_str_from_cpp << endl;

    char c_dest[100];
    char c_src[] = "Hello from C";

    // (1) 复制 strcpy()
    strcpy(c_dest, c_src);
    cout << "strcpy(c_dest, c_src) 结果: " << c_dest << endl;

    // (2) 连接 strcat()
    strcat(c_dest, " and C++");
    cout << "strcat(c_dest, ...) 结果: " << c_dest << endl;

    // (3) 比较 strcmp()
    char cmp1[] = "apple";
    char cmp2[] = "apples";
    int cmp_result = strcmp(cmp1, cmp2);
    cout << "strcmp(\"apple\", \"apples\") 返回: " << cmp_result << " (负数，因为 \"apple\" < \"apples\")" << endl;

    // (4) 查找字符 strchr()
    char search_str[] = "hello world";
    char* found_char_ptr = strchr(search_str, 'w');
    if (found_char_ptr != nullptr) {
        cout << "在 \"" << search_str << "\" 中找到了 'w'，从它开始的字符串是: " << found_char_ptr << endl;
    }
    
    return 0;
}

易错点：cin >> str 遇空格终止，读整行需用 getline(cin, str)

真题训练

答案： D  C  C  B  D

四、易错点与解题技巧

  1. 进制转换陷阱：八进制以0开头（如 012 是10十进制），十六进制字母大小写不敏感。
  2. 补码溢出：8位补码范围 -128~127，超出需用16位表示。
  3. 位运算优先级：异或运算优先级低于与/或，建议加括号（如 (a & b) ^ c）。
  4. 字符串下标：从0开始，越界访问会导致运行时错误。

五、编程题真题入口

CCF GESP C++ 三级上机题 - 题单 - 洛谷 | 计算机科学教育新生态

复习建议：编程题还是有难度还是要多练习，基本是和字符串知识点有联系，字符串薄弱的可以多去洛谷上练习一点字符串的题目。

考前冲刺 ！！加油！！  祝取得好成绩！！

# c++
Logo
AI硬件创业社区

智能硬件社区聚焦AI智能硬件技术生态，汇聚嵌入式AI、物联网硬件开发者，打造交流分享平台，同步全国赛事资讯、开展 OPC 核心人才招募，助力技术落地与开发者成长。

更多推荐

cover

Matter认证实战：多厂商设备互操作中，你的测试报告与DoC为何总对不上？

avatar AI硬件创业社区
cover

千兆以太网PHY链路不稳：为什么你的硬件团队总在甩锅协议栈？

avatar AI硬件创业社区
cover

ESP32-C6语音设备选型陷阱：WiFi6吞吐红利 vs 实时语音链路的残酷现实

avatar AI硬件创业社区