《现代 C++ 零基础到工程实战》课堂笔记

第一章 大部分人被打倒在这里-C++环境和程序分析

1
目录：
2
(1) 为什么要学习现代C++课程介绍
3
(2) 1第一章说明和真实开发环境的安装和使用
4
(3) 2理解第一个简单又重要的cpp程序
5
(4) 3Cpp程序生成过程中每种文件的作用
6
(5) 4代码到程序生成过程
7
(6) 5注释和cout详解
8
(7) 第一章的总结和作业

0. 准备与目录

• 在资源管理器里显示文件扩展名（避免把 .h/.cpp/.obj/.exe/.pdb 混淆）。

• 建议示例目录：

xxxxxxxxxx
7
1
ProjectDemo/
2
 ├─ include/
3
 │   └─ add.h
4
 ├─ src/
5
 │   ├─ add.cpp
6
 │   └─ main.cpp
7
 └─ build/     （编译产物放这里，便于清理）

1. 常见文件与含义

• 源代码文件：.cpp（实现）、.h（声明/接口）

• 目标文件：.obj（MSVC）/ .o（GCC/Clang），每个 .cpp 独立编译生成一个

• 可执行文件：.exe（Windows）

• 调试符号：.pdb（MSVC），Linux/Clang 用可执行内的 -g 符号信息

• 项目/解决方案配置（VS 中常见）：.vcxproj（项目）、.sln（解决方案，支持多项目）

2. 编译流水线（必须理解的五步）

预处理 → 编译（C++ → 汇编）→ 汇编（→ 目标文件）→ 链接（→ 可执行/库）→ 执行

• 预处理：展开 #include、宏替换，删除注释，条件编译

• 编译：把预处理结果翻译成汇编

• 汇编：把汇编变成机器码，得到 .obj/.o

• 链接：把多个目标文件和库合并，解决符号引用，生成 .exe/.dll/.lib

• 执行：操作系统加载程序和依赖的 DLL，跳到入口点（main）

3. ⭐ 理解 #include 真相

xxxxxxxxxx
2
1
// main.cpp
2
include "add.h"   // 预处理阶段等价于把 add.h 的文本“复制粘贴”到这里

第二章 C++变量就是内存-它的一生是怎样的

(8) 第二章介绍

核心结论

• 变量 = 一段内存（有类型/大小/地址/值/作用域/生命周期）。

• 使用 C++ 11 新增的 列表初始化 {} 赋值更安全，带类型检查，可防止“窄化”（精度丢失）。

• 整数除法会丢小数；想要小数，至少让一个操作数是浮点。

• const（运行时常量） vs constexpr（编译期常量）要分清。

• auto 能推导类型，但会丢掉顶层 const；需要常量性要显式写出。

(9) cpp变量分析

来自源码的关键点

​x
1
int y;                  // 未初始化（值不确定，禁止读取！）
2
int x{100};             // 安全的定义变量方法，带类型检查
3
cout << "x=" << x << '\n'; // 链式输出
4

5
cout << "x 的地址 = " << &x << '\n'; // 直接输出指针
6
cout << "sizeof(x) = " << sizeof(x) << " 字节\n";
7

8
long long bigint{0};
9
cout << "sizeof(bigint) = " << sizeof(bigint) << " 字节\n";

输出（示例）（大小与地址因平台而异）

xxxxxxxxxx
4
1
x=100
2
x 的地址 = 0000009F9F5EF874
3
sizeof(x) = 4 字节
4
sizeof(bigint) = 8 字节

踩坑警告

• int y; cout<<y; → 未定义行为，不要读未初始化变量。

(10) 变量代码演示

🟦 1. 基本整数字面量

xxxxxxxxxx
4
1
cout << 123 << '\n';     // 十进制
2
cout << 0123 << '\n';    // 八进制（以 0 开头） → 83
3
cout << 0x123 << '\n';   // 十六进制（0x 开头） → 291
4
cout << 0b1010 << '\n';  // 二进制（0b 开头，C++14 起） → 10

输出（示例）：

xxxxxxxxxx
4
1
123
2
83
3
291
4
10

👉 注意：

• 0123 是 八进制！初学者常误以为是 123。

• 0b 二进制字面量从 C++14 才开始支持。

🟧 2. 整数字面量后缀（类型标识）

xxxxxxxxxx
5
1
cout << 123U << '\n';   // unsigned int
2
cout << 123L << '\n';   // long
3
cout << 123LL << '\n';  // long long
4
cout << 123UL << '\n';  // unsigned long
5
cout << 123ULL << '\n'; // unsigned long long

👉 后缀不区分大小写，但建议使用大写 U、L，更清晰。

🟨 3. 数字分隔符（C++14 起）

xxxxxxxxxx
1
1
cout << 1'000'000 << '\n'; // 1000000，单引号用于分隔，提高可读性

✅ 输出：

xxxxxxxxxx
1
1
1000000

