第一章节
\n
![\"1-1\"](\"1-1.png\")
![\"1-2\"](\"1-2.png\")
![\"1-3\"](\"1-3.png\")
![\"1-4\"](\"1-4.png\")
![\"1-5\"](\"1-5.png\")
![\"1-6\"](\"1-6.png\")
![\"1-7\"](\"1-7.png\")
![\"1-8\"](\"1-8.png\")
![\"1-9\"](\"1-9.png\")
![\"1-10\"](\"1-10.png\")
![\"1-11\"](\"1-11.png\")
![\"1-12\"](\"1-12.png\")
![\"1-13\"](\"1-13.png\")
![\"1-14\"](\"1-14.png\")
![\"1-15\"](\"1-15.png\")
该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自 ChaoCode 的视频课程，强烈推荐。
\n该系列适合有其他语言基础的人观看，基础语法部分描述较少，可能仅列出一些 Swift 的特异点。
\nSwift 语言是 Apple 平台的开发语言，面世时间很短，远远比不过老牌的编程，非常简洁也非常现代（当然也带来了诸如社区不完善、语法特性更新较快等一些缺点）。
\n本系列博客是奔着 SwiftUI 去的，基础语法大概过一下就会到 SwiftUI 部分，所以没有 C++ 等面对对象语言基础的不适合看本系列博客。
\n是的，没有 Mac 学习 Swift 寸步难行。你当然可以试着用网页 Swift 或者一些其他方案，但是非常难用，很劝退。用 iPad 上的 Swift PlayGrounds 再外接键盘要好一点，但是也有很多弊端，完全比不上 Mac 开发。
\nSwift 太年轻了，以至于你 “只能在英文社区找到的内容” 会比 C/Cpp 等多的多。很多时候你得读官方文档，纯英文的。
\n不过你可以借助 AI 来阅读，但是终究有点麻烦。因为有的时候你不仅仅是要查阅一条固定的信息，而是根据一些模糊的想法或需求去翻来翻去，在专业领域 AI 做这类工作并不可靠，经常出问题。
\n先看看你电脑的 Mac 型号和 OS 版本，比方说一台 18 年 MacBook Air，最高系统版本是 Sonoma 14.8.3，那么支持的 XCode 版本就是
\n", "tags": [ "计算机科学", "Swift笔记", "Swift" ] }, { "id": "https://www.starlinglin.top/computer-science/Swift-programme-note/%E6%A4%8B%E9%B8%9FSwift%E7%AC%94%E8%AE%B0%20%EF%BC%831%EF%BC%9A%E5%B8%B8%E9%87%8F%E5%8F%98%E9%87%8F%E5%92%8Cprint/", "url": "https://www.starlinglin.top/computer-science/Swift-programme-note/%E6%A4%8B%E9%B8%9FSwift%E7%AC%94%E8%AE%B0%20%EF%BC%831%EF%BC%9A%E5%B8%B8%E9%87%8F%E5%8F%98%E9%87%8F%E5%92%8Cprint/", "title": "椋鸟Swift笔记#1：常量变量和print", "date_published": "2025-12-18T09:06:49.974Z", "content_html": "该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自 ChaoCode 的视频课程，强烈推荐。
\n本文不提供任何解包修改工具，请自行 Github 寻找，与本文作者无关。
\n本文作者不支持任何形式的游戏倒卖。
\niOS 想玩 XP3 格式的游戏，自然绕不开应用市场中的 XP3Player 或者手动侧载 KrKr。但是无论是哪一个，在现在的 iOS 系统中都会出现奇怪的闪退问题（有反馈说更新到 iOS26 可能解决，但我不想更新系统）。
\n", "tags": [ "游戏", "旮旯", "game", "Gal" ] }, { "id": "https://www.starlinglin.top/%E5%85%B3%E4%BA%8E%E6%9C%AC%E5%8D%9A%E5%AE%A2%E6%97%A5%E5%90%8E%E6%9B%B4%E6%96%B0/", "url": "https://www.starlinglin.top/%E5%85%B3%E4%BA%8E%E6%9C%AC%E5%8D%9A%E5%AE%A2%E6%97%A5%E5%90%8E%E6%9B%B4%E6%96%B0/", "title": "关于本博客日后更新", "date_published": "2025-12-03T16:10:23.000Z", "content_html": "放置了一年多，差点忘了自己还有一个博客了。
\n日后会不定期更新一些内容，但是之前没做完的 cpp 笔记、Linux 笔记、数据结构笔记应该是不会继续更新了：一方面离我现在学到的内容太远；另一方面没有时间去长期频繁更新。
\n日后更新应该不会仅限于计算机相关，还有各种各样我喜欢的东西。
\n", "tags": [] }, { "id": "https://www.starlinglin.top/games/puzzles/%E8%A7%A3%E8%B0%9C%E6%B8%B8%E6%88%8F-RailBound%E8%BD%A8%E9%81%93%E8%81%94%E7%BB%93-%E6%94%BB%E7%95%A5/", "url": "https://www.starlinglin.top/games/puzzles/%E8%A7%A3%E8%B0%9C%E6%B8%B8%E6%88%8F-RailBound%E8%BD%A8%E9%81%93%E8%81%94%E7%BB%93-%E6%94%BB%E7%95%A5/", "title": "解谜游戏-RailBound轨道联结-攻略", "date_published": "2024-11-28T18:49:29.000Z", "content_html": "此游戏关卡随着版本变动，不能保证时效性。本人游戏版本为 v3.06。
\n很多题目存在多解，试试自己思考能不能写出不一样的答案。
\n这个游戏玩法新颖，245 个关卡层层推进，十分有意思。
\n
![\"1-11A\"](\"1-11A.png\")
![\"1-11B\"](\"1-11B.png\")
![\"1-12A\"](\"1-12A.png\")
![\"1-13A\"](\"1-13A.png\")
![\"1-14A\"](\"1-14A.png\")
![\"1-15A\"](\"1-15A.png\")
![\"2-1\"](\"2-1.png\")
![\"2-2\"](\"2-2.png\")
![\"2-3\"](\"2-3.png\")
![\"2-4\"](\"2-4.png\")
![\"2-5\"](\"2-5.png\")
![\"2-6\"](\"2-6.png\")
![\"2-7\"](\"2-7.png\")
![\"2-8\"](\"2-8.png\")
![\"2-9\"](\"2-9.png\")
![\"2-3A\"](\"2-3A.png\")
![\"2-3B\"](\"2-3B.png\")
![\"2-4A\"](\"2-4A.png\")
![\"2-5A\"](\"2-5A.png\")
![\"2-5B\"](\"2-5B.png\")
![\"2-6A\"](\"2-6A.png\")
![\"2-7A\"](\"2-7A.png\")
![\"2-7B\"](\"2-7B.png\")
![\"3-1\"](\"3-1.png\")
![\"3-2\"](\"3-2.png\")
![\"3-3\"](\"3-3.png\")
![\"3-4\"](\"3-4.png\")
![\"3-5\"](\"3-5.png\")
![\"3-6\"](\"3-6.png\")
![\"3-7\"](\"3-7.png\")
![\"3-8\"](\"3-8.png\")
![\"3-9\"](\"3-9.png\")
![\"3-10\"](\"3-10.png\")
![\"3-11\"](\"3-11.png\")
![\"3-3A\"](\"3-3A.png\")
![\"3-7A\"](\"3-7A.png\")
![\"3-8A\"](\"3-8A.png\")
![\"3-8B\"](\"3-8B.png\")
![\"3-10A\"](\"3-10A.png\")
![\"3-10B\"](\"3-10B.png\")
![\"3-10C\"](\"3-10C.png\")
![\"3-11A\"](\"3-11A.png\")
![\"3-11B\"](\"3-11B.png\")
![\"4-1\"](\"4-1.png\")
![\"4-2\"](\"4-2.png\")
![\"4-3\"](\"4-3.png\")
![\"4-4\"](\"4-4.png\")
![\"4-5\"](\"4-5.png\")
![\"4-6\"](\"4-6.png\")
![\"4-7\"](\"4-7.png\")
![\"4-8\"](\"4-8.png\")
![\"4-9\"](\"4-9.png\")
![\"4-3A\"](\"4-3A.png\")
![\"4-3B\"](\"4-3B.png\")
![\"4-4A\"](\"4-4A.png\")
![\"4-5A\"](\"4-5A.png\")
![\"4-6A\"](\"4-6A.png\")
![\"4-6B\"](\"4-6B.png\")
![\"4-6C\"](\"4-6C.png\")
![\"4-7A\"](\"4-7A.png\")
![\"4-7B\"](\"4-7B.png\")
![\"4-8A\"](\"4-8A.png\")
![\"4-8B\"](\"4-8B.png\")
![\"4-9A\"](\"4-9A.png\")
![\"4-9B\"](\"4-9B.png\")
![\"5-1\"](\"5-1.png\")
![\"5-2\"](\"5-2.png\")
![\"5-3\"](\"5-3.png\")
![\"5-4\"](\"5-4.png\")
![\"5-5\"](\"5-5.png\")
![\"5-6\"](\"5-6.png\")
![\"5-7\"](\"5-7.png\")
![\"5-8\"](\"5-8.png\")
![\"5-3A\"](\"5-3A.png\")
![\"5-3B\"](\"5-3B.png\")
![\"5-4A\"](\"5-4A.png\")
![\"5-4B\"](\"5-4B.png\")
![\"5-4C\"](\"5-4C.png\")
![\"5-5A\"](\"5-5A.png\")
![\"5-5B\"](\"5-5B.png\")
![\"5-6A\"](\"5-6A.png\")
![\"5-6B\"](\"5-6B.png\")
![\"5-7A\"](\"5-7A.png\")
![\"5-8A\"](\"5-8A.png\")
![\"6-1\"](\"6-1.png\")
![\"6-2\"](\"6-2.png\")
![\"6-3\"](\"6-3.png\")
![\"6-4\"](\"6-4.png\")
![\"6-5\"](\"6-5.png\")
![\"6-6\"](\"6-6.png\")
![\"6-7\"](\"6-7.png\")
![\"6-8\"](\"6-8.png\")
![\"6-9\"](\"6-9.png\")
![\"6-10\"](\"6-10.png\")
![\"6-2A\"](\"6-2A.png\")
![\"6-3A\"](\"6-3A.png\")
![\"6-3B\"](\"6-3B.png\")
![\"6-4A\"](\"6-4A.png\")
![\"6-4B\"](\"6-4B.png\")
![\"6-4C\"](\"6-4C.png\")
![\"6-5A\"](\"6-5A.png\")
![\"6-6A\"](\"6-6A.png\")
![\"6-7A\"](\"6-7A.png\")
![\"6-8A\"](\"6-8A.png\")
![\"6-8B\"](\"6-8B.png\")
![\"6-9A\"](\"6-9A.png\")
![\"6-9B\"](\"6-9B.png\")
![\"6-9C\"](\"6-9C.png\")
![\"6-9D\"](\"6-9D.png\")
![\"6-10A\"](\"6-10A.png\")
![\"7-1\"](\"7-1.png\")
![\"7-2\"](\"7-2.png\")
![\"7-3\"](\"7-3.png\")
![\"7-4\"](\"7-4.png\")
![\"7-5\"](\"7-5.png\")
![\"7-6\"](\"7-6.png\")
![\"7-7\"](\"7-7.png\")
![\"7-8\"](\"7-8.png\")
![\"7-9\"](\"7-9.png\")
![\"7-3A\"](\"7-3A.png\")
![\"7-3B\"](\"7-3B.png\")
![\"7-4A\"](\"7-4A.png\")
![\"7-4B\"](\"7-4B.png\")
![\"7-5A\"](\"7-5A.png\")
![\"7-6A\"](\"7-6A.png\")
![\"7-7A\"](\"7-7A.png\")
![\"7-7B\"](\"7-7B.png\")
![\"7-7C\"](\"7-7C.png\")
![\"8-1\"](\"8-1.png\")
![\"8-2\"](\"8-2.png\")
![\"8-3\"](\"8-3.png\")
![\"8-4\"](\"8-4.png\")
![\"8-5\"](\"8-5.png\")
![\"8-6\"](\"8-6.png\")
![\"8-7\"](\"8-7.png\")
![\"8-8\"](\"8-8.png\")
![\"8-1A\"](\"8-1A.png\")
![\"8-2A\"](\"8-2A.png\")
![\"8-2B\"](\"8-2B.png\")
![\"8-3A\"](\"8-3A.png\")
![\"8-4A\"](\"8-4A.png\")
![\"8-4B\"](\"8-4B.png\")
![\"8-5A\"](\"8-5A.png\")
![\"8-5B\"](\"8-5B.png\")
![\"8-6A\"](\"8-6A.png\")
![\"8-7A\"](\"8-7A.png\")
![\"8-8A\"](\"8-8A.png\")
![\"9-1\"](\"9-1.png\")
![\"9-2\"](\"9-2.png\")
![\"9-3\"](\"9-3.png\")
![\"9-4\"](\"9-4.png\")
![\"9-5\"](\"9-5.png\")
![\"9-6\"](\"9-6.png\")
![\"9-7\"](\"9-7.png\")
![\"9-8\"](\"9-8.png\")
![\"9-9\"](\"9-9.png\")
![\"9-10\"](\"9-10.png\")
![\"9-11\"](\"9-11.png\")
![\"9-2A\"](\"9-2A.png\")
![\"9-3A\"](\"9-3A.png\")
![\"9-8A\"](\"9-8A.png\")
![\"9-9A\"](\"9-9A.png\")
![\"9-10A\"](\"9-10A.png\")
![\"9-10B\"](\"9-10B.png\")
![\"9-11A\"](\"9-11A.png\")
![\"9-11B\"](\"9-11B.png\")
![\"10-1\"](\"10-1.png\")
![\"10-2\"](\"10-2.png\")
![\"10-3\"](\"10-3.png\")
![\"10-4\"](\"10-4.png\")
![\"10-5\"](\"10-5.png\")
![\"10-6\"](\"10-6.png\")
![\"10-7\"](\"10-7.png\")
![\"10-8\"](\"10-8.png\")
![\"10-1A\"](\"10-1A.png\")
![\"10-2A\"](\"10-2A.png\")
![\"10-2B\"](\"10-2B.png\")
![\"10-5A\"](\"10-5A.png\")
![\"10-6A\"](\"10-6A.png\")
![\"11-1\"](\"11-1.png\")
![\"11-2\"](\"11-2.png\")
![\"11-3\"](\"11-3.png\")
![\"11-4\"](\"11-4.png\")
![\"11-5\"](\"11-5.png\")
![\"11-6\"](\"11-6.png\")
![\"11-7\"](\"11-7.png\")
![\"11-8\"](\"11-8.png\")
![\"11-9\"](\"11-9.png\")
![\"11-10\"](\"11-10.png\")
![\"11-2A\"](\"11-2A.png\")
![\"11-2B\"](\"11-2B.png\")
![\"11-6A\"](\"11-6A.png\")
![\"11-7A\"](\"11-7A.png\")
![\"11-8A\"](\"11-8A.png\")
![\"11-8B\"](\"11-8B.png\")
![\"11-9A\"](\"11-9A.png\")
![\"11-9B\"](\"11-9B.png\")
![\"12-1\"](\"12-1.png\")
![\"12-2\"](\"12-2.png\")
![\"12-3\"](\"12-3.png\")
![\"12-4\"](\"12-4.png\")
![\"12-5\"](\"12-5.png\")
![\"12-6\"](\"12-6.png\")
![\"12-7\"](\"12-7.png\")
![\"12-8\"](\"12-8.png\")
![\"12-9\"](\"12-9.png\")
![\"12-10\"](\"12-10.png\")
![\"12-1A\"](\"12-1A.png\")
![\"12-1B\"](\"12-1B.png\")
![\"12-3A\"](\"12-3A.png\")
![\"12-4A\"](\"12-4A.png\")
![\"12-5A\"](\"12-5A.png\")
![\"12-5B\"](\"12-5B.png\")
![\"12-6A\"](\"12-6A.png\")
![\"12-6B\"](\"12-6B.png\")
![\"12-7A\"](\"12-7A.png\")
![\"12-8A\"](\"12-8A.png\")
![\"12-8B\"](\"12-8B.png\")
这个章节余量轨道相当多，可以说是随便摆。
\n![\"#-1\"](\"#-1.png\")
![\"#-2\"](\"#-2.png\")
![\"#-3\"](\"#-3.png\")
![\"#-4\"](\"#-4.png\")
![\"#-5\"](\"#-5.png\")
![\"#-6\"](\"#-6.png\")
![\"#-7\"](\"#-7.png\")
![\"#-8\"](\"#-8.png\")
![\"#-9\"](\"#-9.png\")
![\"#-10\"](\"#-10.png\")
![\"#-11\"](\"#-11.png\")
![\"#-12\"](\"#-12.png\")
我们回到目录画面，然后在左边看到这样一个施工图标。（其实是 credit）
\n![\"menu\"](\"menu.png\")
点进去之后拖到最底下，这里我们看到最后一个隐藏关卡 “❤️”。
\n![\"egg\"](\"egg.png\")
这一关解法如下：
\n![\"egg-ans\"](\"egg-ans.png\")
转载自《数据结构》（第三版）- 刘大有、杨博等。
\n用算法描述语言 ADL 书写算法的格式及规定如下：
\n算法<算法名>(变量i1,···,变量in.变量j,···,变量jn)\n// <算法的概括说明>或者/*<算法的概括说明>*/\n<步骤名>.[<本步骤的概括说明>]\n\t<操作1> //<操作1的解释>或者/*<操作1的解释>*/\n\t\t或者(操作1的解释)或者<无解释>\n\t···\n\t<操作J1> //<操作J1的解释>或者/*<操作J1的解释>*/\n\t\t或者(操作J1的解释)或者<无解释>\n···\n<步骤名>.[<本步骤的概括说明>]\n\t<操作1> //<操作1的解释>或者/*<操作1的解释>*/\n\t\t或者(操作1的解释)或者<无解释>\n\t···\n\t<操作Jk> //<操作Jk的解释>或者/*<操作Jk的解释>*/\n\t\t或者(操作Jk的解释)或者<无解释>|\n下面是对上述书写格式给出具体解释：
\n关于 “<算法名>(变量 i1,・・・, 变量 in. 变量 j,・・・, 变量 jn)” 的解释
\n <算法名>是由字母和数字组成的有限字符串，并且字符串中的第一个符号必须是字母。\n 在变量表中，变量ik为输入变量.1≤k≤m,m≥0,当m=O时.表示无输入变量;变量jk为输出变量，1≤k≤n,n≥1。\n关于 <算法的概括说明> 的解释
\n 在算法的变量表后对整个算法进行概括说明，说明中应包含算法的主要思想,对算法功能和其变量的解释等。\n 说明较短时使用//，较长时使用/**/\n关于算法步骤的解释
\n 算法的每一步骤都要有步骤名，步骤名由<算法名或算法名缩写><数字>组成。\n 步骤名后面的方括号内是对该步骤所执行操作的高度概括。\n 方括号后是本步骤的一系列操作，每个操作由ADL语句给出,若某操作难于理解则需在其后对其做出解释。\n关于符号 “|” 的解释
\n 每个算法都需要用符号“|”表示其被书写完毕，也就是说，符号“|”作为对应算法被书写完毕的结束符。\n 注意算法不一定在符号“|”处运行结束。\n可使用的算术运算符
\n +、-、*、x、/、DIV、MOD、⌊⌋(取地板运算,如⌊x⌋的值是小于等于x的最大整数)、\n ⌈⌉(取天棚运算，如⌈x⌉的值是大于等于x的最小整数）.....\n可用的关系、逻辑运算符、逻辑常量、集合运算符
\n关系运算符(＝、≠、＜、＞、≥、≤ ...)\n逻辑运算符(AND、OR、NOT)\n逻排常量(true、false)\n集合运算符(∩、∪、-(差)...)\n结束符
\n 通常每条语句(或每个操作)都用".”作为结束符。\n 但在能判断语句结束的位置可略去“.”。\n关于注释语句
\n注释语句有以下3种形式:\n 1.较短的注释语句(注释内容不超过一行)用符号“//”开头,后面是具体注释的内容。\n 2.较长的注释语句用符号“/*”开头,中间是具体注释的内容,用符号“*/”结尾。\n 3.注释语句用左小括号“("开头，中间是具体的注释或说明内容，用右小括号“)”结尾。\n关于赋值语句
\n 形如a←b,其中a是变量,b是表达式或变量;\n a↔b表示交换变量a和变量b的内容;\n a←b←c,表示既将c的值赋给变量a,又将其值赋给变量b。\n关于条件语句
\n1.IF(或如果,或若)<逻辑表达式> THEN(或“，则”)(语句...语句m).\n2.IF(或如果,或若)<逻辑表达式>\n\tTHEN(或“，则")(语句...语句m).\n\tELSE(或“;否则”)(语句...语句n).\n其中m,n≥1。\n3.CASE DO\n\t\t(<逻辑表达式 1>:(语句1...语句n).\n\t\t ···\n\t\t<逻辑表达式m>:(语句...语句nm )).\n其中,n≥1,m≥1,1≤i≤m。\n关于循环语句
\n\t1.WHILE<逻辑表达式>DO(语句1. ..语句n).\n其中，n≥1。\n\t2.FOR<变量>=<算术表达式1> T0<算术表达式2>STEP<算术表达式3>\n\t\t\t\tDO(语句1. ... 语句n).\n其中,n≥1。若<算术表达式3>=1,则“STEP<算术表达式3>"可略去。\n\t3.FOR V<变量>∈<集合> DO (语句...语句n).路\n其中,n≥1。\n关于转移语句
\nGOTO <步骤名>.\n关于 EXIT 语句
\n 可用在通常的结束条件满足之前，用来结束WHILE或FOR循环的执行。\n EXIT语句使得程序转移到紧接在包含EXIT的(最内层的)WHILE或者FOR循环后面的第一个语句。\n关于圆括号
\n当且仅当圆括号中只有1条语句时，圆括号可以省略。\n关于输入、输出语句
\n输人语句为\n\tREAD(x)\n表示读取输人值赋给变量x。\n输出语句为\n\tPRINT(<表达式>)\n或\n\tPRINT<字符串常量>\n本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n标准模板库 STL，是 C++ 标准库的一个非常重要的组成成分。它的作用就类似于一个工具箱，里面有很多现成的模板 “工具”，帮助我们更方便的处理数据。
\nSTL 最早是由 Alexander Stepanov 和 Meng Lee 在惠普实验室开发出来的，是完全开源的，这个原始版本也是现在所有 STL 的始祖。
\n这个版本是 P.J. Plauger 开发的，不允许公开及修改。这个版本是 STL 最早期的版本之一，代码可读性差而且符号命名比较奇怪。但是 Windows Visual C++ 采用的是这个版本。
\n这个由 Rogue Wave 公司开发的版本，不允许公开及修改。这个版本着重于与商业环境的集成，通常用于大型企业级项目中。功能非常丰富且跨平台支持性极好。
\nSGI 版本由 Silicon Graphics 公司开发，这个版本是标准 C++STL 的基础，也是使用最多的 STL 版本。这个版本是开源的，其设计高效而且稳定，代码风格优秀命名合理。是适合初学者的版本。
\n本系列暴死，不会更新了。
\n本篇尚未完工
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n在学 C 语言的时候，我们使用过字符串，当时字符串是以 '\\0' 结尾的字符的集合。同时，C 语言标准库里还提供了一些 str 函数用于处理字符串。但是这种字符串的使用有很大的缺陷：
\n\n\nC++ 中的
\nstd::string类是标准库中用于处理字符串的类。它提供了一种高效、灵活且安全的方式来操作字符序列，替代了 C 语言中基于char*的字符串。std::string自动管理内存，支持动态扩展，避免了手动内存分配的复杂性。它提供了丰富的成员函数和操作符重载，如拼接、查找、截取、比较等操作，极大简化了字符串的处理。此外，std::string还兼容 STL 的容器风格，支持迭代器和各种算法。
首先，我们要知道 string 并不属于严格意义上的 STL。在早期的 C++ 标准化过程中，string 类是 C++ 标准库中一个独立设计的类，设计初衷是提供比 C 语言中的 char* 更强大、灵活的字符串操作能力。STL 和 string 的发展是同时的，因此 STL 中并没有单独做一个 string，但是 STL 比 string 更早被标准化并引入 C++ 标准。
C++ 中的 string 本质上是基于类模板的。虽然我们通常使用 string，但它实际上是 basic_string 类模板的一个特例化版本（ std::basic_string<char> ）。采用类模板主要是因为字符是有很多类型的，常见的是 ASCII 字符（char），但是还有宽字符（wchar_t）、Unicode 字符（char16_t、char32_t）等其他字符需要支持。
迭代器是 C++ 标准库中用于遍历容器（如数组、向量、链表、字符串等）元素的对象。能够访问容器中的元素，同时还提供了灵活的接口来进行容器的遍历和操作。
\niterator 大概可以理解为一个作为容器（这里是 string）内部类的类似指针的东西。注意，不一定是指针，在不同编译器的实现下可能不同，而且部分容器无法用指针的方式作为迭代器。比方说，我使用 typeid 打印 string::iterator 的类型，得到的结果是：
\nclass std::_String_iterator<class std::_String_val<struct std::_Simple_types<char> > >
这里 iterator 显然是一个类，而不是单纯的指针。
\n这里演示一下 string 的迭代器的简单使用，其中涉及的部分接口将在下文介绍。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
string str = \"Hello\"; | |
//iterator 正向遍历 | |
for (string::iterator it = str.begin(); it != str.end(); ++it) | |
{ | |
cout << *it << ' '; // 输出: H e l l o | |
} | |
cout << endl; | |
// 使用 const_iterator 只读遍历 | |
for (string::const_iterator cit = str.cbegin(); cit != str.cend(); ++cit) | |
{ | |
cout << *cit << ' '; // 输出: H e l l o | |
} | |
cout << endl; | |
// 使用 reverse_iterator 反向遍历 | |
for (string::reverse_iterator rit = str.rbegin(); rit != str.rend(); ++rit) | |
{ | |
cout << *rit << ' '; // 输出: o l l e H | |
} | |
cout << endl; | |
return 0; | |
} |
| 构造 | \n解释 | \n
|---|---|
| string(); | \n构造一个长度为 0 的空字符串。 | \n
| string (const string& str); | \n拷贝构造一个字符串。 | \n
| string (const string& str, size_t pos, size_t len = npos); | \n从一个已有字符串的 pos 位置开始，选取长度为 len 的子字符序列来构造一个字符串。(npos 默认为 - 1，在 size_t 中即为 4294967295，也就是说如果省略第三个参数就是往后有多少拷多少) | \n
| string (const char* s); | \nC 语言字符串转为 string。 | \n
| string (const char* s, size_t n); | \n从字符数组 s 中选前 n 个字符构造字符串。 | \n
| string (size_t n, char c); | \n构造一个长度为 n，每一个字符都是 c 的字符串。 | \n
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring s1 = \"Hello world!\"; | |
\tstring s2(s1); | |
\tstring s3(s1, 5, 5); | |
\tstring s4(\"Hello world!\"); | |
\tstring s5(\"Hello world!\", 5); | |
\tstring s6(10, 'x'); | |
\treturn 0; | |
} |
size_t size() const;
size_t length() const;
size 和 length 两个函数的作用和原理完全相同，size 用的更多。
\nsize 函数是为了与 STL 标准容器的接口保持一致而产生的，也更符合容器的抽象概念。但是 length 这个更符合自然语言的接口也被保留下来了，为了兼容性。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring s(\"Hello, World!\"); | |
\tcout << s.size() << endl; | |
\tcout << s.length() << endl; | |
\treturn 0; | |
} |
size_t capacity() const;
capacity 函数返回字符串的容量。
\n注意：string 会默认为字符串预先分配一段最小的初始容量，这个容量可以根据编译器实现不同而有所不同。而当容量超出先前的容量时，就会以顺序表的方式进行容量扩展，而不是精准到每一个字节扩展。（可见数据结构笔记 #1）
\n比方说下面的程序在我的环境下运行输出为：15、15、15、31。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring str1; | |
\tcout << str1.capacity() << endl; | |
\tstring str2 = \"Hello, World!\"; | |
\tcout << str2.capacity() << endl; | |
\tstring str3 = \"123456789012345\"; | |
\tcout << str3.capacity() << endl; | |
\tstring str4 = \"1234567890123456\"; | |
\tcout << str4.capacity() << endl; | |
\treturn 0; | |
} |
bool enpty() const;
检测字符串是否为空串，如果是返回 true，如果否返回 false。
\n#include <iostream> | |
using namespace std; | |
int main() | |
{ | |
\tstring s1 = \"a\"; | |
\tcout << s1.empty() << endl;\t//0 | |
\tstring s2 = \"\"; | |
\tcout << s2.empty() << endl;\t//1 | |
\tstring s3; | |
\tcout << s3.empty() << endl;\t//1 | |
\treturn 0; | |
} |
void clear();
clear 函数将 string 中的有效字符清空，但是不会改变底层空间的大小。
\n#include <iostream> | |
using namespace std; | |
int main() | |
{ | |
\tstring s = \"a\"; | |
\tcout << s.size() << endl;\t//1 | |
\tcout << s.capacity() << endl;\t//15 | |
\ts.clear(); | |
\tcout << s.size() << endl;\t//0 | |
\tcout << s.capacity() << endl;\t//15 | |
\tcout << s << endl; | |
} |
void reserve(size_t n=0);
reserve 函数为字符串预留空间，但是不改变有效元素个数。也就是说，reserve 会改变 capacity，但是不会影响 size。另外，reserve 的参数小于 string 底层空间总大小时，不会进行改变。
\n注意，reserve 并不是将 capacity 改成其参数 n 的大小。而是继续以顺序表扩容的方式增大其容量以至于足以容纳这么多空间。比方说：
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring s(\"Hello world!\"); | |
\tcout << s.capacity() << endl; | |
\ts.reserve(5); | |
\tcout << s.capacity() << endl; | |
\ts.reserve(111); | |
\tcout << s.capacity() << endl; | |
\ts.reserve(112); | |
\tcout << s.capacity() << endl; | |
\treturn 0; | |
} |
该程序在我的环境下的输出为：
\n15 | |
15 | |
111 | |
166 |
void resize (size_t n); | |
void resize (size_t n, char c); |
resize 函数用于改变字符串的有效内容的大小。
\n\\0 来填充。#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring s = \"Hello\"; | |
\tcout << \"s = \" << s << endl; | |
\tcout << \"s.size() = \" << s.size() << endl; | |
\ts.resize(4); | |
\tcout << \"s = \" << s << endl; | |
\tcout << \"s.size() = \" << s.size() << endl; | |
\ts.resize(6, '!'); | |
\tcout << \"s = \" << s << endl; | |
\tcout << \"s.size() = \" << s.size() << endl; | |
\ts.resize(10); | |
\tcout << \"s = \" << s << endl; | |
\tcout << \"s.size() = \" << s.size() << endl; | |
\ts.resize(12, '?'); | |
\tcout << \"s = \" << s << endl; | |
\tcout << \"s.size() = \" << s.size() << endl; | |
\treturn 0; | |
} |
上述程序输出为：
\ns = Hello | |
s.size() = 5 | |
s = Hell | |
s.size() = 4 | |
s = Hell!! | |
s.size() = 6 | |
s = Hell!! | |
s.size() = 10 | |
s = Hell!!?? | |
s.size() = 12 |
注意，这里 !! 和 ?? 之间是存在 4 个 \\0 的，只是不会被打印出来。但实际上我们检视内存就能看到：
![\"内存\"](\"1.png\")
char& operator[] (size_t pos);const char& operator[] (size_t pos) const;与数组的访问操作符类似，返回 pos 位置的字符。如果 pos 等于字符串的有效字符数，也能返回对一个 \\0 的引用。
#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring str = \"Hello\"; | |
\tfor (int i = 0; i < str.size(); i++) | |
\t{ | |
\t\tcout << str[i] << endl; | |
\t} | |
\tstr[0] = 'h'; | |
\tfor (int i = 0; i < str.size(); i++) | |
\t{ | |
\t\tcout << str[i] << endl; | |
\t} | |
\treturn 0; | |
} |
iterator begin();
iterator end();
begin 和 end 函数返回指向字符串起始位置和结束位置下一位置的迭代器。cbegin 和 cend 返回的则是常迭代器，rbegin 和 rend 返回反向迭代器，crbegin 和 crend 自然就是反向常迭代器。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
string str = \"Hello\"; | |
//iterator 正向遍历 | |
for (string::iterator it = str.begin(); it != str.end(); ++it) | |
{ | |
cout << *it << ' '; // 输出: H e l l o | |
} | |
cout << endl; | |
// 使用 const_iterator 只读遍历 | |
for (string::const_iterator cit = str.cbegin(); cit != str.cend(); ++cit) | |
{ | |
cout << *cit << ' '; // 输出: H e l l o | |
} | |
cout << endl; | |
// 使用 reverse_iterator 反向遍历 | |
for (string::reverse_iterator rit = str.rbegin(); rit != str.rend(); ++rit) | |
{ | |
cout << *rit << ' '; // 输出: o l l e H | |
} | |
cout << endl; | |
return 0; | |
} |
C++11 支持的范围 for 也可以用来遍历 string 类对象。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring str = \"Hello, World!\"; | |
\tfor (auto& c : str) | |
\t{ | |
\t\tcout << c << endl; | |
\t} | |
\treturn 0; | |
} |
void push_back (char c);
push_back 在字符串后尾插字符 c。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring str = \"Hello\"; | |
\tcout << \"str: \" << str << endl; | |
\tstr.push_back(' '); | |
\tcout << \"str: \" << str << endl; | |
\tstr.push_back('W'); | |
\tcout << \"str: \" << str << endl; | |
\tstr.push_back('o'); | |
\tcout << \"str: \" << str << endl; | |
\tstr.push_back('r'); | |
\tcout << \"str: \" << str << endl; | |
\tstr.push_back('l'); | |
\tcout << \"str: \" << str << endl; | |
\tstr.push_back('d'); | |
\tcout << \"str: \" << str << endl; | |
\treturn 0; | |
} |
string& append (const string& str); | |
string& append (const string& str, size_t subpos, size_t sublen = npos); | |
string& append (const char* s); | |
string& append (const char* s, size_t n); | |
string& append (size_t n, char c); |
append 用于在字符串后追加一个字符串，有很多重构形式。比方说上面列出的几个（还有更多）。
\n它们的用法看参数名就能理解，下面直接演示一下：
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring s = \"append:\"; | |
\tstring t = \"uvwxyz\"; | |
\ts.append(t);\t\t// 将字符串 t 的内容追加到字符串 s 的末尾 | |
\tcout << s << endl;\t// append:uvwxyz | |
\ts.append(t, 2, 3);\t// 将字符串 t 的子串（从 t [2] 开始数 3 位）追加到字符串 s 的末尾 | |
\tcout << s << endl;\t// append:uvwxyzwxy | |
\ts.append(\"123\");\t// 将字符串 \"123\" 追加到字符串 s 的末尾 | |
\tcout << s << endl;\t// append:uvwxyzwxy123 | |
\ts.append(\"456\", 2);\t// 将字符串 \"456\" 的前 2 个字符追加到字符串 s 的末尾 | |
\tcout << s << endl;\t// append:uvwxyzwxy12345 | |
\ts.append(3, 'x');\t// 将字符 'x' 追加到字符串 s 的末尾 3 次 | |
\tcout << s << endl;\t// append:uvwxyzwxy12345xxx | |
\treturn 0; | |
} |
string& operator+= (const string& str); | |
string& operator+= (const char* s); | |
string& operator+= (char c); |
同样是在字符串后追加一个字符串 str。
\n#include <iostream> | |
#include <string> | |
using namespace std; | |
int main() | |
{ | |
\tstring s = \"append:\"; | |
\tcout << (s += \"abc\") << endl;\t// append:abc | |
\tcout << (s += s) << endl;\t\t// append:abcappend:abc | |
\tcout << (s += '.') << endl;\t\t// append:abcappend:abc. | |
\treturn 0; | |
} |
const char* c_str() const noexcept;
c_str 函数将 C++ 字符串转换为 C 字符串。使用简单无需示例。
\n我们在看别人写的代码时，会发现每个人都有自己的代码风格，这可能体现在注释的习惯上、命名的方法上、变量的使用上。而关于代码中的花括号，我们发现，主流只有两种对齐方法。
\n一种是将花括号头直接与相应的语句放在同一行，这种被称之为 K&R 风格：
\nvoid f() { | |
if (...) { | |
//... | |
} | |
//... | |
} |
另一种是将花括号头放在单独的一行，并且与花括号尾对齐，这种被称之为 Allman 风格：
\nvoid f() | |
{ | |
if (...) | |
{ | |
//... | |
} | |
//... | |
} |
K&R 风格来源于 C 语言的创建者 Brian Kernighan 和 Dennis Ritchie。他们在《The C Programming Language》一书中广泛使用了这种风格，因此成为了现在很多 C 和 C++ 开发者的默认选择。
\n使用 K&R 风格能够节省垂直空间，使代码更加紧凑，减少了滚动浏览页面的频率。
\nAllman 风格来源于 Eric Allman，他是 BSD UNIX 的开发者之一。这种风格是他在早期 Unix 系统代码中推广的。这种风格增强了代码的可读性，尤其是在大段代码中，每一个代码块的位置都很清晰。更容易在视觉上区分代码块的开始和结束，减少嵌套结构不清晰而导致的错误。同时有助于调试代码时快速的定位问题所属代码块。
\n这两种风格都有很多使用者，具体选择哪种更多是个人习惯或者团队规范的结果。一般来说如果更注重代码的可读性，尤其是经常处理长代码段时，Allman 风格会更合适。但是如果没有团队的强制要求，最好还是选择自己觉得最舒服的风格。
\n", "tags": [ "计算机科学", "杂项", "代码风格" ] }, { "id": "https://www.starlinglin.top/computer-science/Cpp-programme-note/%E6%A4%8B%E9%B8%9FC++%E7%AC%94%E8%AE%B0%20%EF%BC%836%EF%BC%9A%E6%A8%A1%E6%9D%BF%E7%9A%84%E5%9F%BA%E7%A1%80%E7%94%A8%E6%B3%95/", "url": "https://www.starlinglin.top/computer-science/Cpp-programme-note/%E6%A4%8B%E9%B8%9FC++%E7%AC%94%E8%AE%B0%20%EF%BC%836%EF%BC%9A%E6%A8%A1%E6%9D%BF%E7%9A%84%E5%9F%BA%E7%A1%80%E7%94%A8%E6%B3%95/", "title": "椋鸟C++笔记#6：模板的基础用法", "date_published": "2024-08-23T14:10:19.000Z", "content_html": "本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n在 C 语言笔记 #22 中，我们提到了泛式编程可以减少对特定数据类型的依赖，并且使用泛型指针 void* 在 C 语言中实现了一个 “万能” 的冒泡排序。而在 C++ 中，泛式编程更加容易，因为 C++ 提供了模版这么一个概念。
一个函数模板就代表了一个函数家族，函数模板与类型无关，只在使用时才被参数化，根据参数的类型来产生函数的特定版本。
\n如果我们想在函数中使用未定的类型，我们只要在函数的声明和定义前各加上一行 template 语句。
\ntemplate 语句的格式为：
\ntemplate <typename T1, typename T2, ..., typename Tn> | |
// 下面直接接模版函数的本体即可，本体中就可以利用我们设置的模版类型 T1,T2…… | |
// 这里 typename 也可以替换为 class，但是这样不符合自然语言逻辑： | |
template <class T1, class T2, ..., class Tn> |
比方说如果我们想写一个任意类型的加法函数，只需要这样：
\ntemplate <typename T> | |
T add(T a, T b) | |
{ | |
return a + b; | |
} |
但是这里要求参数 a 和参数 b 是同一个类型的变量，如果我们的函数涉及到多个互不关联的未定的类型，就需要在 template 的形参列表中加上一些东西，比方说写一个比较两个类型变量的内存大小的函数：
\ntemplate <typename T1, typename T2> | |
bool TypeSizeBigger(T1 x, T2 y) | |
{ | |
return (sizeof(x) > sizeof(y)) ? true : false; | |
} |
在编译阶段，编译器根据传入模板的实参类型来推演生成对应类型的函数以供调用。
\n比方说对于上面的 add 函数在程序中实际有三种类型传入进来调用。那么编译器实际上在编译时就根据模板生成了三个仅类型不同的函数，每一个用于处理不同的类型的调用。用不同类型的参数使用函数模板是，也称为函数模板的实例化。
\n实例化分为隐式实例化和显示实例化：
\n隐式实例化就是让编译器根据实参自己推演模板参数的实际类型。
\ntemplate <typename T> | |
T Add(const T& a, const T& b) | |
{ | |
return a + b; | |
} | |
int main() | |
{ | |
int a = 5, b = 6; | |
double c = 7.1, d = 8.2; | |
Add(a, b); | |
Add(c, d); | |
return 0; | |
} |
显式实例化就是在调用时于函数名后加一个 <> 来指定模板参数的实际类型：
template <typename T> | |
T Add(const T& a, const T& b) | |
{ | |
return a + b; | |
} | |
int main() | |
{ | |
int a = 5, b = 6; | |
double c = 7.1, d = 8.2; | |
Add<int>(a, b); | |
Add<double>(c, d); | |
return 0; | |
} |
如果类型不匹配，编译器将会尝试进行隐式类型转换，如果无法转换成功就会报错。
\n可以有非模板函数与模板函数同名，而且该函数模板还可以被实例化为这个非模板函数。
\n// 专门处理 int 类型 | |
int f(int a, int b) | |
{ | |
return a + b + 1; | |
} | |
template <typename T> | |
T f(T a, T b) | |
{ | |
return a + b; | |
} | |
int main() | |
{ | |
\tcout << f(1, 2) << endl; | |
\tcout << f<int>(1, 2) << endl; | |
\t | |
\treturn 0; | |
} |
此时这个函数输出是先 4 后 3，为什么呢？因为在能够与非模板函数匹配时，编译器不会再特化生成一个对应的函数，而是直接调用。而在指定模板实例化时，编译器依旧会按照模板生成并调用。
\n注意这里并不会冲突报错，哪怕这非模板函数和生成的函数的函数名（包括返回值与参数列表）都一样。因为在编译过程中，函数的名称会经过修饰以确保函数的唯一性。虽然模板函数和普通函数在表面上看起来参数和返回类型相同，但由于模板的存在，编译器在生成模板函数时会应用不同的名称修饰规则。
\n在 linux gcc 环境下，我们测试到非模板函数 f 的原型和修饰后的函数符号如下：
\nint f(int a, int b) | |
_Z1fii |
其中 _Z 代表这是经过修饰的 C++ 符号， 1f 代表名字长度为 1 且名字为 f， ii 代表参数类型为 int, int 。
而模板生成函数的原型与函数符号为：
\ntemplate <typename T> | |
T f<int>(T a, T b) | |
_Z1fIiEii |
其中 _Z 代表这是经过修饰的 C++ 符号， 1f 代表名字长度为 1 且名字为 f， IiE 代表这是一个模板实例化，其中 i 代表模板参数类型为 int，最后的 ii 代表参数类型为 int, int 。
如果模板能够匹配产生一个更好的函数，则优先调用模板。
\n// 专门处理 int 类型 | |
int f(int a, int b) | |
{ | |
return a + b + 1; | |
} | |
template <typename T1, typename T2> | |
T1 f(T1 a, T2 b) | |
{ | |
return a + b; | |
} | |
int main() | |
{ | |
\tcout << f(1.0, 2) << endl; | |
\t | |
\treturn 0; | |
} |
此时优先调用的是模板生成的函数。
\n注意：模板函数不允许自动类型转换，但是普通函数可以自动类型转换。
\n与模板函数类似，我们可以定义模板类。模板类前同样需要 template 语句：
\ntemplate <class T1, class T2, ..., class Tn> | |
// 下面直接接模板类即可 |
比方说写一个动态顺序表模板类：
\ntemplate <class T> | |
class SeqList | |
{ | |
public: | |
\tSeqList(size_t capacity = 10) | |
\t\t: m_data(new T[capacity]) | |
\t\t, m_capacity(capacity) | |
\t\t, m_size(0) | |
\t{} | |
\t~SeqList() | |
\t{ | |
\t\tif (m_data) | |
\t\t\tdelete[] m_data; | |
\t\tm_size = m_capacity = 0; | |
\t} | |
\tvoid push_back(const T& value) | |
\t{ | |
\t\tif (m_size == m_capacity) | |
\t\t{ | |
\t\t\tsize_t new_capacity = m_capacity * 2; | |
\t\t\tT* new_data = new T[new_capacity]; | |
\t\t\tfor (size_t i = 0; i < m_size; ++i) | |
\t\t\t\tnew_data[i] = m_data[i]; | |
\t\t\tdelete[] m_data; | |
\t\t\tm_data = new_data; | |
\t\t\tm_capacity = new_capacity; | |
\t\t} | |
\t\tm_data[m_size++] = value; | |
\t} | |
\tvoid pop_back() | |
\t{ | |
\t\tif (m_size > 0) | |
\t\t\t--m_size; | |
\t} | |
\tsize_t size() const | |
\t{ | |
\t\treturn m_size; | |
\t} | |
\tT& operator[](size_t index) | |
\t{ | |
\t\tif (index >= m_size) | |
\t\t\tthrow out_of_range(\"Index out of range\"); | |
\t\treturn m_data[index]; | |
\t} | |
private: | |
\tT* m_data; | |
\tsize_t m_capacity; | |
\tsize_t m_size; | |
}; |
如果想要类模板声明与定义分离，我们以上面的动态顺序表的析构为例：
\ntemplate <class T> | |
class SeqList | |
{ | |
public: | |
\t//... | |
\t~SeqList(); | |
//... | |
}; | |
template <class T> | |
SeqList<T>::~SeqList() | |
{ | |
if (m_data) | |
delete[] m_data; | |
\tm_size = m_capacity = 0; | |
} |
我们看到如果类模板的函数在类外定义时，需要加模板参数列表。
\n类模板的实例化与函数模板类似，在类名称之后加上 <> 以限定类型。（类模板不能隐式实例化）
SeqList<int> s1; | |
\tSeqList<double> s2; |
本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\nC 语言中，我们使用 malloc 、 calloc 、 realloc 、 free 来动态管理内存。
int main() | |
{ | |
int* p = (int*)malloc(sizeof(int));\t// 动态开辟 | |
free(p); | |
int* q = (int*)calloc(4, sizeof(int));\t// 动态开辟并赋值 | |
int* r = (int*)realloc(q, 10 * sizeof(int));\t// 重新分配空间 | |
free(r); | |
} |
C++ 中有更简单方便的内存管理方式，那就是使用 new 、 delete 来管理内存。
注意：如果使用 new 开辟空间就用 delete 删除，如果使用 new [] 开辟数组就用 delete [] 删除。
\n动态申请与删除一个内置类型变量的空间：
\nint* pi = new int; | |
int* pf = new float; | |
int* pl = new long; | |
int* pb = new bool; | |
delete pi; | |
delete pf; | |
delete pl; | |
delete pb; |
动态申请与删除一个内置类型变量的空间并完成初始化：
\nint* pi = new int(114514); | |
int* pf = new float(3.14f); | |
int* pl = new long(1145141919810); | |
int* pb = new bool(true); | |
delete pi; | |
delete pf; | |
delete pl; | |
delete pb; |
动态申请与删除内置类型变量数组的空间：
\nint* pi = new int[5]; | |
int* pf = new float[5]; | |
int* pl = new long[5]; | |
int* pb = new bool[5]; | |
delete[] pi; | |
delete[] pf; | |
delete[] pl; | |
delete[] pb; |
动态申请与删除内置类型变量数组的空间并完成初始化：
\nint* pi = new int[5]{1, 2, 3, 4, 5}; | |
float* pf = new float[5]{1.1f, 2.2f, 3.3f, 4.4f, 5.5f}; | |
long* pl = new long[5]{10, 20, 30, 40, 50}; | |
bool* pb = new bool[5]{true, false, true, false, true}; | |
delete[] pi; | |
delete[] pf; | |
delete[] pl; | |
delete[] pb; |
这与自定义类型区别主要在于：使用 new/delete 操作自定义类型时会自动调用自定义类型的构造 / 析构函数。
\nclass A | |
{ | |
public: | |
A(int a = 0) | |
: m_a(a) | |
{ | |
cout << \"A\" << endl; | |
} | |
~A() | |
{ | |
cout << \"~A\" << endl; | |
} | |
private: | |
int m_a; | |
}; | |
int main() | |
{ | |
A* oA = new A; | |
delete oA; | |
A* oB = (A*)malloc(sizeof(A)); | |
free(oB); | |
return 0; | |
} |
该程序运行结果为：
\nA | |
~A |
看到 operator new 和 operator delete，很多人会以为这是 new 与 delete 的重载函数。
\n但是，operator new 和 operator delete 不能理解为是 new 与 delete 的重载函数！
\noperator new 与 operator delete 其实是系统提供的全局函数，而 new 和 delete 在底层其实就是调用了这两个函数来实现的。
\n以下给出的函数定义随编译器不同有所变化！
\nvoid* operator new(std::size_t size) | |
{ | |
if (size == 0)\t// 如果请求的大小为 0，分配至少一个字节 | |
{ | |
size = 1; | |
} | |
while (true) | |
{ | |
void* p = std::malloc(size); // 使用 malloc 分配内存 | |
if (p) { | |
return p; // 如果分配成功，返回指针 | |
} | |
std::new_handler handler = std::get_new_handler(); // 获取当前的 new_handler | |
if (!handler) { | |
throw std::bad_alloc(); // 如果没有设置 new_handler，抛出 bad_alloc 异常 | |
} | |
handler(); // 调用 new_handler | |
} | |
} |
void operator delete(void* ptr) noexcept\t//noexcept 说明此函数不会抛出异常 | |
{ | |
std::free(ptr); // 使用 free 释放内存 | |
} |
同样的，new [] 和 delete [] 在底层调用的是 operator new [] 和 operator delete [] 函数。
\nvoid* operator new[](std::size_t size) | |
{ | |
if (size == 0) | |
{ | |
size = 1; | |
} | |
while (true) | |
{ | |
void* p = std::malloc(size); | |
if (p) | |
{ | |
return p; | |
} | |
std::new_handler handler = std::get_new_handler(); | |
if (!handler) | |
{ | |
throw std::bad_alloc(); | |
} | |
handler(); | |
} | |
} | |
void operator delete[](void* ptr) noexcept | |
{ | |
std::free(ptr); | |
} |
如果申请的是内置类型的空间，new 和 malloc、delete 和 free 基本类似。
\n不同的是：
\n对于自定义类型：
\n我们可以直接通过指针显式的调用析构函数：
\n#include <iostream> | |
using namespace std; | |
class A | |
{ | |
public: | |
\tA(int a = 0) | |
\t\t: m_a(a) | |
\t{ | |
\t\tcout << \"A()\" << this << endl; | |
\t} | |
\t~A() | |
\t{ | |
\t\tcout << \"~A()\" << this << endl; | |
\t} | |
private: | |
\tint m_a; | |
}; | |
int main() | |
{ | |
\tA* p1 = new A; | |
\tp1->~A(); | |
\tfree(p1); | |
\treturn 0; | |
} |
那我们能直接显式调用构造函数吗？答案是否定的。
\n但是我们可以使用定位 new 表达式：
\n#include <iostream> | |
using namespace std; | |
class A | |
{ | |
public: | |
\tA(int a = 0) | |
\t\t: m_a(a) | |
\t{ | |
\t\tcout << \"A()\" << this << endl; | |
\t} | |
\t~A() | |
\t{ | |
\t\tcout << \"~A()\" << this << endl; | |
\t} | |
private: | |
\tint m_a; | |
}; | |
int main() | |
{ | |
\tA* p1 = (A*)malloc(sizeof(A)); | |
\tnew (p1) A;\t// 在地址 p1 处执行类 A 的构造函数 | |
\tp1->~A(); | |
\tfree(p1); | |
\treturn 0; | |
} |
其结构就是 new 加上 (这里放地址) 加上 类名 。
或者也可以同时初始化：
\nint main() | |
{ | |
\tA* p1 = (A*)malloc(sizeof(A)); | |
\tnew (p1) A (10);\t// 在地址 p1 处执行类 A 的构造函数并初始化为 10 | |
\tp1->~A(); | |
\tfree(p1); | |
\treturn 0; | |
} |
当然我们也能显示的调用 operator new (operator new []) 与 operator delete (operator delete []) 函数：
\n#include <iostream> | |
using namespace std; | |
class A | |
{ | |
public: | |
\tA(int a = 0) | |
\t\t: m_a(a) | |
\t{ | |
\t\tcout << \"A()\" << this << endl; | |
\t} | |
\t~A() | |
\t{ | |
\t\tcout << \"~A()\" << this << endl; | |
\t} | |
private: | |
\tint m_a; | |
}; | |
int main() | |
{ | |
\tA* p1 = (A*)malloc(sizeof(A)); | |
\tnew (p1) A; | |
\tp1->~A(); | |
\tfree(p1); | |
\tA* p2 = (A*)operator new(sizeof(A)); | |
\tnew (p2) A(10); | |
\tp2->~A(); | |
\toperator delete(p2); | |
\treturn 0; | |
} |
在 Visual Stodio 中我们可以使用 _CrtDumpMemoryLeaks() 函数来检测内存泄露，如果发生内存泄露这个函数会在输出窗口给出提示。
#include <iostream> | |
using namespace std; | |
int main() | |
{ | |
\tint* p = new int; | |
\t_CrtDumpMemoryLeaks(); | |
\treturn 0; | |
} |
执行这段代码，我们可以在来源为调试的输出看到如下内容：
\nDetected memory leaks! | |
Dumping objects -> | |
{81} normal block at 0x00000221287C7400, 4 bytes long. | |
Data: < > CD CD CD CD | |
Object dump complete. |
本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n在类的构造函数的函数名后可以加上这么一串结构，称之为初始化列表：
\nclass Date | |
{ | |
public: | |
Date(int year, int month, int day) | |
: m_year(year)\t\t// 定义与初始化 | |
, m_month(month) | |
, m_day(day) | |
{} | |
Date(int year) | |
: m_year(year) | |
, m_month(1) | |
, m_day(1) | |
{} | |
private: | |
int m_year;\t\t// 声明 | |
int m_month; | |
int m_day; | |
}; |
初始化列表以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式。
\n一个对象在实例化时，就是在初始化列表这里完成变量的定义与初始化的。如果没有初始化列表，也同样是在这里（正式进入构造函数前）完成定义。
\n注意：
\n每个成员变量在初始化列表中只能出现一次（只能初始化一次）。
\n类中如果包含以下成员，必须放在初始化列表的位置进行初始化（因为定义在这里，而这些类型必须在定义时完成初始化）：
\n为了统一，尽量使用初始化列表进行初始化。
\n成员变量在类中的声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。
\n比方说这样就是不行的，因为 m_1 声明在前，此时使用未完成定义的 m_2 来初始化是非法的：
\nclass A | |
{ | |
public: | |
A(int a) | |
\t: m_2(a) | |
, m_1(m_2) | |
{} | |
private: | |
int m_1;\t\t// 声明 | |
int m_2; | |
}; |
对于接受单参构造函数，有这样一个额外的功能，就是隐式类型转换。
\n接受单参构造函数有以下几种：
\n以下面个类为例：
\nclass Date | |
{ | |
public: | |
Date(int year) | |
: m_year(year) | |
, m_month(1) | |
, m_day(1) | |
{} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; |
我们可以写这样一段代码而符合语法：
\nvoid Test() | |
{ | |
Date d1(2023); | |
d1 = 2024; | |
} |
这里直接将 2024 赋值给 d1，就是一个隐式类型转换，将整型变为 Date 类类型。
\n过程其实分为三步：
\noperator= ）复制给 d1。（部分情况下编译器会优化这个过程导致步骤减少）
\n使用 explicit 关键字修饰的构造函数将被禁止隐式类型转换。
\n比方说下面这段代码就会报错：
\nclass Date | |
{ | |
public: | |
explicit Date(int year) | |
: m_year(year) | |
, m_month(1) | |
, m_day(1) | |
{} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; | |
void Test() | |
{ | |
Date d1(2023); | |
d1 = 2024; | |
} |
声明为 static 的类成员称为类的静态成员，用 static 修饰的成员变量，称之为静态成员变量；用 static 修饰的
\n成员函数，称之为静态成员函数。
静态成员变量一定要在类外进行初始化。
\n比方说下面这个类具有统计已有对象数量的功能：
\nclass A | |
{ | |
public: | |
A() { ++m_cnt; } | |
A(const A& t) { ++m_cnt; } | |
~A() { --m_cnt; } | |
static int GetCnt() { return m_cnt; } | |
static int m_cnt; | |
}; | |
int A::m_cnt = 0; |
友元是一种突破封装的方式，有时能为我们提供便利。但是友元会增加耦合度，破坏封装，不可滥用。
\n我们尝试重载函数时，没有去实现流输入操作符与流输出操作符的重载。因为 cout 的输出流对象和隐含的 this 指针在抢占第一个参数的位置，this 指针默认是第一个参数也就是左操作数，但是实际使用中 cout 需要是第一个形参对象才能正常使用。所以要将 operator<< 重载成全局函数。但这会导致类外没办法访问成员（直接将成员设置为公有是破坏封装的不可取的行为），此时就需要友元函数来解决这个问题。
\n#include <iostream> | |
using namespace std; | |
class Date | |
{ | |
public: | |
\tDate(int year, int month, int day) | |
\t{ | |
\t\tm_year = year; | |
\t\tm_month = month; | |
\t\tm_day = day; | |
\t} | |
\tfriend ostream& operator<<(ostream& os, const Date& date); | |
\tfriend istream& operator>>(istream& is, Date& date); | |
private: | |
\tint m_year; | |
\tint m_month; | |
\tint m_day; | |
}; | |
ostream& operator<<(ostream& os, const Date& date) | |
{ | |
\tos << date.m_year << \"-\" << date.m_month << \"-\" << date.m_day; | |
\treturn os; | |
} | |
istream& operator>>(istream& is, Date& date) | |
{ | |
\tcout << \"请输入年月日(使用空格分割)：>\"; | |
\tis >> date.m_year >> date.m_month >> date.m_day; | |
\treturn is; | |
} | |
int main() | |
{ | |
\tDate date1(2024, 5, 25); | |
\tDate date2(2024, 5, 26); | |
\tcout << date1 << endl << date2 << endl; | |
\tcin >> date1; | |
\tcout << date1 << endl; | |
\treturn 0; | |
} |
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加 friend 关键字。
\n#include <iostream> | |
using namespace std; | |
class Date | |
{ | |
\tfriend class Time; | |
public: | |
\tDate(int y, int m, int d) | |
\t\t: m_year(y) | |
\t\t, m_month(m) | |
\t\t, m_day(d) | |
\t{} | |
\tvoid show() | |
\t{ | |
\t\tcout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
\t} | |
private: | |
\tint m_year; | |
\tint m_month; | |
\tint m_day; | |
}; | |
class Time | |
{ | |
public: | |
\tTime(int h, int m, int s, int y, int month, int d) | |
\t\t: m_hour(h) | |
\t\t, m_minute(m) | |
\t\t, m_second(s) | |
\t\t, m_date(y, month, d) | |
\t{} | |
\tvoid show() | |
\t{ | |
\t\tcout << m_hour << \":\" << m_minute << \":\" << m_second << endl; | |
\t\tm_date.show(); | |
\t} | |
private: | |
\tint m_hour; | |
\tint m_minute; | |
\tint m_second; | |
\tDate m_date; | |
}; | |
int main() | |
{ | |
\tTime t(12, 23, 34, 2020, 5, 30); | |
\tt.show(); | |
\treturn 0; | |
} |
如果一个类定义在另外一个类的内部，那这个类就是内部类。
\n但是，假设类 B 定义在类 A 的内部，类 B 和类 A 依旧是独立的，并不是说外部类就能直接访问内部类。反而是内部类可以直接访问外部类中的静态成员。
\n在有外部类的对象参数的情况下，内部类可以借此访问外部类中的所有成员。
\n或者说，内部类可以认为就是一种特殊的外部类的友元类。
\n#include <iostream> | |
using namespace std; | |
class A | |
{ | |
public: | |
\tclass B | |
\t{ | |
\tpublic: | |
\t\tvoid show(const A& AA) | |
\t\t{ | |
\t\t\tcout << a << endl; | |
\t\t\tcout << AA.b << endl; | |
\t\t} | |
\t}; | |
private: | |
\tstatic int a; | |
\tint b; | |
}; | |
int A::a = 10; | |
int main() | |
{ | |
\tA::B BB; | |
\tBB.show(A()); | |
\treturn 0; | |
} |
注意：
\n但是即使我们说内部类可以理解为外部类的友元类，我们可以把上面的时间类写成这样吗：
\n#include <iostream> | |
using namespace std; | |
class Date | |
{ | |
public: | |
\tDate(int y, int m, int d) | |
\t\t: m_year(y) | |
\t\t, m_month(m) | |
\t\t, m_day(d) | |
\t{} | |
\tvoid show() | |
\t{ | |
\t\tcout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
\t} | |
private: | |
\tint m_year; | |
\tint m_month; | |
\tint m_day; | |
\tclass Time | |
\t{ | |
\tpublic: | |
\t\tTime(int hh, int mm, int ss, int y, int m, int d) | |
\t\t\t: m_hour(hh) | |
\t\t\t, m_minute(mm) | |
\t\t\t, m_second(ss) | |
\t\t\t, m_date(y, m, d) | |
\t\t{} | |
\t\tvoid show(const Date& dd) | |
\t\t{ | |
\t\t\tcout << m_hour << \":\" << m_minute << \":\" << m_second << endl; | |
\t\t\tcout << dd.m_year << \"-\" << dd.m_month << \"-\" << dd.m_day << endl; | |
\t\t} | |
\tprivate: | |
\t\tint m_hour; | |
\t\tint m_minute; | |
\t\tint m_second; | |
\t}; | |
}; | |
int main() | |
{ | |
\tDate::Time t(10, 20, 30, 2020, 5, 30); | |
\treturn 0; | |
} |
答案是否定的，此时报错：不允许使用不完整的类型。
\n在 C++ 中，一个类在其自身完整定义之前不能实例化其自身的对象。 Date 类试图在其内部类 Time 中实例化 Date 类型的 m_date 成员，这导致了编译错误。
就像匿名结构体一样，类也有匿名对象。
\n匿名对象是指在创建时不赋予显式名称的对象。匿名对象通常用于一次性使用的场景，尤其是在不需要在其他地方引用该对象的情况下。匿名对象的生命周期只在当前行。
\n#include <iostream> | |
using namespace std; | |
class A | |
{ | |
public: | |
A(int k) | |
: m_m(k) | |
{} | |
~A() {} | |
int GetSquare() | |
{ | |
return m_m * m_m; | |
} | |
private: | |
int m_m; | |
}; | |
void test() | |
{ | |
// 有名对象计算平方 | |
A a(2);\t | |
cout << a.GetSquare() << endl; | |
// 匿名对象计算平方 | |
cout << A(2).GetSquare() << endl; | |
} |
本人服务器配置为 CentOS 7.9 64 位。
\n部分内容有时效性，不能保证可以复现。
\n首先 ssh 登录到我们的服务器。
\n这是为了方便管理，而且部分操作不方便通过 root 账号完成。
\n这里我们创建一个名为 teamspeak 的账户：
\n# 新建用户 teamspeak | ||
useradd teamspeak | ||
# 给予 sudo 权限 | ||
usermod -a -G sudo teamspeak | ||
# 设置密码 | ||
passwd teamspeak | ||
# 切换用户并定位到家目录 | ||
su teamspeak | ||
cd ~ |
https://www.teamspeak.com/zh-CN/downloads/#server
\n以上为官网下载地址，可以在那里查看最新版本，可以选择从官网下载下来再传输到服务器上，也可以直接命令行下载：
\n# 需要服务器已安装 wget | ||
wget https://files.teamspeak-services.com/releases/server/3.13.7/teamspeak3-server_linux_amd64-3.13.7.tar.bz2 |
注意使用 root 账号。
\n# 使用 yum 安装 wget | ||
sudo yum install -y wget |
# 使用 tar 命令解压 | ||
tar -xvf teamspeak3-server_linux_amd64-3.13.7.tar.bz2 |
需要安装 bz2 相关内容，使用 root 账号：
\n# 使用 yum 安装 bzip2 | ||
sudo yum install -y bzip2 |
创建 teamspeak 目录，把解压后的东西塞进去：
\nmkdir teamspeak | ||
mv teamspeak3-server_linux_amd64 teamspeak-rf | ||
rm -rf teamspeak3-server_linux_amd64 | ||
cd teamspeak |
# 没什么好说的，就是同意许可协议 | ||
touch .ts3server_license_accepted |
# 启动服务端 | ||
./ts3server_startscript.sh start |
第一次启动，会显示包括 token 在内的重要的信息，记得保存！！！
\n然后 Ctrl + C 退出。
我们需要为服务器开放一些端口，否则无法与客户端进行通讯。
\n以下是端口列表，不仅仅要在服务器开放，还要在云服务提供商的控制台的安全组中开放。
\n| 端口 | \n协议 | \n说明 | \n
|---|---|---|
| 9987 | \nUDP | \nTeamSpeak 语音服务端口 | \n
| 10011 | \nTCP | \nTeamSpeak ServerQuery raw 端口 | \n
| 10022 | \nTCP | \nTeamSpeak ServerQuery SSH 端口 | \n
| 30033 | \nTCP | \nTeamSpeak 文件传输端口 | \n
| 41144 | \nTCP | \nTSDNS 服务器端口 | \n
| 58913 | \nTCP | \n机器人网站后台端口（不开无所谓） | \n
| 3000 | \nTCP | \n网易云 api 后台端口（后面要用，先放开这个端口） | \n
在服务器开放端口：
\nfirewall-cmd --zone=public --add-port=9987/udp --permanent && firewall-cmd --reloa | ||
firewall-cmd --zone=public --add-port=10011/tcp --permanent && firewall-cmd --reloa | ||
firewall-cmd --zone=public --add-port=10022/tcp --permanent && firewall-cmd --reloa | ||
firewall-cmd --zone=public --add-port=30033/tcp --permanent && firewall-cmd --reloa | ||
firewall-cmd --zone=public --add-port=41144/tcp --permanent && firewall-cmd --reloa | ||
firewall-cmd --zone=public --add-port=3000/tcp --permanent && firewall-cmd --reloa |
在安全组开放端口：
\n![\"安全组\"](\"2.png\")
注意使用 root 账号。
\n# 新建 teamspeak.service | ||
vim /etc/systemd/system/teamspeak.service |
然后 i 进入 INSERT 模式，写文件：
[Unit]\nDescription=Teamspeak Service\nWants=network.target\n\n[Service]\nWorkingDirectory=/home/teamspeak\nExecStart=/home/teamspeak/teamspeak/ts3server_minimal_runscript.sh\nExecStop=/home/teamspeak/teamspeak/ts3server_startscript.sh stop\nExecReload=/home/teamspeak/teamspeak/ts3server_startscript.sh restart\nRestart=always\nRestartSec=15\n \n[Install]\nWantedBy=multi-user.target\n然后 Esc ， :wq! 强制保存并退出。
# 更新配置 | ||
systemctldaemon-reload | ||
# 设置开机启动 | ||
systemctl enable teamspeak.service | ||
# 启动服务 | ||
systemctl start teamspeak.service | ||
# 查看状态，如果有 active (running) 说明成功了 | ||
systemctl status teamspeak.service |
这个时候就可以去官网设置服务器别名了，或者也可以直接裸连服务器地址。
\n连接后使用上面保存的 token 设置自己为超级管理员。
\n随后自定义各种设置。
\nyum -y install epel-release | ||
rpm -Uvh http://li.nux.ro/download/nux/dextop/el7/x86_64/nux-dextop-release-0-5.el7.nux.noarch.rpm | ||
yum -y install ffmpeg opus-devel |
不要下载官方的，因为官方给的 linux 版编译环境有问题导致后面不能正常加载插件
\n下载 ZHANGTIAOYAO1 重构后的版本与 FiveHair 修改后的网易云插件。
\n命令行下载：
\n# 切换 teamspeak 账号 | ||
su teamspeak | ||
cd ~ | ||
wget https://github.com/ZHANGTIANYAO1/TS3AudioBot-NetEaseCloudmusic-plugin/releases/download/1.1.0/with.TS3Bot.linux-x64.zip | ||
wget https://github.com/FiveHair/TS3AudioBot-NetEaseCloudmusic-plugin-UNM/releases/download/2.0.3.1/YunPlugin-UNM-2.0.3.1.zip |
解压本体与插件并拷贝插件至本体的 plugins 目录：
\nunzip with.TS3Bot.linux-x64.zip | ||
mv linux-x64 TS3AudioBot | ||
unzip YunPlugin-UNM-2.0.3.1.zip | ||
cd TS3AudioBot/plugins | ||
rm * | ||
cd ~ | ||
mv YunPlugin-UNM.dll TS3AudioBot/plugins/ | ||
mv YunSettings.ini TS3AudioBot/plugins/ |
cd TS3AudioBot | ||
chmod 755 TS3AudioBot | ||
./TS3AudioBot |
随后根据引导设置管理员的 uid（在客户端上面 “权限” 菜单中打开 “所有客户端列表” 可以看到服务器所有人的 uid）、服务器 ip、密码等。
\n然后直接 Ctrl + C 结束进程。
注意切换 root 账号：
\n# ts3audiobot.service | ||
vim /etc/systemd/system/ts3audiobot.service |
然后 i 进入 INSERT 模式，写文件：
[Unit]\nDescription=TS3AudioBot\nAfter=teamspeak.service\n\n[Service]\nWorkingDirectory=/home/teamspeak/TS3AudioBot/\nExecStart=/home/teamspeak/TS3AudioBot/TS3AudioBot\nRestart=always\nRestartSec=15\n\n[Install]\nWantedBy=multi-user.target\n然后 Esc ， :wq! 强制保存并退出。
# 更新配置 | ||
systemctldaemon-reload | ||
# 设置开机启动 | ||
systemctl enable ts3audiobot.service | ||
# 启动服务 | ||
systemctl start ts3audiobot.service | ||
# 查看状态，如果有 active (running) 说明成功了 | ||
systemctl status ts3audiobot.service |
sudo yum install -y git | ||
# 设置用户名 | ||
git config --global user.name \"名字\" | ||
# 设置邮箱 | ||
git config --global user.email \"邮箱\" |
sudo yum install -y nodejs | ||
sudo yum install -y npm |
注意还是切换到 teamspeak 账号：
\nsu teamspeak | ||
cd ~ | ||
sudo git clone git@gitlab.com:Binaryify/NeteaseCloudMusicApi.git |
由于网易云的赶尽杀绝，大部分 API 都寄了，而这个其实也寄了。但是虽然 github 上改仓库删除归档了，我们依旧能在 gitlab 找到全部源码。
\ncd NeteaseCloudMusicApi | ||
sudo npm install | ||
sudo node app.js |
此时显示 server running ... 即为配置成功，按 Ctrl + C ，退出。
注意切换 root 用户：
\n# netease.service | ||
vim /etc/systemd/system/netease.service |
然后 i 进入 INSERT 模式，写文件：
[Unit]\nDescription=Netease Cloud Music API Service\nAfter=network.target\n\n[Service]\nWorkingDirectory=/home/teamspeak/NeteaseCloudMusicApi/\nExecStart=/usr/bin/node /home/teamspeak/NeteaseCloudMusicApi/app.js\nRestart=always\nRestartSec=15\n\n[Install]\nWantedBy=multi-user.target\n然后 Esc ， :wq! 强制保存并退出。
# 更新配置 | ||
systemctldaemon-reload | ||
# 设置开机启动 | ||
systemctl enable netease.service | ||
# 启动服务 | ||
systemctl start netease.service | ||
# 查看状态，如果有 active (running) 说明成功了 | ||
systemctl status netease.service |
注意还是切回 teamspeak 账号：
\ncd ~ | ||
cd TS3AudioBot/plugins | ||
vim YunSettings.ini |
将链接修改为本地：
\n# 如果原本等号后面有东西就删掉\nWangYiYunAPI_Address = http://localhost:3000\n设置谁能操控机器人谁能点歌，在 /home/teamspeak/TS3AudioBot 目录下的 rights.toml 中有详细的说明与设置方法。
之后的操作仅在客户端就能完成。
\n聊天框输入 !plugin list ，找到网易云插件（状态应该是 RDY 就绪）的编号（假设是 #0）。
输入 !plugin load 0 （后面数字得看编号）加载插件。
然后再查看插件列表，网易云插件的状态应该为（+ON 运行）
\n之后输入 !yun login 后根据机器人的头像与简洁设置登录网易云（请给机器人管理员权限）。
大功告成！
\n![\"测试\"](\"3.png\")
本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\nLinux 是一种开源操作系统，其核心由林纳斯・托瓦兹于 1991 年开发，基于 UNIX 设计理念。Linux 内核本身仅是操作系统的核心部分，负责管理硬件资源，而完整的 Linux 系统还包括工具和库，这些通常由 GNU 计划提供。因此，完整的系统经常被称为 “GNU/Linux”。
\nLinux 有多种发行版，每种都有自己的软件库和管理工具，例如 Ubuntu、Fedora 和 Debian 等。这些发行版适应了从个人桌面计算到服务器，再到嵌入式系统等不同的使用场景。
\nLinux 广泛应用于服务器、超级计算机、网络设备，以及日益增长的移动设备和家庭设备中，特别是其在 Android 操作系统的核心组成部分中的使用，使其成为世界上应用最广泛的操作系统之一。
\n我们自己搭建 Linux 环境一般有下面几种方法：
\n直接将系统安装到主机上使用，就像我们使用 Windows 那样。
\n但是这样非常不方便（哪怕是安装为双系统或者多系统），而且后面网络编程时不利于体验通信。
\n本地使用 VMware、VirtualBox 等虚拟机软件，将 Linux 系统安装到虚拟机中。
\n这样使用较为方便，但是虚拟机网络需配置为桥接，也不利于后面网络编程。
利用 Windows11 提供的新特性，部署 WSL2 后直接在 MSStore 中安装相应版本的 Linux 系统。
\n这样使用非常方便，但是缺点和虚拟机类似。
在云服务提供商（阿里云、百度云、腾讯云等处购买云服务器，然后本地通过 XShell 等软件或者直接控制台 ssh 链接到服务器即可。从云服务提供商处获得的云服务器一般是自带公网 IPv4 点，这是我们自己难以做到的。
\n优点是非常方便使用和管理，而且利于后面网络部分的学习。缺点是价格一般较高（哪怕学生第一年的超优惠价格也是 99 块 1 年）（但是可以白嫖）。
\n下面的白嫖方法应当是有时效性的活动，请注意本内容写于 2024 年 5 月 21 日。
\n阿里云有为学生提供免费的云服务，能白领 7 个月的 Linux 服务器，活动网页如下：
\nhttps://developer.aliyun.com/plan/student
\n这个只要认证学生身份就能领一个月，完成 Clouder 认证就能续领 6 个月（非常简单跟着提示做就行）。
\n购买完云服务后我们应该做的是：
\n我们打开电脑的控制台，直接连接服务器我们可以输入：
\nssh root@114.114.114.114 | |
# 注意这里 root 是指管理员账户，后面是服务器的公网 IP 地址 |
随后按照提示输入密码即可。
\n或者我们只输入公网 IP，随后根据提示输入用户名和密码：
\nssh 114.114.114.114 | |
# 后面是服务器的公网 IP 地址 |
使用像 XShell 这样的软件连接，功能更多更强大，可以方便以后的操作。
\nXShell 的下载官网是：
\nhttps://www.xshell.com/zh/xshell/
\n使用 XShell 的话需要注意一些点：
\nCtrl + Insert ，粘贴是 Shift + Insert 。The remote SSH server rejected X11 forwarding request. 我们只需要执行代码 yum install xorg-x11-xauth 即可。本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n我们写一个类，在类体中什么都不写，这样的类就叫空类。
\n空类真的什么都没有吗？并不是的。
\n类有六个默认成员函数，如果我们自己没有写这六个函数，类也会自己去补齐它们。
\n其中后两个先不管，下面我们介绍一下前面几个函数。
\n我们先看这样一个类：
\nclass Date | |
{ | |
public: | |
void Init(int y, int m, int d) | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
void Print() | |
{ | |
cout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; |
对于这个日期类，我们每次要实例化一个对象时都需要这样先创建对象再使用 Init 函数完成初始化，非常的不方便。
所以在 C++ 中，我们就有了构造函数。构造函数是一个特殊的成员函数，名字与类名相同。当我们创建对象时，其构造函数就会被自动调用，并且在对象的整个生命周期中只调用一次。
\n比方说我们可以把上面的类改写成这样：
\nclass Date | |
{ | |
public: | |
Date(int y, int m, int d)\t// 构造函数前面就不要加 void 了 | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
void Print() | |
{ | |
cout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; |
函数名与类名相同。
\n没有返回值。
\n对象实例化时编译器自动调用对应的构造函数。
\n同样可以重载：
\nclass Date | |
{ | |
public: | |
Date()\t// 无参 | |
{ | |
m_year = 1900; | |
m_month = 1; | |
m_day = 1; | |
} | |
Date(int y, int m, int d)\t// 带参 | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
void Print() | |
{ | |
cout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; | |
int main() | |
{ | |
Date d1;\t// 调用无参的构造函数 | |
Date d2(2024, 5, 22);\t// 调用带参的构造函数 | |
return 0; | |
} |
注意：这里实例化时不能这样写：
\nint main() | |
{ | |
Date d();\t// 调用无参的构造函数不要带括号！ | |
return 0; | |
} |
这里的语句可能会被认为是在声明一个叫 d 的函数，其返回值是 Date 类型的对象。
\n如果类中没有显式定义构造函数，编译器会自动生成一个无参的构造函数，如果显式定义了就不会这么做。
\n这里默认生成的构造函数是遵循什么规则给对象初始化的呢？且看：
\nC++ 中的类型分为内置类型（基本类型，比如 int、double 这些自带的）和自定义类型（我们用 class、struct、union 等自己定义出来的）。而默认生成的构造函数不一定会对内置类型进行初始化（不排除某些编译器有自己的想法？），对于自定义类型编译器会去寻找其构造函数以实现初始化。
\n但是在 C++11 中，打了一个补丁：内置成员变量可以在类中声明时给默认值（要给就全给）。
\nclass Date | |
{ | |
public: | |
Date(int y, int m, int d) | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
void Print() | |
{ | |
cout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
} | |
private: | |
int m_year = 1900; | |
int m_month = 1; | |
int m_day = 1; | |
}; | |
int main() | |
{ | |
Date d;\t//1900-1-1 | |
d.Print(); | |
return 0; | |
} |
析构函数与构造函数相反，在对象销毁时自动调用析构函数，完成对象中资源的清理工作。
\n~ 。这里我们还是以之前的 Stack 类为例：
\n#pragma once | |
#include <iostream> | |
#include <string> | |
using namespace std; | |
typedef int StackDataType; | |
class Stack | |
{ | |
public: | |
\tStack(int size); | |
\t~Stack(); | |
\tvoid Push(StackDataType data); | |
\tStackDataType Pop(); | |
\tStackDataType Top(); | |
\tbool IsEmpty(); | |
\tbool IsFull(); | |
\tint GetSize(); | |
\tint GetTop(); | |
private: | |
\tStackDataType* m_data; | |
\tint m_size; | |
\tint m_capacity; | |
}; |
#include \"Stack.h\" | |
Stack::Stack(int size = 4) | |
{ | |
\tm_data = new StackDataType[size]; | |
\tm_size = 0; | |
\tm_capacity = size; | |
} | |
Stack::~Stack() | |
{ | |
\tdelete[] m_data; | |
} | |
void Stack::Push(StackDataType data) | |
{ | |
\tif (IsFull()) | |
\t{ | |
\t\tcout << \"Stack is full!\" << endl; | |
\t\treturn; | |
\t} | |
\tm_data[m_size++] = data; | |
} | |
StackDataType Stack::Pop() | |
{ | |
\tif (IsEmpty()) | |
\t{ | |
\t\tcout << \"Stack is empty!\" << endl; | |
\t\treturn -1; | |
\t} | |
\treturn m_data[--m_size]; | |
} | |
StackDataType Stack::Top() | |
{ | |
\tif (IsEmpty()) | |
\t{ | |
\t\tcout << \"Stack is empty!\" << endl; | |
\t\treturn -1; | |
\t} | |
\treturn m_data[m_size - 1]; | |
} | |
bool Stack::IsEmpty() | |
{ | |
\treturn m_size == 0; | |
} | |
bool Stack::IsFull() | |
{ | |
\treturn m_size == m_capacity; | |
} | |
int Stack::GetSize() | |
{ | |
\treturn m_size; | |
} | |
int Stack::GetTop() | |
{ | |
\treturn m_size - 1; | |
} |
如果我们想通过一个已有对象去创建一个新对象，就要用到拷贝构造函数。简单来说，就是我们有一个类 X 的对象 a，现在想再创建一个类 X 的对象 b 而且要和 a 完全一致。那么就直接使用拷贝构造函数，使用 a 来创建 b。
\n拷贝构造函数和默认构造函数一样都是构造函数的一个重载形式。
\n拷贝构造函数的参数只有一个且为类类型对象的引用。使用传值的方式会造成无穷递归调用，会被编译器报错。
\nclass Date | |
{ | |
public: | |
Date(int y, int m, int d) | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
Date(const Date& d) | |
{ | |
m_y = d.m_y; | |
m_m = d.m_m; | |
m_d = d.m_d; | |
} | |
void Print() | |
{ | |
cout << m_year << \"-\" << m_month << \"-\" << m_day << endl; | |
} | |
private: | |
int m_year = 1900; | |
int m_month = 1; | |
int m_day = 1; | |
}; |
与之类似的，我们一般传参时，能使用引用就尽量使用引用类型，可以提高程序效率。
\n如果没有显式定义，编译器会生成默认的拷贝构造函数。但是默认的拷贝构造函数是直接将内存按字节序复制过来，属于浅拷贝（值拷贝）。但是我们很多时候是需要深拷贝的，尤其是存在资源申请时，因为这种情况下依旧直接复制内存并不能申请新的资源，不能完成我们所需的拷贝。
\n运算符重载是面对对象编程的一种方法。在 C++ 中，运算符重载允许我们为类对象自定义运算符的计算方法。
\n简单来说，我们自定义一个类，编译器是不知道这个类的加减乘除等计算是如何进行的。像加减乘除等计算，一般只能用于系统的内置类型，但我们可以通过运算符重载来规定自定义类型遇到这些运算符应该怎么处理。
\n运算符重载函数的名字为：operator 后面加上需要重载的运算符符号。
\n比方说下面就是重载了日期类的日期加天数等于新日期的计算（+= 的重载）：
\nclass Date | |
{ | |
public: | |
\tDate(int year = 1900, int month = 1, int day = 1) | |
{ | |
m_year = year; | |
m_month = month; | |
m_day = day; | |
\t} | |
\tDate(const Date& date) | |
{ | |
m_year = date.m_year; | |
m_month = date.m_month; | |
m_day = date.m_day; | |
} | |
\t~Date() {}; | |
\tint GetMonthDays(int year, int month) | |
{ | |
if (month == 2) | |
{ | |
if (IsLeapYear(year)) | |
{ | |
return 29; | |
} | |
else | |
{ | |
return 28; | |
} | |
} | |
else if (month == 4 || month == 6 || month == 9 || month == 11) | |
{ | |
return 30; | |
} | |
else | |
{ | |
return 31; | |
} | |
} | |
\tbool IsLeapYear(int year) | |
{ | |
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) | |
{ | |
return true; | |
} | |
else | |
{ | |
return false; | |
} | |
} | |
\tDate& operator+=(int days) | |
{ | |
while (days > 0) | |
{ | |
if (days + m_day > GetMonthDays(m_year, m_month)) | |
{ | |
days -= GetMonthDays(m_year, m_month) - m_day + 1; | |
m_day = 1; | |
if (m_month == 12) | |
{ | |
m_month = 1; | |
m_year++; | |
} | |
else | |
{ | |
m_month++; | |
} | |
} | |
else | |
{ | |
m_day += days; | |
days = 0; | |
} | |
} | |
return *this; | |
} | |
\tvoid Print() | |
{ | |
std::cout << m_year << \"-\" << m_month << \"-\" << m_day << std::endl; | |
} | |
private: | |
\tint m_year; | |
\tint m_month; | |
\tint m_day; | |
}; |
我们也可以将运算符重载为全局函数。但是需要涉及的成员变量是公有的（这会破坏类的封装性，但是也可以通过友元来解决，后面会讲）：
\nclass Date | |
{ | |
public: | |
\tDate(int year = 1900, int month = 1, int day = 1) | |
{ | |
m_year = year; | |
m_month = month; | |
m_day = day; | |
\t} | |
\tDate(const Date& date) | |
{ | |
m_year = date.m_year; | |
m_month = date.m_month; | |
m_day = date.m_day; | |
} | |
\t~Date() {}; | |
\tint m_year; | |
\tint m_month; | |
\tint m_day; | |
}; | |
bool operator==(const Date& d1, const Date& d2) | |
{ | |
return d1.m_year == d2.m_year | |
&& d1.m_month == d2.m_month | |
&& d1.m_day == d2.m_day; | |
} | |
void test() | |
{ | |
Date d1(2024, 1, 1); | |
Date d2(2024, 1, 1); | |
cout << (d1 == d2) << endl;\t// 由于优先级问题需要加括号 | |
} |
注意：
\n.* （通过成员函数指针访问类的成员函数的运算符）、 :: （作用域限定符）、 sizeof 、 ?: （三目运算符）、 .赋值运算符重载与拷贝构造函数类似。其参数应当选择传引用返引用以提高效率，并且这样能够支持连续赋值。
\n注意：
\n我们还是以日期类为例：
\nDate& Date::operator=(const Date& date) | |
{ | |
\tif (this != &date) | |
\t{ | |
\t\tm_year = date.m_year; | |
\t\tm_month = date.m_month; | |
\t\tm_day = date.m_day; | |
\t} | |
\treturn *this; | |
} |
我们以自增运算符为例，前置自增应当这样重载：
\nDate& Date::operator++() | |
{ | |
\t*this += 1; | |
\treturn *this; | |
} |
而后置自增运算符应当如何重载呢？C++ 规定：为了区分，后置运算符重载时增加一个 int 类型参数，但是调用该函数时忽略该参数，就像这样：
Date Date::operator++(int) | |
{ | |
\tDate date = *this; | |
\t*this += 1; | |
\treturn date; | |
} | |
void test() | |
{ | |
Date d1; | |
Date d2(2024, 1, 1); | |
d1 = d2++; | |
d1 = ++d2; | |
} |
注意后置自增是使用后再自增，因此要返回自增前的旧值。
\n在成员函数的括号后面加一个 const ，就将这个成员函数称为 const 成员函数。这里实际修饰的是该成员函数的 this 指针，表示这个成员函数不能对类的任何成员进行修改。
建议：只要能加 const 就加 const，避免权限放大的问题。
\n具体的例子可以看下面实现完整的日期类中。
\n下面我们通过上面学的内容实现一个日期类吧！
\n#pragma once | |
class Date | |
{ | |
public: | |
\tDate(int year = 1900, int month = 1, int day = 1); | |
\tDate(const Date& date); | |
\t~Date(); | |
\tint GetMonthDays(int year, int month) const; | |
\tint GetYearDays(int year) const; | |
\tbool IsLeapYear(int year) const; | |
\tDate& operator+(int days) const; | |
\tDate& operator-(int days) const; | |
\tDate& operator-=(int days); | |
\tDate& operator+=(int days); | |
\tDate& operator++(); | |
\tDate operator++(int); | |
\tDate& operator--(); | |
\tDate operator--(int); | |
\tDate& operator=(const Date& date); | |
\tbool operator==(const Date& date) const; | |
\tbool operator!=(const Date& date) const; | |
\tbool operator<(const Date& date) const; | |
\tbool operator>(const Date& date) const; | |
\tbool operator<=(const Date& date) const; | |
\tbool operator>=(const Date& date) const; | |
\tint operator-(const Date& date) const; | |
\tvoid Print() const; | |
private: | |
\tint m_year; | |
\tint m_month; | |
\tint m_day; | |
}; |
#include <iostream> | |
#include \"Date.h\" | |
using namespace std; | |
Date::Date(int year, int month, int day) | |
{ | |
\tm_year = year; | |
\tm_month = month; | |
\tm_day = day; | |
} | |
Date::Date(const Date& date) | |
{ | |
\tm_year = date.m_year; | |
\tm_month = date.m_month; | |
\tm_day = date.m_day; | |
} | |
Date::~Date() | |
{ | |
} | |
int Date::GetMonthDays(int year, int month) const | |
{ | |
\tif (month == 2) | |
\t{ | |
\t\tif (IsLeapYear(year)) | |
\t\t{ | |
\t\t\treturn 29; | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\treturn 28; | |
\t\t} | |
\t} | |
\telse if (month == 4 || month == 6 || month == 9 || month == 11) | |
\t{ | |
\t\treturn 30; | |
\t} | |
\telse | |
\t{ | |
\t\treturn 31; | |
\t} | |
} | |
int Date::GetYearDays(int year) const | |
{ | |
\tif (IsLeapYear(year)) | |
\t{ | |
\t\treturn 366; | |
\t} | |
\telse | |
\t{ | |
\t\treturn 365; | |
\t} | |
} | |
bool Date::IsLeapYear(int year) const | |
{ | |
\tif (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) | |
\t{ | |
\t\treturn true; | |
\t} | |
\telse | |
\t{ | |
\t\treturn false; | |
\t} | |
} | |
Date& Date::operator+(int days) const | |
{ | |
\tDate date = *this; | |
\tdate += days; | |
\treturn date; | |
} | |
Date& Date::operator-(int days) const | |
{ | |
\tDate date = *this; | |
\tdate -= days; | |
\treturn date; | |
} | |
Date& Date::operator-=(int days) | |
{ | |
\twhile (days > 0) | |
\t{ | |
\t\tif (days >= m_day) | |
\t\t{ | |
\t\t\tdays -= m_day; | |
\t\t\tif (m_month == 1) | |
\t\t\t{ | |
\t\t\t\tm_month = 12; | |
\t\t\t\tm_year--; | |
\t\t\t} | |
\t\t\telse | |
\t\t\t{ | |
\t\t\t\tm_month--; | |
\t\t\t} | |
\t\t\tm_day = GetMonthDays(m_year, m_month); | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\tm_day -= days; | |
\t\t\tdays = 0; | |
\t\t} | |
\t} | |
\treturn *this; | |
} | |
Date& Date::operator+=(int days) | |
{ | |
\twhile (days > 0) | |
\t{ | |
\t\tif (days + m_day > GetMonthDays(m_year, m_month)) | |
\t\t{ | |
\t\t\tdays -= GetMonthDays(m_year, m_month) - m_day + 1; | |
\t\t\tm_day = 1; | |
\t\t\tif (m_month == 12) | |
\t\t\t{ | |
\t\t\t\tm_month = 1; | |
\t\t\t\tm_year++; | |
\t\t\t} | |
\t\t\telse | |
\t\t\t{ | |
\t\t\t\tm_month++; | |
\t\t\t} | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\tm_day += days; | |
\t\t\tdays = 0; | |
\t\t} | |
\t} | |
\treturn *this; | |
} | |
Date& Date::operator++() | |
{ | |
\t*this += 1; | |
\treturn *this; | |
} | |
Date Date::operator++(int) | |
{ | |
\tDate date = *this; | |
\t*this += 1; | |
\treturn date; | |
} | |
Date& Date::operator--() | |
{ | |
\t*this -= 1; | |
\treturn *this; | |
} | |
Date Date::operator--(int) | |
{ | |
\tDate date = *this; | |
\t*this -= 1; | |
\treturn date; | |
} | |
Date& Date::operator=(const Date& date) | |
{ | |
\tif (this != &date) | |
\t{ | |
\t\tm_year = date.m_year; | |
\t\tm_month = date.m_month; | |
\t\tm_day = date.m_day; | |
\t} | |
\treturn *this; | |
} | |
bool Date::operator==(const Date& date) const | |
{ | |
\tif (m_year == date.m_year && m_month == date.m_month && m_day == date.m_day) | |
\t{ | |
\t\treturn true; | |
\t} | |
\telse | |
\t{ | |
\t\treturn false; | |
\t} | |
} | |
bool Date::operator!=(const Date& date) const | |
{ | |
\treturn !(*this == date); | |
} | |
bool Date::operator<(const Date& date) const | |
{ | |
\tif (m_year < date.m_year) | |
\t{ | |
\t\treturn true; | |
\t} | |
\telse if (m_year == date.m_year) | |
\t{ | |
\t\tif (m_month < date.m_month) | |
\t\t{ | |
\t\t\treturn true; | |
\t\t} | |
\t\telse if (m_month == date.m_month) | |
\t\t{ | |
\t\t\tif (m_day < date.m_day) | |
\t\t\t{ | |
\t\t\t\treturn true; | |
\t\t\t} | |
\t\t} | |
\t} | |
\treturn false; | |
} | |
bool Date::operator>(const Date& date) const | |
{ | |
\treturn !(*this < date) && *this != date; | |
} | |
bool Date::operator<=(const Date& date) const | |
{ | |
\treturn *this < date || *this == date; | |
} | |
bool Date::operator>=(const Date& date) const | |
{ | |
\treturn *this > date || *this == date; | |
} | |
int Date::operator-(const Date& date) const | |
{ | |
\tint days = 0; | |
\tDate temp = *this; | |
\tif (temp < date) | |
\t{ | |
\t\twhile (temp != date) | |
\t\t{ | |
\t\t\ttemp++; | |
\t\t\tdays++; | |
\t\t} | |
\t} | |
\telse | |
\t{ | |
\t\twhile (temp != date) | |
\t\t{ | |
\t\t\ttemp--; | |
\t\t\tdays++; | |
\t\t} | |
\t} | |
\treturn days; | |
} | |
void Date::Print() const | |
{ | |
\tstd::cout << m_year << \"-\" << m_month << \"-\" << m_day << std::endl; | |
} |
有人说我们自定义的类型能够直接取地址或者 const 取地址，因此这两种运算符也是被编译器默认重载了的默认成员函数。
\n事实上这不能认为是类的默认成员函数，虽然我们自己可以去重载这两个运算符（不推荐，一般也用不上），但是空类生成的时候编译器并没有生成这样一个重载成员函数，这个操作是 C++ 内置的基础功能。只有当显式地为类重载了取地址操作符，这个操作的行为才会改变。
\n", "tags": [ "计算机科学", "C++笔记", "C++", "类" ] }, { "id": "https://www.starlinglin.top/computer-science/Cpp-programme-note/%E6%A4%8B%E9%B8%9FC++%E7%AC%94%E8%AE%B0%20%EF%BC%832%EF%BC%9A%E4%BB%8E%E7%BB%93%E6%9E%84%E4%BD%93%E5%88%B0%E7%B1%BB/", "url": "https://www.starlinglin.top/computer-science/Cpp-programme-note/%E6%A4%8B%E9%B8%9FC++%E7%AC%94%E8%AE%B0%20%EF%BC%832%EF%BC%9A%E4%BB%8E%E7%BB%93%E6%9E%84%E4%BD%93%E5%88%B0%E7%B1%BB/", "title": "椋鸟C++笔记#2：从结构体到类", "date_published": "2024-05-12T08:41:02.000Z", "content_html": "本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n我们在 C 语音中学的结构体在 C++ 依旧适用，而且增加了其他的功能。
\n在 C++ 中，结构体不仅可以用来定义变量，还可以定义函数。
\n在这个函数内，还可以直接使用结构体中的变量。
\n比如之前我们在数据结构中实现的栈现在可以这样全部放在结构体内部：
\n#include <iostream> | |
using namespace std; | |
typedef int DataType; | |
struct Stack | |
{ | |
\tvoid Init(size_t capacity) | |
\t{ | |
\t\tm_arr = (DataType*)malloc(sizeof(DataType) * capacity); | |
\t\tif (nullptr == m_arr) | |
\t\t{ | |
\t\t\tperror(\"malloc\"); | |
\t\t\treturn; | |
\t\t} | |
\t\tm_capacity = capacity; | |
\t\tm_size = 0; | |
\t} | |
\tvoid Push(const DataType& data) | |
\t{ | |
\t\tm_arr[m_size] = data; | |
\t\t++m_size; | |
\t} | |
\tvoid DataType Top() | |
\t{ | |
\t\treturn m_arr[m_size - 1]; | |
\t} | |
\tvoid Destory() | |
\t{ | |
\t\tif (nullptr != m_arr) | |
\t\t{ | |
\t\t\tfree(m_arr); | |
\t\t\tm_arr = nullptr; | |
\t\t\tm_capacity = 0; | |
\t\t\tm_size = 0; | |
\t\t} | |
\t} | |
\tDataType* m_arr; | |
\tsize_t m_capacity; | |
\tsize_t m_size; | |
}; | |
int main() | |
{ | |
\tStack stack; | |
\tstack.Init(10); | |
\tstack.Push(1); | |
\tstack.Push(2); | |
\tstack.Push(3); | |
\tstack.Push(4); | |
\t | |
\tcout << stack.Top() << endl; | |
\tstack.Destory(); | |
\treturn 0; | |
} |
我们发现，这样把一类方法的所有函数和变量封装在一起的方式非常高效，便于代码调用和管理。
\n在 C++ 中，引入了一个更加适合这样的封装调用的方式，那就是类（Class）。
\nclass classname | |
{ | |
// 类体，包括成员变量和成员函数 | |
};\t// 注意这里要加分号，与结构体类似 |
class 是 C++ 的关键字，用于定义类；classname 是类的名字；花括号中是类的主体。
同样的，我们可以在类体中放成员变量和成员函数，但是类中成员函数的定义可以有两种方式：
\n定义与声明都放在类中，对于一些简单的小函数直接定义在类中比较方便：
\nclass Date | |
{ | |
void SetDate(int y, int m, int d) | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
int m_year; | |
int m_month; | |
int m_day; | |
} |
在这种情况下，编译器更倾向于将这样的函数作为内联函数处理。
\n定义放在类外，声明放在类中，这样可以让拥有较多较大函数的类看起来更直观：
\n#include <iostream> | |
using namespace std; | |
typedef int DataType; | |
class Stack | |
{ | |
\tvoid Init(size_t capacity); | |
\tvoid Push(const DataType& data); | |
\tDataType Top(); | |
\tvoid Destory(); | |
\tDataType* m_arr; | |
\tsize_t m_capacity; | |
\tsize_t m_size; | |
}; | |
void Stack::Init(size_t capacity) | |
{ | |
m_arr = (DataType*)malloc(sizeof(DataType) * capacity); | |
if (nullptr == m_arr) | |
{ | |
perror(\"malloc\"); | |
return; | |
} | |
m_capacity = capacity; | |
m_size = 0; | |
} | |
void Stack::Push(const DataType& data) | |
{ | |
m_arr[m_size] = data; | |
++m_size; | |
} | |
DataType Stack::Top() | |
{ | |
return m_arr[m_size - 1]; | |
} | |
void Stack::Destory() | |
{ | |
if (nullptr != m_arr) | |
{ | |
free(m_arr); | |
m_arr = nullptr; | |
m_capacity = 0; | |
m_size = 0; | |
} | |
} |
我们发现，这样声明与定义分离可以让类的结构变的简单明了。但是在类外再对这些函数作定义时就需要在函数名前加上类名和作用域限定符，就像上一篇中的命名空间域一样。
\n其实，这也是一个域，叫类域。
\n类域与局部域、全局域、命名空间域类似，一个类中的成员变量和成员函数都属于这个类域。
\n在 C++ 中，类与结构体的成员是有访问权限这么一个属性的。访问权限有 public（公有）、private（私有）、**protected（保护）** 三种。我们可以通过访问限定符来设定成员的访问权限：
\n#include <iostream> | |
using namespace std; | |
typedef int DataType; | |
class Stack | |
{ | |
public: | |
\tvoid Init(size_t capacity); | |
\tvoid Push(const DataType& data); | |
\tDataType Top(); | |
\tvoid Destory(); | |
private: | |
\tDataType* m_arr; | |
\tsize_t m_capacity; | |
\tsize_t m_size; | |
}; | |
void Stack::Init(size_t capacity) | |
{ | |
m_arr = (DataType*)malloc(sizeof(DataType) * capacity); | |
if (nullptr == m_arr) | |
{ | |
perror(\"malloc\"); | |
return; | |
} | |
m_capacity = capacity; | |
m_size = 0; | |
} | |
void Stack::Push(const DataType& data) | |
{ | |
m_arr[m_size] = data; | |
++m_size; | |
} | |
DataType Stack::Top() | |
{ | |
return m_arr[m_size - 1]; | |
} | |
void Stack::Destory() | |
{ | |
if (nullptr != m_arr) | |
{ | |
free(m_arr); | |
m_arr = nullptr; | |
m_capacity = 0; | |
m_size = 0; | |
} | |
} |
我们看到，在上面的程序中，从 public: 之后，一直到下一个访问限定符之前的内容都会被设置为公有访问权限，而 private 和 protected 同理。
那么不同的访问权限到底意味着什么呢？
\n用类类型创建对象的过程，称为类的实例化：
\n类是对对象进行描述的，是一个模型或者图纸一样的东西，限定了类有哪些成员。与结构体相同，定义出一个类并没有分配实际的内存空间来存储它。
\n一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类的成员变量（不包括成员函数，原因下面说）。
\nclass Date | |
{ | |
public: | |
void SetDate(int y, int m, int d) | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; | |
int main() | |
{ | |
Date date;\t// 实例化，对象 date 就是类 Date 实例化的结果 | |
date.SetDate(2024, 5, 11); | |
return 0; | |
} |
我们如何计算类对象的大小？这就需要我们知道类对象是如何存储的。
\n其实很简单，我们用 sizeof 试试就知道，类对象的大小只包括类的成员变量的大小（与结构体一样遵循内存对齐规则，详见 C 语言笔记 #28）
那么成员函数呢？
\n成员函数放在公共代码区的一个类成员函数表中。
\n我们还是以日期类为例：
\nclass Date | |
{ | |
public: | |
void SetDate(int y, int m, int d) | |
{ | |
m_year = y; | |
m_month = m; | |
m_day = d; | |
} | |
private: | |
int m_year; | |
int m_month; | |
int m_day; | |
}; | |
int main() | |
{ | |
Date date1; | |
date1.SetDate(2024, 5, 11); | |
Date date2; | |
date2.SetDate(2024, 5, 12); | |
return 0; | |
} |
我们看到，对于 Date 类的两个对象，我们都调用了函数 SetDate。
\n但是这个函数只有三个参数 y、m 和 d，而且上面提到类成员函数是储存在公共代码区的，所以两次调用的是同一个地址。
\n那么 SetDate 函数是如何知到调用时应该对那一个对象进行操作的呢？为什么 date1.SetDate(2024, 5, 11); 不会去修改对象 date2 的成员变量呢？
在 C++ 中，是通过引入 this 指针来解决这个问题的：
C++ 编译器给每个 “非静态的成员函数” 增加了一个隐藏的指针参数，让该指针指向当前对象（函数运行时调用该函数的对象），在函数体中所有 “成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
\n所以上面函数定义中也可以这样写：
\nvoid SetDate(int y, int m, int d) | |
{ | |
this->m_year = y; | |
this->m_month = m; | |
this->m_day = d; | |
} |
类的类型* const ，const 意味着在成员函数中不能给 this 指针赋值。#pragma once | |
#include <stdbool.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#include <assert.h> | |
// 数据类型 | |
typedef int STDataType; | |
typedef struct Stack | |
{ | |
\tSTDataType* _data; | |
\tint _top; | |
\tint _capacity; | |
} Stack, * pStack; | |
// 栈的初始化 | |
void InitStack(pStack pst); | |
// 压栈 | |
void StackPush(pStack pst, STDataType x); | |
// 弹栈 | |
void StackPop(pStack pst); | |
// 栈顶元素 | |
STDataType StackTop(pStack pst); | |
// 栈大小 | |
int StackSize(pStack pst); | |
// 栈判空 | |
_Bool StackEmpty(pStack pst); | |
// 栈销毁 | |
void StackDestory(pStack pst); |
#include \"Stack.h\" | |
// 栈的初始化 | |
void InitStack(pStack pst) | |
{ | |
\tassert(pst); | |
\tpst->_data = NULL; | |
\tpst->_top = 0; | |
\tpst->_capacity = 0; | |
} | |
// 容量检查扩容 | |
void StackCheck(pStack pst) | |
{ | |
\tif (pst->_top == pst->_capacity) | |
\t{ | |
\t\tint newCapacity = ((pst->_capacity == 0) ? 4 : (2 * pst->_capacity)); | |
\t\tSTDataType* temp = (STDataType*)realloc(pst->_data, newCapacity * sizeof(STDataType)); | |
\t\tif (temp == NULL) | |
\t\t{ | |
\t\t\tperror(\"realloc\"); | |
\t\t\texit(EXIT_FAILURE); | |
\t\t} | |
\t\tpst->_data = temp; | |
\t\tpst->_capacity = newCapacity; | |
\t} | |
} | |
// 压栈 | |
void StackPush(pStack pst, STDataType x) | |
{ | |
\tassert(pst); | |
\tStackCheck(pst); | |
\tmemcpy(&(pst->_data[pst->_top]), &x, sizeof(STDataType)); | |
\tpst->_top++; | |
} | |
// 弹栈 | |
void StackPop(pStack pst) | |
{ | |
\tassert(pst); | |
\tassert(!StackEmpty(pst)); | |
\tpst->_top--; | |
} | |
// 栈顶元素 | |
STDataType StackTop(pStack pst) | |
{ | |
\tassert(pst); | |
\treturn pst->_data[pst->_top - 1]; | |
} | |
// 栈大小 | |
int StackSize(pStack pst) | |
{ | |
\tassert(pst); | |
\treturn pst->_top; | |
} | |
// 栈判空 | |
_Bool StackEmpty(pStack pst) | |
{ | |
\tassert(pst); | |
\treturn pst->_top == 0; | |
} | |
// 栈销毁 | |
void StackDestory(pStack pst) | |
{ | |
\tassert(pst); | |
\tfree(pst->_data); | |
\tpst->_capacity = 0; | |
\tpst->_top = 0; | |
\tpst->_data = NULL; | |
} |
先忽略 Stack 函数与～Stack 函数，下一篇笔记讲。
\n#pragma once | |
#include <iostream> | |
#include <string> | |
using namespace std; | |
typedef int StackDataType; | |
class Stack | |
{ | |
public: | |
\tStack(int size); | |
\t~Stack(); | |
\tvoid Push(StackDataType data); | |
\tStackDataType Pop(); | |
\tStackDataType Top(); | |
\tbool IsEmpty(); | |
\tbool IsFull(); | |
\tint GetSize(); | |
\tint GetTop(); | |
private: | |
\tStackDataType* m_data; | |
\tint m_size; | |
\tint m_capacity; | |
}; |
#include \"Stack.h\" | |
Stack::Stack(int size = 4) | |
{ | |
\tm_data = new StackDataType[size]; | |
\tm_size = 0; | |
\tm_capacity = size; | |
} | |
Stack::~Stack() | |
{ | |
\tdelete[] m_data; | |
} | |
void Stack::Push(StackDataType data) | |
{ | |
\tif (IsFull()) | |
\t{ | |
\t\tcout << \"Stack is full!\" << endl; | |
\t\treturn; | |
\t} | |
\tm_data[m_size++] = data; | |
} | |
StackDataType Stack::Pop() | |
{ | |
\tif (IsEmpty()) | |
\t{ | |
\t\tcout << \"Stack is empty!\" << endl; | |
\t\treturn -1; | |
\t} | |
\treturn m_data[--m_size]; | |
} | |
StackDataType Stack::Top() | |
{ | |
\tif (IsEmpty()) | |
\t{ | |
\t\tcout << \"Stack is empty!\" << endl; | |
\t\treturn -1; | |
\t} | |
\treturn m_data[m_size - 1]; | |
} | |
bool Stack::IsEmpty() | |
{ | |
\treturn m_size == 0; | |
} | |
bool Stack::IsFull() | |
{ | |
\treturn m_size == m_capacity; | |
} | |
int Stack::GetSize() | |
{ | |
\treturn m_size; | |
} | |
int Stack::GetTop() | |
{ | |
\treturn m_size - 1; | |
} |
本系列暴死，不会更新了。
\n该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\nC++ 是由 Bjarne Stroustrup 在上世纪 80 年代开发的一款基于 C 语音的编程语言。一开始是作为 C 语言的完善与改进，后来随着一次次标准化更新，已经脱胎换骨了。但是 C + 依旧向下兼容大部分 C 语言代码。
\n这一篇笔记先从一些比较基础的地方讲其与 C 语言的区别。
\n首先 C 语言只有 32 个关键字，而 C++98 却有 63 个关键字，C++11 及之后的标准中甚至更多。
\n具体有哪些可以点下面的链接查看：
\nC++关键词
\n在 C 语言中，我们能遇到这样的情况：想要用的函数名、变量名在库中已经存在，因此不得不改名。
\n而在 C++ 中，我们会遇到更多的库，其中有海量的函数，再加上我们自己会写的函数，命名重复的问题就凸显出来。
\n因此，C++ 就引入了命名空间的概念，用以对标识符的名称进行本地化，以避免命名冲突或者名字污染。
\n其原理大致可以理解为把各个函数放到各自的命名空间中，同一个命名空间内还是不能重名，但是不同命名空间之间可以有重名的函数（通过命名空间来区分）。
\n定义一个命名空间要使用关键字 namespace ，其定义方式与定义结构体类似（也同样可以嵌套）：
int rand; | |
int Add(int Adder1, int Adder2) | |
{ | |
return Adder1 + Adder2; | |
} | |
namespace ExampleSpace1 | |
{ | |
int rand; | |
int Add(int Adder1, int Adder2) | |
{ | |
return Adder1 + Adder2; | |
} | |
} | |
namespace ExampleSpace2 | |
{ | |
int rand; | |
int Add(int Adder1, int Adder2) | |
{ | |
return Adder1 + Adder2; | |
} | |
namespace ExampleSpace3 | |
\t{ | |
int rand; | |
int Add(int Adder1, int Adder2) | |
{ | |
return Adder1 + Adder2; | |
} | |
\t} | |
} |
如上方所示，我们在全局、ExampleSpace1、ExampleSpace2、ExampleSpace2 中的 ExampleSpace3 中分别定义了整型变量 rand 和函数 Add。但是由于其所处命名空间是不同的，所以不会出现问题。
\n另外，在同一个工程中，可以有多个同名的命名空间，它们最后会被 “合并起来”，比方说我们可以在 test1.h 中定义命名空间 Test：
\nnamespace Test | |
{ | |
int a; | |
int b; | |
} |
然后在 test2.h 中继续定义命名空间 Test：
\nnamespace Test | |
{ | |
int c; | |
int d; | |
} |
那么在之后使用命名空间 Test 时，两边的内容就相当于 “合并” 起来作为一个命名空间。
\n那么我们应该如何使用命名空间呢？以下面这段为例：
\nint a; | |
namespace ExampleSpace1 | |
{ | |
int a; | |
int b; | |
} | |
namespace ExampleSpace2 | |
{ | |
int c; | |
namespace ExampleSpace3 | |
\t{ | |
int d; | |
\t} | |
} |
使用命名空间一般有三种方式。
\n两个英文冒号连在一起就是作用域限定符（::）。
\nint main() | |
{ | |
printf(\"%d\\n\", a);\t// 未加限定时访问全局域的 a | |
printf(\"%d\\n\", ::a);\t// 限定为空同样访问全局域的 a | |
printf(\"%d\\n\", ExampleSpace1::a);\t// 访问 ExampleSpace1 中的 a | |
printf(\"%d\\n\", ExampleSpace2::a);\t// 访问 ExampleSpace2 中的 a | |
printf(\"%d\\n\", ExampleSpace2::ExampleSpace3::a);\t// 访问 ExampleSpace2 中的 ExampleSpace3 中的 a | |
} |
比方说这样就能引入 ExampleSpace1 中的 b。
\nusing ExampleSpace1::b; | |
int main() | |
{ | |
\tcout << b << endl; | |
\treturn 0; | |
} |
这里我们不能使用引入 ExampleSpace1 中的 a，因为全局中已经存在一个 a 了，产生多义性问题。
\n如果某个命名空间里面有大量的内容，我们总不能一个一个去引入，所以我们可以直接引入整个命名空间：
\n// 注意嵌套的情况下不能直接写 ExampleSpace3 | |
using namespace ExampleSpace2::ExampleSpace3; | |
int main() | |
{ | |
\tcout << d << endl; | |
\treturn 0; | |
} |
那如果我们引入 ExampleSpace2 的话，能不能直接使用 ExampleSpace3 中的内容呢？
\n答案是否定的，但是如果引入 ExampleSpace2 的话我们就可以写成这样了：
\nusing namespace ExampleSpace2; | |
int main() | |
{ | |
\tcout << ExampleSpace3::d << endl; | |
\treturn 0; | |
} |
此时就不用写成 ExampleSpace2::ExampleSpace3::d（虽然也行）。
\n展开（使用）命名空间是可以在作用域中进行的，不是说一定在全局中展开，比方说：
\nint main() | |
{ | |
\tif (true) | |
\t{ | |
\t\tusing namespace ExampleSpace2::ExampleSpace3; | |
\t\tcout << d << endl; | |
\t} | |
} |
比方说全局中的命名空间 ExampleSpace1 我们如果放在某作用域内展开，并不是说这个时候使用其中的变量或者函数或者别的什么就是该作用域内的东西了。这些东西依旧存在于全局，我们这里的展开只是给了一个权限使得我们能在这个作用域内定向的使用 ExampleSpace1 中的东西。
\n这里我们可以看一个例子，比方说下面这段代码的运行结果是 10，不会报错：
\nint a = 0; | |
int main() | |
{ | |
\tif (true) | |
\t{ | |
\t\tint a = 10; | |
\t\tcout << a << endl; | |
\t} | |
} |
因为编译器会先在作用域内寻找符合的变量，这可以与全局中的变量共存。
\n但是如果写成这样，就会报错了：
\nint a = 0; | |
namespace X | |
{ | |
\tint a = 10; | |
} | |
int main() | |
{ | |
\tif (true) | |
\t{ | |
\t\tusing namespace X; | |
\t\tcout << a << endl; | |
\t} | |
} |
这就是因为展开命名空间实际上只是给予了访问权限并不是真正的展开。编译器先在作用域内没有找到 a，然后在全局中寻找，而有了命名空间 X 访问权限的编译器此时就在全局中发现了两个 a，一个直接写在全局中，另一个写在命名空间 X 中。这就产生了多义性错误。
\n我们看看 C++ 中的 Hello World! 程序：
\n#include <iostream> | |
using namespace std; | |
int main() | |
{ | |
cout << \"Hello world!\" << endl; | |
return 0; | |
} |
第一行包含的库 <iostream> 是 C++ 的标准输入输出库，可以理解为之前 C 语言的 <stdio.h> ，但是内容更丰富全面。（C++ 的库文件一般不带 .h 后缀）
第二行中的命名空间 std 就是 C++ 中的标准库命名空间，C++ 所有标准库的定义都实现在这个命名空间，我们必须包含这个命名空间才能使用其中的内容。
\n第六行中的输出方式是 C++ 特有的 IO 流方式，其中 << 是流插入运算符，与之相对的 >> 是流提取运算符。使用这种方式进行输入输出比较方便，不需要手动控制格式。其更具体的使用与原理等后面会学。
缺省参数就是在声明或者定义函数时为其参数设定一个缺省值（默认值），在调用这个函数时，如果没有指定这个参数就使用其缺省值，比方说：
\n#include <iostream> | |
using namespace std; | |
void func(int a, int b = 10, int c = 20) | |
{ | |
\tcout << \"a = \" << a << \", b = \" << b << \", c = \" << c << endl; | |
} | |
int main() | |
{ | |
\tfunc(1); | |
\tfunc(1, 2); | |
\tfunc(1, 2, 3); | |
\treturn 0; | |
} |
该程序输出为：
\na = 1, b = 10, c = 20 | |
a = 1, b = 2, c = 20 | |
a = 1, b = 2, c = 3 |
一旦某个参数被赋予了默认值，其右侧的所有参数也必须有默认值。这是因为实参的传递是按参数列表从左到右的顺序进行的。
\n也就是说，不能写出下面这种东西：
\nvoid func(int a, int b = 10, int c) | |
{ | |
\tcout << \"a = \" << a << \", b = \" << b << \", c = \" << c << endl; | |
} |
因为只要 b 有默认值，它右边的 c 也要有默认值才行。
\n如果函数同时有声明和定义，并且分开书写，那么默认参数应只在其中之一中指定，通常是在函数声明中。这是为了防止缺省参数被重定义：
\n#include <iostream> | |
using namespace std; | |
void func(int a, int b = 10, int c = 20); | |
void func(int a, int b, int c) | |
{ | |
\tcout << \"a = \" << a << \", b = \" << b << \", c = \" << c << endl; | |
} | |
int main() | |
{ | |
\tfunc(1); | |
\tfunc(1, 2); | |
\tfunc(1, 2, 3); | |
\treturn 0; | |
} |
C++ 支持在同一个作用域中声明几个有相同函数名的函数，前提是他们能够通过参数列表区分开来。
\n重载函数的出现，方便了功能类似但参数类型不同的函数，举个例子：
\n#include <iostream> | |
using namespace std; | |
void print(int a) | |
{ | |
\tcout << \"int: \" << a << endl; | |
} | |
void print(double a) | |
{ | |
\tcout << \"double: \" << a << endl; | |
} | |
void print(char a) | |
{ | |
\tcout << \"char: \" << a << endl; | |
} | |
int main() | |
{ | |
\tprint(10); | |
\tprint(10.5); | |
\tprint('A'); | |
\treturn 0; | |
} |
其输出为：
\nint: 10 | |
double: 10.5 | |
char: A |
在 C 语言笔记 #36 中，我们就说过 C/C++ 代码生成可执行程序要经过预处理、编译、汇编、链接几个阶段。
\n每一个源代码文件都要经历预处理、编译和汇编过程生成对应的 .o 文件（Linux 下）或者 .obj 文件（Windows 下）。最终它们与链接库通过链接器链接起来变成可执行程序。
代码中调用函数的步骤在汇编后实际上就变成了跳转到函数指令执行地址。一般来说，在多文件项目中，链接前每一个头文件是独立的，不知道要调用的函数地址在哪。此时就会用一个 “记号” 来代替，而在链接阶段，链接器通过这个 “记号” 在符号表中寻找对应函数的地址并填进去。
\n而在 C 语言中，这个记号仅由函数名决定，因此如果有重名函数就无法被链接器区分。
\n在 C++ 中，这个记号有命名空间、函数名、参数列表多方面决定，因此能够被链接器区分开来。
\n对于 Linux 环境的 g++ 编译器，这个记号由以下几个部分组成：
\n'_Z' 加上 函数名长度 加上 函数名 加上各参数类型的缩写。
比方说函数 int Add(int a, int b); 对应的记号是：_Z3Addii
而函数 void func(int a, float b, int* p); 对应的记号是：_Z4funcifPi
对于 Windows 环境下的名字修饰规则就比较复杂，记号由以下部分组成：
\n'?' 加上 函数名 加上 '@' 加上 命名空间（如果有嵌套用'@'隔开） 加上 '@' 加上 代表函数调用类型、参数、返回值的一串代码（具体符号含义复杂不做介绍） 加上 '@Z'
比方说对于函数 int func(int); 对应的记号是： ?func@@YAHH@Z
而函数 int C::C2::func(int); 对应的记号是：?func@C2@C@@AAEHH@Z
在 C++ 中，引用是一个非常重要的特性，它为另一个已存在的变量提供了一个别名。引用主要用于函数参数传递和返回值，使得代码更加有效且易于理解。
\nC++ 使用符号 & 来声明引用，例如 int& ref = var; 这里 ref 就成了 var 的一个引用，对引用的任何操作都是直接对原变量的操作。
注意 1：引用在声明时必须被初始化，这是与指针最大的不同之一。一旦一个引用被初始化指向一个变量，它就不能被改变指向另一个变量。
\n注意 2：引用必须连接到一块合法的内存，不能像指针那样可以有 NULL 值。
不加修饰引用的操作权限是可读可写，而权限只能缩小不能扩大，因此不能对常量进行引用：
\nconst int a = 10; | |
//int& ra = a;\t//err，a 为常量只读，权限不能扩大 | |
const int& ra = a;\t//ok，const 修饰后 ra 也是只读的引用，权限不变 | |
//int& rb = 666;\t//err，666 是常量只读，权限不能扩大 | |
const int& rb = 666;\t//ok | |
double pi = 3.14; | |
//int& rpi = pi;\t//err，类型不同 | |
const int& rpi = pi;\t//ok，这里发生隐式的类型转换变成 3 |
对于上方的代码，我们注意到如果引用被 const 修饰，能够获得更高的灵活性。这被称为常引用。
\n使用引用作为函数参数的主要好处是能够直接操作调用者的变量，避免了数据的复制，从而提高效率。
\nvoid Swap(int& a, int& b) | |
{ | |
int tmp = a; | |
a = b; | |
b = tmp; | |
} |
使用引用返回函数结果主要是为了避免返回值的拷贝，特别是当返回对象较大时。
\n它还允许函数返回操作结果直接对应到调用者的某个变量或对象上。
\n注意：确保返回的对象在函数返回后仍然存在，要不然不要使用！
\n比方说这段代码中返回的 n 被 static 修饰，在函数栈帧销毁后依旧存在，所以可用：
\nint& Count() | |
{ | |
static int n = 0; | |
n++; | |
return n; | |
} |
再比方说这段代码中返回的是 array 数组中的内容，不是栈帧中开辟的局部变量，所以没问题：
\n#include <iostream> | |
using namespace std; | |
int& getElement(int* array, int index) | |
{ | |
return array[index]; // 返回数组元素的引用 | |
} | |
int main() | |
{ | |
int arr[3] = {1, 2, 3}; | |
getElement(arr, 0) = 4; // 通过引用修改数组元素 | |
cout << arr[0] << endl; // 输出 4 | |
return 0; | |
} |
那如果返回值是栈帧内开辟的局部变量会发生什么呢？且看下例：
\nint& Add(int a, int b) | |
{ | |
int c = a + b; | |
return c; | |
} | |
int main() | |
{ | |
int& ret = Add(1, 2); | |
Add(3, 4); | |
cout << \"Add(1,2) is: \" << ret << endl; | |
return 0; | |
} |
其输出结果并非 3，而是 7，为什么呢？
\n（现在不少编译器机制变的更加复杂，导致输出不是 7 而是一串随机值，但这只是一个例子）
\n结合我们在 C 语言笔记 #16 中的内容分析：
\n第一次调用 Add 函数时，1 和 2 作为参数 ab 压栈，esp 寄存器上移。然后创建 Add 函数的栈帧，esp 和 ebp 移到 Add 函数的栈帧两端。变量 c 创建在 Add 函数栈帧中，而 Add 函数返回后 esp 和 ebp 回到 main 函数栈帧的两端，这片空间被释放。因此实际返回的是一片已经被释放的内存空间。
\n但是此时如果直接输出，其仍能输出 3，因为虽然对应的空间已经被释放但是还没有被覆写。
\n第二次调用 Add 函数时，3 与 4 压栈，esp 与 ebp 上移，创建 Add 函数的栈帧。此时除了数字不同，指令地址与第一次完全一致（较新的编译器可能不是了）。因此计算结果 7 放在了原本第一次 c 的位置，也就是把原本的 4 覆盖了。这时再去输出 ret 自然就得到了 Add (1, 2) = 7 的荒谬结论。
\n避免数据的拷贝，当数据占空间较大时有很大的效率优势与空间优势。
\n我们测试一下看看：
\n#include <time.h> | |
struct A | |
{ | |
\tint a[10000]; | |
}; | |
A a; | |
A TestFunc1() { return a; } | |
A& TestFunc2() { return a; } | |
int main() | |
{ | |
\t// 以值作为函数的返回值类型 | |
\tsize_t begin1 = clock(); | |
\tfor (size_t i = 0; i < 1000000; ++i) | |
\t\tTestFunc1(); | |
\tsize_t end1 = clock(); | |
\t// 以引用作为函数的返回值类型 | |
\tsize_t begin2 = clock(); | |
\tfor (size_t i = 0; i < 1000000; ++i) | |
\t\tTestFunc2(); | |
\tsize_t end2 = clock(); | |
\t// 计算两个函数运算完成之后的时间 | |
\tcout << \"TestFunc1 time:\" << end1 - begin1 << endl; | |
\tcout << \"TestFunc2 time:\" << end2 - begin2 << endl; | |
\treturn 0; | |
} |
其输出：
\nTestFunc1 time:1610 | |
TestFunc2 time:1 |
可见其效率差距之大。
\n底层上引用就是靠指针实现的，优势在于可读性更高。
\n我们把汇编对比一下就知道，指针实现和引用实现的汇编代码都是基本一致的。
\n硬要说区别的话有如下几条：
\n如果程序中有一个比较小的函数被频繁调用，我们就会面临这样的问题：这个函数太小了没什么必要去创建一个函数，这会造成很多没必要的栈帧开销；但是这个函数确实在程序中使用的很多，不写成函数而是拆开来写在程序里很麻烦。
\n那么我们就可以使用内联函数解决这个问题；当然也可以使用宏或者宏函数解决，但是宏无法调试没有安全检查也非常容易出错，是不推荐使用的。
\n在声明 / 定义函数的时候，在前面加上关键字 inline ，这个函数就会变成内联函数。
编译器在处理内联函数时不会像正常函数一样写成调用函数的汇编代码，而是直接把这个内联函数在这里展开，比方说下面两段代码本质上没有区别：
\ninline int max(int a, int b) | |
{ | |
\treturn a > b ? a : b; | |
} | |
int main() | |
{ | |
\tcout << \"max(10, 20) = \" << max(10, 20) << endl; | |
\tcout << \"max(0, 0) = \" << max(0, 0) << endl; | |
\tcout << \"max(-10, -20) = \" << max(-10, -20) << endl; | |
\treturn 0; | |
} |
int main() | |
{ | |
\tcout << \"max(10, 20) = \" << (10 > 20 ? 10 : 20) << endl; | |
\tcout << \"max(0, 0) = \" << (0 > 0 ? 0 : 0) << endl; | |
\tcout << \"max(-10, -20) = \" << (-10 > -20 ? -10 : -20) << endl; | |
\treturn 0; | |
} |
内联函数是一种以时间换空间的做法，可能会让目标文件变的很大，但是能大大减少栈帧开销，提高运行效率。
\n注意：Visual Studio 中，在 debug 模式下，编译器一般不会对内联函数进行展开，需在 release 下进行。（或在编译器配置中设置内联函数扩展的属性）
\n注意：内联函数只是向编译器提出了展开的建议，不同编译器对其实现机制可能不同。有可能写了内联编译器却不采纳，有可能没有写内联编译器却自己优化成了内联函数。
\n注意：内联函数尽量不要声明与定义分离，因为编译器处理声明时找不到函数地址（内联函数直接展开没有函数地址），然后就会报链接错误或者直接忽略内联。
\n这里我们要说的是 C++11 开始的 auto 关键字，C++11 之前也有 auto 关键字，但是含义不同。
\nauto 关键字在 C++11 之前用于在定义时修饰变量为具有自动存储期的变量，以表示这个变量会在离开当前作用域后自动归还内存。但是啊，我们如果没有单独去修饰变量为 static、extern 或 thread_local 的话，变量自然就会被创建为具有自动存储期的，正常人不会闲着没事干去加一个 auto 在前面。因此，auto 的这个用法在 C++11 以后已经废除。
\n从 C++11 开始，auto 关键字用于替代类型名使用。什么意思呢？
\n比方说我们定义各种类型的变量，都可以直接用 auto 来替代类型，编译器会自动分析这里应该是什么类型：
\n#include <iostream> | |
using namespace std; | |
int main() | |
{ | |
\tauto a = 1; | |
\tauto b = 3.14; | |
\tauto c = { 1, 2 }; | |
\tauto d = \"hello world\"; | |
\tauto e = 'c'; | |
\tcout << typeid(a).name() << endl; | |
\tcout << typeid(b).name() << endl; | |
\tcout << typeid(c).name() << endl; | |
\tcout << typeid(d).name() << endl; | |
\tcout << typeid(e).name() << endl; | |
\treturn 0; | |
} |
注意：这里的 typeid().name() 用于输出类型的名字。
其输出结果为：
\nint | |
double | |
class std::initializer_list<int> | |
char const * __ptr64 | |
char |
又或者，我们可以在函数的返回值类型处写 auto，编译器同样会自动分析函数的返回值类型。
\n注意：在同一行用 auto 定义多个变量时，它们必须是相同类型的。
\n注意：auto 声明指针类型时 * 可加可不加，但是声明引用类型时，必须有 & 。
注意：auto 可以用于函数的返回值，但是不能用于函数的参数。
\n== 注意：auto 不要直接用于声明数组。== 像 auto a[] = {1, 2, 3}; 这种是非法的。
在之前我们如果想遍历一个数组要这样做：
\nvoid TestForLoop() | |
{ | |
\tint arr[] = { 1, 2, 3, 4, 5 }; | |
\tfor (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) | |
\t{ | |
\t\tarr[i] *= 2; | |
\t} | |
\tfor (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) | |
\t{ | |
\t\tcout << arr[i] << \" \"; | |
\t} | |
} |
而在 C++11 以后，可以直接写成：
\nvoid TestForLoopWithRange() | |
{ | |
\tint arr[] = { 1, 2, 3, 4, 5 }; | |
\tfor (auto& e : arr) | |
\t{ | |
\t\te *= 2; | |
\t} | |
\tfor (auto e : arr) | |
\t{ | |
\t\tcout << e << \" \"; | |
\t} | |
} |
这里 for 循环的括号中有冒号分割为两个部分：
\n指针空值 nullptr（C++11）
\n在我们声明一个变量的时候，良好的习惯是在声明时进行初始化。如果声明一个指针而暂时没有指向，我们一般会将其初始化为空指针。
\n在之前，我们空指针一般直接用 NULL 来赋值，比方说 int* p = NULL; 。
NULL 实际上是一个宏，我们在 stddef.h 中能够看到其定义：
#ifndef NULL | |
#ifdef __cplusplus | |
#define NULL\t0 | |
#else | |
#define NULL\t((void *)0) | |
#endif | |
#endif |
我们发现在 C++ 中，NULL 被定义为 0，这可能会带来一些问题，比方说下面这段代码：
\nvoid func(int i) | |
{ | |
cout << \"int\" << endl; | |
} | |
void func(int* pi) | |
{ | |
cout << \"int*\" << endl; | |
} | |
int main() | |
{ | |
func(0); | |
func(NULL); | |
} |
我们发现两行输出都是 int，这显然与我们的初衷相悖。
\n在 C++11 以后，增加了关键字 nullptr，不需要包含头文件。
\nnullptr 默认为 ((void*)0) ，且存在到任意指针类型的隐式转换。
我们平时使用这个关键字而不是 NULL 作为空指针就能解决上面的问题，能够提高代码的健壮性。
\n", "tags": [ "计算机科学", "C++笔记", "C++" ] }, { "id": "https://www.starlinglin.top/computer-science/data-structure-note/%E6%A4%8B%E9%B8%9F%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0%20%EF%BC%8311%EF%BC%9A%E6%8E%92%E5%BA%8F%C2%B7%E4%B8%8B/", "url": "https://www.starlinglin.top/computer-science/data-structure-note/%E6%A4%8B%E9%B8%9F%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0%20%EF%BC%8311%EF%BC%9A%E6%8E%92%E5%BA%8F%C2%B7%E4%B8%8B/", "title": "椋鸟数据结构笔记#11：排序·下", "date_published": "2024-04-23T13:42:31.000Z", "content_html": "该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n当数据量非常庞大以至于无法全部写入内存时，我们应该怎么排序这些数据呢？
\n这时，就要学会直接进行在外存中排序，也就是外部排序。
\n外排序不是一种独立的排序算法，还是要依赖于之前的那些排序方式。
\n其基本思想是这样的：
\n看起来不是很复杂，但是归并部分还是很有东西的。下面我们逐步讲解：
\n这并不复杂，比方说我们将文件拆分为 splitCount 个：
\nvoid FileSort(const char* filename, int splitCount) | |
{ | |
\tclock_t start = clock(); | |
\t// 分割文件 | |
\tFILE* fp = fopen(filename, \"r\"); | |
\tif (fp == NULL) | |
\t{ | |
\t\tperror(\"fail to open\"); | |
\t\texit(EXIT_FAILURE); | |
\t} | |
\tint* num = (int*)malloc(sizeof(int) * N / splitCount);\t// 存放每个分割文件的数据 | |
\tint iNum = 0;\t//num 数组的下标 | |
\tint iFile = 0;\t// 分割文件的下标 | |
\tint n = 0;\t// 读取的数据 | |
\tchar splitFileName[50] = { 0 };\t// 分割文件名 | |
\twhile (fscanf(fp, \"%d\", &n) != EOF) | |
\t{ | |
\t\tif (iNum < N / splitCount - 1) | |
\t\t{ | |
\t\t\tnum[iNum++] = n; | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\tnum[iNum] = n; | |
\t\t\t// 排序 | |
\t\t\tHeapSort(num, N / splitCount); | |
\t\t\t// 写入文件 | |
\t\t\tsprintf(splitFileName, \"SubSort\\\\sort_split%d.txt\", iFile++); | |
\t\t\tFILE* splitFile = fopen(splitFileName, \"w\"); | |
\t\t\tif (splitFile == NULL) | |
\t\t\t{ | |
\t\t\t\tperror(\"fail to open\"); | |
\t\t\t\texit(EXIT_FAILURE); | |
\t\t\t} | |
\t\t\tfor (int i = 0; i < N / splitCount; i++) | |
\t\t\t{ | |
\t\t\t\tfprintf(splitFile, \"%d\\n\", num[i]); | |
\t\t\t} | |
\t\t\tfclose(splitFile); | |
\t\t\tprintf(\"已分割第%d个文件，总共需分割%d个文件。\\n\", iFile, splitCount); | |
\t\t\tiNum = 0; | |
\t\t} | |
\t} | |
\t// 归并文件 | |
// 这里插入归并文件的代码 | |
\t// 关闭文件 | |
\tfclose(fp); | |
\tclock_t end = clock(); | |
\tprintf(\"排序完成，共%d个数据，分割为%d个文件，归并为1个文件。\\n\", N, splitCount); | |
\tprintf(\"耗时：%f秒。\\n\", (double)(end - start) / CLOCKS_PER_SEC); | |
} |
这是重点也是最复杂的地方。
\n我们知道两个排序文件归并的方法：两边一起读取，一直对比两边读取的数，不断取小写入输出文件即可。
\nvoid MergeFile(char* file1, char* file2, char* mergeFileName) | |
{ | |
\tFILE* fp1 = fopen(file1, \"r\"); | |
\tFILE* fp2 = fopen(file2, \"r\"); | |
\tif (fp1 == NULL) | |
\t{ | |
\t\tperror(\"fail to open\"); | |
\t\texit(EXIT_FAILURE); | |
\t} | |
\tif (fp2 == NULL) | |
\t{ | |
\t\tperror(\"fail to open\"); | |
\t\texit(EXIT_FAILURE); | |
\t} | |
\tFILE* fin = fopen(\"tmp.txt\", \"w\"); | |
\tif (fin == NULL) | |
\t{ | |
\t\tperror(\"fail to open\"); | |
\t\texit(EXIT_FAILURE); | |
\t} | |
\tint n1, n2; | |
\tint ret1 = fscanf(fp1, \"%d\", &n1); | |
\tint ret2 = fscanf(fp2, \"%d\", &n2); | |
\twhile (ret1 != EOF && ret2 != EOF) | |
\t{ | |
\t\tif (n1 < n2) | |
\t\t{ | |
\t\t\tfprintf(fin, \"%d\\n\", n1); | |
\t\t\tret1 = fscanf(fp1, \"%d\", &n1); | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\tfprintf(fin, \"%d\\n\", n2); | |
\t\t\tret2 = fscanf(fp2, \"%d\", &n2); | |
\t\t} | |
\t} | |
\twhile (fscanf(fp1, \"%d\", &n1) != EOF) | |
\t{ | |
\t\tfprintf(fin, \"%d\\n\", n1); | |
\t} | |
\twhile (fscanf(fp2, \"%d\", &n2) != EOF) | |
\t{ | |
\t\tfprintf(fin, \"%d\\n\", n2); | |
\t} | |
\tfclose(fp1); | |
\tfclose(fp2); | |
\tfclose(fin); | |
\tremove(file1); | |
\tremove(file2); | |
\trename(\"tmp.txt\", mergeFileName); | |
} |
注意：这里我们先写入数据至 tmp.txt 中，最后在将其改名为 mergeFileName 是为了防止 mergeFileName 就是 file1 或者 file2 的情况（也即直接把 file2 归并到 file1 中而不创建新的文件，或者反过来）。
\n但是我们往往不仅仅要把数据切分为两个，而是几十个上百个。这时我们就需要使用多文件归并的方法。
\n直接逐个归并
\n这是最容易理解也是最差的方法。就是把拆分文件 1 和拆分文件 2 归并，结果再和拆分文件 3 归并，结果再和拆分文件 4 归并…… 最终得到完整的归并文件。
\n傻子都能看出来这个方法的不靠谱，但是我们还是将代码贴出来：
\n// 归并文件，这段代码填入上方 FileSort 函数中归并的留空位置 | |
char* mergeFileName = \"sort_merge.txt\"; | |
char file1[50] = \"SubSort\\\\sort_split0.txt\", file2[50] = {0}; | |
for (int i = 1; i < splitCount; i++) | |
{ | |
\tsprintf(file2, \"SubSort\\\\sort_split%d.txt\", i); | |
\tMergeFile(file1, file2, mergeFileName); | |
\tstrcpy(file1, mergeFileName); | |
\tprintf(\"已归并%d个文件，总共需归并%d个文件。\\n\", i + 1, splitCount); | |
} |
这个方法是真的不靠谱，一亿个数据半小时还没归并完。
\n分治归并
\n就是不断地两两分组归并，比方说 9 至 16 个文件归并成 5 至 8 个，5 至 8 个归并位 3 至 4 个，再归并为 2 个，最后合成完整的排序后文件。
\n// 分治归并文件，这段代码填入上方 FileSort 函数中归并的留空位置 | |
MergeFileR(0, splitCount - 1); | |
remove(\"SubSort\\\\sort_split0.txt\"); |
其中 MergeFileR 的定义如下：
\nvoid MergeFileR(int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint mid = (left + right) / 2; | |
\t// 递归归并 | |
\tMergeFileR(left, mid); | |
\tMergeFileR(mid + 1, right); | |
\t// 归并 | |
\tchar file1[50] = { 0 }, file2[50] = { 0 }, mergeFileName[50] = { 0 }; | |
\tsprintf(file1, \"SubSort\\\\sort_split%d.txt\", left); | |
\tsprintf(file2, \"SubSort\\\\sort_split%d.txt\", mid + 1); | |
\tsprintf(mergeFileName, \"SubSort\\\\sort_split%d.txt\", left); | |
\tMergeFile(file1, file2, mergeFileName); | |
\tprintf(\"已归并%d与%d文件至%d。\\n\", left, mid + 1, left); | |
} |
这个方法要靠谱一点，测试如下：
\n![\"测试\"](\"test.png\")
进一步优化可以将基础操作从两个文件归并变成 3 个文件归并或者更多，这样分治时就是 3 合一或者更多。这样多路归并会增加内存开销和内部时间开销，但是会大大减少外部读写的开销。
\n更进一步优化可以引入败者树、最佳归并树等，我还不会。
\n", "tags": [ "计算机科学", "数据结构笔记", "算法", "数据结构", "排序" ] }, { "id": "https://www.starlinglin.top/computer-science/data-structure-note/%E6%A4%8B%E9%B8%9F%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0%20%EF%BC%8310%EF%BC%9A%E6%8E%92%E5%BA%8F%C2%B7%E4%B8%AD/", "url": "https://www.starlinglin.top/computer-science/data-structure-note/%E6%A4%8B%E9%B8%9F%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0%20%EF%BC%8310%EF%BC%9A%E6%8E%92%E5%BA%8F%C2%B7%E4%B8%AD/", "title": "椋鸟数据结构笔记#10：排序·中", "date_published": "2024-04-20T12:45:25.000Z", "content_html": "该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n![\"归并排序\"](\"%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F.gif\")
归并排序是一种非常高效的排序算法。基本思想是将一个大数组分成两半，分别对这两半进行排序，然后将排序好的两部分合并在一起。这个过程递归进行，每次将数组分半，直到每个部分只有一个元素，自然是有序的，最终得到一个完整的有序数组。
\n归并排序的步骤如下：
\n归并排序的时间复杂度为O(NlogN)，在最好最坏情况都是如此。是一种效率稳定的排序方法。
\nvoid _MergeSort(int* arr, int left, int right, int* tmp) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint mid = (left + right) / 2; | |
\t//[left, mid] [mid + 1, right] | |
\t | |
\t_MergeSort(arr, left, mid, tmp); | |
\t_MergeSort(arr, mid + 1, right, tmp); | |
\t// 合并 | |
\tint begin1 = left, end1 = mid; | |
\tint begin2 = mid + 1, end2 = right; | |
\tint index = left; | |
\twhile (begin1 <= end1 && begin2 <= end2) | |
\t{ | |
\t\tif (arr[begin1] < arr[begin2]) | |
\t\t{ | |
\t\t\ttmp[index++] = arr[begin1++]; | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\ttmp[index++] = arr[begin2++]; | |
\t\t} | |
\t} | |
\twhile (begin1 <= end1) | |
\t{ | |
\t\ttmp[index++] = arr[begin1++]; | |
\t} | |
\twhile (begin2 <= end2) | |
\t{ | |
\t\ttmp[index++] = arr[begin2++]; | |
\t} | |
\tmemcpy(arr + left, tmp + left, sizeof(int) * (right - left + 1)); | |
} | |
void MergeSort(int* arr, int n) | |
{ | |
\tint* tmp = (int*)malloc(sizeof(int) * n); | |
\tif (tmp == NULL) | |
\t{ | |
\t\tperror(\"malloc\"); | |
\t\treturn; | |
\t} | |
\t_MergeSort(arr, 0, n - 1, tmp); | |
\tfree(tmp); | |
\ttmp = NULL; | |
} |
同样的，归并排序的递归也可以整合为非递归的形式：
\nvoid MergeSortNonR(int* arr, int n) | |
{ | |
\tint* tmp = (int*)malloc(n * sizeof(int)); | |
\tif (tmp == NULL) | |
\t{ | |
\t\tperror(\"malloc fail\"); | |
\t\treturn; | |
\t} | |
\tfor (int gap = 1; gap < n; gap *= 2) | |
\t{ | |
\t\tfor (int j = 0; j < n; j += 2 * gap) | |
\t\t{ | |
\t\t\tint begin1 = j, end1 = begin1 + gap - 1; | |
\t\t\tint begin2 = begin1 + gap, end2 = begin2 + gap - 1; | |
\t\t\tif (end1 >= n || begin2 >= n) | |
\t\t\t{ | |
\t\t\t\tbreak; | |
\t\t\t} | |
\t\t\tif (end2 >= n) | |
\t\t\t{ | |
\t\t\t\tend2 = n - 1; | |
\t\t\t} | |
\t\t\tint i = j; | |
\t\t\twhile (begin1 <= end1 && begin2 <= end2) | |
\t\t\t{ | |
\t\t\t\tif (arr[begin1] < arr[begin2]) | |
\t\t\t\t{ | |
\t\t\t\t\ttmp[i++] = arr[begin1++]; | |
\t\t\t\t} | |
\t\t\t\telse | |
\t\t\t\t{ | |
\t\t\t\t\ttmp[i++] = arr[begin2++]; | |
\t\t\t\t} | |
\t\t\t} | |
\t\t\twhile (begin1 <= end1) | |
\t\t\t{ | |
\t\t\t\ttmp[i++] = arr[begin1++]; | |
\t\t\t} | |
\t\t\twhile (begin2 <= end2) | |
\t\t\t{ | |
\t\t\t\ttmp[i++] = arr[begin2++]; | |
\t\t\t} | |
\t\t\tmemcpy(arr + j, tmp + j, sizeof(int) * (end2 - j + 1));\t// 用 j 不用 begin1，begin1 已经改变 | |
\t\t} | |
\t} | |
\tfree(tmp); | |
\ttmp = NULL; | |
} |
下面是对一千万个随机数据的排序测试
\n![\"一千万随机数据测试归并排序\"](\"test1.png\")
归并排序是稳定的。
\n非比较排序不通过直接比较元素之间的大小关系来排序，而是利用其他方法，如数字或者字符串的特性。
\n非比较排序往往能达到非常非常高的时间效率，但是也往往受到非常大的使用限制。
\n计数排序使用一个额外的数组来记录每个值的出现次数，然后根据这些计数来组织输出排序结果。
\n计数排序的步骤：
\n计数排序的时间复杂度是O(N+K)，其中 K 是数组中数据跨度的范围大小（比方说一个数组中所有数据都是 1，那这个跨度就是 1，如果里面有一个 1 变成了 100 万，那 K 就直接变成了 100 万）。
\n所以说，如果数据跨度比较小，计数排序的时间复杂度就可以认为是O(N)，其效率非常离谱。
\nvoid CountSort(int* arr, int n) | |
{ | |
\tint max = arr[0]; | |
\tint min = arr[0]; | |
\tfor (int i = 1; i < n; ++i) | |
\t{ | |
\t\tif (arr[i] > max) | |
\t\t{ | |
\t\t\tmax = arr[i]; | |
\t\t} | |
\t\tif (arr[i] < min) | |
\t\t{ | |
\t\t\tmin = arr[i]; | |
\t\t} | |
\t} | |
\tint range = max - min + 1; | |
\tint* count = (int*)malloc(sizeof(int) * range); | |
\tif (count == NULL) | |
\t{ | |
\t\tperror(\"malloc\"); | |
\t\treturn; | |
\t} | |
\tmemset(count, 0, sizeof(int) * range); | |
\tfor (int i = 0; i < n; ++i) | |
\t{ | |
\t\tcount[arr[i] - min]++; | |
\t} | |
\tint index = 0; | |
\tfor (int i = 0; i < range; ++i) | |
\t{ | |
\t\twhile (count[i]--) | |
\t\t{ | |
\t\t\tarr[index++] = i + min; | |
\t\t} | |
\t} | |
\tfree(count); | |
\tcount = NULL; | |
} |
下面是对一千万个随机数据的排序测试（数据在 0 到 32767）：
\n![\"一千万随机数据计数排序测试\"](\"test2.png\")
下面是对一千万个随机数据的排序测试（数据在 0 到十亿）：
\n![\"一千万随机数据计数排序测试\"](\"test3.png\")
就像上面所说，计数排序只有在数据跨度较小时能够获得极高的时间效率。而且计数排序只能用于排序整型数据。另外，其空间复杂度较高。
\n注意：桶排序效率高的离谱，局限性也高的离谱，如果还是随便生成大量数据测试可能导致程序崩溃甚至电脑卡死！
\n桶排序是基于基数排序和分布的一种排序算法。其基本思想是将一个区间内的数据分散到多个有序的桶中，然后分别对每个桶中的元素进行排序，最后将各个桶中的元素按顺序合并，从而得到一个完全有序的数组。
\n桶排序的步骤描述起来较难理解，下面在代码部分详细解释。
\n桶排序时间复杂度最低可达O(N)，非常高。但是但凡数据跨度比较大、bucketsize（下面会解释是什么）选取的函数不那么合适，就会导致时间和空间复杂度剧烈变化，可能直接造成代码崩溃。
\nvoid BucketSort(int* arr, int n) | |
{ | |
\tint max = arr[0]; | |
\tint min = arr[0]; | |
\tfor (int i = 1; i < n; ++i) | |
\t{ | |
\t\tif (arr[i] > max) | |
\t\t{ | |
\t\t\tmax = arr[i]; | |
\t\t} | |
\t\tif (arr[i] < min) | |
\t\t{ | |
\t\t\tmin = arr[i]; | |
\t\t} | |
\t} | |
\tint range = max - min + 1; | |
\tint bucketSize = 5;\t// 这里对不同的情形需要设置不同的数字，效率差距非常大 | |
\tint bucketCount = range / bucketSize + 1; | |
\tint** bucket = (int**)malloc(sizeof(int*) * bucketCount); | |
\tfor (int i = 0; i < bucketCount; ++i) | |
\t{ | |
\t\tbucket[i] = (int*)malloc(sizeof(int) * n); | |
\t} | |
\tint* count = (int*)malloc(sizeof(int) * bucketCount); | |
\tmemset(count, 0, sizeof(int) * bucketCount); | |
\tfor (int i = 0; i < n; ++i) | |
\t{ | |
\t\tint index = (arr[i] - min) / bucketSize; | |
\t\tbucket[index][count[index]++] = arr[i]; | |
\t} | |
\tint index = 0; | |
\tfor (int i = 0; i < bucketCount; ++i) | |
\t{ | |
\t\tInsertSort(bucket[i], count[i]);\t// 采用插入排序只是一种方法，这里不唯一 | |
\t\tfor (int j = 0; j < count[i]; ++j) | |
\t\t{ | |
\t\t\tarr[index++] = bucket[i][j]; | |
\t\t} | |
\t} | |
\tfor (int i = 0; i < bucketCount; ++i) | |
\t{ | |
\t\tfree(bucket[i]); | |
\t} | |
\tfree(bucket); | |
\tbucket = NULL; | |
\tfree(count); | |
\tcount = NULL; | |
} |
在上方实现中，我们首先确定了数据范围 range。
\n然后我们要根据 range 确定每一个桶内我们要存放范围大小为多少的数据，也就是 bucketSize。注意，这不是说每个 bucket 只能放 bucketSize 个数据，而是可以放多少值不同的数据（相同值可以无限叠放）。
\n随后我们就计算出了桶的数量 bucketCount，并且创建了这么多桶。同时每一个桶都配备了一个计数器（对应到 count 数组里）。
\n最后就是与计数排序类似的步骤，数据分桶再收集即可。
\n100 万 0~99 的数据，bucketSize = 2：
\n![\"桶排序，bucketSize=2\"](\"test6.png\")
100 万 0~99 的数据，bucketSize = 5：
\n![\"桶排序，bucketSize=5\"](\"test7.png\")
100 万 0~99 的数据，bucketSize = 1：
\n![\"桶排序，bucketSize=1\"](\"test8.png\")
![\"基数排序\"](\"%E5%9F%BA%E6%95%B0%E6%8E%92%E5%BA%8F.gif\")
基数排序是对计数排序的一个升级方法。只要我们 == 把数组中的数从低位到高位逐次进行只看某一位的计数排序，最终就能得到有序的数组。== 这可能有些难以理解，但是我们可以看一个例子：
\n\n\n数组 =[170,45,75,90,802,24,2,66]
\n我们将按照十进制的个位、十位、百位等进行排序。这里最大的数字是 802，有三位数字，所以我们将进行三轮排序。
\n第一轮：按个位排序
\n\n
\n- 170 的个位是 0
\n- 45 的个位是 5
\n- 75 的个位是 5
\n- 90 的个位是 0
\n- 802 的个位是 2
\n- 24 的个位是 4
\n- 2 的个位是 2
\n- 66 的个位是 6
\n按个位排序的结果为：170,90,802,2,24,45,75,66170,90,802,2,24,45,75,66
\n第二轮：按十位排序
\n\n
\n- 170 的十位是 7
\n- 90 的十位是 9
\n- 802 的十位是 0
\n- 2 的十位是 0（没有十位，视为 0）
\n- 24 的十位是 2
\n- 45 的十位是 4
\n- 75 的十位是 7
\n- 66 的十位是 6
\n按十位排序的结果为：802,2,24,45,66,170,75,90802,2,24,45,66,170,75,90
\n第三轮：按百位排序
\n\n
\n- 802 的百位是 8
\n- 2 的百位是 0（没有百位，视为 0）
\n- 24 的百位是 0
\n- 45 的百位是 0
\n- 66 的百位是 0
\n- 170 的百位是 1
\n- 75 的百位是 0
\n- 90 的百位是 0
\n按百位排序的结果为：2,24,45,66,75,90,170,8022,24,45,66,75,90,170,802
\n最终排序结果为：2,24,45,66,75,90,170,8022,24,45,66,75,90,170,802
\n
基数排序的时间复杂度仅为O(k×N)，非常高效。
\nvoid RadixSort(int* arr, int n) | |
{ | |
\tint max = arr[0]; | |
\tfor (int i = 1; i < n; ++i) | |
\t{ | |
\t\tif (arr[i] > max) | |
\t\t{ | |
\t\t\tmax = arr[i]; | |
\t\t} | |
\t} | |
\tint maxDigit = 0; | |
\twhile (max) | |
\t{ | |
\t\tmax /= 10; | |
\t\t++maxDigit; | |
\t} | |
\tint* count = (int*)malloc(sizeof(int) * 10); | |
\tint* bucket = (int*)malloc(sizeof(int) * n); | |
\tint radix = 1; | |
\tfor (int i = 0; i < maxDigit; ++i)\t//@ | |
\t{ | |
\t\tmemset(count, 0, sizeof(int) * 10); | |
\t\tfor (int j = 0; j < n; ++j) | |
\t\t{ | |
\t\t\tcount[(arr[j] / radix) % 10]++; | |
\t\t} | |
\t\tfor (int j = 1; j < 10; ++j) | |
\t\t{ | |
\t\t\tcount[j] += count[j - 1]; | |
\t\t} | |
\t\tfor (int j = n - 1; j >= 0; --j) | |
\t\t{ | |
\t\t\tbucket[--count[(arr[j] / radix) % 10]] = arr[j]; | |
\t\t} | |
\t\tmemcpy(arr, bucket, sizeof(int) * n); | |
\t\tradix *= 10; | |
\t} | |
\tfree(count); | |
\tcount = NULL; | |
\tfree(bucket); | |
\tbucket = NULL; | |
} |
对于上方 @标记的循环体中的 3 个子循环，这里需要给出一些解锁：
\n第一个 for 循环
\n循环遍历整个数组，计算当前位的数字（个位、十位、百位等），并对应的增加 count 数组中对应索引的值。这里arr[j]/radix%10 计算出当前位的值（如个位、十位等），count 数组用来记录每个数字（0-9）在当前位出现的次数。
\n第二个 for 循环
\n通过累加前一个索引的 count 值，将 count 数组转化为前缀和数组。这一步是为了在下一个循环中能够直接定位每个元素在 bucket 中的存放位置。每个元素的存放位置取决于它当前位的值，并使用前缀和确定其在 bucket 中的结束位置。
\n第三个 for 循环
\n从数组的最后一个元素开始向前遍历，这样可以保持排序的稳定性（即相同值的元素保持原有顺序）。通过查找当前位的数字对应的 count 数组值，确定元素在 bucket 中的位置（使用 --count 是为了下次遇到同样的数时位置向前移动一个单位），然后将元素放在 bucket 中相应的位置。
下面是对一千万个随机数据的排序测试（数据在 0 到 32767）：
\n![\"一千万随机数据基数排序测试\"](\"test4.png\")
下面是对一千万个随机数据的排序测试（数据在 0 到十亿）：
\n![\"一千万随机数据基数排序测试\"](\"test5.png\")
可以看到，基数排序一定程度上减除了计数排序对大范围数据处理的劣势，但是也增加了空间复杂度。与此同时，基数排序依旧保留了计数排序只能处理整数的缺点。
\n", "tags": [ "计算机科学", "数据结构笔记", "算法", "数据结构", "排序" ] }, { "id": "https://www.starlinglin.top/computer-science/data-structure-note/%E6%A4%8B%E9%B8%9F%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0%20%EF%BC%839%EF%BC%9A%E6%8E%92%E5%BA%8F%C2%B7%E4%B8%8A/", "url": "https://www.starlinglin.top/computer-science/data-structure-note/%E6%A4%8B%E9%B8%9F%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0%20%EF%BC%839%EF%BC%9A%E6%8E%92%E5%BA%8F%C2%B7%E4%B8%8A/", "title": "椋鸟数据结构笔记#9：排序·上", "date_published": "2024-04-11T16:55:22.000Z", "content_html": "该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。
\n萌新的学习笔记，写错了恳请斧正。
\n先介绍一个概念，就是排序的稳定性。
\n排序算法的稳定性是指，如果待排序的序列中存在值相等的元素，经过排序后这些元素之间的先后顺序不变。简而言之，稳定的排序算法可以保留相等元素原本的相对顺序。
\n假设有一组人的年龄列表，有些人年龄相同：5,3,8,3,2。
\n如果我们对这个列表进行稳定排序，那么两个年龄为 3 的人在排序后的列表中，先出现的那个人在原列表中也是先出现的。
\n如果排序算法是稳定的，排序后我们得到的可能是这样：2,3 (第一个),3 (第二个),5,8。
\n如果排序算法是不稳定的，排序后可能得到：2,3 (第二个),3 (第一个),5,8，这里 3 的顺序被颠倒了，说明排序算法是不稳定的。
\n稳定性在某些场合下是很重要的。比如，在处理多关键字排序时，稳定性可以保证前一次排序的结果在后一次排序时不会被打乱。如果一个排序算法是稳定的，那么它可以更容易地被用于复杂的排序任务中。
\n![\"插入排序\"](\"%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F.gif\")
直接插入排序是一种简单直观的排序算法。通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用原地排序，因此适合用于小规模数据。
\n直接插入排序的步骤：
\n在最坏的情况下，插入排序的时间复杂度为O(N2)，其中N 是数组的长度。在最好的情况下，如果数组已经是排好序的，插入排序的时间复杂度可以降低到O(N)，平均来说，其复杂度更接近O(N2)。适用于小规模数据的排序或者原本就接近有序的情况。
\nvoid InsertSort(int* arr, int n) | |
{ | |
\tfor (int i = 0; i < n - 1; ++i) | |
\t{ | |
\t\tint end = i; | |
\t\tint tmp = arr[end + 1]; | |
\t\twhile (end >= 0) | |
\t\t{ | |
\t\t\tif (tmp < arr[end]) | |
\t\t\t{ | |
\t\t\t\tarr[end + 1] = arr[end]; | |
\t\t\t\t--end; | |
\t\t\t} | |
\t\t\telse | |
\t\t\t{ | |
\t\t\t\tbreak; | |
\t\t\t} | |
\t\t} | |
\t\tarr[end + 1] = tmp; | |
\t} | |
} |
直接插入排序是稳定的。
\n![\"希尔排序\"](\"%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F.gif\")
希尔排序是插入排序的一种改进版本，也被称为 “缩小增量排序”。其核心思想是将原来要排序的列表分割成多个子序列，先让这些子序列基本有序，再对整个列表进行一次直接插入排序。这样做的目的是让数据移动的次数减少，从而达到减少排序时间的目的。希尔排序的效率比直接插入排序有显著提升。
\n希尔排序的步骤：
\ngap 的序列不一定要像我这样取（每次是上一次的一半），但是不同的增量序列会对这个算法的时间复杂度产生很大的影响。
\n希尔排序的时间复杂度计算起来非常困难，或者说数学界都还没有给出一个合适的答案。
\n有人指出当gap=2t−k+1−1 时，希尔排序的时间复杂度为O(n3/2)，其中t 是排序次数，1≤k≤t≤⌊log2(n+1)⌋。
\n还有人得出希尔排序在某个范围内比较次数约为 n1.3，当 n 趋于正无穷时，可以减少到n(log2n)2。
\n如果我们使用 Knuth 提出的序列，即gap=⌊gap/3⌋+1，那么时间复杂度约为O(N1.25)。
\n但是我们还是可以知道希尔排序最坏情况下时间复杂度为O(N2)，最好情况时间复杂度高于O(NlogN)，一般情况下都远优于时间复杂度为O(N2)的算法。
\nvoid ShellSort(int* arr, int n) | |
{ | |
\tint gap = n; | |
\twhile (gap > 1) | |
\t{ | |
\t\tgap /= 2; | |
\t\tfor (int i = 0; i < n - gap; ++i) | |
\t\t{ | |
\t\t\tint end = i; | |
\t\t\tint tmp = arr[end + gap]; | |
\t\t\twhile (end >= 0) | |
\t\t\t{ | |
\t\t\t\tif (tmp < arr[end]) | |
\t\t\t\t{ | |
\t\t\t\t\tarr[end + gap] = arr[end]; | |
\t\t\t\t\tend -= gap; | |
\t\t\t\t} | |
\t\t\t\telse | |
\t\t\t\t{ | |
\t\t\t\t\tbreak; | |
\t\t\t\t} | |
\t\t\t} | |
\t\t\tarr[end + gap] = tmp; | |
\t\t} | |
\t} | |
} |
希尔排序是不稳定的。
\n![\"选择排序\"](\"%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F.gif\")
直接选择排序是一种简单直观的排序算法。简单说就是在一堆数中，一次次从头到尾挑出最小的数，然后依次排列起来。
\n直接选择排序的步骤：
\n时间复杂度为O(N2)，没有最好最坏的说法，效率不高。
\nvoid SelectSort(int* arr, int n) | |
{ | |
\tfor (int i = 0; i < n - 1; ++i) | |
\t{ | |
\t\tint min = i; | |
\t\tfor (int j = i + 1; j < n; ++j) | |
\t\t{ | |
\t\t\tif (arr[j] < arr[min]) | |
\t\t\t{ | |
\t\t\t\tmin = j; | |
\t\t\t} | |
\t\t} | |
\t\tif (min != i) | |
\t\t{ | |
\t\t\tSwap(&arr[i], &arr[min]); | |
\t\t} | |
\t} | |
} |
直接选择排序是不稳定的。
\n![\"堆排序\"](\"%E5%A0%86%E6%8E%92%E5%BA%8F.gif\")
堆排序算法是利用大堆（或小堆）的性质来对数组进行排序的，相关内容在前几篇笔记已详细介绍。
\n堆排序的步骤：
\n堆排序的效率非常高，时间复杂度为O(NlogN)。
\nvoid AdjustDown(int* arr, int n, int parent) | |
{ | |
\tint child = parent * 2 + 1; | |
\twhile (child < n) | |
\t{ | |
\t\tif (child + 1 < n && arr[child + 1] > arr[child]) | |
\t\t{ | |
\t\t\t++child; | |
\t\t} | |
\t\tif (arr[child] > arr[parent]) | |
\t\t{ | |
\t\t\tSwap(&arr[child], &arr[parent]); | |
\t\t\tparent = child; | |
\t\t\tchild = parent * 2 + 1; | |
\t\t} | |
\t\telse | |
\t\t{ | |
\t\t\tbreak; | |
\t\t} | |
\t} | |
} | |
void HeapSort(int* arr, int n) | |
{ | |
\tfor (int i = n / 2 - 1; i >= 0; --i) | |
\t{ | |
\t\tAdjustDown(arr, n, i); | |
\t} | |
\tint end = n - 1; | |
\twhile (end > 0) | |
\t{ | |
\t\tSwap(&arr[0], &arr[end]); | |
\t\tAdjustDown(arr, end, 0); | |
\t\t--end; | |
\t} | |
} |
堆排序是不稳定的。
\n![\"冒泡排序\"](\"%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F.gif\")
冒泡排序是我们的老熟人了，是一种简单的排序算法，重复的遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。越小（或越大）的元素会经过交换慢慢 “浮” 到数列的顶端，因此称为冒泡排序。
\n冒泡排序的步骤如下：
\n时间复杂度为O(N2)，而且大 O 表示法省略的常数不小，效率相当低。
\nvoid BubbleSort(int* arr, int n) | |
{ | |
\tfor (int i = 0; i < n - 1; ++i) | |
\t{ | |
\t\tint flag = 0; | |
\t\tfor (int j = 0; j < n - i - 1; ++j) | |
\t\t{ | |
\t\t\tif (arr[j] > arr[j + 1]) | |
\t\t\t{ | |
\t\t\t\tSwap(&arr[j], &arr[j + 1]); | |
\t\t\t\tflag = 1; | |
\t\t\t} | |
\t\t} | |
\t\tif (flag == 0) | |
\t\t{ | |
\t\t\tbreak; | |
\t\t} | |
\t} | |
} |
冒泡排序是稳定的。
\n快速排序是一种非常高效的排序，基本思想是 ==“分而治之”==（将一个大问题分解成小问题）。
\n快速排序的核心是选择一个 “基准值”，然后将数组分为两部分：一部分包含小于基准值的元素，另一部分包含大于基准值的元素。通过递归不断对这两部分继续进行分区，直到整个序列有序。
\n快速排序的步骤如下：
\n快速排序的效率非常高，平均时间复杂度为O(NlogN)，但最坏情况下会退化到O(N2)。
\n但是非常神奇，这个最坏情况与其他排序不同，是在原数组有序或者接近有序的情况下为最坏情况。（越乱排序越快）
\n但是我们可以通过一些技巧来避免快速排序会取到最坏情况这件事，这会在下面介绍。
\n![\"Hoare快排\"](\"hoare.gif\")
这是 Hoare 大佬刚提出快速排序时给出的方法。
\n我们记录排序区间的左下标 left 和右下标 right，并选取基准值 key 的下标（这边我们以 key=left 为例，若选择 key=right 下面反过来想就能得出）。我们使 right 从右往左跑直到找到小于基准值或者遇到 left，然后我们让 left 从左往右跑直到找到大于基准值或者遇到 right，随后交换 left 和 right 标记的值。重复这个过程就能完成一次分区，随后再写入递归即可完成排序。
\nvoid QuickSort(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint key = left, begin = left, end = right; | |
\twhile (left < right) | |
\t{ | |
\t\twhile (left < right && arr[right] >= arr[key]) | |
\t\t{ | |
\t\t\t--right; | |
\t\t} | |
\t\twhile (left < right && arr[left] <= arr[key]) | |
\t\t{ | |
\t\t\t++left; | |
\t\t} | |
\t\tSwap(&arr[left], &arr[right]); | |
\t} | |
\tSwap(&arr[left], &arr[key]); | |
\tQuickSort(arr, begin, left - 1); | |
\tQuickSort(arr, left + 1, end); | |
} |
![\"挖坑法\"](\"dighole.gif\")
挖坑法在逻辑上更易于理解，不会陷入为什么左右标记不会越过对方、为什么一定要先移动某个标记等问题。
\n挖坑法就是把基准值单独复制出来放到一个变量里，原本的位置作为一个 “坑位”（还是假设 key=left）。然后右标记左移直到发现小于基准值的数，把这个数 “挖出来” 填到 “坑位” 里。这个时候挖走的形成了一个新的坑位，这时左标记右移直到找到大于基准值的数，再次挖到 “坑位” 里。重复这个过程直到两个指针相遇（数据都分区好了），最后把原本挖出去的基准值再填回来（这个时候坑位正好在中间）。这就成功完成了一次分区过程，递归即可。
\nvoid QuickSortDigHole(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint key = left, begin = left, end = right; | |
\tint tmp = arr[key];\t// 挖坑 | |
\twhile (left < right) | |
\t{ | |
\t\twhile (left < right && arr[right] >= tmp) | |
\t\t{ | |
\t\t\t--right; | |
\t\t} | |
\t\tarr[left] = arr[right];\t// 此时坑位从左边变为右边 | |
\t\twhile (left < right && arr[left] <= tmp) | |
\t\t{ | |
\t\t\t++left; | |
\t\t} | |
\t\tarr[right] = arr[left];\t// 此时坑位从右边变为左边 | |
\t} | |
\tarr[left] = tmp; | |
\tQuickSort(arr, begin, left - 1); | |
\tQuickSort(arr, left + 1, end); | |
} |
![\"前后指针法\"](\"prevcur.gif\")
前后指针法的代码更简洁，也不难理解。
\n就是一开始把 prev 标记放在 left（还是假设 key=left），cur 标记放在 left+1，然后前指针 cur 一直往前冲，遇到比基准值小的数就和后指针 prev 标记的值对调，再让后指针往前一步。重复这个过程让小于基准的值全部堆到数组的前面（准确说是 prev 的前面），最后把 key 标记的值和 prev 标记的对调就完成了一次分区。 递归即可。
\nvoid QuickSortPrevCur(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint key = left, begin = left, end = right; | |
\tint prev = left, cur = left + 1; | |
\twhile (cur <= right) | |
\t{ | |
\t\tif (arr[cur] < arr[key] && ++prev != cur) | |
\t\t{ | |
\t\t\tSwap(&arr[prev], &arr[cur]); | |
\t\t} | |
\t\t++cur; | |
\t} | |
\tSwap(&arr[prev], &arr[key]); | |
\tkey = prev; | |
\t//[begin, key - 1] [key] [key + 1, end] | |
\tQuickSort(arr, begin, key - 1); | |
\tQuickSort(arr, key + 1, end); | |
} |
这个方法没怎么好说的，就是用栈模拟递归，里面每一次分区依旧可以选择上面任意一种方法。
\nvoid InitStack(pStack pst) | |
{ | |
\tassert(pst); | |
\tpst->_data = NULL; | |
\tpst->_top = 0; | |
\tpst->_capacity = 0; | |
} | |
void StackPush(pStack pst, STDataType x) | |
{ | |
\tassert(pst); | |
\tStackCheck(pst); | |
\tmemcpy(&(pst->_data[pst->_top]), &x, sizeof(STDataType)); | |
\tpst->_top++; | |
} | |
void StackPop(pStack pst) | |
{ | |
\tassert(pst); | |
\tassert(!StackEmpty(pst)); | |
\tpst->_top--; | |
} | |
STDataType StackTop(pStack pst) | |
{ | |
\tassert(pst); | |
\treturn pst->_data[pst->_top - 1]; | |
} | |
void StackDestory(pStack pst) | |
{ | |
\tassert(pst); | |
\tfree(pst->_data); | |
\tpst->_capacity = 0; | |
\tpst->_top = 0; | |
\tpst->_data = NULL; | |
} | |
void QuickSortNonR(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tStack st; | |
\tInitStack(&st); | |
\tStackPush(&st, left); | |
\tStackPush(&st, right); | |
\twhile (!StackEmpty(&st)) | |
\t{ | |
\t\tint end = StackTop(&st); | |
\t\tStackPop(&st); | |
\t\tint begin = StackTop(&st); | |
\t\tStackPop(&st); | |
\t\tint key = begin; | |
\t\tint prev = begin, cur = begin + 1; | |
\t\twhile (cur <= end) | |
\t\t{ | |
\t\t\tif (arr[cur] < arr[key] && ++prev != cur) | |
\t\t\t{ | |
\t\t\t\tSwap(&arr[prev], &arr[cur]); | |
\t\t\t} | |
\t\t\t++cur; | |
\t\t} | |
\t\tSwap(&arr[prev], &arr[key]); | |
\t\tkey = prev; | |
\t\t//[begin, key - 1] [key] [key + 1, end] | |
\t\tif (begin < key - 1) | |
\t\t{ | |
\t\t\tStackPush(&st, begin); | |
\t\t\tStackPush(&st, key - 1); | |
\t\t} | |
\t\tif (key + 1 < end) | |
\t\t{ | |
\t\t\tStackPush(&st, key + 1); | |
\t\t\tStackPush(&st, end); | |
\t\t} | |
\t} | |
\tStackDestory(&st); | |
} |
除了非递归的方法，这几个实现的时间复杂度并没有太多区别，使用非递归的方法会慢一点点。下面是对一千万个随机数据的排序测试（单位毫秒）：
\n
这个方法是在序列中随机选一个值和首元素调换再作为基准值，大大减小了遇到最坏情况（每次选 key 是有序的）的可能。
\nvoid QuickSortRandomKey(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint key = left, begin = left, end = right; | |
\t// 生成随机数并将该位置与首位调换 | |
\tint random = rand() % (right - left + 1) + left; | |
\tSwap(&arr[random], &arr[left]); | |
\twhile (left < right) | |
\t{ | |
\t\twhile (left < right && arr[right] >= arr[key]) | |
\t\t{ | |
\t\t\t--right; | |
\t\t} | |
\t\twhile (left < right && arr[left] <= arr[key]) | |
\t\t{ | |
\t\t\t++left; | |
\t\t} | |
\t\tSwap(&arr[left], &arr[right]); | |
\t} | |
\tSwap(&arr[left], &arr[key]); | |
\tQuickSort(arr, begin, left - 1); | |
\tQuickSort(arr, left + 1, end); | |
} |
这个方法是取序列中 left、right、(left+right)/2 所对应的值的中位数与首元素调换作为基准值，这几乎完全避免了最坏情况的可能。
\nint GetMid(int* arr, int left, int right) | |
{ | |
\tint center = (left + right) / 2; | |
\tif (arr[left] > arr[center]) | |
\t{ | |
\t\tSwap(&arr[left], &arr[center]); | |
\t} | |
\tif (arr[left] > arr[right]) | |
\t{ | |
\t\tSwap(&arr[left], &arr[right]); | |
\t} | |
\tif (arr[left] > arr[center]) | |
\t{ | |
\t\tSwap(&arr[center], &arr[right]); | |
\t} | |
\treturn arr[center]; | |
} | |
void QuickSortMidKey(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tint key = left, begin = left, end = right; | |
\t// 三数取中 | |
\tint mid = GetMid(arr, left, right); | |
\tSwap(&arr[mid], &arr[left]); | |
\twhile (left < right) | |
\t{ | |
\t\twhile (left < right && arr[right] >= arr[key]) | |
\t\t{ | |
\t\t\t--right; | |
\t\t} | |
\t\twhile (left < right && arr[left] <= arr[key]) | |
\t\t{ | |
\t\t\t++left; | |
\t\t} | |
\t\tSwap(&arr[left], &arr[right]); | |
\t} | |
\tSwap(&arr[left], &arr[key]); | |
\tQuickSort(arr, begin, left - 1); | |
\tQuickSort(arr, left + 1, end); | |
} |
当递归已经进行到序列变的很短的时候，依旧选择继续递归快速排序的效率其实较低，反而不如将已经较短的序列拿去进行插入排序。所以在递归时加上一个选择语句进行优化：
\nvoid QuickSortOptimized(int* arr, int left, int right) | |
{ | |
\tif (left >= right) | |
\t{ | |
\t\treturn; | |
\t} | |
\tif (right - left < 10) | |
\t{ | |
\t\tInsertSort(arr + left, right - left + 1); | |
\t} | |
\telse | |
\t{ | |
\t\tint key = left, begin = left, end = right; | |
\t\twhile (left < right) | |
\t\t{ | |
\t\t\twhile (left < right && arr[right] >= arr[key]) | |
\t\t\t{ | |
\t\t\t\t--right; | |
\t\t\t} | |
\t\t\twhile (left < right && arr[left] <= arr[key]) | |
\t\t\t{ | |
\t\t\t\t++left; | |
\t\t\t} | |
\t\t\tSwap(&arr[left], &arr[right]); | |
\t\t} | |
\t\tSwap(&arr[left], &arr[key]); | |
\t\tQuickSort(arr, begin, left - 1); | |
\t\tQuickSort(arr, left + 1, end); | |
\t} | |
} |
对于随机序列，随机选 key 和三数取中法并没有太大的作用：
\n
但是如果是有序或者近有序序列，就完爆原版了：
\n
而小区间优化，说实话效果有限：
\n
快速排序是不稳定的。
\n未完待续。
\n