tanteijms

大三下课程指北

Wed, 01 Jul 2026 00:00:00 GMT

大三下课程指北#

必修课#

计算机系统结构#

内容非常杂，又有计组，又有 csapp，还有交换原理的。总之需要多背，多做题，题型记录下来就没问题～

97 拿下，不枉我根本没睡觉。感觉就是期末背一背，注意题型！

现代交换原理#

真·现代交换原理，考新的东西太多了，IPv6+，SRv6，APN6，5G…古代交换的那部分反而很少，只有最基础的几个网络，CLOS Benes Banyans。实验比较简单，照着指导书做就行。由于周五放假冲掉了太多的课，我们班没考期中。有小测，老师直接不管手机电脑，爽抄。即便没期中，期末占比也被挤压到了 45%。总的来说虽然课件内容很夸张，但是照着提纲学没什么大问题。今年把 5G 细节的几个网考了，有点难绷，AFM UPF SFM，考注册以后连接的具体业务，这真的有人背了吗…

真被 5G 阴了，85，嘛就这样吧，我估计也有一次作业没交被扣分。

软件工程#

人称肖概（肖丁老师编著），确实像文科课，最重要的就是 UML 几个画图，过程能讲清楚。我们这届期中末都开卷了，徐鹏老师争取的，但其实概念题还是找不到（笑）。好在是复习压力小了很多。徐鹏老师人很好，讲课幽默风趣，会跟你开玩笑，然后讲很新的东西，组织了 2 次 vibe coding 的课，让他的研究生讲。但其实谁能有咱们自己懂 vibe coding 呢。大作业 1 次需求分析，1 次详细设计书，最后前后端验收最主要看测试，以及相应的功能。测试里面测试桩比较重要，前端无所谓，具体算法无所谓，重要的是搞懂软工开发的设计。基本用黑马的 springboot 框架秒了

专业选修#

编译课设#

题目一样，可以速成。今年验收拷打比较狠，我们当时被有一个问题问晕了，下来一想我们和老师说的不是一个事，之后给老师解释，最后就 90，没想象中的高

OS课设#

题目也一样吧，有点难速成。我基于 os30days 的做了一版，然后验收主要讲的这个，内容很杂很多，老师会看你基于官方的源码改了什么，你的做法是什么，怎么设计的，并且会现场听每一个人的工作量，验收讲 ppt 基本 1h 了，老师听的特别细。

课程是鼓励自己做 os 的。我又做了一个 arm 架构 risc-v 指令集的，做了个半成品 demo，没细讲，最后给老师演示了一下。最后 2 个都做，拿了 95

SQL课设#

叶文老师超级无敌好！做 TPC-H/-C ，期中期末验收，说是验收，其实是唠嗑，老师看你现在做了啥，用的什么方法，然后说你这块做的不够的，下来补一下，根本不会扣分。期末没做好的，报告里补充好就行

我又做了选题2，是当年阿里搞的一个竞赛的题，基本就是让你手搓一个 sql。这玩意跟编译很像，前端交互 - 词法/语法分析 - 语义分析 - 绑定 token - 设计逻辑执行计划/物理执行计划 - 落到磁盘上具体怎么操作。25 道题，当时做了 20 个左右，现场给老师讲了一下。老师说基本没什么做这个选题，其实他也不知道细节，所以更多的是我们给他讲，系统的原理是啥，这块怎么设计某个关键字

最后 98

选修#

Linux#

期末闭卷考试。平时有云平台小测，考试前发样题，60-70% 的原题或者变题，多背一背。其余的得去书上看，找细节。今年幸运的是最后 20 分的变成&分析大题是几乎一样的代码，只是改了一下考点，但也能秒

豪课，原题多背背就高分了，93 拿下

并行计算与GPU#

3 次 lab，一次期末大作业，很多选题，最后老师开腾讯会议验收。分 ABC 3 个当，分别对应最终系数 0.8/1.0/1.2，我选的 C，是学习一篇论文+复现，也不知道他怎么判分，对于我复现的完成度。这是真传统 GPU，这论文 17 年的，纯图形学，要看吐了，全是数学公式计算，比 agent 的论文难读多了…

3 次 lab 会有课堂展示机会，不清楚具体加分差多少。但有点难绷的点是老师不排顺序，每次上个人讲完，下一个人冲上去抢，我一次都没抢上，有的人倒是讲了好几次…

下一代Internet技术#

豪课。几次小作业，期末计科是论文，别的专业考试好像。论文老师声称要查 ai 率，我找了一下查 ai 率的，没找到免费的网站，自己也懒得用 dpsk 一点点降 ai 率了，感觉他不会去真的查。最后 PDF 转曲扔上去了，除非他 OCR，哈哈哈

91。第一次出分 85，何何的意味，而且好几个同学觉得自己偏低。最后问老师说是考勤错了，好吧好吧

大数据#

挺有意思的一节课，就是实验太多了。

2 次传统大数据，hadoop、zookeeper 等等。

1 次 openclaw 的，老师紧跟 agent 前沿。

1 次移动公开课的实验，有点神秘了，他们自己的平台太烂了，各种 bug，指导书写的有不全，他们自己的人也搞不清楚，微信群里面问问问问不出来结果，老师都生气了感觉，反复@他们，但还是没解决方案。3 人一组组队做的，我没做这个，但队友做红温了。

期末是 2 选 1，一个是 benchmark 相关，挺有意思，但是指导书让你把服务器选在国内，他还要本地部署 qwen，莫名其妙的国内的，拉阿里官方魔搭巨慢；huggingface 吧，又延迟，开代理了也还是好慢，里外不是人。我最后是电脑本机下载，再 scp 传上去的，终于能快点。建议选个海外节点省事了。不过做 benchmark 确实很好玩，刚好最近是数据驱动时代，数据越来越重要了。

另一个可以选大模型助理大数据，做医疗金融等的分析，具体是啥我忘了，但是比 benchmark 省事，我 ddl 当天 2 小时搞定交上去了，看都没看）

每次实验完都可以有分享，这块要求拓展，有 2-3 分加分。

所以你可以看到，3 学分，16 周要做 5 个实验，建议一开始 3 个人就直接同时开始做，不然期末很头疼

满昏拿下。确实豪课，只要提前规划好就行，实验反正 ai 都能做

机器学习#

传统机器学习，2 次小测，1 次大测，期末大作业是二选一，一个是点积云分类，一个是时序预测。当天课上下发测试集，可以继续调，下课前给老师.csv/.npy的结果集，他去跑程序测试，看误差小于某个阈值就满分。时序的很快就满分了，我甚至做的时候用免费版 cursor 随便跑了一下就行了；点积云反倒调了很多，但是一直没过满分线。后来老师抓住我，说不能 2 个都做。本来还想刷分

移动互联网开发#

这课我一次没去过。甚至我5月才进的群，老师还设置的QQ群但是进群看不到历史消息，差点没交上平时作业。2 次小作业，基于它给的源码开发一下就好了。期末大作业是 2 个，一个是应用开发，随便选一个做，我用它给的音频的用 FFT 做了调音器；一个是理论分析，我做了安卓的音频解码分析。这个老师也说不能 2 个都做，但云平台交的，我也没管了

信息知识与获取#

有点坑，往届都推荐，今年开始点名了，没去的几次都被抓了，去的几次都没点。1 次调研，2、3 作业分别是信息检索、信息抽取，3 可以在 2 的基础上做。他给的评分标准很细，61-70…91-100 都划分了档，我疯狂奴役 ai 来给我提分，也不知道最后咋样

其他#

体育#

射箭。好像是近几年才开的，很有意思。本人原来 0 射箭经验，但上手也蛮快。射箭最重要的其实在调弓，而不是射术，初学者调弓能让你从脱靶直接到 8、9 环。建议每次调弓的时候都拍照记录，这样换弓的时候很方便。

上课在体育馆三楼，10 个靶，轮流射。累了可以从校门出去到后面的楼道休息，老师不会发现的…

考核分：