👉 这是 数字分隔符，只是给人看的，不影响数值。

🟩 4. 浮点数字面量

xxxxxxxxxx
5
1
cout << 3.14 << '\n';     // double（默认）
2
cout << 3.14f << '\n';    // float（小写 f 或 F）
3
cout << 3.14L << '\n';    // long double（大写 L）
4
cout << 1.23e3 << '\n';   // 科学计数法：1.23 × 10³ → 1230
5
cout << 1.23e-2 << '\n';  // 1.23 × 10⁻² → 0.0123

输出：

xxxxxxxxxx
5
1
3.14
2
3.14
3
3.14
4
1230
5
0.0123

👉 e 或 E 表示 ×10 的幂，非常常见于科学计算。

🟦 5. 字符字面量（Character）

xxxxxxxxxx
4
1
cout << 'A' << '\n';         // A
2
cout << static_cast<int>('A') << '\n'; // 65（ASCII 码）
3
cout << '\n';               // 换行字符
4
cout << '\t' << "Tab" << '\n'; // 制表符 Tab（跳到下一个对齐列）

👉 字符字面量用 单引号 'A' 👉 它的底层其实是一个整数（ASCII 或 UTF-8 编码）

🟧 6. 字符串字面量（String）

xxxxxxxxxx
2
1
cout << "Hello" << '\n';       // 普通字符串（const char[6]）
2
cout << "Hello\nWorld" << '\n'; // 含转义字符

👉 字符串字面量用 双引号 "..." 👉 编译时会自动在末尾加上 \0（字符串结束符）

🟨 7. 布尔字面量（Boolean）

xxxxxxxxxx
6
1
cout << true << " " << false << '\n';  // 默认输出 1 0
2

3
cout << boolalpha;  // 打开布尔字面量输出
4
cout << true << " " << false << '\n';  // 输出 true false
5

6
cout << noboolalpha; // 关闭

输出：

xxxxxxxxxx
2
1
1 0
2
true false

👉 boolalpha 是一个 I/O 控制器（manipulator），切换布尔输出格式。

🟩 8. 空指针与 nullptr（C++11 起）

xxxxxxxxxx
2
1
int* p = nullptr; // 空指针，推荐
2
cout << "p = " << p << '\n';

输出：

xxxxxxxxxx
1
1
p = 0

👉 nullptr 是类型安全的空指针，不要再用老式 NULL（那是 0 的宏定义）。

📝 9. endl vs '\n'

xxxxxxxxxx
2
1
cout << "line\n";        // ✅ 换行，不强制刷新（高频输出更高效）
2
cout << "line" << endl;  // ✅ 换行+刷新缓冲区（频繁用会慢）

👉 endl 等价于 '\n' + 强制 flush。 在日志、交互式输出中有用，但在循环中频繁使用会降低性能。

⚡ 小结表

🧪 完整演示代码

xxxxxxxxxx
35
1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    // 整数
6
    cout << 123 << " " << 0123 << " " << 0x123 << " " << 0b1010 << '\n';
7

8
    // 后缀
9
    cout << 123U << " " << 123L << " " << 123LL << " " << 123ULL << '\n';
10

11
    // 数字分隔符
12
    cout << 1'000'000 << '\n';
13

14
    // 浮点数
15
    cout << 3.14 << " " << 3.14f << " " << 3.14L << '\n';
16
    cout << 1.23e3 << " " << 1.23e-2 << '\n';
17

18
    // 字符与字符串
19
    cout << 'A' << " " << static_cast<int>('A') << '\n';
20
    cout << "Hello\nWorld" << '\n';
21

22
    // 布尔
23
    cout << true << " " << false << '\n';
24
    cout << boolalpha << true << " " << false << '\n';
25

26
    // 空指针
27
    int* p = nullptr;
28
    cout << "p = " << p << '\n';
29

30
    // endl vs '\n'
31
    cout << "line\n";
32
    cout << "line" << endl;
33

34
    return 0;
35
}

(11) 变量的算术运算

基础运算＋自增自减

xxxxxxxxxx
6
1
int x{1+2};         // 3
2
int y{3};           
3
int z{ x*y + 10 };  // 3*3+10=19
4
z += 10; z -= 5; z *= 4; z /= 2; // 复合赋值
5
z++; --z;           // 后++/前--（单独一行时效果等同）
6
cout << "z = " << z << '\n';

输出（示例）

xxxxxxxxxx
1
1
z = 48

⭐ 易混淆对比｜前++ vs 后++

xxxxxxxxxx
3
1
int a=5;
2
int b = a++;   // b = 5, a = 6  （先用后加）
3
int c = ++a;   // a 先加到 7，再赋值；c = 7, a = 7

(12) cpp浮点数计算和转化

1. 整数除法会丢小数；想要小数，至少让一个操作数是浮点。

2. 浮点数转整数小数位被直接扔掉，不会四舍五入

xxxxxxxxxx
13
1
int u;
2
u = 1.1;     // -> 1  （小数直接丢弃：**不四舍五入**）
3
u = 1.9;     // -> 1
4
u = 2 / 3;   // -> 0  （整除）
5

6
int x1{1}, x2{2};
7
float f2{0};
8

9
f2 = x1 / x2;                 // 0，再转 float 得 0
10
f2 = x1 / (float)x2;          // 0.5（先提升参与运算）
11
f2 = (float)(x1 / x2);        // 0   （先整除，再整体转）
12
cout << "1/2 = "  << 1 / 2  << '\n';  // 0
13
cout << "1/2. = " << 1 / 2. << '\n';  // 0.5，    “2.” 字面量为 float

输出（示例）

xxxxxxxxxx
2
1
1/2 = 0
2
1/2. = 0.5

易混淆对比｜“什么时候是浮点除法？”

xxxxxxxxxx
4
1
double a = 1 / 2;                 // 0 -> 再转 double 得 0
2
double b = 1.0 / 2;               // 0.5
3
double c = static_cast<double>(1) / 2; // 0.5 ✅ 推荐写法（意图清晰）
4
double d = (double)(1 / 2);       // 0 ⚠️ 先整除，已来不及了

⭐ 额外提醒

xxxxxxxxxx
3
1
float f1{3.3};   // ⚠️ 列表初始化禁止“窄化”，可能编译失败
2
float f2 = 3.3;  // 允许（会从 double 转为 float，精度可能损失）
3
float f3{3.3f};  // ✅ 推荐：用 f 后缀给 float 字面量

(13) 变量的作用域和生命周期

来自源码的作用域演示

xxxxxxxxxx
11
1
int gx{0};     // 全局：静态存储期（进入 main 前创建，进程结束释放）
2

3
int main() {
4
  int px{1};   // 局部：块作用域（进入块时创建，离开块时销毁）
5
  {
6
    int py{2};
7
    int px{555};  // 遮蔽外层同名变量（若外层也叫 px）
8
    cout << "gx=" << gx << ", px=" << px << ", py=" << py << '\n';
9
  }
10
  // cout << py; // ❌ py 已出作用域，不能访问
11
}

输出（示例）

xxxxxxxxxx
1
1
gx=0, px=555, py=2

规则速记

• 作用域 = 一对 {}；离开就“看不到/不存在”了。

• 就近原则：内层同名会 遮蔽 外层同名变量。

• 工程实践：尽量缩小变量作用域；能在小块里就别放外面。

(14) cpp运行时和编译时常量

const / constexpr：

作用：让人知道这是常量，不要去改动 constexpr编译期常量：必须是常量表达式

xxxxxxxxxx
6
1
const int cx{100};        // 运行时常量：只读，但不要求编译期可得
2
int t1 = 10;
3
const int cx2{ t1 + 10 }; // ✅ 可以：仍是运行时常量
4

5
constexpr int cex{300};   // 编译期常量：必须是常量表达式
6
// constexpr int cex2{ t1 * 10 }; // ❌ 错：t1 不是常量表达式

能做什么？

• constexpr 可用于需要编译期常量的场景：数组长度、模板非类型参数、case 标签等。

• const 值不变，但可能直到运行时才确定（不能用在上面那些需要编译期常量的地方）。

(15) cpp的auto自动推导类型

来自源码的典型推导

xxxxxxxxxx
11
1
constexpr int cex{300};
2
auto a1 = 10;           // int
3
auto d1 = 9.;           // double
4
auto f1 = 8.f;          // float
5
auto acex = cex;        // int（变量 cex 的 const 被“剥落”，auto 推导常量是会变为普通变量）
6

7
constexpr auto c1 = cex; // constexpr int（保留编译期常量语义）
8
const auto c2 = a1;      // const int（保留只读）
9

10
auto a4 = 14LL;          // long long
11
auto a5 = (int)d1;       // int（先显式转，再推导）

输出（示例，类型注释）

xxxxxxxxxx
3
1
// a1: int, d1: double, f1: float
2
// acex: int（不是 const/constexpr！）
3
// c1: constexpr int, c2: const int

易混淆对比｜保留“常量性”

xxxxxxxxxx
3
1
auto v1 = cex;          // int          （❌ 常量性丢了）
2
const auto v2 = cex;    // const int    （✅ 只读）
3
constexpr auto v3 = cex;// constexpr int（✅ 编译期常量）

关于 auto + 花括号 {}

• auto 配合花括号可能触发 std::initializer_list 的推导规则（不同标准/编译器下体验不一致，容易困惑）。

• 新手建议：避免 auto x{...};，优先 auto x = ...; 或显式类型，以免出现意料之外的推导。

第三章 C++开始逻辑了-有了分歧怎么办

(17) 第三章介绍

这章在讲：

• 位运算（逐位非/与/或）与逻辑运算（! && ||）的区别