射箭姿势。占 30 分，这部分不用真弓，用的是弹力带
射箭准度。占 20 分，10m 距离，5 轮每轮 6 支箭，280 环以上 20 分，260 环以上 18 分，以此类推

有点坑的是 1000m 要占 20 分的成绩，不要哇…

个人体验：还是值得一学的，而且难度也不大，姿势就几个要点，准度我以前 0 基础，最后也拿下 262 环（好像还是班里第一），大家基本都能到 240+，所以不会扣很多分

Qwen 混合注意力模型

Sat, 15 Mar 2025 00:00:00 GMT

Qwen最新的注意力架构是其下一代模型Qwen3-Next的核心创新，它通过一种名为**混合注意力（Hybrid Attention）**的机制，旨在解决传统Transformer模型在处理长上下文时计算成本高昂的问题，同时保持甚至提升模型性能。该架构的核心特点可以总结为以下几点：

混合注意力机制：Gated DeltaNet + Gated Attention

Qwen3-Next的注意力层并非单一结构，而是将两种不同的注意力机制以特定比例混合使用，实现了效率与性能的平衡。

Gated DeltaNet (线性注意力，占75%)：这是一种基于状态空间模型（SSM）的线性注意力机制。其核心优势在于计算复杂度与序列长度呈线性关系（O(N)），而非传统注意力的二次方关系（O(N²)），这使得模型在处理超长文本时效率极高。Gated DeltaNet通过引入门控机制，能够更有效地更新和保留历史信息，在上下文学习（in-context learning）方面表现优于其他线性注意力方案（如滑动窗口注意力和Mamba2）。
Gated Attention (标准注意力，占25%)：在保留的25%的标准注意力层中，Qwen团队也进行了优化，称为Gated Attention。它在标准注意力的输出上增加了门控机制，以缓解注意力计算中的低秩问题，保证数值稳定性。同时，这些层还进行了其他增强，如将注意力头维度从128扩展至256，并仅对前25%的位置维度添加旋转位置编码（RoPE），以提升模型在超长文本上的外推能力。

这种3:1的混合比例设计，让高效的Gated DeltaNet处理序列中的大部分内容，而强大的Gated Attention则在关键层进行深度信息交互和精细化加工，从而兼顾了长序列处理效率和复杂推理能力。

高稀疏度混合专家（MoE）架构

Qwen3-Next采用了极其稀疏的MoE架构来进一步提升效率。以Qwen3-Next-80B-A3B模型为例，其总参数量高达800亿，但每次推理时仅激活约30亿参数，激活率仅为3.7%。

专家规模扩大：相比前代Qwen3-MoE的128个总专家，Qwen3-Next扩展到了512个总专家，并采用10个路由专家加1个共享专家的组合设计。这种设计通过增加专家总数，在不牺牲效果的前提下，最大化地提升了资源利用率。
极致的性价比：这种高稀疏度设计使得模型在训练成本上仅为性能相近的Qwen3-32B稠密模型的9.3%左右，实现了极致的训练和推理性价比。

多令牌预测（Multi-Token Prediction, MTP）

Qwen3-Next在主干中原生地集成了多令牌预测机制。与传统的自回归模型一次只预测一个token不同，MTP允许模型在训练时同时预测后续的多个token。

提升训练效率：这增加了训练信号的密度，有助于提升模型主干的整体性能。
加速推理：MTP为推理时的”推测解码”（Speculative Decoding）技术提供了高质量的草稿模块，通过提高接受率，可以显著加快文本生成速度。

训练稳定性优化

为了确保大规模、长上下文训练的稳定性，Qwen3-Next在多个层面进行了优化：

归一化改进：采用了零中心化的RMSNorm（Zero-Centered RMSNorm），并对归一化层的权重施加衰减，以防止权重无界增长。
MoE路由优化：在初始化时对MoE路由器的参数进行归一化，确保每个专家在训练早期都能被无偏地选中，减小随机性对结果的扰动。

总结#

Qwen3-Next的混合注意力架构通过Gated DeltaNet和Gated Attention的协同工作，结合高稀疏度MoE和多令牌预测，在保持强大模型能力的同时，实现了训练和推理成本的大幅降低。官方数据显示，该架构在长上下文场景下的推理吞吐量相比前代模型提升了10倍以上，训练成本则降低了90%，代表了下一代大模型在追求效率与性能平衡上的重要方向。

商务英语与国际交流 - 期中复习

Fri, 01 Nov 2024 00:00:00 GMT

1️⃣ Interviews（面试）#

面试是商务英语中常见的场景，以下是一些有用的词汇和句型：

💼 词汇：#

CV/Resume：简历
Cover letter：求职信
Candidate：候选人
Strengths and weaknesses：优点与缺点
References：推荐人
Offer：录用通知

✍️ 常见句型：#

Can you tell us about your background?
- 你能介绍一下你的背景吗？
Why do you want to work here?
- 你为什么想在这里工作？
What are your strengths and weaknesses?
- 你有哪些优点和缺点？
How do you handle challenges or stress?
- 你如何应对挑战或压力？
Could you describe a situation where you demonstrated leadership?
- 能描述一下你展现领导能力的情况吗？
What motivates you in your career?
- 什么激励你在职业生涯中前进？
Do you have any questions for us?
- 你有什么问题想问我们的吗？

📋 提示：#

面试时，除了回答问题，还需要展示自己的语言能力和自信，准备好展示你对职位的理解和你能为公司带来的贡献。
强调 STAR 技巧（Situation, Task, Action, Result），这是回答面试问题时很有效的框架。

2️⃣ Day-to-Day Work（日常工作）#

日常工作中，掌握一些常用的词汇和句型能帮助你更加高效地沟通。

💼 词汇：#

Task：任务
Deadline：截止日期
Priority：优先级
Schedule：日程安排
Teamwork：团队合作
Meeting：会议
Project：项目
Report：报告
Feedback：反馈
Workload：工作量
Supervisor/Manager：上司/经理

✍️ 常见句型：#

Could you help me with this task?
- 你能帮我处理这个任务吗？
I’ve completed the report, and it’s ready for review.
- 我已经完成了报告，可以审阅了。
I need to prioritize these tasks.
- 我需要优先处理这些任务。
The deadline for this project is next Friday.
- 这个项目的截止日期是下周五。
Let’s schedule a meeting for tomorrow.
- 我们安排明天开个会议吧。
Could you please send me an update on the project?
- 你能给我发一下项目的最新进展吗？

📋 提示：#

确保你能有效地与同事沟通任务、进度和需求。
了解和使用 时间管理技巧，例如 “prioritize tasks”（优先处理任务）或 “meet deadlines”（按时完成工作）。

3️⃣ Working Environment（工作环境）#

描述工作环境时，常常涉及到团队氛围、公司文化、工作条件等内容。

💼 词汇：#

Workplace：工作场所
Office layout：办公室布局
Culture：文化
Open-plan office：开放式办公室
Flexible hours：弹性工作时间
Work-life balance：工作与生活平衡
Remote work/Telecommuting：远程工作
Collaboration：合作
Team spirit：团队精神
Innovation：创新

✍️ 常见句型：#

Our company promotes a healthy work-life balance.
- 我们公司提倡健康的工作与生活平衡。
We have an open-plan office to encourage collaboration.
- 我们有开放式办公室，旨在鼓励合作。
Do you prefer working in a team or independently?
- 你更喜欢团队合作还是独立工作？
How do you feel about flexible working hours?
- 你如何看待弹性工作时间？
The company has a very supportive and collaborative environment.
- 这家公司有一个非常支持和合作的工作环境。

📋 提示：#

要特别注意在描述工作环境时，展示你的适应性和对不同工作方式（例如远程工作）的看法。
你可以提到公司文化，展示自己与公司文化的契合度。

4️⃣ Presentations（演讲）#

演讲是商务交流中的一个重要方面，掌握一些表达方式可以帮助你更好地展示自己的观点。

💼 词汇：#

Slide：幻灯片
Visual aids：视觉辅助工具
Audience：听众
Introduction：介绍
Conclusion：总结
Key points：关键点
Q&A session：问答环节
Presentation skills：演讲技巧
Engage the audience：吸引听众注意力
Clarity：清晰度

✍️ 常见句型：#

Good morning, everyone. Thank you for joining today’s presentation.
- 大家早上好，感谢参加今天的演讲。
Let’s move on to the next slide.
- 我们继续看下一张幻灯片。
To summarize, the key points are as follows:
- 总结一下，关键点如下：
Do you have any questions or feedback?
- 有任何问题或反馈吗？
In conclusion, our recommendations are…
- 总结来说，我们的建议是…
I’d like to open the floor to questions now.
- 现在我想开放提问环节。

📋 提示：#

演讲时，要确保你的语言清晰、简洁，并避免过于复杂的表达。
使用视觉辅助工具（如幻灯片）来强化你的要点。
练习互动，通过提问或鼓励听众参与来保持演讲的活跃。

📚 复习小贴士：#

词汇积累：每天学习一些相关领域的词汇，并学会如何在实际场景中运用。
句型运用：记住常用的句型和表达方式，确保自己能流利使用。
模拟练习：通过模拟面试、日常工作对话、演讲等方式练习口语和听力。
场景记忆法：将每个场景中的词汇和句型与实际生活中的情境相结合，帮助记忆。

GNS3 - Win11 家庭版在 VMware 里启动虚拟机报错

Sat, 12 Oct 2024 00:00:00 GMT

启动时报错：此平台不支持虚拟化的 Intel VT-x/EPT。不使用虚拟化的 Intel VT-x/EPT，是否继续?
然后陷入无限循环，不能正常启动GNS3虚拟机，并在上面跑路由器

任务管理器 - 性能 - CPU查看虚拟化是否已启用，如果不，那需要进去BIOS然后启用VT-x
VMware workstation对于GNS3这个虚拟机的配置和管理，需要勾选☑ 虚拟化 Intel VT-x/EPT 或 AMD-V/RVI
禁用Hyper-v相关
1. 打开”控制面板” > “程序” > “启用或关闭 Windows 功能”。
2. 取消勾选以下选项：
  - Hyper-V
  - Windows 虚拟机监控程序平台
  - 虚拟机平台
3. 点击”确定”，然后重启计算机。

我到这一步就可以用了，如果还是不行，后续操作：

使用命令行禁用 Hyper-V：
1. 以管理员身份打开 PowerShell 或命令提示符。
2. 执行以下命令：
3. powershell
4. 复制代码
5. bcdedit /set hypervisorlaunchtype off
6. 重启计算机。
禁用内核隔离：
1. 打开”设置” > “隐私与安全” > “Windows 安全” > “设备安全性”。
2. 在”内核隔离”部分，点击”内核隔离详细信息”。
3. 关闭”内存完整性”选项。
4. 重启计算机。

Apache License 2.0 简介

Tue, 20 Aug 2024 00:00:00 GMT

阿帕奇协议 2.0，当前最受企业欢迎的开源许可证之一，Apache软件基金会发布，兼顾自由使用与法律保护，适合企业或组织开源自己的项目，且减少法律、专利纠纷

允许用户对自己的代码：

权利	描述
✅ 使用（Use）	商业或非商业都行
✅ 修改（Modify）	可自由修改源码
✅ 复制（Copy）	可以分发副本
✅ 分发（Distribute）	可以将原始或修改后的代码重新发布
✅ 商用（Commercial use）	允许闭源或作为商业产品一部分出售
✅ 子许可证（Sublicense）	允许把你的代码集成到别人产品里再出售

合规条件

条件	说明
🧾 保留版权声明	原始作者的版权信息（COPYRIGHT）不能删，要放在源码中
📄 附带 LICENSE 文件	你发布时要把 Apache 2.0 LICENSE 一起带上
📝 标注修改	如果你修改了代码，要说明你改了什么（加个说明）
🔒 专利授权	贡献者自动授予你专利使用权（反过来你也授予别人）

C++ 学习笔记

Sat, 01 Jun 2024 00:00:00 GMT

cout#

1
cout << age, pi, grade, isPassed << endl;这里endl提示“无法确定需要哪个函数模板什么意思”，我写了using namespace std;

这个问题是因为你在使用 cout 时，使用了逗号 , 分隔了多个输出项，这在 C++ 中是有问题的。逗号运算符的行为并不是你期望的输出多个变量，而是按照顺序执行并返回最后一个值。

问题所在：#

1
cout << age, pi, grade, isPassed << endl;

这里使用了逗号运算符 ,，它的作用是依次执行每个表达式，但是它返回的只是最后一个表达式的值（在这个例子中是 isPassed），所以 cout 并不会依次输出每个变量。实际上，这段代码并没有按照你的预期执行。

正确的写法：#

你应该将每个输出项分开，使用多个 << 操作符，而不是逗号。正确的写法如下：

1
cout << age << " " << pi << " " << grade << " " << isPassed << endl;

解释：#

<< 是 C++ 中流输出操作符，用于将数据输出到标准输出流（cout）。
每次输出一个值时，使用 << 将其连接起来，逐个输出。
" " 用来在每个输出项之间加一个空格（如果需要的话）。

完整示例：#

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

4
int main() {
5
    int age = 20;
6
    double pi = 3.14159;
7
    char grade = 'A';
8
    bool isPassed = true;
9

10
    // 正确的输出方式
11
    cout << age << " " << pi << " " << grade << " " << isPassed << endl;
12

13
    return 0;
14
}

输出结果：

1
20 3.14159 A 1

在C++中，要注意区分操作符的使用，特别是 << 和 ,，它们的含义是完全不同的！😊

cin#

我们来详细讨论一下 cin >> a >> b; 语句的含义。

`cin >> a >> b;` 的作用：#

cin 是 C++ 中标准库 iostream 提供的输入流对象，表示从标准输入流（通常是键盘）获取数据。>> 是流提取运算符，它从 cin 中提取数据并将其存储到对应的变量中。

解释：#

cin >> a：从标准输入读取一个值，并将其存储到变量 a 中。
cin >> b：接着从标准输入读取下一个值，并将其存储到变量 b 中。

这样，cin >> a >> b; 的含义是：

首先读取一个整数并存储到 a。
接着读取下一个整数并存储到 b。

为什么要使用 `cin >> a >> b;` 而不是 `cin >> a, b;`：#

在你最初写的代码 cin >> a, b; 中，使用了逗号运算符 ,，其效果并不像你预期的那样是一次性输入两个变量。逗号运算符的作用是执行左边的表达式并返回右边的结果，因此：

cin >> a 会正确地从输入中读取一个值并将其存储到 a 中。
然后，逗号运算符会执行 b，但 b 没有被赋值，所以 b 根本不会被读取。

总结：

cin >> a >> b; 通过连续使用 >> 运算符来依次从标准输入读取多个变量。
cin >> a, b; 是错误的写法，因为逗号运算符的使用不符合从输入流中提取数据的意图。

输出的精度控制#

让我详细讲解一下 iomanip、fixed 和 setprecision，以及它们是如何控制输出格式的。

`iomanip` 头文件#

<iomanip> 是 C++ 中一个用于控制输入输出格式的标准库头文件。它提供了一些流操控符，用来设置 cin 和 cout 的输入输出格式。例如，setprecision、fixed、setw 等都属于 iomanip 中的功能。

`fixed` 和 `setprecision` 的作用：#