• 短路求值对表达式副作用的影响

• bool 与算术/位运算的互动（0/1、可参与 & | ~ 但不推荐）

• if / else if / else 的写法与常见坑（多余分号、= 与 == 混淆、条件顺序）

• std::string：初始化/赋值、长度/容量、截断、比较、数值转换、拼接、查找与替换

(18) 逻辑判断if语法分析

最小示例

xxxxxxxxxx
11
1
int x; 
2
cin >> x;             // 从标准输入读取
3
if (x > 100) {        // 分支1
4
    cout << "x > 100\n";
5
} else if (x > 200) { // 分支2（此写法有逻辑问题，见下）
6
    cout << "x > 200\n";
7
} else if (x < 50) {  // 分支3
8
    cout << "x < 50\n";
9
} else {              // 兜底
10
    cout << "else x = " << x << '\n';
11
}

示例运行

• 输入 30 → x < 50

• 输入 150 → x > 100

• 输入 205 → 仍然是 x > 100（为什么没有走 >200？ 见下）

易错点与修正

• 条件顺序：x > 100 放在最前，x > 200 永远到不了（因为 >200 也满足 >100）。 ✅ 推荐：从“更严格/更特殊”的条件开始：

  xxxxxxxxxx
  4
  1
  if (x > 200) { ... }
  2
  else if (x > 100) { ... }
  3
  else if (x < 50) { ... }
  4
  else { ... }
  

  补充 对于简短的语句，可用：if () ________; 例如：if (f1 | t1) cout << "(f1|t1)true\n";

(19) if代码演示和常见错误

源码片段（关键坑点）

xxxxxxxxxx
13
1
if (x == 101)
2
    cout << "x==101\n";
3
if (x != 102) cout << "[!=102]";
4
if (x == 103); {        // ⚠️ 多了一个分号！导致下面的大括号总会执行
5
    cout << "[103]";
6
}
7

8
if (x = 104)            // ⚠️ 把 == 写成了 =
9
    cout << "[104]";    // 条件恒为 true，且副作用把 x 赋值为 104
10

11
if (105 == x) {         // ✅ “常量在左”的写法可避免把 == 写成 = 的事故
12
    cout << "[105]";
13
}

示例运行（假设输入 101）

xxxxxxxxxx
3
1
x > 100
2
x==101
3
[!=102][103][104]

解释：

• [103] 总会打印（多余分号导致的“悬空 if”）

• [104] 总会打印，且把 x 改成了 104（= 赋值表达式的结果为 104，非 0 即真）

修正写法

xxxxxxxxxx
7
1
if (x == 103) {         // ❌ 去掉多余分号
2
    cout << "[103]";
3
}
4

5
if (x == 104) {         // ❌ 不要写成 =
6
    cout << "[104]";
7
}

(20) 算术运算逐位非与或（位运算）

xxxxxxxxxx
9
1
#include <bitset>
2
char a = 0b10000001;    // C++14 起支持 0b 前缀
3
char b = 0b00000001;
4
cout << "a:\t"  << bitset<8>(a)     << '\n';
5
cout << "~a:\t" << bitset<8>(~a)    << '\n';
6
cout << "b:\t"  << bitset<8>(b)     << '\n';
7
cout << "~b:\t" << bitset<8>(~b)    << '\n';
8
cout << "a&b:\t" << bitset<8>(a & b) << '\n';
9
cout << "a|b:\t" << bitset<8>(a | b) << '\n';

示例运行

xxxxxxxxxx
6
1
a:      10000001
2
~a:     01111110
3
b:      00000001
4
~b:     11111110
5
a&b:    00000001
6
a|b:    10000001

要点

• ~ 逐位取反；& 逐位与；| 逐位或。

• 用 bitset<8> 可直观看 8 位结果。

(21) bool类型的算数运算

重要知识点： 非 0 则真 值为 0 → 被视为 false（假） 值不为 0 → 被视为 true（真）

bool 与算术/位运算

xxxxxxxxxx
6
1
bool f1{false}, t1{true};
2
cout << "f1=" << f1 << ", t1=" << t1 << '\n';     // 输出 0 / 1
3

4
cout << (f1 | t1) << '\n';  // 1  （位或）
5
cout << (f1 & t1) << '\n';  // 0  （位与）
6
cout << (!t1) << '\n';      // 0  （逻辑非）

示例运行

xxxxxxxxxx
4
1
f1=0, t1=1
2
1
3
0
4
0

(22) cpp逻辑运算和数学运算处理逻辑区别（短路）

1) 逻辑运算符与短路

背景设定：

xxxxxxxxxx
2
1
bool f1 = false;
2
bool t1 = true;

代码片段：

xxxxxxxxxx
18
1
// 逻辑运算符（代用运算符）
2
// 逻辑非 !        not
3
// 逻辑或 ||       or
4
// 逻辑与 &&       and
5
// 逻辑运算符 短路求值：如果通过第一个操作数就能得到结果，就不再求值第二个
6
if (f1 or t1) {
7
    cout << "f1 or t1" << endl;
8
}
9
if (f1 and t1) {
10
} else {
11
    cout << "f1 and t1 else" << endl;
12
}
13
if (not f1) {
14
    cout << "not f1" << endl;
15
}
16
if (not (f1 and t1)) {
17
    cout << "not (f1 and t1)" << endl;
18
}

逐句解释：

• if (f1 or t1) 左侧 f1=false，无法确定为真，继续计算右侧 t1=true，结果为 true → 打印 f1 or t1。

• if (f1 and t1) ... else ... and 的左侧 f1=false 已经足以确定整个表达式为 false，短路，右侧 t1 不再计算 → 走 else，打印 f1 and t1 else。

• if (not f1) not false == true → 打印 not f1。

• if (not (f1 and t1)) 括号里 f1 and t1 因 f1=false 短路 为 false，not false == true → 打印 not (f1 and t1)。

结论：

• 逻辑或 || / or：左真右不算；左假要看右边。

• 逻辑与 && / and：左假右不算；左真才看右边。

• 逻辑非 ! / not：取反。 短路求值会跳过右侧表达式的求值与副作用。

2) ”逻辑或“ 和 ”逐位或“ 的差异：|| / or vs |

xxxxxxxxxx
13
1
// 验证短路求值
2
int x1{0};
3
x1 = 10;
4
if ((x1++) or (x1 += 2)) {
5
    cout << "(x1++) or (x1 += 2)" << endl;
6
}
7
cout << "x1 = " << x1 << endl;
8

9
x1 = 10;
10
if ((x1++) | (x1 += 2)) {
11
    cout << "(x1++) | (x1 += 2)" << endl;
12
}
13
cout << "x1 = " << x1 << endl;

2.1 逻辑或（有短路） || / or

• 初始：x1 = 10

• 计算 ((x1++) or (x1 += 2))

  • 先算左边 x1++：结果值为 10，然后 x1 自增为 11

  • 在逻辑环境中，10 被视为 true → 短路，右侧 (x1 += 2) 完全不执行

• 条件为真 → 打印 "(x1++) or (x1 += 2)"

• 输出 x1 = 11

这一段的关键点：因为短路，x1 += 2 没有发生，副作用被跳过。

2.2 逐位或（无短路） |

• 初始：x1 = 10

• 计算 ((x1++) | (x1 += 2))

  • 先算左边 x1++：结果为 10，自增后 x1 = 11

  • 不短路，继续算右边 (x1 += 2)：结果为 13，此时 x1 = 13

  • 做按位或：10 (1010b) | 13 (1101b) = 15 (1111b) → 非零，条件为真

• 打印 "(x1++) | (x1 += 2)"

• 输出 x1 = 13

关键点：逐位或 | 总会计算两侧表达式，副作用都会发生。

结论（本段）：

• ||/or 是逻辑或，有短路；

• | 是按位或，没有短路，两边一定都会求值； 在使用逻辑判断时，优先使用 逻辑或，效率更高

补充：比较运算符

(23) c++ string 功能分析（综述）

1) 基础对象

• 字符：char（如 'c'、'\n'）。

• 字符串字面量：const char*；多个 char 组成；以 '\0' 结尾。

• C++ 字符串：std::string；动态长度；值语义；易拷贝。

2) 本章 API 地图（与上面小节对应）

• 创建 / 赋值：构造、operator=。

• 长度 / 容量：size()、capacity()。

• 截断：substr(off[,count])。

• 判空 / 比较：empty()、==、!=。

• 查找 / 替换：find()、replace()、npos。

• 数字转换：stoi/stol/stoll/stof/stod/stold、to_string()。

• 拼接：+、+=。

3) 编码与实践

• GBK 与 UTF-8 的字节长度不同。

• size() 统计字节，不统计“字符数”。

• 课堂建议：中文不直接写在源码；统一编码；必要时外部文件读入。

4) 一句话复盘

• 取长：size()；截断：substr；

• 查找：find；替换：replace；

• 转数：sto*；转串：to_string；

• 判空：empty()；拼接：+ / +=。

(24) string 代码示例分析赋值

1) 头文件与基础

• 头文件：#include <string>

• 命名空间：using namespace std;

• 类型名：std::string

2) 初始化

xxxxxxxxxx
2
1
string a{"test string 1"};
2
cout << a << "\n";                // 输出：test string 1

xxxxxxxxxx
3
1
string b{a};                       // 拷贝构造
2
a = "test string 1-2";             // 修改 a 不影响 b
3
cout << b << "\n";                 // 输出：test string 1

xxxxxxxxxx
2
1
string c;                          // 默认构造，空串
2
cout << c.empty() << "\n";         // 输出：1

3) 赋值

xxxxxxxxxx
7
1
string d{"hello"};
2
d = "world";                       // 从字面量赋值
3
cout << d << "\n";                 // 输出：world
4