fixed：
- fixed 是一个格式控制符，用于控制浮点数（float 或 double）的输出格式。
- 使用 fixed 后，输出的浮点数会以 固定小数点格式 显示，而不是使用 科学计数法（如果数值较大或较小时，默认情况下会使用科学计数法）。
示例：
```
1
float num = 3.1415926535;
2
cout << num << endl;   // 默认会以科学计数法输出
3
cout << fixed << num << endl;  // 使用 fixed 显示为固定小数点格式
```
输出结果：
```
1
cpp复制编辑3.14159   // 默认输出（科学计数法）
2
3.141593  // 使用 fixed 输出（固定小数点格式）
```
所以 fixed 改变了浮点数的输出形式，让它按照常见的小数形式输出，而不是科学计数法。
setprecision(n)：
- setprecision(n) 用来指定输出的 浮点数精度，即小数点后显示的位数。
- 如果你在使用 fixed 后调用 setprecision(n)，它会指定 小数点后显示的位数。
示例：
```
1
cpp复制编辑float num = 3.1415926535;
2
cout << fixed << setprecision(3) << num << endl;  // 输出小数点后3位
```
输出结果：
```
1
3.142
```
这里使用了 setprecision(3) 来控制小数点后面保留 3 位数字。

组合使用：#

fixed 和 setprecision 可以组合使用，以控制浮点数输出的格式。fixed 用来强制使用固定小数点格式，而 setprecision 用来设置小数位的数量。

示例：

1
cpp复制编辑#include <iostream>
2
#include <iomanip>
3
using namespace std;
4

5
int main() {
6
    float pi = 3.1415926535;
7

8
    // 使用 fixed 和 setprecision 来控制输出
9
    cout << fixed << setprecision(2) << pi << endl;   // 保留2位小数
10
    cout << fixed << setprecision(4) << pi << endl;   // 保留4位小数
11

12
    return 0;
13
}

输出结果：

1
3.14   // 保留2位小数
2
3.1416 // 保留4位小数

总结：#

fixed：用于将浮点数输出格式化为固定小数点格式，避免使用科学计数法。
setprecision(n)：用于设置浮点数输出时的精度（即保留的小数位数）。当与 fixed 一起使用时，它控制的是小数点后保留的位数。

常见用法：#

1
#include <iostream>
2
#include <iomanip>  // 包含 iomanip 头文件
3
using namespace std;
4

5
int main() {
6
    double value = 123.456789;
7

8
    // 设置精度并以固定格式显示浮点数
9
    cout << fixed << setprecision(3) << value << endl;  // 输出 123.457
10
    cout << fixed << setprecision(6) << value << endl;  // 输出 123.456789
11

12
    return 0;
13
}

通过这些格式控制符，你可以灵活地控制浮点数的输出格式，使得程序的输出更加精确和可读。

全局变量：整个程序可用，但容易污染命名空间#

全局变量（global variables）在程序的整个生命周期内都有效，并且可以在 任何函数、任何文件 中访问和修改，这带来了 命名冲突、可读性下降和调试困难 等问题。

影响代码的可维护性#

全局变量的值可以在任何地方被修改，这会导致代码的可读性下降，使得 函数之间的依赖性增强，难以排查错误。这与封装的初衷是相悖的

多线程环境下，全局变量可能导致数据竞争#

如果多个线程 同时访问和修改 一个全局变量，而没有加锁，就会发生 数据竞争（Race Condition），导致 未定义行为。若非原子操作，就会数据竞争，导致线程之间未能完全实现想要实现的操作

如何避免全局变量的污染？#

1. 使用 `const` 限制全局变量的修改#

2. 使用 `static` 让全局变量仅在当前文件可见#

1
static int fileScopeVar = 100;  // 仅限当前文件

3. 使用 namespace 避免命名冲突#

1
namespace Math {
2
    int value = 10;
3
}
4

5
namespace Physics {
6
    int value = 20;
7
}
8

9
int main() {
10
    cout << Math::value << endl;   // 10
11
    cout << Physics::value << endl; // 20
12
}

📌 不同 namespace 内的 value 互不干扰。

4. 使用 `类` 或 `结构体` 包装全局变量#

1
class Config {
2
public:
3
    static int maxUsers;
4
};
5
int Config::maxUsers = 100;

📌 这样可以更清晰地组织变量，防止随意修改。

C++ 的引用传递（Pass by Reference）#

1. 什么是引用传递？#

在 C++ 中，引用传递（Pass by Reference） 是指在函数参数中使用 引用（&），让函数 直接操作原变量，而不是创建副本。这样可以：

避免值传递时的拷贝开销（尤其是对于大对象）
允许函数修改原变量

2. 引用传递 vs. 值传递#

传递方式	关键字	作用	变量是否会被修改
值传递（Pass by Value）	`int x`	传递变量的拷贝	❌ 不会修改原变量
引用传递（Pass by Reference）	`int &x`	传递变量的别名	✅ 会修改原变量

3. 引用传递的语法#

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

4
// 使用引用传递
5
void modify(int &num) {  // num 是原变量的别名
6
    num += 10;  // 直接修改原变量
7
}
8

9
int main() {
10
    int a = 5;
11
    modify(a);  // 传递 a 的引用
12
    cout << "修改后的 a：" << a << endl;  // 输出 15
13
    return 0;
14
}

🔹 说明：

int &num 表示 num 是 a 的别名。
在 modify() 函数内部，修改 num 就是修改 a 本身。

4. 为什么要用引用传递？#

✅ 1. 避免值传递的拷贝开销#

如果传递一个大对象，值传递会创建完整的副本，非常消耗内存。引用传递可以避免拷贝，提高效率。

1
#include <iostream>
2
#include <vector>
3

4
using namespace std;
5

6
// 传递 vector 的引用，避免拷贝
7
void printVector(const vector<int> &v) {
8
    for (int num : v) {
9
        cout << num << " ";
10
    }
11
    cout << endl;
12
}
13

14
int main() {
15
    vector<int> numbers = {1, 2, 3, 4, 5};
16
    printVector(numbers);  // 传递引用
17
    return 0;
18
}

展开收起

🔹 const vector<int> &v

const 让 v 不能被修改，保证安全性。
避免拷贝，提高性能。

✅ 2. 允许修改原变量#

1
void doubleValue(int &x) {
2
    x *= 2;  // 直接修改 x
3
}
4

5
int main() {
6
    int num = 10;
7
    doubleValue(num);
8
    cout << num << endl;  // 输出 20
9
}

int &x 让 x 直接指向 num，所以 x *= 2 直接修改 num。

✅ 3. 适用于多个返回值#

C++ 的函数默认只能返回一个值，但可以用引用传递多个值：

1
void swap(int &a, int &b) {
2
    int temp = a;
3
    a = b;
4
    b = temp;
5
}
6

7
int main() {
8
    int x = 3, y = 5;
9
    swap(x, y);
10
    cout << x << " " << y << endl;  // 输出 5 3
11
}

a 和 b 互换，调用 swap(x, y) 后，x 和 y 真正交换了值。

5. 常量引用 `const &`（防止修改）#

如果不希望函数修改变量，又想用引用传递避免拷贝，就用 常量引用 const &。

1
void print(const int &num) {  // 不能修改 num
2
    cout << num << endl;
3
}
4

5
int main() {
6
    int a = 10;
7
    print(a);
8
}

🔹 const int &num

传递 a 的引用 不会拷贝，提高效率。
const 保证 num 不能被修改。

6. 什么时候用引用传递？#

情况	推荐方式
变量较小（如 `int`, `char`）	值传递 `int x`
变量较大（如 `vector`, `string`）	引用传递 `const vector<int>& v`
需要修改变量	引用传递 `int& x`
仅读取变量	常量引用 `const int& x`

7. 总结#

✅ 引用传递的优势：

避免拷贝，提高效率
允许修改原变量
适用于多个返回值
可以使用 const & 防止修改

📌 记住：

如果不修改变量，用 const &（提高效率）。
如果需要修改变量，用 &。
变量较小（int、char）时，用值传递 int x 影响不大。

默认参数#

在 C++ 中，函数可以定义默认参数，调用时如果不提供对应参数，就使用默认值。

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

4
// `b` 有默认值 10
5
int add(int a, int b = 10) {
6
    return a + b;
7
}
8

9
int main() {
10
    cout << add(5) << endl;   // 5 + 10 = 15
11
    cout << add(5, 20) << endl; // 5 + 20 = 25
12
}

📌 关键点：

默认参数必须从右向左定义，否则编译会报错。默认参数始终放在最后面
默认参数可以减少函数重载的需求。