5
string e{"x"};
6
e = d;                             // 从 string 赋值
7
cout << e << "\n";                 // 输出：world

4) 小坑 & 提示

• string ≠ const char*。但可以用字面量给 string 赋值。

(25) string 字符串长度、截断和比较

1) 长度：size() / length() ；容量：capacity()

xxxxxxxxxx
10
1
string s{"123456789"};
2
cout << s.size() << "\n";          // 输出：9
3
cout << s.length() << "\n";        // 输出：9
4
cout << s.capacity() << "\n";      // ≥9（运行值：15）
5

6
/*
7
.capacity() 表示 string 底层当前分配的可用空间容量，即当前底层内存中可容纳的最大字符数（不含 '\0'）
8
通常大于等于 .size()，
9
目的是提升性能，避免频繁内存重新分配。
10
*/

• size() 完全等价于 length() ，两者不含结尾 \0。

2) 截断：substr(off[, count])

xxxxxxxxxx
3
1
string t{"123456789"};
2
cout << t.substr(3) << "\n";       // 从下标3：456789
3
cout << t.substr(1,3) << "\n";     // 从下标1（第2个字符）起取3个：234

• substr 返回新字符串，不改变原字符串

• off 从 0 开始，因为字符串的下标是从 0 开始。

3) 判空

xxxxxxxxxx
4
1
string x;  // 默认空串
2
if (x.empty())        cout << "empty\n";          // 推荐
3
if (x.size()==0)      cout << "size == 0\n";      // 也可以
4
if (x == "")          cout << "== \"\"\n";        // 也可以，输出：== ""

4) 比较

xxxxxxxxxx
6
1
string a{"test"};
2
cout << (a=="test")  << "\n";      // 1
3
cout << (a!="test1") << "\n";      // 1
4

5
string b{"if2"};
6
cout << (a==b) << "\n";            // 0，即 false

5) 中文与编码

• GBK：常见中文 2 字节。

• UTF-8：2~4 字节不等。

• size() 计的是字节数，不是“汉字个数”。

(26) string 数字转换与拼接

1) 字符串 → 整数（stoi）

xxxxxxxxxx
2
1
auto i = stoi("1234");
2
cout << i + 1 << "\n";               // 1235

xxxxxxxxxx
1
1
cout << stoll("-1231231231233") << "\n"; // 长整型

• 如果失败会抛异常：invalid_argument 或 out_of_range。

2) 字符串 → 浮点（stod）

xxxxxxxxxx
2
1
double d = stod("123.5");
2
cout << d << "\n";                 // 123.5

xxxxxxxxxx
3
1
float f1 = stof("33.1f");          // 在 'f' 处停止
2
float f2 = stof("33.2");
3
cout << f1 << " " << f2 << "\n";   // 33.1 33.2

这里 "33.1f" 是一个字符串，std::stof() 会从头开始尝试解析：

结果：

• 它成功解析出 "33.1" 部分；

• 'f' 之后的内容被忽略；

• 返回浮点数 33.1f。

所以，“在 'f' 处停止”的意思是：

std::stof() 在扫描字符串 "33.1f" 时， 读到 'f' 发现这不是合法数字字符， 因此停止继续解析，并返回目前得到的数值 33.1。

🟨 为什么不报错？

因为 std::stof() 只要求：

字符串开头部分能成功转成一个数值。

后面如果还有额外字符，只要前面那部分能转成数，函数就不会抛异常。

比如：

xxxxxxxxxx
2
1
cout << std::stof("123abc") << endl;  // 输出 123
2
cout << std::stof("3.14xyz") << endl; // 输出 3.14

只有以下情况才会抛异常：

• 字符串完全无法解析出数字（例如 "abc"）

• 或数字太大超出 float 范围（例如 "1e1000"）

3) 数字 → 字符串（to_string）

xxxxxxxxxx
3
1
auto p = to_string(3.1415926);
2
cout << p << "\n";                 // 3.141593（默认约6位）
3
cout << to_string(-19998) << "\n"; // -19998

需要格式控制：用 std::format(C++20) 或 ostringstream。

5) 拼接：+、+=（数值先 to_string）

xxxxxxxxxx
10
1
string user="xcj";
2
string txt="login success!";
3
int tid=1023;
4

5
string log = user + ":" + txt + ":" + to_string(tid);
6
log = "[debug]" + log;
7
log += ";";
8

9
cout << log << "\n";
10
// 输出：[debug]xcj:login success!:1023;

• 两侧至少一个是 string，否则 "a" + "b" 非法。

(27) string 的查找和替换

1) 查找：find

xxxxxxxxxx
4
1
string s = "test for find [user] test";
2

3
auto p1 = s.find("[test]");
4
if (p1==string::npos) cout << "[test] not find\n";  // 未找到

xxxxxxxxxx
3
1
string key = "[user]";
2
auto pos = s.find(key);
3
cout << pos << "\n";                 // 14（位置可能随实现）

2) 定位后查看：substr(pos)

xxxxxxxxxx
1
1
cout << s.substr(pos) << "\n";       // "[user] test"

3) 替换：replace(pos, len, new_str)

xxxxxxxxxx
11
1
auto bak = s;                        // 备份
2

3
auto ref = s.replace(
4
    pos,   // 1 被替换字符的起始位置
5
    key.size(), // 2 要被替换掉的内容长度
6
    "xcj"  // 3 要替换为的字符串
7
    );
8
    
9
// s 被原地修改
10
cout << bak << "\n";                 // test for find [user] test
11
cout << ref << "\n";                 // test for find xcj test

• replace 返回被修改后的字符串引用。

• 替换后位置会变化；再次查找要重新 find。

4) 小心中文

• len 是字节数；中文多字节时要谨慎。

• 需要“按字符替换”请先解码或用库。

补充：隐式转换 和 显式转换

🧩 一、什么是类型转换？

类型转换指的是： 把一个变量的值从一种类型“转换”为另一种类型，以便进行计算、比较或赋值。

在 C++ 中，这种转换分为两大类：

🪄 二、隐式类型转换（Implicit Conversion）

🔹 概念

编译器在需要时自动将一种类型转换为另一种类型，不需要你写任何额外代码。 也称为“自动类型提升（type promotion）”。

🔹 特点

• 自动发生，无需人工干预

• 不会改变原变量类型，只在表达式中临时转换

• 可能会丢失精度（例如 int → float → double）

🔹 常见规则

1. 整型提升：char、short 自动提升为 int

2. 算术转换：不同类型混合运算时，按精度高的转换

3. bool 自动转换：非零为 true，零为 false

🔹 示例

xxxxxxxxxx
9
1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    int i = 5;
6
    double d = 2.5;
7
    double result = i + d;  // int 自动转换为 double
8
    cout << result << endl; // 输出：7.5
9
}

📘说明： 这里的 i 是 int，但在运算中被自动转成 double。

🧠 三、显式类型转换（Explicit Conversion）

🔹 概念

由程序员手动指定类型转换，也叫“强制类型转换”。

🔹 使用场景

• 控制精度或避免自动转换引起的错误

• 明确告诉编译器“我就是要这么转！”

🔹 常见写法

1️⃣ C风格强制转换

xxxxxxxxxx
2
1
int a = 10;
2
double b = (double)a;  // C 风格

2️⃣ C++ 新式强制转换（推荐）

🔹 示例

xxxxxxxxxx
8
1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    double pi = 3.14159;
6
    int n = static_cast<int>(pi);  // 显式转换：去掉小数部分
7
    cout << n << endl;  // 输出：3
8
}

🧾 四、两者对比总结

🧩 五、小结口诀

💡 “编译器主动叫隐式，程序员亲自上阵叫显式。”

隐式靠编译器帮你“自动提升”， 显式靠你“手动指定类型”，更安全、更可控。

(28) 枚举enum类型和新特性分析

1) 为什么用枚举？

• 用名字替代“魔法数字”。

• 编译期常量，零开销。

• 典型：日志级别、消息类型。

2) 枚举声明会产生两类实体

• 一个类型：枚举类型名。

• 一组常量：枚举值1 ... 枚举值5（它们是 常量，不是 变量）。

这些常量在 “非作用域枚举” 里会直接出现在外层作用域。

3) 非作用域枚举（C++11 之前）

3.1 定义与自增规则（默认从 0 开始自增，若被新赋值从新值继续自增）

xxxxxxxxxx
7
1
enum 枚举类型名 {
2
  枚举值1,        // 默认 0，从 0 开始
3
  枚举值2,        // 1（每个加 1）
4
  枚举值3 = 100,  // 显式赋值为 100
5
  枚举值4,        // 101（从 100 继续 +1）
6
  枚举值5         // 102
7
};

输出示例

xxxxxxxxxx
2
1
cout << "枚举值1 = " << 枚举值1 << "\n"; // 0
2
cout << "枚举值4 = " << 枚举值4 << "\n"; // 101

3.2 变量类型该如何写

• 想存“枚举值”，变量类型应该是该枚举类型：

xxxxxxxxxx
1
1
枚举类型名 ev1{ 枚举值5 };          // ✅ 类型安全

• 也可以用 auto（类型被推导成 枚举类型名）：

xxxxxxxxxx
1
1
auto ev2 = 枚举值5;                  // ✅ 等价

• 存成 int 虽能编过，但不推荐：

xxxxxxxxxx
1
1
int ev3 = 枚举值5;                   // ⚠️ 变量变成 int，丢失“这是哪个枚举”的信息

3.3 enum 花括号里的名字不是普通变量，是枚举常量