字符串，使用 `string` 类型📝#

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
void greet(string msg = "Hello, World!");  // 声明
6

7
int main() {
8
    greet();           // 输出 "Hello, World!"
9
    greet("Hi, C++!"); // 输出 "Hi, C++!"
10
    return 0;
11
}
12

13
void greet(string msg) {  // 实现
14
    cout << msg << endl;
15
}

展开收起

📌 解析#

为什么用 string 类型？
- string 是 C++ STL 提供的标准字符串类型，比 C 风格的 char* 更安全、易用。
- greet 的参数 msg 需要存储字符串，所以 string 是最佳选择。
默认参数 = "Hello, World!"
- 在 greet(string msg = "Hello, World!") 中，如果调用 greet();，就会使用默认值 "Hello, World!"。
- 如果调用 greet("Hi, C++!");，msg 取 "Hi, C++!"，默认值被覆盖。

全局变量#

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

4
int x = 5; // 全局变量
5

6
void test() {
7
    int x = 10;
8
    cout << x << " ";
9
}
10

11
int main() {
12
    cout << x << " ";
13
    test();
14
    cout << x << endl;
15
    return 0;
16
}

展开收起

输出： 5 10 5

最后cout << x << endl时访问全局变量

递归调用，要累加#

1
int sum(int n) {
2
    if (n == 1) {
3
        return 1;
4
    } else {
5
        return n + sum(n - 1); // ✅ 正确的递归累加
6
    }
7
}

优化Fibonacci计算#

✅ 解决方案：优化 Fibonacci 计算#

方法 1：记忆化递归（O(n)）#

使用 数组缓存已计算的值，避免重复计算：

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

4
const int N = 100;  // 足够大的缓存数组
5
int memo[N] = {0};  // 初始化所有值为 0
6

7
int fib(int n) {
8
    if (n == 0) return 0;
9
    if (n == 1) return 1;
10
    if (memo[n] != 0) return memo[n];  // 如果已计算，直接返回
11
    return memo[n] = fib(n - 1) + fib(n - 2);
12
}
13

14
int main() {
15
    cout << fib(10) << endl; // 输出 55
16
}

展开收起

🔹 时间复杂度 O(n)，只计算每个 fib(i) 一次！

指针#

📌 指针注意点

int *p = nullptr; 使用 nullptr 进行初始化，避免野指针。
访问空指针（nullptr）会导致 段错误（Segmentation Fault）。

引用Reference#

引用是 变量的别名，必须在声明时初始化，并且不能更改绑定的变量。

📌 引用的基本用法

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

4
int main() {
5
    int x = 10;
6
    int &ref = x;  // ref 是 x 的引用
7

8
    ref = 20;  // 修改 ref 其实就是修改 x
9
    cout << "x 的值: " << x << endl;  // 输出 20
10

11
    return 0;
12
}

new & delete#

🌟 `new` / `delete`（动态内存管理）#

C++ 允许在运行时动态分配和释放内存，避免数组大小的固定限制。

📌 动态分配单个变量

1
int *p = new int(10);  // 分配一个 int，值为 10
2
delete p;  // 释放内存
3
p = nullptr;  // 避免野指针

📌 动态分配数组

1
int *arr = new int[5];  // 分配 5 个 int
2
delete[] arr;  // 释放数组

🔹 new 分配的内存必须 delete 释放，否则会内存泄漏！

动态数组#

🚀 在 C++ 中，new 可以用来动态分配数组，而 数组大小可以是变量，这就是动态数组。

🌟 示例#

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