• 这些名字在非作用域枚举里，会直接“注入”到外层作用域，可直接用：

  xxxxxxxxxx
  1
  1
  cout << 枚举值1 << "\n";   // ✅ 会隐式转成 int 打印，比如 0
  

• 但它们不是变量，不可以赋值、取地址：

  xxxxxxxxxx
  2
  1
  枚举值1 = 枚举值2;      // ❌ 错：不能给枚举常量重新赋值
  2
  // &枚举值1;            // ❌ 错：不是对象，不能取地址
  

• 由于是常量，它们还能用于 switch、数组大小等需要编译期常量的地方。

3.4 与整型的关系（允许隐式转换）

xxxxxxxxxx
11
1
enum Status { PLAY, PAUSE, STOP }; // 0,1,2
2

3
Status status{ STOP };             // 值 2
4
int var1 = status;                 // ✅ 隐式转 int
5
if (status == 2) {
6
  cout << "2 STOP\n";              // 预期：2 STOP
7
}
8
status = PLAY;
9
if (status == PLAY) {
10
  cout << PLAY << " PLAY\n";       // 预期：0 PLAY
11
}

• 枚举是整数，可以做大小比较。

4) 强作用域枚举 enum class（C++11 及之后）

4.1 定义与访问

xxxxxxxxxx
6
1
enum class LogLevel { DEBUG, INFO, ERROR, FATAL };
2

3
LogLevel level{ LogLevel::DEBUG };      // ✅ 必须加作用域
4
// cout << level;                        // ❌ 不能直接当整数打印
5
int s = static_cast<int>(level);         // ✅ 显式转换
6
cout << s << "\n";                       // 预期：0

• 无法直接当做整数使用，防止混淆。

• 访问值必须加类型，减少命名冲突：LogLevel::DEBUG。

4.2 比较与应用（日志门槛）

xxxxxxxxxx
4
1
LogLevel log_level = LogLevel::DEBUG;
2
if (level <= log_level) {
3
  cout << "记录日志\n";                  // 预期：记录日志
4
}

• 同一 enum class 之间可比较（按声明顺序）。

5) “能 / 不能”速查（把边界感再夯实）

xxxxxxxxxx
15
1
enum Status { PLAY, PAUSE, STOP };
2

3
// 变量类型用枚举类型（推荐）
4
Status s = STOP;                 // ✅
5
if (s == STOP) {}                // ✅
6

7
// 用 auto（也安全）
8
auto s2 = STOP;                  // ✅ 推导为 Status
9

10
// 直接存成 int（不推荐）
11
int v = STOP;                    // ⚠️ 易与普通 int 混用
12

13
// 把 int 赋给枚举（隐式不行；显式可以，但要自己保证范围）
14
Status s3 = 2;                   // ❌ 编译不过
15
Status s4 = static_cast<Status>(2); // ✅ 但请确保 2 合法

xxxxxxxxxx
6
1
enum class LogLevel { DEBUG, INFO, ERROR, FATAL };
2

3
LogLevel lv = LogLevel::ERROR;   // ✅
4
int i = lv;                      // ❌ 不能隐式转为 int
5
int j = static_cast<int>(lv);    // ✅ 显式转换
6
// LogLevel::DEBUG 这类名字不会“裸露”在外层作用域

(30) 入口函数 main 参数传递和环境变量获取

目标：看懂 int main(int argc, char* argv[], char* env[]) 三个“入口参数”的含义、用法、易错点；能在终端或 VS 里传参与读取；能遍历/查询环境变量；会把字符串参数转换成数值。

1. 三种常见的 main 形态（思维导图对应）

• int main() 不接收任何命令行参数。

• int main(int argc, char* argv[]) 最常用。argc 是参数个数（含程序名），argv 是字符串数组。

• int main(int argc, char* argv[], char* env[]) 多了 env（又写作 envp）：环境变量数组；最后一个元素是 nullptr（哨兵）。

小结（一句一条）： • argc 是数量； • argv[i] 是第 i 个 C 字符串； • env[i] 是第 i 条环境变量 "KEY=VALUE"，直到 nullptr 为止。

2. 代码骨架

xxxxxxxxxx
13
1
#include <iostream>
2
using namespace std;
3

4
int main(int argc, char* argv[], char* env[]) {
5
    cout << "argc = " << argc << endl;
6
    cout << "argv[0] = " << argv[0] << endl;      // 通常是可执行文件路径/名称
7

8
    if (argc > 1) cout << argv[1] << endl;
9
    if (argc > 2) cout << argv[2] << endl;
10
    if (argc > 3) cout << argv[3] << endl;
11

12
    cout << env[0] << endl; 
13
}

3. 如何“传参”（三种情景）

3.1 终端/控制台

• Linux / macOS：

  xxxxxxxxxx
  1
  1
  ./test_main DEBUG 16 3.14
  

• Windows（PowerShell/CMD）：

  xxxxxxxxxx
  1
  1
  .\test_main.exe DEBUG 16 3.14