4
int main() {
5
    int x;
6
    cout << "请输入数组大小: ";
7
    cin >> x;
8

9
    int *arr = new int[x];  // 使用变量 x 分配动态数组

📌 注意事项

动态数组的大小可以是变量，不像 C++98 之前的静态数组，必须用常量定义大小。
一定要 delete[] arr;，否则会 内存泄漏（Memory Leak）！
C++ 推荐使用 std::vector 代替原生指针数组，因为 vector 会自动管理内存。

🌟 `vector<int>` 替代动态数组（推荐）#

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
int main() {
6
    int x;
7
    cout << "请输入数组大小: ";
8
    cin >> x;
9

10
    vector<int> arr(x);  // 使用 vector 自动管理内存

✅ std::vector<int> 更安全、更推荐，不用担心 new/delete 造成的内存管理问题！🚀

类的定义以分号结尾#

在 class solution 定义的结尾处。

在 C++ 中，类的定义需要以分号 ; 结尾。因此，你的代码应该改为：

1
class solution
2
{
3
public:
4
    int climbStairs(int n)
5
    {
6
        if (n <= 2)
7
            return n;
8
        int prev1 = 1, prev2 = 2, curr; // 1阶，一个方法；2阶，两个方法。
9
        // 状态转移方程是f(n)=f(n-1)+f(n-2)
10
        for (int i = 3; i <= n; i++)
11
        {
12
            curr = prev1 + prev2;
13
            prev1 = prev2; // prev1是n-2，更小的那个
14
            prev2 = curr;
15
        }
16
        return curr;
17
    }
18
}; // 这里需要分号

展开收起

总结：
✅ 类定义必须以分号 ; 结束。

🌟C++11范围for （Range-based for loop）#

C++11 引入了一种更简洁的 for 循环，称为 范围 for（Range-based for loop），专门用于遍历数组和容器（如 vector、set、map 等）。

🌟 基本语法#

1
for (元素类型 变量名 : 容器) {
2
    // 对变量名进行操作
3
}

✅ 特点

无需使用索引，避免手动写 i = 0; i < n; i++
自动取出容器内的元素，简化代码
只能用于 遍历所有元素，无法修改数组大小

🌟 示例：修改 `vector`（必须加 `&`）#

默认情况下，范围 for 传递的是拷贝，如果你想修改 vector 里的值，必须使用 引用 &：

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
int main() {
6
    vector<int> arr = {1, 2, 3, 4, 5};
7

8
    // 用引用 & 遍历并修改元素
9
    for (int &x : arr) {
10
        x *= 2;  // 所有元素变成 2 倍，取地址后，x直接修改即可，类似引用（别名），而不是
11
    }

std::String #

🌟 C++ 中 std::string 的用法详解 ++#

++std::string 是 C++ 标准库中的字符串类型，相比 C 风格字符串（char[]），它更安全、更灵活、更易用，支持动态长度、字符串拼接、查找、子串操作等。

✅ 特点：可以直接赋值，不像 char[] 需要 strcpy 支持 + 拼接，不像 char[] 需要 strcat 自动管理内存，不会像 char[] 那样容易越界

`cin`读取单个单词#

1
string name;
2
cout << "请输入你的名字：";
3
cin >> name;  // 只读取一个单词，遇到空格停止

✅ 注意： cin 读取单个单词，遇到空格会停止输入。

getline(cin, string) 读取一整行内容#

1
string sentence;
2
cout << "请输入一句话：";
3
getline(cin, sentence);  // 读取整行，包括空格

📌 cin 读取 int 之后再 getline() 读取字符串，为什么会跳过输入？ 💡 问题的根源在 C++ 里，cin 读取整数（如 int）时不会读取换行符 \n，但 getline(cin, str) 会读取整行（包括换行符）。因此，如果先用 cin >> 读取 int，再用 getline() 读取字符串，就可能发生“跳过输入” 的问题。

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
int main() {
6
    int age;
7
    string name;
8

9
    cout << "请输入你的年龄：";
10
    cin >> age;  // 读取 int，但换行符仍留在输入缓冲区
11

12
    cout << "请输入你的名字：";
13
    getline(cin, name);  // 直接读取输入缓冲区的换行符，导致 name 变为空字符串
14

15
    cout << "年龄：" << age << ", 姓名：" << name << endl;
16
    return 0;
17
}

展开收起

✅ 解决方案：使用 cin.ignore() cin.ignore() 用于丢弃输入缓冲区中的字符，避免 getline() 读取残留的换行符。

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
int main() {
6
    int age;
7
    string name;
8

9
    cout << "请输入你的年龄：";
10
    cin >> age;
11
    cin.ignore();  // 清除输入缓冲区中的换行符
12

13
    cout << "请输入你的名字：";
14
    getline(cin, name);  // 这次 getline() 就能正确读取整行了
15

16
    cout << "年龄：" << age << ", 姓名：" << name << endl;
17
    return 0;
18
}

展开收起

📌 cin.ignore() 详解 cin.ignore(n, char) 丢弃输入缓冲区中的字符，常用两种方式：

cin.ignore()（默认 n=1）：丢弃一个字符（通常是 \n）。 cin.ignore(100, ‘\n’)：最多丢弃 100 个字符，直到遇到 \n（保证清空缓冲区）。一般来说，cin.ignore() 就足够清除 \n 了，但如果有未知的额外输入，可以用 cin.ignore(100, ‘\n’)。

cout << s.length() << endl;
cout << s.size() << endl; size和length等价

字符串比较：按字典序。从第一个字符开始比较

（5）查找子串#

1
string s = "Hello World";
2
int pos = s.find("World");  // 查找 "World" 的位置
3
if (pos != string::npos) {
4
    cout << "找到 'World'，位置：" << pos << endl;
5
}

✅ find() 返回子串起始位置，找不到时返回 string::npos。

（6）截取子串#

1
string s = "Hello World";
2
string sub = s.substr(6, 5);  // 从索引 6 开始，取 5 个字符
3
cout << sub << endl;  // World

✅ substr(start, length)

start：起始索引
length：子串长度

（7）删除、插入、替换#

1
string s = "Hello World";
2
s.erase(5, 1);  // 删除索引 5 位置的 1 个字符（去掉空格）
3
cout << s << endl;  // HelloWorld
4

5
s.insert(5, " ");  // 在索引 5 插入空格
6
cout << s << endl;  // Hello World
7

8
s.replace(6, 5, "C++");  // 从索引 6 开始的 5 个字符替换成 "C++"
9
cout << s << endl;  // Hello C++

✅ 常用操作

erase(pos, len)：从 pos 位置删除 len 个字符
insert(pos, str)：在 pos 位置插入 str

输入一行字符串，查找 `"abc"` 是否存在#

1
#include <iostream>
2
#include <string>
3

4
using namespace std;
5

6
int main()
7
{
8
    string str;
9
    getline(cin, str);
10
    int pos = str.find("abc");
11
    if (pos != string::npos)
12
        cout << "找到，位置是：" << pos << endl;
13

14
    return 0;
15
}

展开收起

忽略大小写搜索（可选）：如果希望不区分大小写查找 "abc"，可以先把 str 转小写：

1
transform(str.begin(), str.end(), str.begin(), ::tolower);

反转字符串#

使用 rbegin()/rend() 迭代器

1
for (auto it = str.rbegin(); it != str.rend(); ++it)//通常推荐使用++it，前置递增
2
    cout << *it;
3
cout << endl;

这种写法利用 反向迭代器，更符合 C++ STL 风格。

1️⃣ `++it` vs. `it++` 的区别#

方式	作用	效率	返回值
`++it`	前置递增：先增加，再返回新值	更快（更高效）	递增后的迭代器
`it++`	后置递增：先返回当前值，再增加	较慢（返回旧值需要额外开销）	递增前的迭代器

2️⃣ `++it` 更高效的原因#

对于内置类型（如 int，char），++it 和 it++ 差别不大，因为它们的递增操作代价几乎相同。

但对于迭代器（如 std::vector<int>::iterator）或自定义对象：

it++（后置递增） 需要创建一个临时副本，返回原始值，增加额外开销。
++it（前置递增） 直接递增，不创建副本，更高效。

🔹 模拟后置递增 (`it++`) 的实现#

1
Iterator operator++(int)  // 后置递增
2
{
3
    Iterator temp = *this;  // 复制当前迭代器
4
    ++(*this);              // 递增当前迭代器
5
    return temp;            // 返回旧值
6
}

⚠️ 额外开销：

创建 temp 复制当前迭代器
递增 *this
返回 temp，导致额外的复制操作

🔹 模拟前置递增 (`++it`) 的实现#

1
Iterator& operator++()  // 前置递增
2
{
3
    // 直接递增当前迭代器，不创建临时副本
4
    ++(*this);
5
    return *this;
6
}

✅ 高效之处：

没有复制开销
直接修改自身，返回自身引用
性能更优

🎯 总结#

用法	何时使用？	是否推荐？
`++it`	一般情况下（更高效）	✅ 推荐
`it++`	需要用到递增前的值	⚠️ 谨慎使用

✅ 记住#

💡 使用 ++it（前置递增）是最佳实践，除非明确需要 it++。🚀

📌 反向迭代器（Reverse Iterator）#

C++ 的标准库提供了一种反向迭代器（Reverse Iterator），可以用来从容器的尾部向前遍历。这在需要倒序输出或逆序查找时非常有用。

1️⃣ 反向迭代器的基本用法#

在 C++ 中，标准容器（如 std::vector、std::string、std::list 等）都提供了反向迭代器，其表示方法是：

rbegin() —— 指向容器的最后一个元素
rend() —— 指向容器第一个元素的前一个位置

🔹 示例：使用 `rbegin()` / `rend()` 逆序遍历字符串#

1
#include <iostream>
2
#include <string>
3

4
using namespace std;
5

6
int main()
7
{
8
    string str = "hello";
9

10
    // 使用反向迭代器遍历字符串
11
    for (auto it = str.rbegin(); it != str.rend(); ++it)
12
    {
13
        cout << *it;
14
    }
15
    cout << endl;
16

17
    return 0;
18
}

展开收起

🔹 输出

1
olleh

✅ 解析

str.rbegin() 返回指向 o 的迭代器（最后一个字符）
str.rend() 指向 h 之前的位置，循环不会访问它
++it 让迭代器向前（即反向）移动。++it 是容器反向迭代器的特殊用法，单独记忆。而++it 直接递增，不会像后置一样创建一个临时副本，这样能够节省开支，更高效
rbegin和rend都是对begin和end的reverse，则前缀+r，方便记忆。begin和end是正向迭代器的参数
rend是第零号字符的前一个位置，end是第length-1号字符的后一个位置。对应

2️⃣ 反向迭代器 vs 正向迭代器#

🔹 例子：正向 vs 反向遍历#

1
#include <iostream>
2
#include <vector>
3

4
using namespace std;
5

6
int main()
7
{
8
    vector<int> v = {1, 2, 3, 4, 5};
9

10
    cout << "正向遍历: ";//对比熟悉一下这两个语法
11
    for (auto it = v.begin(); it != v.end(); ++it)
12
        cout << *it << " ";
13
    cout << endl;
14

15
    cout << "反向遍历: ";
16
    for (auto it = v.rbegin(); it != v.rend(); ++it)
17
        cout << *it << " ";
18
    cout << endl;
19

20
    return 0;
21
}

展开收起

3️⃣ reverse() vs 反向迭代器

C++ 还提供了 std::reverse() 直接翻转数组或字符串：

在algorithm库里

1
#include <iostream>
2
#include <string>
3
#include <algorithm>
4

5
using namespace std;
6

7
int main()
8
{
9
    string str = "hello";
10

11
    reverse(str.begin(), str.end());  // 直接翻转字符串
12
    cout << str << endl;  // 输出 "olleh"
13

14
    return 0;
15
}

展开收起

如果只是想一次性翻转整个序列，std::reverse() 更加简单高效。
如果需要按需倒序遍历或操作，使用 rbegin() / rend()。

reverse()#

🚀 `reverse()` 方法详解#

reverse() 是 C++ STL（标准模板库）中的一个函数，用于原地反转一个范围（如数组、vector、string等）。

📌 1. `reverse()` 的基本用法#

🔹 语法#

1
void reverse(BidirectionalIterator first, BidirectionalIterator last);

左闭右开

first：要反转的范围的起始迭代器（包含）
last：要反转的范围的结束迭代器（不包含）
返回值：reverse() 没有返回值，它是原地修改的，即直接修改原容器，不创建新对象。

📌 2. `reverse()` 反转数组#

1
#include <iostream>
2
#include <algorithm>
3

4
using namespace std;
5

6
int main()
7
{
8
    int arr[] = {1, 2, 3, 4, 5};
9
    int n = sizeof(arr) / sizeof(arr[0]);
10

11
    reverse(arr, arr + n);  // 反转整个数组
12

13
    for (int i = 0; i < n; i++)
14
        cout << arr[i] << " ";
15

16
    return 0;
17
}

展开收起

传入需要反转的数组范围的首、末地址

reverse() 函数不仅可以反转整个数组，还可以反转数组的部分。你只需要指定要反转的范围，即传入两个迭代器（或指针），它们分别指向反转部分的开始和结束位置。

只要框定范围就可以。注意是左闭右开的

1
reverse(arr + 2, arr + 5);  // 反转 arr[2] 到 arr[4]

+2 +5是指针的，移位加法s

📌 3. `reverse()` 反转 `vector`#

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
using namespace std;
6

7
int main()
8
{
9
    vector<int> vec = {10, 20, 30, 40, 50};
10

11
    reverse(vec.begin(), vec.end());  // 反转整个 vector。左闭右开，则end()恰好指向的是最后一个元素的后一个位置
12

13
    for (int num : vec)
14
        cout << num << " ";
15

16
    return 0;
17
}

展开收起

📌 4. `reverse()` 反转 `string`#

📌 5. `reverse()` 反转部分元素#

你也可以只反转一部分范围。注意范围的确定是前包含后不包含的即可，左闭右开。

📌 6. 使用 `reverse()` 结合 `rbegin()` 和 `rend()`#

如果想反转整个容器，你也可以用反向迭代器 rbegin() 和 rend()：

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
using namespace std;
6

7
int main()
8
{
9
    vector<int> vec = {10, 20, 30, 40, 50};
10

11
    reverse(vec.rbegin(), vec.rend());  // 反转整个 vector
12

13
    for (int num : vec)
14
        cout << num << " ";
15

16
    return 0;
17
}

展开收起

🔹 输出

1
50 40 30 20 10

✅ 用 rbegin() 和 rend() 效果和 reverse(vec.begin(), vec.end()) 一样，但更直观。

呃但我感觉意义不明

📌 7. `reverse()` 与 `reverse_copy()` 的区别#

🔹 `reverse()`（原地反转）#

直接修改原容器，不会返回新对象。

🔹 `reverse_copy()`（拷贝反转）#

不会修改原容器，而是将结果复制到一个新的容器中。

✅ reverse_copy() 适用于不想修改原数组的情况！

std::unordered_map#

1
unordered_map<int, int> freq;
2

3
int x = nums[ri];
4
freq[x]++;
5

6
while (freq[x] > k)
7
{
8
  freq[nums[le]]--;
9
  le++;
10
}

unordered_map很好用

vector<int> &nums的长度#

用nums.size()来获取

创建动态数组#

1
int* a = new int[x];
2
int a[] = new int[5];//只能用来创建静态数组

释放动态数组#

1
delete[] a;

C++11范围for#

范围 for 不能用于普通指针（int* a），它只能用于 C++ 容器（如 std::vector、std::array）。

std::vector<int>，就可以正确使用范围 for，例如：

1
vector<int> arr(x);  // 使用 vector 代替动态数组
2
for (int &val : arr)
3
{
4
    cout << val << " ";
5
}

多维数组#

土法，new&delete#

1
#include <iostream>
2

3
using namespace std;
4

5
int main()
6
{
7
    int rows = 3, cols = 3;
8

9
    // 创建一个指针数组（每个指针指向一行）
10
    int **a = new int *[rows];
11

12
    // 为每一行分配内存
13
    for (int i = 0; i < rows; i++)
14
        a[i] = new int[cols];
15

16
    // 释放内存（必须先释放行，再释放指针数组）
17
    for (int i = 0; i < rows; i++)
18
        delete[] a[i];
19
    delete[] a;
20

21
    return 0;
22
}

展开收起

优化：std::vector#

1
vector<vector<int>> a(rows, vector<int>(cols));

vector<vector<int>> a(rows, vector<int>(cols));
- 直接创建一个 rows × cols 大小的二维数组，自动管理内存，不需要 new/delete。
自动释放内存
- vector 在超出作用域后会自动释放内存，不需要手动 delete[]。

for(char &x : arr[i])#

1
for (char &x : arr[i])//传引用
2
        {
3
            if ((unsigned char)x >= 65 && (unsigned char)x <= 90)
4
                x += 32;
5
        }

传引用是很好的选择

初始化数组为0#

方法 1：使用 `new` 时加 `()` 进行值初始化#

1
int *tag = new int[len]();  // 这样会把所有元素初始化为 0

✔ 适用于 动态分配的数组，保证所有元素都变成 0。

方法 2：使用 `std::fill` 填充 0#

1
#include <algorithm>
2
int *tag = new int[len];  // 这里不会初始化为 0
3
std::fill(tag, tag + len, 0);  // 手动填充 0

✔ 适用于任意情况，可以填充任意值，不局限于 0。

方法 3：使用 `memset` 填充 0#

1
#include <cstring>
2
int *tag = new int[len];  // 这里不会初始化为 0
3
memset(tag, 0, sizeof(int) * len);

⚠ memset 只适用于填充 0，不能用于填充非 0 值，否则可能会导致错误。

方法 4：改用 `std::vector`#

如果不一定要使用裸指针，建议使用 std::vector：

1
#include <vector>
2
std::vector<int> tag(len, 0);  // 直接初始化为 0

✔ 自动管理内存，不会有内存泄漏问题，推荐使用！🎯

内置快排+插入排序优化#

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};
7
    std::sort(vec.begin(), vec.end()); // 升序排序
8
    for (int num : vec) std::cout << num << " "; // 输出：1 2 5 5 6 9
9
}

O(n log n)

range::sort()#

ranges::sort(nums)：

是 C++20 引入的 Ranges 库中的函数，它简化了排序操作。
它直接接受一个范围（即容器或其他支持迭代器的对象），而不需要显式传递迭代器。
ranges::sort 是基于范围（range）的操作，因此代码更加简洁和直观。

语法示例：

1
#include <ranges>
2
std::vector<int> nums = {5, 2, 9, 1, 5, 6};
3
std::ranges::sort(nums);

初始化vector#

✅ 空 vector（无元素）#

1
std::vector<int> pairs;

✅ 指定大小并用默认值（0）填充#

1
std::vector<int> pairs(5);  // 创建一个含有5个0的 vector

✅ 指定大小和初始值#

1
std::vector<int> pairs(5, 42);  // 创建一个含有5个42的 vector

✅ 使用列表初始化#

1
std::vector<int> pairs = {1, 2, 3, 4, 5};

✅ 使用 `std::fill`（或其他算法）#

1
std::vector<int> pairs(5);
2
std::fill(pairs.begin(), pairs.end(), 7);  // 把所有元素设为7

✅ 复制另一个 vector#

1
std::vector<int> other = {1, 2, 3};
2
std::vector<int> pairs(other);  // 拷贝构造

对空vector添加元素#

✅ 使用 `push_back()` 添加单个元素#

1
std::vector<int> pairs;
2
pairs.push_back(10);
3
pairs.push_back(20);
4
pairs.push_back(30);

这会将 10, 20, 30 按顺序加到 vector 末尾。

✅ 使用 `emplace_back()`（性能更优一点）#

1
pairs.emplace_back(40);

✅ 插入多个元素：`insert()`#

1
std::vector<int> more = {50, 60, 70};
2
pairs.insert(pairs.end(), more.begin(), more.end());

✅ 添加整个数组或列表#

1
pairs.insert(pairs.end(), {80, 90, 100});

lower_bound()不同情况下的返回值#

int index = distance(temp.begin(), lower_bound(temp.begin(), temp.end(), success));

✅ 情况1：能找到刚好等于或大于 success 的值#

1
std::vector<int> temp = {1, 3, 5, 7, 9};
2
int success = 5;

lower_bound 找的是第一个 >= 5 的值。
5 在索引 2 处，所以：

1
index = 2;

✅ 情况2：所有元素都小于 success#

1
std::vector<int> temp = {1, 2, 3};
2
int success = 10;

没有元素 >= 10，lower_bound 返回的是 temp.end()。
所以：

1
index = 3; // 即 temp.size()

✅ 情况3：所有元素都 >= success#

1
std::vector<int> temp = {10, 20, 30};
2
int success = 5;

第一个 >= 5 的是 10，在索引 0：

1
index = 0;

✅ 情况4：有多个相同的元素（等于 success）#

1
std::vector<int> temp = {1, 3, 5, 5, 5, 7};
2
int success = 5;

lower_bound 会返回第一个 5 的位置 → 索引 2：

1
index = 2;

✅ 情况5：success 小于最小值#

1
std::vector<int> temp = {4, 5, 6};
2
int success = 1;

lower_bound 返回第一个大于等于 1 的 → 索引 0：

1
index = 0;

🔁 总结表格：#

`temp`	`success`	结果 index	说明
{1, 3, 5, 7}	5	2	找到等于 5 的
{1, 3, 5, 7}	6	3	第一个 ≥6 的是 7
{1, 3, 5, 7}	8	4	没有 ≥8 的 → 返回 end()
{10, 20, 30}	5	0	所有都比它大
{1, 2, 3, 4}	0	0	所有都比它大

由索引转换为迭代器#

要用nums.begin() + index来获得

如果你已经知道当前的下标索引，并且想从 某个特定位置 开始调用 std::lower_bound()，你可以通过传递 起始迭代器 来指定起始位置。

假设你知道当前的索引 index，那么你可以通过 nums.begin() + index 来获得从该索引开始的迭代器。

语法：#

1
auto it = std::lower_bound(nums.begin() + index, nums.end(), value);

nums.begin()是第0号，+index就刚好是当前的这个数

从当前索引开始的迭代器#

lower_bound(nums.begin() + i + 1, nums.end(), target2) 返回的 迭代器 是从 nums.begin() + i + 1 开始的。

解释：#

nums.begin() + i + 1 是 从当前索引 i 的下一个元素开始，也就是从 nums[i+1] 开始。
lower_bound() 会在这个范围内查找 第一个大于或等于 target2 的元素。

代码解析：#

1
int index1 = distance(nums.begin(), lower_bound(nums.begin() + i + 1, nums.end(), target2));

lower_bound(nums.begin() + i + 1, nums.end(), target2) 计算 从 i + 1 开始，直到 nums.end() 范围内第一个 大于或等于 target2 的位置。
然后，distance(nums.begin(), ...) 计算 从 nums.begin() 到返回的迭代器的位置的距离，也就是找出目标元素在数组中的索引。

upper_bound()#

upper_bound() 是一个 STL 算法，用于在 已排序容器 中查找 第一个大于给定值的元素 的位置。

具体来说，upper_bound 会返回 第一个大于给定值的元素 的迭代器。如果所有元素都小于等于给定值，它将返回指向容器末尾的迭代器。

`upper_bound()` 语法：#

1
std::upper_bound(first, last, value)

first 和 last：是待查找范围的迭代器（通常是容器的 begin() 和 end()）。
value：需要查找的目标值。

返回值是一个迭代器，指向 第一个大于 value 的元素。

特点：#

如果 value 小于容器中的所有元素，返回的是容器的 begin() 迭代器。
如果 value 大于容器中的所有元素，返回的是容器的 end() 迭代器。
如果找到了与 value 相等的元素，返回的是 第一个大于 value 的元素。

所以，想要找到小于等于value的最大的那个数，要给upper_bound()的结果减掉1

tanteijms

大三下课程指北

大三下课程指北#

必修课#

计算机系统结构#

现代交换原理#

软件工程#

专业选修#

编译课设#

OS课设#

SQL课设#

选修#

Linux#

并行计算与GPU#

下一代Internet技术#

大数据#

机器学习#

移动互联网开发#

信息知识与获取#

其他#

体育#

Qwen 混合注意力模型

总结#

商务英语与国际交流 - 期中复习

1️⃣ Interviews（面试）#

💼 词汇：#

✍️ 常见句型：#

📋 提示：#

2️⃣ Day-to-Day Work（日常工作）#

💼 词汇：#

✍️ 常见句型：#

📋 提示：#

3️⃣ Working Environment（工作环境）#

💼 词汇：#

✍️ 常见句型：#

📋 提示：#

4️⃣ Presentations（演讲）#

💼 词汇：#

✍️ 常见句型：#

📋 提示：#

📚 复习小贴士：#

GNS3 - Win11 家庭版在 VMware 里启动虚拟机报错

Apache License 2.0 简介

C++ 学习笔记

cout#

问题所在：#

正确的写法：#

解释：#

完整示例：#

cin#

cin >> a >> b; 的作用：#

解释：#

为什么要使用 cin >> a >> b; 而不是 cin >> a, b;：#

输出的精度控制#

iomanip 头文件#

fixed 和 setprecision 的作用：#

组合使用：#

总结：#

常见用法：#

全局变量：整个程序可用，但容易污染命名空间#

影响代码的可维护性#

多线程环境下，全局变量可能导致数据竞争#

如何避免全局变量的污染？#

1. 使用 const 限制全局变量的修改#

2. 使用 static 让全局变量仅在当前文件可见#

3. 使用 namespace 避免命名冲突#

4. 使用 类 或 结构体 包装全局变量#

C++ 的引用传递（Pass by Reference）#

1. 什么是引用传递？#

2. 引用传递 vs. 值传递#

3. 引用传递的语法#

4. 为什么要用引用传递？#

✅ 1. 避免值传递的拷贝开销#

✅ 2. 允许修改原变量#

✅ 3. 适用于多个返回值#

5. 常量引用 const &（防止修改）#

6. 什么时候用引用传递？#

7. 总结#

默认参数#

字符串，使用 string 类型📝#

`cin >> a >> b;` 的作用：#

为什么要使用 `cin >> a >> b;` 而不是 `cin >> a, b;`：#

`iomanip` 头文件#

`fixed` 和 `setprecision` 的作用：#

1. 使用 `const` 限制全局变量的修改#

2. 使用 `static` 让全局变量仅在当前文件可见#

4. 使用 `类` 或 `结构体` 包装全局变量#

5. 常量引用 `const &`（防止修改）#

字符串，使用 `string` 类型📝#

🌟 `new` / `delete`（动态内存管理）#

🌟 `vector<int>` 替代动态数组（推荐）#

🌟 示例：修改 `vector`（必须加 `&`）#

`cin`读取单个单词#

输入一行字符串，查找 `"abc"` 是否存在#

1️⃣ `++it` vs. `it++` 的区别#

2️⃣ `++it` 更高效的原因#

🔹 模拟后置递增 (`it++`) 的实现#

🔹 模拟前置递增 (`++it`) 的实现#

🔹 示例：使用 `rbegin()` / `rend()` 逆序遍历字符串#

🚀 `reverse()` 方法详解#

📌 1. `reverse()` 的基本用法#

📌 2. `reverse()` 反转数组#

📌 3. `reverse()` 反转 `vector`#

📌 4. `reverse()` 反转 `string`#

📌 5. `reverse()` 反转部分元素#

📌 6. 使用 `reverse()` 结合 `rbegin()` 和 `rend()`#

📌 7. `reverse()` 与 `reverse_copy()` 的区别#

🔹 `reverse()`（原地反转）#

🔹 `reverse_copy()`（拷贝反转）#

方法 1：使用 `new` 时加 `()` 进行值初始化#

方法 2：使用 `std::fill` 填充 0#

方法 3：使用 `memset` 填充 0#

方法 4：改用 `std::vector`#