博客

椋鸟Swift笔记#0：学习Swift前

2025-12-18T09:38:00.089Z

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自 ChaoCode 的视频课程，强烈推荐。

该系列适合有其他语言基础的人观看，基础语法部分描述较少，可能仅列出一些 Swift 的特异点。

# 关于 Swift 语言

Swift 语言是 Apple 平台的开发语言，面世时间很短，远远比不过老牌的编程，非常简洁也非常现代（当然也带来了诸如社区不完善、语法特性更新较快等一些缺点）。

本系列博客是奔着 SwiftUI 去的，基础语法大概过一下就会到 SwiftUI 部分，所以没有 C++ 等面对对象语言基础的不适合看本系列博客。

# 你需要准备的

# 1. 你需要一台 Mac

是的，没有 Mac 学习 Swift 寸步难行。你当然可以试着用网页 Swift 或者一些其他方案，但是非常难用，很劝退。用 iPad 上的 Swift PlayGrounds 再外接键盘要好一点，但是也有很多弊端，完全比不上 Mac 开发。

# 2. 你需要一定程度的英文水平

Swift 太年轻了，以至于你 “只能在英文社区找到的内容” 会比 C/Cpp 等多的多。很多时候你得读官方文档，纯英文的。

不过你可以借助 AI 来阅读，但是终究有点麻烦。因为有的时候你不仅仅是要查阅一条固定的信息，而是根据一些模糊的想法或需求去翻来翻去，在专业领域 AI 做这类工作并不可靠，经常出问题。

# Xcode 环境搭建

先看看你电脑的 Mac 型号和 OS 版本，比方说一台 18 年 MacBook Air，最高系统版本是 Sonoma 14.8.3，那么支持的 XCode 版本就是

椋鸟Swift笔记#1：常量变量和print

2025-12-18T09:06:49.974Z

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自 ChaoCode 的视频课程，强烈推荐。

关于解决在iOS的XP3播放器中由汉化组弹窗导致的闪退问题

2025-12-11T18:34:08.860Z

本文不提供任何解包修改工具，请自行 Github 寻找，与本文作者无关。

本文作者不支持任何形式的游戏倒卖。

iOS 想玩 XP3 格式的游戏，自然绕不开应用市场中的 XP3Player 或者手动侧载 KrKr。但是无论是哪一个，在现在的 iOS 系统中都会出现奇怪的闪退问题（有反馈说更新到 iOS26 可能解决，但我不想更新系统）。

关于本博客日后更新

2025-12-03T16:10:23.000Z

放置了一年多，差点忘了自己还有一个博客了。

日后会不定期更新一些内容，但是之前没做完的 cpp 笔记、Linux 笔记、数据结构笔记应该是不会继续更新了：一方面离我现在学到的内容太远；另一方面没有时间去长期频繁更新。

日后更新应该不会仅限于计算机相关，还有各种各样我喜欢的东西。

解谜游戏-RailBound轨道联结-攻略

2024-11-28T18:49:29.000Z

此游戏关卡随着版本变动，不能保证时效性。本人游戏版本为 v3.06。

很多题目存在多解，试试自己思考能不能写出不一样的答案。

这个游戏玩法新颖，245 个关卡层层推进，十分有意思。

第一章节

第一章节-扩展关

第二章节

第二章节-扩展关

第三章节

第三章节-扩展关

第四章节

第四章节-扩展关

第五章节

第五章节-扩展关

第六章节

第六章节-扩展关

第七章节

第七章节-扩展关

第八章节

第八章节-扩展关

第九章节

第九章节-扩展关

第十章节

第十章节-扩展关

第十一章节

第十一章节-扩展关

第十二章节

第十二章节-扩展关

井号章节

这个章节余量轨道相当多，可以说是随便摆。

彩蛋章节

我们回到目录画面，然后在左边看到这样一个施工图标。（其实是 credit）

点进去之后拖到最底下，这里我们看到最后一个隐藏关卡 “❤️”。

这一关解法如下：

转载·算法描述语言ADL

2024-09-21T07:26:09.000Z

转载自《数据结构》（第三版）- 刘大有、杨博等。

用算法描述语言 ADL 书写算法的格式及规定如下：

算法<算法名>(变量i1,···,变量in.变量j,···,变量jn)
// <算法的概括说明>或者/*<算法的概括说明>*/
<步骤名>.[<本步骤的概括说明>]
	<操作1> //<操作1的解释>或者/*<操作1的解释>*/
		或者(操作1的解释)或者<无解释>
	···
	<操作J1> //<操作J1的解释>或者/*<操作J1的解释>*/
		或者(操作J1的解释)或者<无解释>
···
<步骤名>.[<本步骤的概括说明>]
	<操作1> //<操作1的解释>或者/*<操作1的解释>*/
		或者(操作1的解释)或者<无解释>
	···
	<操作Jk> //<操作Jk的解释>或者/*<操作Jk的解释>*/
		或者(操作Jk的解释)或者<无解释>|

下面是对上述书写格式给出具体解释：

关于 “<算法名>(变量 i1,・・・, 变量 in. 变量 j,・・・, 变量 jn)” 的解释

  <算法名>是由字母和数字组成的有限字符串，并且字符串中的第一个符号必须是字母。
  在变量表中，变量ik为输入变量.1≤k≤m,m≥0,当m=O时.表示无输入变量;变量jk为输出变量，1≤k≤n,n≥1。

关于 <算法的概括说明> 的解释

  在算法的变量表后对整个算法进行概括说明，说明中应包含算法的主要思想,对算法功能和其变量的解释等。
  说明较短时使用//，较长时使用/**/

关于算法步骤的解释

  算法的每一步骤都要有步骤名，步骤名由<算法名或算法名缩写><数字>组成。
  步骤名后面的方括号内是对该步骤所执行操作的高度概括。
  方括号后是本步骤的一系列操作，每个操作由ADL语句给出,若某操作难于理解则需在其后对其做出解释。

关于符号 “|” 的解释

  每个算法都需要用符号“|”表示其被书写完毕，也就是说，符号“|”作为对应算法被书写完毕的结束符。
  注意算法不一定在符号“|”处运行结束。

可使用的算术运算符

  +、-、*、x、/、DIV、MOD、⌊⌋(取地板运算,如⌊x⌋的值是小于等于x的最大整数)、
  ⌈⌉(取天棚运算，如⌈x⌉的值是大于等于x的最小整数）.....

可用的关系、逻辑运算符、逻辑常量、集合运算符

关系运算符(＝、≠、＜、＞、≥、≤ ...)
逻辑运算符(AND、OR、NOT)
逻排常量(true、false)
集合运算符(∩、∪、-(差)...)

结束符

 通常每条语句(或每个操作)都用".”作为结束符。
 但在能判断语句结束的位置可略去“.”。

关于注释语句

注释语句有以下3种形式:
  1.较短的注释语句(注释内容不超过一行)用符号“//”开头,后面是具体注释的内容。
  2.较长的注释语句用符号“/*”开头,中间是具体注释的内容,用符号“*/”结尾。
  3.注释语句用左小括号“("开头，中间是具体的注释或说明内容，用右小括号“)”结尾。

关于赋值语句

 形如a←b,其中a是变量,b是表达式或变量;
 a↔b表示交换变量a和变量b的内容;
 a←b←c,表示既将c的值赋给变量a,又将其值赋给变量b。

关于条件语句

1.IF(或如果,或若)<逻辑表达式> THEN(或“，则”)(语句...语句m).
2.IF(或如果,或若)<逻辑表达式>
	THEN(或“，则")(语句...语句m).
	ELSE(或“;否则”)(语句...语句n).
其中m,n≥1。
3.CASE DO
		(<逻辑表达式 1>:(语句1...语句n).
		       ···
		<逻辑表达式m>:(语句...语句nm )).
其中,n≥1,m≥1,1≤i≤m。

关于循环语句

	1.WHILE<逻辑表达式>DO(语句1. ..语句n).
其中，n≥1。
	2.FOR<变量>=<算术表达式1> T0<算术表达式2>STEP<算术表达式3>
				DO(语句1. ... 语句n).
其中,n≥1。若<算术表达式3>=1,则“STEP<算术表达式3>"可略去。
	3.FOR V<变量>∈<集合> DO (语句...语句n).路
其中,n≥1。

关于转移语句
```
GOTO <步骤名>.
```

关于 EXIT 语句

  可用在通常的结束条件满足之前，用来结束WHILE或FOR循环的执行。
  EXIT语句使得程序转移到紧接在包含EXIT的(最内层的)WHILE或者FOR循环后面的第一个语句。

关于圆括号

当且仅当圆括号中只有1条语句时，圆括号可以省略。

关于输入、输出语句

输人语句为
	READ(x)
表示读取输人值赋给变量x。
输出语句为
	PRINT(<表达式>)
或
	PRINT<字符串常量>

椋鸟C++笔记#7：标准模板库STL初识

2024-09-11T13:30:34.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 标准模板库（Standard Template Library）

标准模板库 STL，是 C++ 标准库的一个非常重要的组成成分。它的作用就类似于一个工具箱，里面有很多现成的模板 “工具”，帮助我们更方便的处理数据。

# STL 的版本

STL 最早是由 Alexander Stepanov 和 Meng Lee 在惠普实验室开发出来的，是完全开源的，这个原始版本也是现在所有 STL 的始祖。

# P.J. 版

这个版本是 P.J. Plauger 开发的，不允许公开及修改。这个版本是 STL 最早期的版本之一，代码可读性差而且符号命名比较奇怪。但是 Windows Visual C++ 采用的是这个版本。

# RW 版

这个由 Rogue Wave 公司开发的版本，不允许公开及修改。这个版本着重于与商业环境的集成，通常用于大型企业级项目中。功能非常丰富且跨平台支持性极好。

# SGI 版

SGI 版本由 Silicon Graphics 公司开发，这个版本是标准 C++STL 的基础，也是使用最多的 STL 版本。这个版本是开源的，其设计高效而且稳定，代码风格优秀命名合理。是适合初学者的版本。

# STL 的组成部分

容器：就像不同类型的 “数据盒子”，用来存放各种数据，比如动态数组、链表、集合等。
迭代器：是用来从这些 “数据盒子” 里拿数据的 “工具”，就像指针，能帮助我们遍历和操作里面的内容。
算法：是一组现成的 “操作指令”，用来对数据进行排序、查找、复制等处理。
仿函数：仿函数就是一个带有 “函数功能” 的对象，能像函数一样被调用。
配接器：用来改变容器、迭代器或仿函数行为的工具。
空间配置器：类似于内存池，负责为容器开辟和释放内存。

椋鸟C++笔记#8：标准库中的string类

2024-09-11T13:30:34.000Z

本系列暴死，不会更新了。

本篇尚未完工

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# C 语言里的字符串

在学 C 语言的时候，我们使用过字符串，当时字符串是以 '\0' 结尾的字符的集合。同时，C 语言标准库里还提供了一些 str 函数用于处理字符串。但是这种字符串的使用有很大的缺陷：

关于字符串处理的库函数和字符串本身是分离的，不符合面向对象的思想。
内存管理非常复杂，依赖于程序员对每一个字符串进行分配和释放内存，容易出现内存泄露或者越界访问。
很多 str 函数的操作并没有那么方便，想实现一些功能会有比较繁琐的操作，还要考虑内存大小的问题容易出错。
C 语言的字符串并不方便动态扩展，需要手动重新分配内存。
虽然本质上 C 语言的字符串就是一个字符数组，但是这里字符串和字符数组表现出来的性质是有所不同的（详见 C 语言笔记 #20 的最后一个样例），这导致两者容易被搞混！

# C++ 中的 string 类

# string 类是什么

C++ 中的 std::string 类是标准库中用于处理字符串的类。它提供了一种高效、灵活且安全的方式来操作字符序列，替代了 C 语言中基于 char* 的字符串。 std::string 自动管理内存，支持动态扩展，避免了手动内存分配的复杂性。它提供了丰富的成员函数和操作符重载，如拼接、查找、截取、比较等操作，极大简化了字符串的处理。此外， std::string 还兼容 STL 的容器风格，支持迭代器和各种算法。

# string 类与 STL 的关系

首先，我们要知道 string 并不属于严格意义上的 STL。在早期的 C++ 标准化过程中，string 类是 C++ 标准库中一个独立设计的类，设计初衷是提供比 C 语言中的 char* 更强大、灵活的字符串操作能力。STL 和 string 的发展是同时的，因此 STL 中并没有单独做一个 string，但是 STL 比 string 更早被标准化并引入 C++ 标准。

# string 类其实也是一个类模板

C++ 中的 string 本质上是基于类模板的。虽然我们通常使用 string，但它实际上是 basic_string 类模板的一个特例化版本（ std::basic_string<char> ）。采用类模板主要是因为字符是有很多类型的，常见的是 ASCII 字符（char），但是还有宽字符（wchar_t）、Unicode 字符（char16_t、char32_t）等其他字符需要支持。

# string 类的迭代器 iterator

迭代器是 C++ 标准库中用于遍历容器（如数组、向量、链表、字符串等）元素的对象。能够访问容器中的元素，同时还提供了灵活的接口来进行容器的遍历和操作。

iterator 大概可以理解为一个作为容器（这里是 string）内部类的类似指针的东西。注意，不一定是指针，在不同编译器的实现下可能不同，而且部分容器无法用指针的方式作为迭代器。比方说，我使用 typeid 打印 string::iterator 的类型，得到的结果是：

class std::_String_iterator<class std::_String_val<struct std::_Simple_types<char> > >

这里 iterator 显然是一个类，而不是单纯的指针。

这里演示一下 string 的迭代器的简单使用，其中涉及的部分接口将在下文介绍。

	#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;
	}

# string 类常用接口（并不完全）

# string 类常见构造

构造	解释
string();	构造一个长度为 0 的空字符串。
string (const string& str);	拷贝构造一个字符串。
string (const string& str, size_t pos, size_t len = npos);	从一个已有字符串的 pos 位置开始，选取长度为 len 的子字符序列来构造一个字符串。(npos 默认为 - 1，在 size_t 中即为 4294967295，也就是说如果省略第三个参数就是往后有多少拷多少)
string (const char* s);	C 语言字符串转为 string。
string (const char* s, size_t n);	从字符数组 s 中选前 n 个字符构造字符串。
string (size_t n, char c);	构造一个长度为 n，每一个字符都是 c 的字符串。

	#include <string>

	using namespace std;

	int main()
	{
	string s1 = "Hello world!";
	string s2(s1);
	string s3(s1, 5, 5);
	string s4("Hello world!");
	string s5("Hello world!", 5);
	string s6(10, 'x');

	return 0;
	}

# string 类常用容器操作

# size 与 length

size_t size() const;

size_t length() const;

size 和 length 两个函数的作用和原理完全相同，size 用的更多。

size 函数是为了与 STL 标准容器的接口保持一致而产生的，也更符合容器的抽象概念。但是 length 这个更符合自然语言的接口也被保留下来了，为了兼容性。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string s("Hello, World!");
	cout << s.size() << endl;
	cout << s.length() << endl;

	return 0;
	}

# capacity

size_t capacity() const;

capacity 函数返回字符串的容量。

注意：string 会默认为字符串预先分配一段最小的初始容量，这个容量可以根据编译器实现不同而有所不同。而当容量超出先前的容量时，就会以顺序表的方式进行容量扩展，而不是精准到每一个字节扩展。（可见数据结构笔记 #1）

比方说下面的程序在我的环境下运行输出为：15、15、15、31。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string str1;
	cout << str1.capacity() << endl;

	string str2 = "Hello, World!";
	cout << str2.capacity() << endl;

	string str3 = "123456789012345";
	cout << str3.capacity() << endl;

	string str4 = "1234567890123456";
	cout << str4.capacity() << endl;

	return 0;
	}

# empty

bool enpty() const;

检测字符串是否为空串，如果是返回 true，如果否返回 false。

	#include <iostream>

	using namespace std;

	int main()
	{
	string s1 = "a";
	cout << s1.empty() << endl; //0

	string s2 = "";
	cout << s2.empty() << endl; //1

	string s3;
	cout << s3.empty() << endl; //1

	return 0;
	}

# clear

void clear();

clear 函数将 string 中的有效字符清空，但是不会改变底层空间的大小。

	#include <iostream>

	using namespace std;

	int main()
	{
	string s = "a";
	cout << s.size() << endl; //1
	cout << s.capacity() << endl; //15

	s.clear();
	cout << s.size() << endl; //0
	cout << s.capacity() << endl; //15
	cout << s << endl;
	}

# reserve

void reserve(size_t n=0);

reserve 函数为字符串预留空间，但是不改变有效元素个数。也就是说，reserve 会改变 capacity，但是不会影响 size。另外，reserve 的参数小于 string 底层空间总大小时，不会进行改变。

注意，reserve 并不是将 capacity 改成其参数 n 的大小。而是继续以顺序表扩容的方式增大其容量以至于足以容纳这么多空间。比方说：

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string s("Hello world!");
	cout << s.capacity() << endl;
	s.reserve(5);
	cout << s.capacity() << endl;
	s.reserve(111);
	cout << s.capacity() << endl;
	s.reserve(112);
	cout << s.capacity() << endl;

	return 0;
	}

该程序在我的环境下的输出为：

	15
	15
	111
	166

# resize

	void resize (size_t n);
	void resize (size_t n, char c);

resize 函数用于改变字符串的有效内容的大小。

当 n 比原先的 size 小：字符串将被截断到指定的大小。
当 n 比原先的 size 大：扩大字符串，用给定的字符 c 来填充扩展部分。如果没有给定 c，则使用 \0 来填充。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string s = "Hello";
	cout << "s = " << s << endl;
	cout << "s.size() = " << s.size() << endl;

	s.resize(4);
	cout << "s = " << s << endl;
	cout << "s.size() = " << s.size() << endl;

	s.resize(6, '!');
	cout << "s = " << s << endl;
	cout << "s.size() = " << s.size() << endl;

	s.resize(10);
	cout << "s = " << s << endl;
	cout << "s.size() = " << s.size() << endl;

	s.resize(12, '?');
	cout << "s = " << s << endl;
	cout << "s.size() = " << s.size() << endl;

	return 0;
	}

上述程序输出为：

	s = 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 的，只是不会被打印出来。但实际上我们检视内存就能看到：

# string 类对象的访问和遍历操作

# operator[]

# `char& operator[] (size_t pos);`

# `const char& operator[] (size_t pos) const;`

与数组的访问操作符类似，返回 pos 位置的字符。如果 pos 等于字符串的有效字符数，也能返回对一个 \0 的引用。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string str = "Hello";
	for (int i = 0; i < str.size(); i++)
	{
	cout << str[i] << endl;
	}

	str[0] = 'h';
	for (int i = 0; i < str.size(); i++)
	{
	cout << str[i] << endl;
	}

	return 0;
	}

# begin 与 end (包括 r 系与 c 系)

iterator begin();

iterator end();

begin 和 end 函数返回指向字符串起始位置和结束位置下一位置的迭代器。cbegin 和 cend 返回的则是常迭代器，rbegin 和 rend 返回反向迭代器，crbegin 和 crend 自然就是反向常迭代器。

	#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;
	}

# 范围 for (C++11)

C++11 支持的范围 for 也可以用来遍历 string 类对象。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string str = "Hello, World!";
	for (auto& c : str)
	{
	cout << c << endl;
	}

	return 0;
	}

# string 类对象的修改操作

# push_back

void push_back (char c);

push_back 在字符串后尾插字符 c。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string str = "Hello";
	cout << "str: " << str << endl;

	str.push_back(' ');
	cout << "str: " << str << endl;

	str.push_back('W');
	cout << "str: " << str << endl;

	str.push_back('o');
	cout << "str: " << str << endl;

	str.push_back('r');
	cout << "str: " << str << endl;

	str.push_back('l');
	cout << "str: " << str << endl;

	str.push_back('d');
	cout << "str: " << str << endl;

	return 0;
	}

# append

	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 用于在字符串后追加一个字符串，有很多重构形式。比方说上面列出的几个（还有更多）。

它们的用法看参数名就能理解，下面直接演示一下：

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string s = "append:";
	string t = "uvwxyz";
	s.append(t); // 将字符串 t 的内容追加到字符串 s 的末尾
	cout << s << endl; // append:uvwxyz
	s.append(t, 2, 3); // 将字符串 t 的子串（从 t [2] 开始数 3 位）追加到字符串 s 的末尾
	cout << s << endl; // append:uvwxyzwxy
	s.append("123"); // 将字符串 "123" 追加到字符串 s 的末尾
	cout << s << endl; // append:uvwxyzwxy123
	s.append("456", 2); // 将字符串 "456" 的前 2 个字符追加到字符串 s 的末尾
	cout << s << endl; // append:uvwxyzwxy12345
	s.append(3, 'x'); // 将字符 'x' 追加到字符串 s 的末尾 3 次
	cout << s << endl; // append:uvwxyzwxy12345xxx

	return 0;
	}

# operator+=

	string& operator+= (const string& str);
	string& operator+= (const char* s);
	string& operator+= (char c);

同样是在字符串后追加一个字符串 str。

	#include <iostream>
	#include <string>

	using namespace std;

	int main()
	{
	string s = "append:";
	cout << (s += "abc") << endl; // append:abc
	cout << (s += s) << endl; // append:abcappend:abc
	cout << (s += '.') << endl; // append:abcappend:abc.

	return 0;
	}

# c_str

const char* c_str() const noexcept;

c_str 函数将 C++ 字符串转换为 C 字符串。使用简单无需示例。

# find

# rfind

# npos

# substr

# string 类非成员函数

# operator+

# operator>>

# operator<<

# getline

# relational operators(==、!=、<、<=、>、>=)

K&R风格与Allman风格

2024-08-23T15:21:51.000Z

我们在看别人写的代码时，会发现每个人都有自己的代码风格，这可能体现在注释的习惯上、命名的方法上、变量的使用上。而关于代码中的花括号，我们发现，主流只有两种对齐方法。

一种是将花括号头直接与相应的语句放在同一行，这种被称之为 K&R 风格：

	void f() {
	if (...) {
	//...
	}
	//...
	}

另一种是将花括号头放在单独的一行，并且与花括号尾对齐，这种被称之为 Allman 风格：

	void f()
	{
	if (...)
	{
	//...
	}
	//...
	}

# K&R 风格（紧凑风）

K&R 风格来源于 C 语言的创建者 Brian Kernighan 和 Dennis Ritchie。他们在《The C Programming Language》一书中广泛使用了这种风格，因此成为了现在很多 C 和 C++ 开发者的默认选择。

使用 K&R 风格能够节省垂直空间，使代码更加紧凑，减少了滚动浏览页面的频率。

# Allman 风格（折叠风）

Allman 风格来源于 Eric Allman，他是 BSD UNIX 的开发者之一。这种风格是他在早期 Unix 系统代码中推广的。这种风格增强了代码的可读性，尤其是在大段代码中，每一个代码块的位置都很清晰。更容易在视觉上区分代码块的开始和结束，减少嵌套结构不清晰而导致的错误。同时有助于调试代码时快速的定位问题所属代码块。

# 如何选择代码风格

这两种风格都有很多使用者，具体选择哪种更多是个人习惯或者团队规范的结果。一般来说如果更注重代码的可读性，尤其是经常处理长代码段时，Allman 风格会更合适。但是如果没有团队的强制要求，最好还是选择自己觉得最舒服的风格。

椋鸟C++笔记#6：模板的基础用法

2024-08-23T14:10:19.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 泛式编程

在 C 语言笔记 #22 中，我们提到了泛式编程可以减少对特定数据类型的依赖，并且使用泛型指针 void* 在 C 语言中实现了一个 “万能” 的冒泡排序。而在 C++ 中，泛式编程更加容易，因为 C++ 提供了模版这么一个概念。

# 函数模板

一个函数模板就代表了一个函数家族，函数模板与类型无关，只在使用时才被参数化，根据参数的类型来产生函数的特定版本。

如果我们想在函数中使用未定的类型，我们只要在函数的声明和定义前各加上一行 template 语句。

template 语句的格式为：

	template <typename T1, typename T2, ..., typename Tn>
	// 下面直接接模版函数的本体即可，本体中就可以利用我们设置的模版类型 T1,T2……
	// 这里 typename 也可以替换为 class，但是这样不符合自然语言逻辑：
	template <class T1, class T2, ..., class Tn>

比方说如果我们想写一个任意类型的加法函数，只需要这样：

	template <typename T>
	T add(T a, T b)
	{
	return a + b;
	}

但是这里要求参数 a 和参数 b 是同一个类型的变量，如果我们的函数涉及到多个互不关联的未定的类型，就需要在 template 的形参列表中加上一些东西，比方说写一个比较两个类型变量的内存大小的函数：

	template <typename T1, typename T2>
	bool TypeSizeBigger(T1 x, T2 y)
	{
	return (sizeof(x) > sizeof(y)) ? true : false;
	}

# 函数模板的实例化

在编译阶段，编译器根据传入模板的实参类型来推演生成对应类型的函数以供调用。

比方说对于上面的 add 函数在程序中实际有三种类型传入进来调用。那么编译器实际上在编译时就根据模板生成了三个仅类型不同的函数，每一个用于处理不同的类型的调用。用不同类型的参数使用函数模板是，也称为函数模板的实例化。

实例化分为隐式实例化和显示实例化：

# 隐式实例化

隐式实例化就是让编译器根据实参自己推演模板参数的实际类型。

	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(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;
	}

如果类型不匹配，编译器将会尝试进行隐式类型转换，如果无法转换成功就会报错。

# 模板函数的匹配原则

可以有非模板函数与模板函数同名，而且该函数模板还可以被实例化为这个非模板函数。
// 专门处理 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()
{
cout << f(1, 2) << endl;
cout << f<int>(1, 2) << endl;
return 0;
}
此时这个函数输出是先 4 后 3，为什么呢？因为在能够与非模板函数匹配时，编译器不会再特化生成一个对应的函数，而是直接调用。而在指定模板实例化时，编译器依旧会按照模板生成并调用。

注意这里并不会冲突报错，哪怕这非模板函数和生成的函数的函数名（包括返回值与参数列表）都一样。因为在编译过程中，函数的名称会经过修饰以确保函数的唯一性。虽然模板函数和普通函数在表面上看起来参数和返回类型相同，但由于模板的存在，编译器在生成模板函数时会应用不同的名称修饰规则。

在 linux gcc 环境下，我们测试到非模板函数 f 的原型和修饰后的函数符号如下：
int f(int a, int b)
_Z1fii
其中 _Z 代表这是经过修饰的 C++ 符号， 1f 代表名字长度为 1 且名字为 f， ii 代表参数类型为 int, int 。

而模板生成函数的原型与函数符号为：
template <typename T>
T f<int>(T a, T b)
_Z1fIiEii
其中 _Z 代表这是经过修饰的 C++ 符号， 1f 代表名字长度为 1 且名字为 f， IiE 代表这是一个模板实例化，其中 i 代表模板参数类型为 int，最后的 ii 代表参数类型为 int, int 。

如果模板能够匹配产生一个更好的函数，则优先调用模板。

	// 专门处理 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()
	{
	cout << f(1.0, 2) << endl;

	return 0;
	}

此时优先调用的是模板生成的函数。

注意：模板函数不允许自动类型转换，但是普通函数可以自动类型转换。

# 类模板

与模板函数类似，我们可以定义模板类。模板类前同样需要 template 语句：

	template <class T1, class T2, ..., class Tn>
	// 下面直接接模板类即可

比方说写一个动态顺序表模板类：

	template <class T>
	class SeqList
	{
	public:
	SeqList(size_t capacity = 10)
	: m_data(new T[capacity])
	, m_capacity(capacity)
	, m_size(0)
	{}

	~SeqList()
	{
	if (m_data)
	delete[] m_data;
	m_size = m_capacity = 0;
	}

	void push_back(const T& value)
	{
	if (m_size == m_capacity)
	{
	size_t new_capacity = m_capacity * 2;
	T* new_data = new T[new_capacity];
	for (size_t i = 0; i < m_size; ++i)
	new_data[i] = m_data[i];
	delete[] m_data;
	m_data = new_data;
	m_capacity = new_capacity;
	}
	m_data[m_size++] = value;
	}

	void pop_back()
	{
	if (m_size > 0)
	--m_size;
	}

	size_t size() const
	{
	return m_size;
	}

	T& operator[](size_t index)
	{
	if (index >= m_size)
	throw out_of_range("Index out of range");
	return m_data[index];
	}


	private:
	T* m_data;
	size_t m_capacity;
	size_t m_size;
	};

# 类模板声明与定义分离

如果想要类模板声明与定义分离，我们以上面的动态顺序表的析构为例：

	template <class T>
	class SeqList
	{
	public:
	//...
	~SeqList();
	//...
	};

	template <class T>
	SeqList<T>::~SeqList()
	{
	if (m_data)
	delete[] m_data;
	m_size = m_capacity = 0;
	}

我们看到如果类模板的函数在类外定义时，需要加模板参数列表。

# 类模板的实例化

类模板的实例化与函数模板类似，在类名称之后加上 <> 以限定类型。（类模板不能隐式实例化）

	SeqList<int> s1;
	SeqList<double> s2;

椋鸟C++笔记#5：C++内存管理

2024-06-10T18:15:47.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# C 语言中的动态内存管理

C 语言中，我们使用 malloc 、 calloc 、 realloc 、 free 来动态管理内存。

	int main()
	{
	int* p = (int*)malloc(sizeof(int)); // 动态开辟
	free(p);
	int* q = (int*)calloc(4, sizeof(int)); // 动态开辟并赋值
	int* r = (int)realloc(q, 10 sizeof(int)); // 重新分配空间
	free(r);
	}

# C++ 中的动态内存管理

C++ 中有更简单方便的内存管理方式，那就是使用 new 、 delete 来管理内存。

# 使用 new/delete 操作内置类型

注意：如果使用 new 开辟空间就用 delete 删除，如果使用 new [] 开辟数组就用 delete [] 删除。

动态申请与删除一个内置类型变量的空间：

	int* pi = new int;
	int* pf = new float;
	int* pl = new long;
	int* pb = new bool;

	delete pi;
	delete pf;
	delete pl;
	delete pb;

动态申请与删除一个内置类型变量的空间并完成初始化：

	int* 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;

动态申请与删除内置类型变量数组的空间：

	int* 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;

动态申请与删除内置类型变量数组的空间并完成初始化：

	int* 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 操作自定义类型

这与自定义类型区别主要在于：使用 new/delete 操作自定义类型时会自动调用自定义类型的构造 / 析构函数。

	class 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;
	}

该程序运行结果为：

	A
	~A

# operator new (operator new []) 与 operator delete (operator delete []) 函数

看到 operator new 和 operator delete，很多人会以为这是 new 与 delete 的重载函数。

但是，operator new 和 operator delete 不能理解为是 new 与 delete 的重载函数！

operator new 与 operator delete 其实是系统提供的全局函数，而 new 和 delete 在底层其实就是调用了这两个函数来实现的。

以下给出的函数定义随编译器不同有所变化！

# operator new 函数

	void* operator new(std::size_t size)
	{
	if (size == 0) // 如果请求的大小为 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
	}
	}

# operator delete 函数

	void operator delete(void* ptr) noexcept //noexcept 说明此函数不会抛出异常
	{
	std::free(ptr); // 使用 free 释放内存
	}

# operator new [] 和 operator delete []

同样的，new [] 和 delete [] 在底层调用的是 operator new [] 和 operator delete [] 函数。

	void* 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 与 delete 的实现原理

如果申请的是内置类型的空间，new 和 malloc、delete 和 free 基本类似。

不同的是：

new/delete 申请和释放的是单个元素的空间，new [] 和 delete [] 申请的是连续空间。
new 在申请空间失败时会抛异常；malloc 会返回 NULL。

对于自定义类型：

new 的原理：
- 调用 operator new 函数申请空间。
- 执行构造函数。
delete 的原理：
- 执行析构函数。
- 调用 operator delete 函数释放空间。
new [] 的原理：
- 调用 operator new [] 函数申请空间。
- 分别执行构造函数。
- 在这片空间前紧挨的位置申请 4 个字节用于保存 N。
delete [] 的原理：
- 往前读取 4 个字节，获得 N。
- N 个元素分别执行析构函数。
- 调用 operator delete [] 函数释放空间。

# 定位 new 表达式（placement-new）

我们可以直接通过指针显式的调用析构函数：

	#include <iostream>

	using namespace std;

	class A
	{
	public:
	A(int a = 0)
	: m_a(a)
	{
	cout << "A()" << this << endl;
	}

	~A()
	{
	cout << "~A()" << this << endl;
	}

	private:
	int m_a;
	};

	int main()
	{
	A* p1 = new A;
	p1->~A();
	free(p1);

	return 0;
	}

那我们能直接显式调用构造函数吗？答案是否定的。

但是我们可以使用定位 new 表达式：

	#include <iostream>

	using namespace std;

	class A
	{
	public:
	A(int a = 0)
	: m_a(a)
	{
	cout << "A()" << this << endl;
	}

	~A()
	{
	cout << "~A()" << this << endl;
	}

	private:
	int m_a;
	};

	int main()
	{
	A* p1 = (A*)malloc(sizeof(A));
	new (p1) A; // 在地址 p1 处执行类 A 的构造函数
	p1->~A();
	free(p1);

	return 0;
	}

其结构就是 new 加上 (这里放地址) 加上 类名 。

或者也可以同时初始化：

	int main()
	{
	A* p1 = (A*)malloc(sizeof(A));
	new (p1) A (10); // 在地址 p1 处执行类 A 的构造函数并初始化为 10
	p1->~A();
	free(p1);

	return 0;
	}

当然我们也能显示的调用 operator new (operator new []) 与 operator delete (operator delete []) 函数：

	#include <iostream>

	using namespace std;

	class A
	{
	public:
	A(int a = 0)
	: m_a(a)
	{
	cout << "A()" << this << endl;
	}

	~A()
	{
	cout << "~A()" << this << endl;
	}

	private:
	int m_a;
	};

	int main()
	{
	A* p1 = (A*)malloc(sizeof(A));
	new (p1) A;
	p1->~A();
	free(p1);

	A* p2 = (A*)operator new(sizeof(A));
	new (p2) A(10);
	p2->~A();
	operator delete(p2);

	return 0;
	}

# 检测内存泄露

在 Visual Stodio 中我们可以使用 _CrtDumpMemoryLeaks() 函数来检测内存泄露，如果发生内存泄露这个函数会在输出窗口给出提示。

	#include <iostream>

	using namespace std;

	int main()
	{
	int* p = new int;

	_CrtDumpMemoryLeaks();
	return 0;
	}

执行这段代码，我们可以在来源为调试的输出看到如下内容：

	Detected memory leaks!
	Dumping objects ->
	{81} normal block at 0x00000221287C7400, 4 bytes long.
	Data: < > CD CD CD CD
	Object dump complete.

椋鸟C++笔记#4：类的初始化与封装

2024-05-30T12:00:00.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 初始化列表

在类的构造函数的函数名后可以加上这么一串结构，称之为初始化列表：

	class Date
	{
	public:
	Date(int year, int month, int day)
	: m_year(year) // 定义与初始化
	, m_month(month)
	, m_day(day)
	{}

	Date(int year)
	: m_year(year)
	, m_month(1)
	, m_day(1)
	{}

	private:
	int m_year; // 声明
	int m_month;
	int m_day;
	};

初始化列表以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式。

一个对象在实例化时，就是在初始化列表这里完成变量的定义与初始化的。如果没有初始化列表，也同样是在这里（正式进入构造函数前）完成定义。

注意：

每个成员变量在初始化列表中只能出现一次（只能初始化一次）。
类中如果包含以下成员，必须放在初始化列表的位置进行初始化（因为定义在这里，而这些类型必须在定义时完成初始化）：
- 引用成员变量
- const 成员变量
- 自定义类型成员且该类没有默认构造函数
为了统一，尽量使用初始化列表进行初始化。
成员变量在类中的声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

比方说这样就是不行的，因为 m_1 声明在前，此时使用未完成定义的 m_2 来初始化是非法的：
class A
{
public:
A(int a)
: m_2(a)
, m_1(m_2)
{}
private:
int m_1; // 声明
int m_2;
};

# 隐式转换与 explicit 关键字

# 隐式转换

对于接受单参构造函数，有这样一个额外的功能，就是隐式类型转换。

接受单参构造函数有以下几种：

构造函数只有一个参数。
构造函数有多个参数，但只有第一个参数没有默认值。
全缺省构造函数。

以下面个类为例：

	class Date
	{
	public:
	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;
	}

这里直接将 2024 赋值给 d1，就是一个隐式类型转换，将整型变为 Date 类类型。

过程其实分为三步：

编译器首先创建了一个临时的 Date 类对象。
编译器调用单参构造函数使用 2024 初始化了这个临时对象。
编译器再将这个临时对象调用赋值运算符重载（ operator= ）复制给 d1。

（部分情况下编译器会优化这个过程导致步骤减少）

# explicit 关键字

使用 explicit 关键字修饰的构造函数将被禁止隐式类型转换。

比方说下面这段代码就会报错：

	class 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 修饰的成员变量，称之为静态成员变量；用 static 修饰的
成员函数，称之为静态成员函数。

静态成员变量一定要在类外进行初始化。

比方说下面这个类具有统计已有对象数量的功能：

	class 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;

# static 成员的特性

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
静态成员变量必须在类外定义，定义时不添加 static 关键字，类中只是声明。
类静态成员可用 “类名：：静态成员” 或者 “对象。静态成员” 来访问。
静态成员函数没有隐藏的 this 指针，不能访问任何非静态成员（低权限）。
静态成员也是类的成员，受 public、protected、private 访问限定符的限制。

# 友元

友元是一种突破封装的方式，有时能为我们提供便利。但是友元会增加耦合度，破坏封装，不可滥用。

# 友元函数

我们尝试重载函数时，没有去实现流输入操作符与流输出操作符的重载。因为 cout 的输出流对象和隐含的 this 指针在抢占第一个参数的位置，this 指针默认是第一个参数也就是左操作数，但是实际使用中 cout 需要是第一个形参对象才能正常使用。所以要将 operator<< 重载成全局函数。但这会导致类外没办法访问成员（直接将成员设置为公有是破坏封装的不可取的行为），此时就需要友元函数来解决这个问题。

	#include <iostream>

	using namespace std;

	class Date
	{
	public:
	Date(int year, int month, int day)
	{
	m_year = year;
	m_month = month;
	m_day = day;
	}

	friend ostream& operator<<(ostream& os, const Date& date);
	friend istream& operator>>(istream& is, Date& date);

	private:
	int m_year;
	int m_month;
	int m_day;
	};

	ostream& operator<<(ostream& os, const Date& date)
	{
	os << date.m_year << "-" << date.m_month << "-" << date.m_day;
	return os;
	}

	istream& operator>>(istream& is, Date& date)
	{
	cout << "请输入年月日(使用空格分割)：>";
	is >> date.m_year >> date.m_month >> date.m_day;
	return is;
	}

	int main()
	{
	Date date1(2024, 5, 25);
	Date date2(2024, 5, 26);
	cout << date1 << endl << date2 << endl;

	cin >> date1;
	cout << date1 << endl;

	return 0;
	}

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加 friend 关键字。

友元函数可访问类的私有和保护成员，但不是类的成员函数。
友元函数不能用 const 修饰。
友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
一个函数可以是多个类的友元函数。
友元函数的调用与普通函数的调用原理相同。

# 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
友元关系不能传递。如果 B 是 A 的友元，C 是 B 的友元，那么不能说明 C 是 A 的友元，不能访问 A 的非公有成员。
友元关系不能继承。这个先记住就行，后面继承的时候再说。

	#include <iostream>

	using namespace std;

	class Date
	{
	friend class Time;

	public:
	Date(int y, int m, int d)
	: m_year(y)
	, m_month(m)
	, m_day(d)
	{}

	void show()
	{
	cout << m_year << "-" << m_month << "-" << m_day << endl;
	}

	private:
	int m_year;
	int m_month;
	int m_day;
	};

	class Time
	{
	public:
	Time(int h, int m, int s, int y, int month, int d)
	: m_hour(h)
	, m_minute(m)
	, m_second(s)
	, m_date(y, month, d)
	{}

	void show()
	{
	cout << m_hour << ":" << m_minute << ":" << m_second << endl;
	m_date.show();
	}

	private:
	int m_hour;
	int m_minute;
	int m_second;
	Date m_date;
	};

	int main()
	{
	Time t(12, 23, 34, 2020, 5, 30);
	t.show();

	return 0;
	}

# 内部类

如果一个类定义在另外一个类的内部，那这个类就是内部类。

但是，假设类 B 定义在类 A 的内部，类 B 和类 A 依旧是独立的，并不是说外部类就能直接访问内部类。反而是内部类可以直接访问外部类中的静态成员。

在有外部类的对象参数的情况下，内部类可以借此访问外部类中的所有成员。

或者说，内部类可以认为就是一种特殊的外部类的友元类。

	#include <iostream>

	using namespace std;

	class A
	{
	public:
	class B
	{
	public:
	void show(const A& AA)
	{
	cout << a << endl;
	cout << AA.b << endl;
	}
	};

	private:
	static int a;
	int b;
	};

	int A::a = 10;

	int main()
	{
	A::B BB;
	BB.show(A());

	return 0;
	}

注意：

内部类定义在类的 public、protected、private 都是可以的。
内部类可以直接访问外部类的 static 成员，不需要类名。
如果用 sizeof 去取外部类的大小，不用考虑内部类，直接当做没有内部类即可，与结构体嵌套有很大区别。

但是即使我们说内部类可以理解为外部类的友元类，我们可以把上面的时间类写成这样吗：

	#include <iostream>

	using namespace std;

	class Date
	{
	public:
	Date(int y, int m, int d)
	: m_year(y)
	, m_month(m)
	, m_day(d)
	{}

	void show()
	{
	cout << m_year << "-" << m_month << "-" << m_day << endl;
	}

	private:
	int m_year;
	int m_month;
	int m_day;

	class Time
	{
	public:
	Time(int hh, int mm, int ss, int y, int m, int d)
	: m_hour(hh)
	, m_minute(mm)
	, m_second(ss)
	, m_date(y, m, d)
	{}

	void show(const Date& dd)
	{
	cout << m_hour << ":" << m_minute << ":" << m_second << endl;
	cout << dd.m_year << "-" << dd.m_month << "-" << dd.m_day << endl;
	}

	private:
	int m_hour;
	int m_minute;
	int m_second;
	};
	};

	int main()
	{
	Date::Time t(10, 20, 30, 2020, 5, 30);

	return 0;
	}

答案是否定的，此时报错：不允许使用不完整的类型。

在 C++ 中，一个类在其自身完整定义之前不能实例化其自身的对象。 Date 类试图在其内部类 Time 中实例化 Date 类型的 m_date 成员，这导致了编译错误。

# 匿名对象

就像匿名结构体一样，类也有匿名对象。

匿名对象是指在创建时不赋予显式名称的对象。匿名对象通常用于一次性使用的场景，尤其是在不需要在其他地方引用该对象的情况下。匿名对象的生命周期只在当前行。

	#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);
	cout << a.GetSquare() << endl;

	// 匿名对象计算平方
	cout << A(2).GetSquare() << endl;
	}

在CentOS7下构建TeamSpeak服务器并增加网易云点歌插件

2024-05-29T20:06:09.000Z

本人服务器配置为 CentOS 7.9 64 位。

部分内容有时效性，不能保证可以复现。

首先 ssh 登录到我们的服务器。

# 部署 TeamSpeak

# 创建一个新用户

这是为了方便管理，而且部分操作不方便通过 root 账号完成。

这里我们创建一个名为 teamspeak 的账户：

XShell

		# 新建用户 teamspeak
		useradd teamspeak
		# 给予 sudo 权限
		usermod -a -G sudo teamspeak
		# 设置密码
		passwd teamspeak
		# 切换用户并定位到家目录
		su teamspeak
		cd ~

# 下载并解压服务端

# 下载

Teamspeak服务端下载

https://www.teamspeak.com/zh-CN/downloads/#server

以上为官网下载地址，可以在那里查看最新版本，可以选择从官网下载下来再传输到服务器上，也可以直接命令行下载：

XShell

		# 需要服务器已安装 wget
		wget https://files.teamspeak-services.com/releases/server/3.13.7/teamspeak3-server_linux_amd64-3.13.7.tar.bz2

如果你的服务器没有安装wget

注意使用 root 账号。

XShell

		# 使用 yum 安装 wget
		sudo yum install -y wget

# 解压

XShell

		# 使用 tar 命令解压
		tar -xvf teamspeak3-server_linux_amd64-3.13.7.tar.bz2

如果解压报错Error is not recoverable: exiting now

需要安装 bz2 相关内容，使用 root 账号：

XShell

		# 使用 yum 安装 bzip2
		sudo yum install -y bzip2

创建 teamspeak 目录，把解压后的东西塞进去：

XShell

		mkdir teamspeak
		mv teamspeak3-server_linux_amd64 teamspeak-rf
		rm -rf teamspeak3-server_linux_amd64
		cd teamspeak

# 启动服务端

# 同意许可协议

XShell

		# 没什么好说的，就是同意许可协议
		touch .ts3server_license_accepted

# 启动与配置

XShell

		# 启动服务端
		./ts3server_startscript.sh start

第一次启动，会显示包括 token 在内的重要的信息，记得保存！！！

然后 Ctrl + C 退出。

# 开放端口

我们需要为服务器开放一些端口，否则无法与客户端进行通讯。

以下是端口列表，不仅仅要在服务器开放，还要在云服务提供商的控制台的安全组中开放。

端口	协议	说明
9987	UDP	TeamSpeak 语音服务端口
10011	TCP	TeamSpeak ServerQuery raw 端口
10022	TCP	TeamSpeak ServerQuery SSH 端口
30033	TCP	TeamSpeak 文件传输端口
41144	TCP	TSDNS 服务器端口
58913	TCP	机器人网站后台端口（不开无所谓）
3000	TCP	网易云 api 后台端口（后面要用，先放开这个端口）

在服务器开放端口：

XShell

		firewall-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

在安全组开放端口：

# 设置开机自启

注意使用 root 账号。

XShell

		# 新建 teamspeak.service
		vim /etc/systemd/system/teamspeak.service

然后 i 进入 INSERT 模式，写文件：

[Unit]
Description=Teamspeak Service
Wants=network.target

[Service]
WorkingDirectory=/home/teamspeak
ExecStart=/home/teamspeak/teamspeak/ts3server_minimal_runscript.sh
ExecStop=/home/teamspeak/teamspeak/ts3server_startscript.sh stop
ExecReload=/home/teamspeak/teamspeak/ts3server_startscript.sh restart
Restart=always
RestartSec=15
 
[Install]
WantedBy=multi-user.target

然后 Esc ， :wq! 强制保存并退出。

XShell

		# 更新配置
		systemctldaemon-reload

		# 设置开机启动
		systemctl enable teamspeak.service

		# 启动服务
		systemctl start teamspeak.service

		# 查看状态，如果有 active (running) 说明成功了
		systemctl status teamspeak.service

# 客户端连接

这个时候就可以去官网设置服务器别名了，或者也可以直接裸连服务器地址。

连接后使用上面保存的 token 设置自己为超级管理员。

随后自定义各种设置。

# 部署 TS3AudioBot 并添加网易云插件

# 安装 ffmpeg

XShell

		yum -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

# 下载 TS3AudioBot 本体与插件并解压

不要下载官方的，因为官方给的 linux 版编译环境有问题导致后面不能正常加载插件

下载 ZHANGTIAOYAO1 重构后的版本与 FiveHair 修改后的网易云插件。

命令行下载：

XShell

		# 切换 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 目录：

XShell

		unzip 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/

# 配置 TS3AudioBot 启动

XShell

		cd TS3AudioBot
		chmod 755 TS3AudioBot
		./TS3AudioBot

随后根据引导设置管理员的 uid（在客户端上面 “权限” 菜单中打开 “所有客户端列表” 可以看到服务器所有人的 uid）、服务器 ip、密码等。

然后直接 Ctrl + C 结束进程。

# 设置开机自启

注意切换 root 账号：

XShell

		# ts3audiobot.service
		vim /etc/systemd/system/ts3audiobot.service

然后 i 进入 INSERT 模式，写文件：

[Unit]
Description=TS3AudioBot
After=teamspeak.service

[Service]
WorkingDirectory=/home/teamspeak/TS3AudioBot/
ExecStart=/home/teamspeak/TS3AudioBot/TS3AudioBot
Restart=always
RestartSec=15

[Install]
WantedBy=multi-user.target

然后 Esc ， :wq! 强制保存并退出。

XShell

		# 更新配置
		systemctldaemon-reload

		# 设置开机启动
		systemctl enable ts3audiobot.service

		# 启动服务
		systemctl start ts3audiobot.service

		# 查看状态，如果有 active (running) 说明成功了
		systemctl status ts3audiobot.service

# 部署网易云 API

# 安装 git

XShell

		sudo yum install -y git
		# 设置用户名
		git config --global user.name "名字"
		# 设置邮箱
		git config --global user.email "邮箱"

# 安装 Node.js 和 npm

XShell

		sudo yum install -y nodejs
		sudo yum install -y npm

# 搭建 API

注意还是切换到 teamspeak 账号：

XShell

		su teamspeak
		cd ~
		sudo git clone git@gitlab.com:Binaryify/NeteaseCloudMusicApi.git

由于网易云的赶尽杀绝，大部分 API 都寄了，而这个其实也寄了。但是虽然 github 上改仓库删除归档了，我们依旧能在 gitlab 找到全部源码。

XShell

		cd NeteaseCloudMusicApi
		sudo npm install
		sudo node app.js

此时显示 server running ... 即为配置成功，按 Ctrl + C ，退出。

# 设置开机自启

注意切换 root 用户：

XShell

		# netease.service
		vim /etc/systemd/system/netease.service

然后 i 进入 INSERT 模式，写文件：

[Unit]
Description=Netease Cloud Music API Service
After=network.target

[Service]
WorkingDirectory=/home/teamspeak/NeteaseCloudMusicApi/
ExecStart=/usr/bin/node /home/teamspeak/NeteaseCloudMusicApi/app.js
Restart=always
RestartSec=15

[Install]
WantedBy=multi-user.target

然后 Esc ， :wq! 强制保存并退出。

XShell

		# 更新配置
		systemctldaemon-reload

		# 设置开机启动
		systemctl enable netease.service

		# 启动服务
		systemctl start netease.service

		# 查看状态，如果有 active (running) 说明成功了
		systemctl status netease.service

# 将插件与 API 连接

注意还是切回 teamspeak 账号：

XShell

		cd ~
		cd TS3AudioBot/plugins
		vim YunSettings.ini

将链接修改为本地：

# 如果原本等号后面有东西就删掉
WangYiYunAPI_Address = http://localhost:3000

# 设置机器人指令权限

设置谁能操控机器人谁能点歌，在 /home/teamspeak/TS3AudioBot 目录下的 rights.toml 中有详细的说明与设置方法。

# 启动机器人

之后的操作仅在客户端就能完成。

聊天框输入 !plugin list ，找到网易云插件（状态应该是 RDY 就绪）的编号（假设是 #0）。

输入 !plugin load 0 （后面数字得看编号）加载插件。

然后再查看插件列表，网易云插件的状态应该为（+ON 运行）

之后输入 !yun login 后根据机器人的头像与简洁设置登录网易云（请给机器人管理员权限）。

大功告成！

椋鸟Linux笔记#0：学习Linux前

2024-05-24T12:55:21.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 关于 Linux

Linux 是一种开源操作系统，其核心由林纳斯・托瓦兹于 1991 年开发，基于 UNIX 设计理念。Linux 内核本身仅是操作系统的核心部分，负责管理硬件资源，而完整的 Linux 系统还包括工具和库，这些通常由 GNU 计划提供。因此，完整的系统经常被称为 “GNU/Linux”。

Linux 有多种发行版，每种都有自己的软件库和管理工具，例如 Ubuntu、Fedora 和 Debian 等。这些发行版适应了从个人桌面计算到服务器，再到嵌入式系统等不同的使用场景。

Linux 广泛应用于服务器、超级计算机、网络设备，以及日益增长的移动设备和家庭设备中，特别是其在 Android 操作系统的核心组成部分中的使用，使其成为世界上应用最广泛的操作系统之一。

# Linux 环境的搭建

我们自己搭建 Linux 环境一般有下面几种方法：

# 直接安装 Linux 系统

直接将系统安装到主机上使用，就像我们使用 Windows 那样。

但是这样非常不方便（哪怕是安装为双系统或者多系统），而且后面网络编程时不利于体验通信。

# 安装在虚拟机上

本地使用 VMware、VirtualBox 等虚拟机软件，将 Linux 系统安装到虚拟机中。
这样使用较为方便，但是虚拟机网络需配置为桥接，也不利于后面网络编程。

# 安装为 WSL2 子系统

利用 Windows11 提供的新特性，部署 WSL2 后直接在 MSStore 中安装相应版本的 Linux 系统。
这样使用非常方便，但是缺点和虚拟机类似。

# 使用云服务

在云服务提供商（阿里云、百度云、腾讯云等处购买云服务器，然后本地通过 XShell 等软件或者直接控制台 ssh 链接到服务器即可。从云服务提供商处获得的云服务器一般是自带公网 IPv4 点，这是我们自己难以做到的。

优点是非常方便使用和管理，而且利于后面网络部分的学习。缺点是价格一般较高（哪怕学生第一年的超优惠价格也是 99 块 1 年）（但是可以白嫖）。

白嫖云服务（不是广告）

下面的白嫖方法应当是有时效性的活动，请注意本内容写于 2024 年 5 月 21 日。

阿里云有为学生提供免费的云服务，能白领 7 个月的 Linux 服务器，活动网页如下：

阿里云学生权益

https://developer.aliyun.com/plan/student

这个只要认证学生身份就能领一个月，完成 Clouder 认证就能续领 6 个月（非常简单跟着提示做就行）。

购买完云服务后我们应该做的是：

在云服务商的控制台查看我们服务器的公网 IP 地址，保存或者记下来。
设置 root 用户的密码。

# 直接控制台连接远程服务器

我们打开电脑的控制台，直接连接服务器我们可以输入：

	ssh root@114.114.114.114
	# 注意这里 root 是指管理员账户，后面是服务器的公网 IP 地址

随后按照提示输入密码即可。

或者我们只输入公网 IP，随后根据提示输入用户名和密码：

	ssh 114.114.114.114
	# 后面是服务器的公网 IP 地址

# 使用 XShell 连接远程服务器

使用像 XShell 这样的软件连接，功能更多更强大，可以方便以后的操作。

XShell 的下载官网是：

Xshell

https://www.xshell.com/zh/xshell/

使用 XShell 的话需要注意一些点：

XShell 下允许使用复制和粘贴快捷键，复制是 Ctrl + Insert ，粘贴是 Shift + Insert 。
要解决连接后出现警告 The remote SSH server rejected X11 forwarding request. 我们只需要执行代码 yum install xorg-x11-xauth 即可。

椋鸟C++笔记#3：类的默认成员函数

2024-05-24T11:23:01.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 类的默认成员函数

我们写一个类，在类体中什么都不写，这样的类就叫空类。

空类真的什么都没有吗？并不是的。

类有六个默认成员函数，如果我们自己没有写这六个函数，类也会自己去补齐它们。

默认构造函数（Default Constructor） - 用于无参的初始化一个对象。
析构函数（Destructor） - 用于在对象生命周期结束时进行资源的回收等收尾工作。
拷贝构造函数（Copy Constructor） - 用于通过同类型的另一个对象来初始化新对象。
拷贝赋值运算符（Copy Assignment Operator） - 用于将一个对象的内容赋值给另一个同类型的对象。
移动构造函数（Move Constructor） - C++11 引入，用于通过 "移动" 而非拷贝另一个同类型的对象来初始化新对象。
移动赋值运算符（Move Assignment Operator） - C++11 引入，用于通过 "移动" 而非拷贝来将一个对象的内容赋值给另一个同类型的对象。

其中后两个先不管，下面我们介绍一下前面几个函数。

# 构造函数（Constructor）

我们先看这样一个类：

	class 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++ 中，我们就有了构造函数。构造函数是一个特殊的成员函数，名字与类名相同。当我们创建对象时，其构造函数就会被自动调用，并且在对象的整个生命周期中只调用一次。

比方说我们可以把上面的类改写成这样：

	class Date
	{
	public:
	Date(int y, int m, int d) // 构造函数前面就不要加 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;
	};

# 构造函数的特点

函数名与类名相同。
没有返回值。
对象实例化时编译器自动调用对应的构造函数。

同样可以重载：

	class Date
	{
	public:
	Date() // 无参
	{
	m_year = 1900;
	m_month = 1;
	m_day = 1;
	}

	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;
	int m_month;
	int m_day;
	};

	int main()
	{
	Date d1; // 调用无参的构造函数
	Date d2(2024, 5, 22); // 调用带参的构造函数

	return 0;
	}

注意：这里实例化时不能这样写：

	int main()
	{
	Date d(); // 调用无参的构造函数不要带括号！

	return 0;
	}

这里的语句可能会被认为是在声明一个叫 d 的函数，其返回值是 Date 类型的对象。

如果类中没有显式定义构造函数，编译器会自动生成一个无参的构造函数，如果显式定义了就不会这么做。

这里默认生成的构造函数是遵循什么规则给对象初始化的呢？且看：

C++ 中的类型分为内置类型（基本类型，比如 int、double 这些自带的）和自定义类型（我们用 class、struct、union 等自己定义出来的）。而默认生成的构造函数不一定会对内置类型进行初始化（不排除某些编译器有自己的想法？），对于自定义类型编译器会去寻找其构造函数以实现初始化。

但是在 C++11 中，打了一个补丁：内置成员变量可以在类中声明时给默认值（要给就全给）。

	class 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; //1900-1-1
	d.Print();

	return 0;
	}

# 析构函数（Destructor）

析构函数与构造函数相反，在对象销毁时自动调用析构函数，完成对象中资源的清理工作。

# 析构函数的特点

析构函数名是在类名前加上字符 ~ 。
析构函数无参数无返回值类型，不能重载。
一个类只能有一个析构函数。若显式未定义，则自动生成默认的析构函数。
对象生命周期结束时，自动调用析构函数。
和构造函数同样的，自动生成的析构函数不会清理内置类型的变量（本身也不需要清理），对于自定义类型的变量去寻找其析构函数并调用。

这里我们还是以之前的 Stack 类为例：

Stack.h

	#pragma once

	#include <iostream>
	#include <string>

	using namespace std;

	typedef int StackDataType;

	class Stack
	{
	public:
	Stack(int size);
	~Stack();
	void Push(StackDataType data);
	StackDataType Pop();
	StackDataType Top();
	bool IsEmpty();
	bool IsFull();
	int GetSize();
	int GetTop();

	private:
	StackDataType* m_data;
	int m_size;
	int m_capacity;
	};

Stack.cpp

	#include "Stack.h"

	Stack::Stack(int size = 4)
	{
	m_data = new StackDataType[size];
	m_size = 0;
	m_capacity = size;
	}

	Stack::~Stack()
	{
	delete[] m_data;
	}

	void Stack::Push(StackDataType data)
	{
	if (IsFull())
	{
	cout << "Stack is full!" << endl;
	return;
	}

	m_data[m_size++] = data;
	}

	StackDataType Stack::Pop()
	{
	if (IsEmpty())
	{
	cout << "Stack is empty!" << endl;
	return -1;
	}

	return m_data[--m_size];
	}

	StackDataType Stack::Top()
	{
	if (IsEmpty())
	{
	cout << "Stack is empty!" << endl;
	return -1;
	}

	return m_data[m_size - 1];
	}

	bool Stack::IsEmpty()
	{
	return m_size == 0;
	}

	bool Stack::IsFull()
	{
	return m_size == m_capacity;
	}

	int Stack::GetSize()
	{
	return m_size;
	}

	int Stack::GetTop()
	{
	return m_size - 1;
	}

# 拷贝构造函数（Copy Constructor）

如果我们想通过一个已有对象去创建一个新对象，就要用到拷贝构造函数。简单来说，就是我们有一个类 X 的对象 a，现在想再创建一个类 X 的对象 b 而且要和 a 完全一致。那么就直接使用拷贝构造函数，使用 a 来创建 b。

# 拷贝构造函数的特点

拷贝构造函数和默认构造函数一样都是构造函数的一个重载形式。

拷贝构造函数的参数只有一个且为类类型对象的引用。使用传值的方式会造成无穷递归调用，会被编译器报错。

	class 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;
	};

与之类似的，我们一般传参时，能使用引用就尽量使用引用类型，可以提高程序效率。

如果没有显式定义，编译器会生成默认的拷贝构造函数。但是默认的拷贝构造函数是直接将内存按字节序复制过来，属于浅拷贝（值拷贝）。但是我们很多时候是需要深拷贝的，尤其是存在资源申请时，因为这种情况下依旧直接复制内存并不能申请新的资源，不能完成我们所需的拷贝。

# 运算符重载（Operator Overloading）

运算符重载是面对对象编程的一种方法。在 C++ 中，运算符重载允许我们为类对象自定义运算符的计算方法。

简单来说，我们自定义一个类，编译器是不知道这个类的加减乘除等计算是如何进行的。像加减乘除等计算，一般只能用于系统的内置类型，但我们可以通过运算符重载来规定自定义类型遇到这些运算符应该怎么处理。

运算符重载函数的名字为：operator 后面加上需要重载的运算符符号。

比方说下面就是重载了日期类的日期加天数等于新日期的计算（+= 的重载）：

	class Date
	{
	public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
	m_year = year;
	m_month = month;
	m_day = day;
	}

	Date(const Date& date)
	{
	m_year = date.m_year;
	m_month = date.m_month;
	m_day = date.m_day;
	}

	~Date() {};

	int 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;
	}
	}

	bool IsLeapYear(int year)
	{
	if (year % 4 == 0 && year % 100 != 0 \|\| year % 400 == 0)
	{
	return true;
	}
	else
	{
	return false;
	}
	}

	Date& 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;
	}

	void Print()
	{
	std::cout << m_year << "-" << m_month << "-" << m_day << std::endl;
	}

	private:
	int m_year;
	int m_month;
	int m_day;
	};

我们也可以将运算符重载为全局函数。但是需要涉及的成员变量是公有的（这会破坏类的封装性，但是也可以通过友元来解决，后面会讲）：

	class Date
	{
	public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
	m_year = year;
	m_month = month;
	m_day = day;
	}

	Date(const Date& date)
	{
	m_year = date.m_year;
	m_month = date.m_month;
	m_day = date.m_day;
	}

	~Date() {};

	int m_year;
	int m_month;
	int 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; // 由于优先级问题需要加括号
	}

注意：

只能重载已有的运算符，不能自创新的符号。
不能对内置类型去重载。
有 5 个运算符不能重载： .* （通过成员函数指针访问类的成员函数的运算符）、 :: （作用域限定符）、 sizeof 、 ?: （三目运算符）、 .
重载操作符至少要有一个类类型参数。作为类成员函数重载时，其有一个隐藏的参数，为其第一个参数 this。

# 赋值运算符重载

赋值运算符重载与拷贝构造函数类似。其参数应当选择传引用返引用以提高效率，并且这样能够支持连续赋值。

注意：

应当注意是否出现自己给自己赋值的情况。
赋值运算符不能重载为全局函数，只能是成员函数（全局函数没有 this 指针，而且赋值运算符如果不显式实现，编译器会生成一个默认的，此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突）。
用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式在内存逐字节拷贝（浅拷贝）。

我们还是以日期类为例：

	Date& Date::operator=(const Date& date)
	{
	if (this != &date)
	{
	m_year = date.m_year;
	m_month = date.m_month;
	m_day = date.m_day;
	}
	return *this;
	}

# 前置 / 后置的自增和自减运算符重载

我们以自增运算符为例，前置自增应当这样重载：

	Date& Date::operator++()
	{
	*this += 1;
	return *this;
	}

而后置自增运算符应当如何重载呢？C++ 规定：为了区分，后置运算符重载时增加一个 int 类型参数，但是调用该函数时忽略该参数，就像这样：

	Date Date::operator++(int)
	{
	Date date = *this;
	*this += 1;
	return date;
	}

	void test()
	{
	Date d1;
	Date d2(2024, 1, 1);
	d1 = d2++;
	d1 = ++d2;
	}

注意后置自增是使用后再自增，因此要返回自增前的旧值。

# const 成员

在成员函数的括号后面加一个 const ，就将这个成员函数称为 const 成员函数。这里实际修饰的是该成员函数的 this 指针，表示这个成员函数不能对类的任何成员进行修改。

建议：只要能加 const 就加 const，避免权限放大的问题。

具体的例子可以看下面实现完整的日期类中。

# 实现完整的日期类

下面我们通过上面学的内容实现一个日期类吧！

Date.h

	#pragma once

	class Date
	{
	public:
	Date(int year = 1900, int month = 1, int day = 1);
	Date(const Date& date);
	~Date();

	int GetMonthDays(int year, int month) const;
	int GetYearDays(int year) const;
	bool IsLeapYear(int year) const;

	Date& operator+(int days) const;
	Date& operator-(int days) const;
	Date& operator-=(int days);
	Date& operator+=(int days);
	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	Date& operator=(const Date& date);
	bool operator==(const Date& date) const;
	bool operator!=(const Date& date) const;
	bool operator<(const Date& date) const;
	bool operator>(const Date& date) const;
	bool operator<=(const Date& date) const;
	bool operator>=(const Date& date) const;
	int operator-(const Date& date) const;

	void Print() const;

	private:
	int m_year;
	int m_month;
	int m_day;
	};

Date.cpp

	#include <iostream>
	#include "Date.h"

	using namespace std;

	Date::Date(int year, int month, int day)
	{
	m_year = year;
	m_month = month;
	m_day = day;
	}

	Date::Date(const Date& date)
	{
	m_year = date.m_year;
	m_month = date.m_month;
	m_day = date.m_day;
	}

	Date::~Date()
	{
	}

	int Date::GetMonthDays(int year, int month) const
	{
	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;
	}
	}

	int Date::GetYearDays(int year) const
	{
	if (IsLeapYear(year))
	{
	return 366;
	}
	else
	{
	return 365;
	}
	}

	bool Date::IsLeapYear(int year) const
	{
	if (year % 4 == 0 && year % 100 != 0 \|\| year % 400 == 0)
	{
	return true;
	}
	else
	{
	return false;
	}
	}

	Date& Date::operator+(int days) const
	{
	Date date = *this;
	date += days;
	return date;
	}

	Date& Date::operator-(int days) const
	{
	Date date = *this;
	date -= days;
	return date;
	}

	Date& Date::operator-=(int days)
	{
	while (days > 0)
	{
	if (days >= m_day)
	{
	days -= m_day;
	if (m_month == 1)
	{
	m_month = 12;
	m_year--;
	}
	else
	{
	m_month--;
	}
	m_day = GetMonthDays(m_year, m_month);
	}
	else
	{
	m_day -= days;
	days = 0;
	}
	}
	return *this;
	}

	Date& Date::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;
	}

	Date& Date::operator++()
	{
	*this += 1;
	return *this;
	}

	Date Date::operator++(int)
	{
	Date date = *this;
	*this += 1;
	return date;
	}

	Date& Date::operator--()
	{
	*this -= 1;
	return *this;
	}

	Date Date::operator--(int)
	{
	Date date = *this;
	*this -= 1;
	return date;
	}

	Date& Date::operator=(const Date& date)
	{
	if (this != &date)
	{
	m_year = date.m_year;
	m_month = date.m_month;
	m_day = date.m_day;
	}
	return *this;
	}

	bool Date::operator==(const Date& date) const
	{
	if (m_year == date.m_year && m_month == date.m_month && m_day == date.m_day)
	{
	return true;
	}
	else
	{
	return false;
	}
	}

	bool Date::operator!=(const Date& date) const
	{
	return !(*this == date);
	}

	bool Date::operator<(const Date& date) const
	{
	if (m_year < date.m_year)
	{
	return true;
	}
	else if (m_year == date.m_year)
	{
	if (m_month < date.m_month)
	{
	return true;
	}
	else if (m_month == date.m_month)
	{
	if (m_day < date.m_day)
	{
	return true;
	}
	}
	}
	return false;
	}

	bool Date::operator>(const Date& date) const
	{
	return !(this < date) && this != date;
	}

	bool Date::operator<=(const Date& date) const
	{
	return this < date \|\| this == date;
	}

	bool Date::operator>=(const Date& date) const
	{
	return this > date \|\| this == date;
	}

	int Date::operator-(const Date& date) const
	{
	int days = 0;
	Date temp = *this;
	if (temp < date)
	{
	while (temp != date)
	{
	temp++;
	days++;
	}
	}
	else
	{
	while (temp != date)
	{
	temp--;
	days++;
	}
	}
	return days;
	}

	void Date::Print() const
	{
	std::cout << m_year << "-" << m_month << "-" << m_day << std::endl;
	}

# 关于取地址和 const 取地址运算符（& 操作符）

有人说我们自定义的类型能够直接取地址或者 const 取地址，因此这两种运算符也是被编译器默认重载了的默认成员函数。

事实上这不能认为是类的默认成员函数，虽然我们自己可以去重载这两个运算符（不推荐，一般也用不上），但是空类生成的时候编译器并没有生成这样一个重载成员函数，这个操作是 C++ 内置的基础功能。只有当显式地为类重载了取地址操作符，这个操作的行为才会改变。

椋鸟C++笔记#2：从结构体到类

2024-05-12T08:41:02.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# C++ 中的结构体

我们在 C 语音中学的结构体在 C++ 依旧适用，而且增加了其他的功能。

在 C++ 中，结构体不仅可以用来定义变量，还可以定义函数。

在这个函数内，还可以直接使用结构体中的变量。

比如之前我们在数据结构中实现的栈现在可以这样全部放在结构体内部：

	#include <iostream>

	using namespace std;

	typedef int DataType;

	struct Stack
	{
	void 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 Push(const DataType& data)
	{
	m_arr[m_size] = data;
	++m_size;
	}

	void DataType Top()
	{
	return m_arr[m_size - 1];
	}

	void Destory()
	{
	if (nullptr != m_arr)
	{
	free(m_arr);
	m_arr = nullptr;
	m_capacity = 0;
	m_size = 0;
	}
	}

	DataType* m_arr;
	size_t m_capacity;
	size_t m_size;
	};

	int main()
	{
	Stack stack;
	stack.Init(10);
	stack.Push(1);
	stack.Push(2);
	stack.Push(3);
	stack.Push(4);

	cout << stack.Top() << endl;

	stack.Destory();

	return 0;
	}

我们发现，这样把一类方法的所有函数和变量封装在一起的方式非常高效，便于代码调用和管理。

在 C++ 中，引入了一个更加适合这样的封装调用的方式，那就是类（Class）。

# 类的定义

	class classname
	{
	// 类体，包括成员变量和成员函数
	}; // 注意这里要加分号，与结构体类似

class 是 C++ 的关键字，用于定义类；classname 是类的名字；花括号中是类的主体。

同样的，我们可以在类体中放成员变量和成员函数，但是类中成员函数的定义可以有两种方式：

定义与声明都放在类中，对于一些简单的小函数直接定义在类中比较方便：

	class 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;
	}

在这种情况下，编译器更倾向于将这样的函数作为内联函数处理。

定义放在类外，声明放在类中，这样可以让拥有较多较大函数的类看起来更直观：

	#include <iostream>

	using namespace std;

	typedef int DataType;

	class Stack
	{
	void Init(size_t capacity);
	void Push(const DataType& data);
	DataType Top();
	void Destory();

	DataType* m_arr;
	size_t m_capacity;
	size_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;
	}
	}

我们发现，这样声明与定义分离可以让类的结构变的简单明了。但是在类外再对这些函数作定义时就需要在函数名前加上类名和作用域限定符，就像上一篇中的命名空间域一样。

其实，这也是一个域，叫类域。

# 类域

类域与局部域、全局域、命名空间域类似，一个类中的成员变量和成员函数都属于这个类域。

# 访问限定符

在 C++ 中，类与结构体的成员是有访问权限这么一个属性的。访问权限有 public（公有）、private（私有）、**protected（保护）** 三种。我们可以通过访问限定符来设定成员的访问权限：

	#include <iostream>

	using namespace std;

	typedef int DataType;

	class Stack
	{
	public:
	void Init(size_t capacity);
	void Push(const DataType& data);
	DataType Top();
	void Destory();

	private:
	DataType* m_arr;
	size_t m_capacity;
	size_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 同理。

那么不同的访问权限到底意味着什么呢？

public 修饰的成员在类外可以直接被访问。
protected 和 private 修饰的成员在类外不能直接被访问（此处 protected 和 private 是类似的）。
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
如果后面没有访问限定符，作用域就到子即类结束。
如果没有加访问限定符，class 的默认访问权限为 private，struct 为 public。（因为 struct 要兼容 C）

# 类的实例化

用类类型创建对象的过程，称为类的实例化：

类是对对象进行描述的，是一个模型或者图纸一样的东西，限定了类有哪些成员。与结构体相同，定义出一个类并没有分配实际的内存空间来存储它。

一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类的成员变量（不包括成员函数，原因下面说）。

	class 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; // 实例化，对象 date 就是类 Date 实例化的结果
	date.SetDate(2024, 5, 11);

	return 0;
	}

# 类对象模型

我们如何计算类对象的大小？这就需要我们知道类对象是如何存储的。

其实很简单，我们用 sizeof 试试就知道，类对象的大小只包括类的成员变量的大小（与结构体一样遵循内存对齐规则，详见 C 语言笔记 #28）

那么成员函数呢？

成员函数放在公共代码区的一个类成员函数表中。

# this 指针

我们还是以日期类为例：

	class 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。

但是这个函数只有三个参数 y、m 和 d，而且上面提到类成员函数是储存在公共代码区的，所以两次调用的是同一个地址。

那么 SetDate 函数是如何知到调用时应该对那一个对象进行操作的呢？为什么 date1.SetDate(2024, 5, 11); 不会去修改对象 date2 的成员变量呢？

在 C++ 中，是通过引入 this 指针来解决这个问题的：

C++ 编译器给每个 “非静态的成员函数” 增加了一个隐藏的指针参数，让该指针指向当前对象（函数运行时调用该函数的对象），在函数体中所有 “成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

所以上面函数定义中也可以这样写：

	void SetDate(int y, int m, int d)
	{
	this->m_year = y;
	this->m_month = m;
	this->m_day = d;
	}

# this 指针的特性

this 指针的类型： 类的类型* const ，const 意味着在成员函数中不能给 this 指针赋值。
只能在成员函数内部使用。
本质上是成员函数的形参，当对象调用成员函数时将对象的地址作为实参传递给 this 实参。所以对象中不存储 this 指针。
this 指针是成员函数的第一个隐含的指针形参，一般由 ecx 寄存器自动传递，不需要用户传递。

# 对比 C 与 C++Stack 的实现

# C 语言

Stack.h

	#pragma once

	#include <stdbool.h>
	#include <stdlib.h>
	#include <string.h>
	#include <assert.h>

	// 数据类型
	typedef int STDataType;

	typedef struct Stack
	{
	STDataType* _data;
	int _top;
	int _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);

Stack.c

	#include "Stack.h"

	// 栈的初始化
	void InitStack(pStack pst)
	{
	assert(pst);
	pst->_data = NULL;
	pst->_top = 0;
	pst->_capacity = 0;
	}
	// 容量检查扩容
	void StackCheck(pStack pst)
	{
	if (pst->_top == pst->_capacity)
	{
	int newCapacity = ((pst->_capacity == 0) ? 4 : (2 * pst->_capacity));
	STDataType* temp = (STDataType)realloc(pst->_data, newCapacity sizeof(STDataType));
	if (temp == NULL)
	{
	perror("realloc");
	exit(EXIT_FAILURE);
	}
	pst->_data = temp;
	pst->_capacity = newCapacity;
	}
	}
	// 压栈
	void StackPush(pStack pst, STDataType x)
	{
	assert(pst);
	StackCheck(pst);
	memcpy(&(pst->_data[pst->_top]), &x, sizeof(STDataType));
	pst->_top++;
	}
	// 弹栈
	void StackPop(pStack pst)
	{
	assert(pst);
	assert(!StackEmpty(pst));
	pst->_top--;
	}
	// 栈顶元素
	STDataType StackTop(pStack pst)
	{
	assert(pst);
	return pst->_data[pst->_top - 1];
	}
	// 栈大小
	int StackSize(pStack pst)
	{
	assert(pst);
	return pst->_top;
	}
	// 栈判空
	_Bool StackEmpty(pStack pst)
	{
	assert(pst);
	return pst->_top == 0;
	}
	// 栈销毁
	void StackDestory(pStack pst)
	{
	assert(pst);
	free(pst->_data);
	pst->_capacity = 0;
	pst->_top = 0;
	pst->_data = NULL;
	}

# C++

先忽略 Stack 函数与～Stack 函数，下一篇笔记讲。

Stack.h

	#pragma once

	#include <iostream>
	#include <string>

	using namespace std;

	typedef int StackDataType;

	class Stack
	{
	public:
	Stack(int size);
	~Stack();
	void Push(StackDataType data);
	StackDataType Pop();
	StackDataType Top();
	bool IsEmpty();
	bool IsFull();
	int GetSize();
	int GetTop();

	private:
	StackDataType* m_data;
	int m_size;
	int m_capacity;
	};

Stack.cpp

	#include "Stack.h"

	Stack::Stack(int size = 4)
	{
	m_data = new StackDataType[size];
	m_size = 0;
	m_capacity = size;
	}

	Stack::~Stack()
	{
	delete[] m_data;
	}

	void Stack::Push(StackDataType data)
	{
	if (IsFull())
	{
	cout << "Stack is full!" << endl;
	return;
	}

	m_data[m_size++] = data;
	}

	StackDataType Stack::Pop()
	{
	if (IsEmpty())
	{
	cout << "Stack is empty!" << endl;
	return -1;
	}

	return m_data[--m_size];
	}

	StackDataType Stack::Top()
	{
	if (IsEmpty())
	{
	cout << "Stack is empty!" << endl;
	return -1;
	}

	return m_data[m_size - 1];
	}

	bool Stack::IsEmpty()
	{
	return m_size == 0;
	}

	bool Stack::IsFull()
	{
	return m_size == m_capacity;
	}

	int Stack::GetSize()
	{
	return m_size;
	}

	int Stack::GetTop()
	{
	return m_size - 1;
	}

椋鸟C++笔记#1：C++初识

2024-04-28T11:06:54.000Z

本系列暴死，不会更新了。

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# C++ 简介

C++ 是由 Bjarne Stroustrup 在上世纪 80 年代开发的一款基于 C 语音的编程语言。一开始是作为 C 语言的完善与改进，后来随着一次次标准化更新，已经脱胎换骨了。但是 C + 依旧向下兼容大部分 C 语言代码。

这一篇笔记先从一些比较基础的地方讲其与 C 语言的区别。

# C++ 的关键字（C++98 标准）

首先 C 语言只有 32 个关键字，而 C++98 却有 63 个关键字，C++11 及之后的标准中甚至更多。

具体有哪些可以点下面的链接查看：

C/C++参考手册

C++关键词

# 命名空间

在 C 语言中，我们能遇到这样的情况：想要用的函数名、变量名在库中已经存在，因此不得不改名。

而在 C++ 中，我们会遇到更多的库，其中有海量的函数，再加上我们自己会写的函数，命名重复的问题就凸显出来。

因此，C++ 就引入了命名空间的概念，用以对标识符的名称进行本地化，以避免命名冲突或者名字污染。

其原理大致可以理解为把各个函数放到各自的命名空间中，同一个命名空间内还是不能重名，但是不同命名空间之间可以有重名的函数（通过命名空间来区分）。

# 定义命名空间

定义一个命名空间要使用关键字 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
	{
	int rand;
	int Add(int Adder1, int Adder2)
	{
	return Adder1 + Adder2;
	}
	}
	}

如上方所示，我们在全局、ExampleSpace1、ExampleSpace2、ExampleSpace2 中的 ExampleSpace3 中分别定义了整型变量 rand 和函数 Add。但是由于其所处命名空间是不同的，所以不会出现问题。

另外，在同一个工程中，可以有多个同名的命名空间，它们最后会被 “合并起来”，比方说我们可以在 test1.h 中定义命名空间 Test：

test1.h

	namespace Test
	{
	int a;
	int b;
	}

然后在 test2.h 中继续定义命名空间 Test：

test2.h

	namespace Test
	{
	int c;
	int d;
	}

那么在之后使用命名空间 Test 时，两边的内容就相当于 “合并” 起来作为一个命名空间。

# 展开（使用）命名空间

那么我们应该如何使用命名空间呢？以下面这段为例：

	int a;

	namespace ExampleSpace1
	{
	int a;
	int b;
	}

	namespace ExampleSpace2
	{
	int c;
	namespace ExampleSpace3
	{
	int d;
	}
	}

使用命名空间一般有三种方式。

# 方式：命名空间名称加作用域限定符

两个英文冒号连在一起就是作用域限定符（::）。

	int main()
	{
	printf("%d\n", a); // 未加限定时访问全局域的 a
	printf("%d\n", ::a); // 限定为空同样访问全局域的 a
	printf("%d\n", ExampleSpace1::a); // 访问 ExampleSpace1 中的 a
	printf("%d\n", ExampleSpace2::a); // 访问 ExampleSpace2 中的 a
	printf("%d\n", ExampleSpace2::ExampleSpace3::a); // 访问 ExampleSpace2 中的 ExampleSpace3 中的 a
	}

# 方式：用 using 关键字引入命名空间内容

比方说这样就能引入 ExampleSpace1 中的 b。

	using ExampleSpace1::b;

	int main()
	{
	cout << b << endl;
	return 0;
	}

这里我们不能使用引入 ExampleSpace1 中的 a，因为全局中已经存在一个 a 了，产生多义性问题。

# 方式：用 using namespace 引入整个命名空间

如果某个命名空间里面有大量的内容，我们总不能一个一个去引入，所以我们可以直接引入整个命名空间：

	// 注意嵌套的情况下不能直接写 ExampleSpace3
	using namespace ExampleSpace2::ExampleSpace3;

	int main()
	{
	cout << d << endl;
	return 0;
	}

那如果我们引入 ExampleSpace2 的话，能不能直接使用 ExampleSpace3 中的内容呢？

答案是否定的，但是如果引入 ExampleSpace2 的话我们就可以写成这样了：

	using namespace ExampleSpace2;

	int main()
	{
	cout << ExampleSpace3::d << endl;
	return 0;
	}

此时就不用写成 ExampleSpace2::ExampleSpace3::d（虽然也行）。

# 注意：命名空间展开位置

展开（使用）命名空间是可以在作用域中进行的，不是说一定在全局中展开，比方说：

	int main()
	{
	if (true)
	{
	using namespace ExampleSpace2::ExampleSpace3;
	cout << d << endl;
	}
	}

# 注意：展开命名空间的实际含义

比方说全局中的命名空间 ExampleSpace1 我们如果放在某作用域内展开，并不是说这个时候使用其中的变量或者函数或者别的什么就是该作用域内的东西了。这些东西依旧存在于全局，我们这里的展开只是给了一个权限使得我们能在这个作用域内定向的使用 ExampleSpace1 中的东西。

这里我们可以看一个例子，比方说下面这段代码的运行结果是 10，不会报错：

	int a = 0;

	int main()
	{
	if (true)
	{
	int a = 10;
	cout << a << endl;
	}
	}

因为编译器会先在作用域内寻找符合的变量，这可以与全局中的变量共存。

但是如果写成这样，就会报错了：

	int a = 0;

	namespace X
	{
	int a = 10;
	}

	int main()
	{
	if (true)
	{
	using namespace X;
	cout << a << endl;
	}
	}

这就是因为展开命名空间实际上只是给予了访问权限并不是真正的展开。编译器先在作用域内没有找到 a，然后在全局中寻找，而有了命名空间 X 访问权限的编译器此时就在全局中发现了两个 a，一个直接写在全局中，另一个写在命名空间 X 中。这就产生了多义性错误。

# C++ 的输入与输出

# C++ 中的标准输入输出库与标准库命名空间

我们看看 C++ 中的 Hello World! 程序：

	#include <iostream>
	using namespace std;

	int main()
	{
	cout << "Hello world!" << endl;
	return 0;
	}

第一行包含的库 <iostream> 是 C++ 的标准输入输出库，可以理解为之前 C 语言的 <stdio.h> ，但是内容更丰富全面。（C++ 的库文件一般不带 .h 后缀）

第二行中的命名空间 std 就是 C++ 中的标准库命名空间，C++ 所有标准库的定义都实现在这个命名空间，我们必须包含这个命名空间才能使用其中的内容。

第六行中的输出方式是 C++ 特有的 IO 流方式，其中 << 是流插入运算符，与之相对的 >> 是流提取运算符。使用这种方式进行输入输出比较方便，不需要手动控制格式。其更具体的使用与原理等后面会学。

# 缺省参数

# 缺省参数的概念

缺省参数就是在声明或者定义函数时为其参数设定一个缺省值（默认值），在调用这个函数时，如果没有指定这个参数就使用其缺省值，比方说：

	#include <iostream>

	using namespace std;

	void func(int a, int b = 10, int c = 20)
	{
	cout << "a = " << a << ", b = " << b << ", c = " << c << endl;
	}

	int main()
	{
	func(1);
	func(1, 2);
	func(1, 2, 3);
	return 0;
	}

该程序输出为：

	a = 1, b = 10, c = 20
	a = 1, b = 2, c = 20
	a = 1, b = 2, c = 3

# 注意：缺省参数在参数列表中的位置

一旦某个参数被赋予了默认值，其右侧的所有参数也必须有默认值。这是因为实参的传递是按参数列表从左到右的顺序进行的。

也就是说，不能写出下面这种东西：

	void func(int a, int b = 10, int c)
	{
	cout << "a = " << a << ", b = " << b << ", c = " << c << endl;
	}

因为只要 b 有默认值，它右边的 c 也要有默认值才行。

# 注意：函数有声明时缺省参数只能出现一次

如果函数同时有声明和定义，并且分开书写，那么默认参数应只在其中之一中指定，通常是在函数声明中。这是为了防止缺省参数被重定义：

	#include <iostream>

	using namespace std;

	void func(int a, int b = 10, int c = 20);

	void func(int a, int b, int c)
	{
	cout << "a = " << a << ", b = " << b << ", c = " << c << endl;
	}

	int main()
	{
	func(1);
	func(1, 2);
	func(1, 2, 3);
	return 0;
	}

# 注意：缺省值必须是常量或者全局变量

# 函数重载

# 函数重载的概念

C++ 支持在同一个作用域中声明几个有相同函数名的函数，前提是他们能够通过参数列表区分开来。

重载函数的出现，方便了功能类似但参数类型不同的函数，举个例子：

	#include <iostream>

	using namespace std;

	void print(int a)
	{
	cout << "int: " << a << endl;
	}

	void print(double a)
	{
	cout << "double: " << a << endl;
	}

	void print(char a)
	{
	cout << "char: " << a << endl;
	}

	int main()
	{
	print(10);
	print(10.5);
	print('A');

	return 0;
	}

其输出为：

	int: 10
	double: 10.5
	char: A

# 函数重载实现的原理

在 C 语言笔记 #36 中，我们就说过 C/C++ 代码生成可执行程序要经过预处理、编译、汇编、链接几个阶段。

每一个源代码文件都要经历预处理、编译和汇编过程生成对应的 .o 文件（Linux 下）或者 .obj 文件（Windows 下）。最终它们与链接库通过链接器链接起来变成可执行程序。

代码中调用函数的步骤在汇编后实际上就变成了跳转到函数指令执行地址。一般来说，在多文件项目中，链接前每一个头文件是独立的，不知道要调用的函数地址在哪。此时就会用一个 “记号” 来代替，而在链接阶段，链接器通过这个 “记号” 在符号表中寻找对应函数的地址并填进去。

而在 C 语言中，这个记号仅由函数名决定，因此如果有重名函数就无法被链接器区分。

在 C++ 中，这个记号有命名空间、函数名、参数列表多方面决定，因此能够被链接器区分开来。

对于 Linux 环境的 g++ 编译器，这个记号由以下几个部分组成：

'_Z' 加上 函数名长度 加上 函数名 加上各参数类型的缩写。

比方说函数 int Add(int a, int b); 对应的记号是：_Z3Addii

而函数 void func(int a, float b, int* p); 对应的记号是：_Z4funcifPi
对于 Windows 环境下的名字修饰规则就比较复杂，记号由以下部分组成：

'?' 加上 函数名 加上 '@' 加上 命名空间（如果有嵌套用'@'隔开） 加上 '@' 加上 代表函数调用类型、参数、返回值的一串代码（具体符号含义复杂不做介绍） 加上 '@Z'

比方说对于函数 int func(int); 对应的记号是： ?func@@YAHH@Z

而函数 int C::C2::func(int); 对应的记号是：?func@C2@C@@AAEHH@Z

# 引用

# 引用的概念

在 C++ 中，引用是一个非常重要的特性，它为另一个已存在的变量提供了一个别名。引用主要用于函数参数传递和返回值，使得代码更加有效且易于理解。

C++ 使用符号 & 来声明引用，例如 int& ref = var; 这里 ref 就成了 var 的一个引用，对引用的任何操作都是直接对原变量的操作。

注意 1：引用在声明时必须被初始化，这是与指针最大的不同之一。一旦一个引用被初始化指向一个变量，它就不能被改变指向另一个变量。

注意 2：引用必须连接到一块合法的内存，不能像指针那样可以有 NULL 值。

# 引用的操作权限

不加修饰引用的操作权限是可读可写，而权限只能缩小不能扩大，因此不能对常量进行引用：

	const int a = 10;
	//int& ra = a; //err，a 为常量只读，权限不能扩大
	const int& ra = a; //ok，const 修饰后 ra 也是只读的引用，权限不变

	//int& rb = 666; //err，666 是常量只读，权限不能扩大
	const int& rb = 666; //ok

	double pi = 3.14;
	//int& rpi = pi; //err，类型不同
	const int& rpi = pi; //ok，这里发生隐式的类型转换变成 3

# 常引用

对于上方的代码，我们注意到如果引用被 const 修饰，能够获得更高的灵活性。这被称为常引用。

常引用可以引用常量，这使得我们能够在不修改原始数据的前提下，安全地使用或检查其值。
常引用会延长临时对象的生命周期，当一个临时对象被一个常引用绑定时，该临时对象的生命周期会被延长，直到这个常引用的生命周期结束。

# 引用在函数中的使用场景

# 作参数

使用引用作为函数参数的主要好处是能够直接操作调用者的变量，避免了数据的复制，从而提高效率。

	void Swap(int& a, int& b)
	{
	int tmp = a;
	a = b;
	b = tmp;
	}

# 作返回值

使用引用返回函数结果主要是为了避免返回值的拷贝，特别是当返回对象较大时。

它还允许函数返回操作结果直接对应到调用者的某个变量或对象上。

注意：确保返回的对象在函数返回后仍然存在，要不然不要使用！

比方说这段代码中返回的 n 被 static 修饰，在函数栈帧销毁后依旧存在，所以可用：

	int& Count()
	{
	static int n = 0;
	n++;
	return n;
	}

再比方说这段代码中返回的是 array 数组中的内容，不是栈帧中开辟的局部变量，所以没问题：

	#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;
	}

那如果返回值是栈帧内开辟的局部变量会发生什么呢？且看下例：

	int& 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，为什么呢？

（现在不少编译器机制变的更加复杂，导致输出不是 7 而是一串随机值，但这只是一个例子）

结合我们在 C 语言笔记 #16 中的内容分析：

第一次调用 Add 函数时，1 和 2 作为参数 ab 压栈，esp 寄存器上移。然后创建 Add 函数的栈帧，esp 和 ebp 移到 Add 函数的栈帧两端。变量 c 创建在 Add 函数栈帧中，而 Add 函数返回后 esp 和 ebp 回到 main 函数栈帧的两端，这片空间被释放。因此实际返回的是一片已经被释放的内存空间。

但是此时如果直接输出，其仍能输出 3，因为虽然对应的空间已经被释放但是还没有被覆写。

第二次调用 Add 函数时，3 与 4 压栈，esp 与 ebp 上移，创建 Add 函数的栈帧。此时除了数字不同，指令地址与第一次完全一致（较新的编译器可能不是了）。因此计算结果 7 放在了原本第一次 c 的位置，也就是把原本的 4 覆盖了。这时再去输出 ret 自然就得到了 Add (1, 2) = 7 的荒谬结论。

# 引用传值的优势

避免数据的拷贝，当数据占空间较大时有很大的效率优势与空间优势。

我们测试一下看看：

	#include <time.h>

	struct A
	{
	int a[10000];
	};

	A a;

	A TestFunc1() { return a; }
	A& TestFunc2() { return a; }

	int main()
	{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 1000000; ++i)
	TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 1000000; ++i)
	TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;

	return 0;
	}

其输出：

	TestFunc1 time:1610
	TestFunc2 time:1

可见其效率差距之大。

# 引用和指针的区别

底层上引用就是靠指针实现的，优势在于可读性更高。

我们把汇编对比一下就知道，指针实现和引用实现的汇编代码都是基本一致的。

硬要说区别的话有如下几条：

引用必须初始化，指针不需要。
引用初始化后不能再引用其他实体了，指针的话只要是同类型的就能随便改。
有空指针没有空引用。
sizeof 关键字对指针会得到地址所占的字节数，但是对引用能得到引用类型的大小。
引用自增自减作用于被引用实体，指针则作用于自身。
存在多级指针，不存在多级引用。
引用比指针更安全。

# 内联函数

# 内联函数的概念

如果程序中有一个比较小的函数被频繁调用，我们就会面临这样的问题：这个函数太小了没什么必要去创建一个函数，这会造成很多没必要的栈帧开销；但是这个函数确实在程序中使用的很多，不写成函数而是拆开来写在程序里很麻烦。

那么我们就可以使用内联函数解决这个问题；当然也可以使用宏或者宏函数解决，但是宏无法调试没有安全检查也非常容易出错，是不推荐使用的。

在声明 / 定义函数的时候，在前面加上关键字 inline ，这个函数就会变成内联函数。

编译器在处理内联函数时不会像正常函数一样写成调用函数的汇编代码，而是直接把这个内联函数在这里展开，比方说下面两段代码本质上没有区别：

	inline int max(int a, int b)
	{
	return a > b ? a : b;
	}

	int main()
	{
	cout << "max(10, 20) = " << max(10, 20) << endl;
	cout << "max(0, 0) = " << max(0, 0) << endl;
	cout << "max(-10, -20) = " << max(-10, -20) << endl;

	return 0;
	}

	int main()
	{
	cout << "max(10, 20) = " << (10 > 20 ? 10 : 20) << endl;
	cout << "max(0, 0) = " << (0 > 0 ? 0 : 0) << endl;
	cout << "max(-10, -20) = " << (-10 > -20 ? -10 : -20) << endl;

	return 0;
	}

# 内联函数的意义

内联函数是一种以时间换空间的做法，可能会让目标文件变的很大，但是能大大减少栈帧开销，提高运行效率。

# 内联函数的注意事项

注意：Visual Studio 中，在 debug 模式下，编译器一般不会对内联函数进行展开，需在 release 下进行。（或在编译器配置中设置内联函数扩展的属性）

注意：内联函数只是向编译器提出了展开的建议，不同编译器对其实现机制可能不同。有可能写了内联编译器却不采纳，有可能没有写内联编译器却自己优化成了内联函数。

注意：内联函数尽量不要声明与定义分离，因为编译器处理声明时找不到函数地址（内联函数直接展开没有函数地址），然后就会报链接错误或者直接忽略内联。

# auto 关键字（C++11）

# auto 关键字的概念

这里我们要说的是 C++11 开始的 auto 关键字，C++11 之前也有 auto 关键字，但是含义不同。

auto 关键字在 C++11 之前用于在定义时修饰变量为具有自动存储期的变量，以表示这个变量会在离开当前作用域后自动归还内存。但是啊，我们如果没有单独去修饰变量为 static、extern 或 thread_local 的话，变量自然就会被创建为具有自动存储期的，正常人不会闲着没事干去加一个 auto 在前面。因此，auto 的这个用法在 C++11 以后已经废除。

从 C++11 开始，auto 关键字用于替代类型名使用。什么意思呢？

比方说我们定义各种类型的变量，都可以直接用 auto 来替代类型，编译器会自动分析这里应该是什么类型：

	#include <iostream>

	using namespace std;

	int main()
	{
	auto a = 1;
	auto b = 3.14;
	auto c = { 1, 2 };
	auto d = "hello world";
	auto e = 'c';

	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(e).name() << endl;

	return 0;
	}

注意：这里的 typeid().name() 用于输出类型的名字。

其输出结果为：

	int
	double
	class std::initializer_list<int>
	char const * __ptr64
	char

又或者，我们可以在函数的返回值类型处写 auto，编译器同样会自动分析函数的返回值类型。

# auto 关键字的注意事项

注意：在同一行用 auto 定义多个变量时，它们必须是相同类型的。

注意：auto 声明指针类型时 * 可加可不加，但是声明引用类型时，必须有 & 。

注意：auto 可以用于函数的返回值，但是不能用于函数的参数。

== 注意：auto 不要直接用于声明数组。== 像 auto a[] = {1, 2, 3}; 这种是非法的。

# 基于范围的 for 循环（C++11）

在之前我们如果想遍历一个数组要这样做：

	void TestForLoop()
	{
	int arr[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
	arr[i] *= 2;
	}
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
	cout << arr[i] << " ";
	}
	}

而在 C++11 以后，可以直接写成：

	void TestForLoopWithRange()
	{
	int arr[] = { 1, 2, 3, 4, 5 };
	for (auto& e : arr)
	{
	e *= 2;
	}
	for (auto e : arr)
	{
	cout << e << " ";
	}
	}

这里 for 循环的括号中有冒号分割为两个部分：

左边是在某个范围内用于迭代的变量，一般用 auto 定义。如果要对范围本身的数据进行修改，就要向上面那样写成引用形式的变量。
右边是迭代的范围，目前我们只能接触到数组，之后还有别的迭代器。

指针空值 nullptr（C++11）

在我们声明一个变量的时候，良好的习惯是在声明时进行初始化。如果声明一个指针而暂时没有指向，我们一般会将其初始化为空指针。

在之前，我们空指针一般直接用 NULL 来赋值，比方说 int* p = NULL; 。

NULL 实际上是一个宏，我们在 stddef.h 中能够看到其定义：

	#ifndef NULL
	#ifdef __cplusplus
	#define NULL 0
	#else
	#define NULL ((void *)0)
	#endif
	#endif

我们发现在 C++ 中，NULL 被定义为 0，这可能会带来一些问题，比方说下面这段代码：

	void func(int i)
	{
	cout << "int" << endl;
	}

	void func(int* pi)
	{
	cout << "int*" << endl;
	}

	int main()
	{
	func(0);
	func(NULL);
	}

我们发现两行输出都是 int，这显然与我们的初衷相悖。

在 C++11 以后，增加了关键字 nullptr，不需要包含头文件。

nullptr 默认为 ((void*)0) ，且存在到任意指针类型的隐式转换。

我们平时使用这个关键字而不是 NULL 作为空指针就能解决上面的问题，能够提高代码的健壮性。

椋鸟数据结构笔记#11：排序·下

2024-04-23T13:42:31.000Z

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 外排序（外部排序）

当数据量非常庞大以至于无法全部写入内存时，我们应该怎么排序这些数据呢？

这时，就要学会直接进行在外存中排序，也就是外部排序。

外排序不是一种独立的排序算法，还是要依赖于之前的那些排序方式。

其基本思想是这样的：

将庞大的数据拆分为一个一个子文件，使得每一个子文件的数据量在内存排序可承受的范围内。
将每一个文件进行正常的排序，可以选用之前学的任何排序方法。
将排序好的文件再进行归并，最终合成为包含有序的所有数据的文件。

看起来不是很复杂，但是归并部分还是很有东西的。下面我们逐步讲解：

# 文件拆分并排序

这并不复杂，比方说我们将文件拆分为 splitCount 个：

	void FileSort(const char* filename, int splitCount)
	{
	clock_t start = clock();

	// 分割文件
	FILE* fp = fopen(filename, "r");
	if (fp == NULL)
	{
	perror("fail to open");
	exit(EXIT_FAILURE);
	}
	int* num = (int)malloc(sizeof(int) N / splitCount); // 存放每个分割文件的数据
	int iNum = 0; //num 数组的下标
	int iFile = 0; // 分割文件的下标
	int n = 0; // 读取的数据
	char splitFileName[50] = { 0 }; // 分割文件名
	while (fscanf(fp, "%d", &n) != EOF)
	{
	if (iNum < N / splitCount - 1)
	{
	num[iNum++] = n;
	}
	else
	{
	num[iNum] = n;
	// 排序
	HeapSort(num, N / splitCount);
	// 写入文件
	sprintf(splitFileName, "SubSort\\sort_split%d.txt", iFile++);
	FILE* splitFile = fopen(splitFileName, "w");
	if (splitFile == NULL)
	{
	perror("fail to open");
	exit(EXIT_FAILURE);
	}
	for (int i = 0; i < N / splitCount; i++)
	{
	fprintf(splitFile, "%d\n", num[i]);
	}
	fclose(splitFile);
	printf("已分割第%d个文件，总共需分割%d个文件。\n", iFile, splitCount);
	iNum = 0;
	}
	}

	// 归并文件
	// 这里插入归并文件的代码

	// 关闭文件
	fclose(fp);

	clock_t end = clock();

	printf("排序完成，共%d个数据，分割为%d个文件，归并为1个文件。\n", N, splitCount);
	printf("耗时：%f秒。\n", (double)(end - start) / CLOCKS_PER_SEC);
	}

# 归并文件

这是重点也是最复杂的地方。

# 两个文件归并

我们知道两个排序文件归并的方法：两边一起读取，一直对比两边读取的数，不断取小写入输出文件即可。

	void MergeFile(char* file1, char* file2, char* mergeFileName)
	{
	FILE* fp1 = fopen(file1, "r");
	FILE* fp2 = fopen(file2, "r");
	if (fp1 == NULL)
	{
	perror("fail to open");
	exit(EXIT_FAILURE);
	}
	if (fp2 == NULL)
	{
	perror("fail to open");
	exit(EXIT_FAILURE);
	}
	FILE* fin = fopen("tmp.txt", "w");
	if (fin == NULL)
	{
	perror("fail to open");
	exit(EXIT_FAILURE);
	}
	int n1, n2;
	int ret1 = fscanf(fp1, "%d", &n1);
	int ret2 = fscanf(fp2, "%d", &n2);
	while (ret1 != EOF && ret2 != EOF)
	{
	if (n1 < n2)
	{
	fprintf(fin, "%d\n", n1);
	ret1 = fscanf(fp1, "%d", &n1);
	}
	else
	{
	fprintf(fin, "%d\n", n2);
	ret2 = fscanf(fp2, "%d", &n2);
	}
	}
	while (fscanf(fp1, "%d", &n1) != EOF)
	{
	fprintf(fin, "%d\n", n1);
	}
	while (fscanf(fp2, "%d", &n2) != EOF)
	{
	fprintf(fin, "%d\n", n2);
	}
	fclose(fp1);
	fclose(fp2);
	fclose(fin);
	remove(file1);
	remove(file2);
	rename("tmp.txt", mergeFileName);
	}

注意：这里我们先写入数据至 tmp.txt 中，最后在将其改名为 mergeFileName 是为了防止 mergeFileName 就是 file1 或者 file2 的情况（也即直接把 file2 归并到 file1 中而不创建新的文件，或者反过来）。

# 多文件归并

但是我们往往不仅仅要把数据切分为两个，而是几十个上百个。这时我们就需要使用多文件归并的方法。

直接逐个归并

这是最容易理解也是最差的方法。就是把拆分文件 1 和拆分文件 2 归并，结果再和拆分文件 3 归并，结果再和拆分文件 4 归并…… 最终得到完整的归并文件。

傻子都能看出来这个方法的不靠谱，但是我们还是将代码贴出来：

	// 归并文件，这段代码填入上方 FileSort 函数中归并的留空位置
	char* mergeFileName = "sort_merge.txt";
	char file1[50] = "SubSort\\sort_split0.txt", file2[50] = {0};
	for (int i = 1; i < splitCount; i++)
	{
	sprintf(file2, "SubSort\\sort_split%d.txt", i);
	MergeFile(file1, file2, mergeFileName);
	strcpy(file1, mergeFileName);
	printf("已归并%d个文件，总共需归并%d个文件。\n", i + 1, splitCount);
	}

这个方法是真的不靠谱，一亿个数据半小时还没归并完。

分治归并

就是不断地两两分组归并，比方说 9 至 16 个文件归并成 5 至 8 个，5 至 8 个归并位 3 至 4 个，再归并为 2 个，最后合成完整的排序后文件。

	// 分治归并文件，这段代码填入上方 FileSort 函数中归并的留空位置
	MergeFileR(0, splitCount - 1);
	remove("SubSort\\sort_split0.txt");

其中 MergeFileR 的定义如下：

	void MergeFileR(int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	int mid = (left + right) / 2;
	// 递归归并
	MergeFileR(left, mid);
	MergeFileR(mid + 1, right);
	// 归并
	char file1[50] = { 0 }, file2[50] = { 0 }, mergeFileName[50] = { 0 };
	sprintf(file1, "SubSort\\sort_split%d.txt", left);
	sprintf(file2, "SubSort\\sort_split%d.txt", mid + 1);
	sprintf(mergeFileName, "SubSort\\sort_split%d.txt", left);
	MergeFile(file1, file2, mergeFileName);
	printf("已归并%d与%d文件至%d。\n", left, mid + 1, left);
	}

这个方法要靠谱一点，测试如下：

# 优化

进一步优化可以将基础操作从两个文件归并变成 3 个文件归并或者更多，这样分治时就是 3 合一或者更多。这样多路归并会增加内存开销和内部时间开销，但是会大大减少外部读写的开销。

更进一步优化可以引入败者树、最佳归并树等，我还不会。

椋鸟数据结构笔记#10：排序·中

2024-04-20T12:45:25.000Z

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 四、归并排序

归并排序是一种非常高效的排序算法。基本思想是将一个大数组分成两半，分别对这两半进行排序，然后将排序好的两部分合并在一起。这个过程递归进行，每次将数组分半，直到每个部分只有一个元素，自然是有序的，最终得到一个完整的有序数组。

归并排序的步骤如下：

分割：把当前序列平均分割成两半。
递归排序：递归地对这两半进行归并排序，直到分割的子序列只包含一个元素。
合并：将两个有序的子序列合并成一个有序序列。

# 时间复杂度

归并排序的时间复杂度为 $O(N\log\,N)$ ，在最好最坏情况都是如此。是一种效率稳定的排序方法。

# 实现

# 递归实现

归并排序递归

	void _MergeSort(int* arr, int left, int right, int* tmp)
	{
	if (left >= right)
	{
	return;
	}

	int mid = (left + right) / 2;
	//[left, mid] [mid + 1, right]

	_MergeSort(arr, left, mid, tmp);
	_MergeSort(arr, mid + 1, right, tmp);

	// 合并
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
	if (arr[begin1] < arr[begin2])
	{
	tmp[index++] = arr[begin1++];
	}
	else
	{
	tmp[index++] = arr[begin2++];
	}
	}
	while (begin1 <= end1)
	{
	tmp[index++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
	tmp[index++] = arr[begin2++];
	}
	memcpy(arr + left, tmp + left, sizeof(int) * (right - left + 1));
	}

	void MergeSort(int* arr, int n)
	{
	int* tmp = (int)malloc(sizeof(int) n);
	if (tmp == NULL)
	{
	perror("malloc");
	return;
	}

	_MergeSort(arr, 0, n - 1, tmp);

	free(tmp);
	tmp = NULL;
	}

# 非递归实现

同样的，归并排序的递归也可以整合为非递归的形式：

归并排序非递归

	void MergeSortNonR(int* arr, int n)
	{
	int* tmp = (int)malloc(n sizeof(int));
	if (tmp == NULL)
	{
	perror("malloc fail");
	return;
	}
	for (int gap = 1; gap < n; gap *= 2)
	{
	for (int j = 0; j < n; j += 2 * gap)
	{
	int begin1 = j, end1 = begin1 + gap - 1;
	int begin2 = begin1 + gap, end2 = begin2 + gap - 1;
	if (end1 >= n \|\| begin2 >= n)
	{
	break;
	}
	if (end2 >= n)
	{
	end2 = n - 1;
	}
	int i = j;
	while (begin1 <= end1 && begin2 <= end2)
	{
	if (arr[begin1] < arr[begin2])
	{
	tmp[i++] = arr[begin1++];
	}
	else
	{
	tmp[i++] = arr[begin2++];
	}
	}
	while (begin1 <= end1)
	{
	tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
	tmp[i++] = arr[begin2++];
	}
	memcpy(arr + j, tmp + j, sizeof(int) * (end2 - j + 1)); // 用 j 不用 begin1，begin1 已经改变
	}
	}
	free(tmp);
	tmp = NULL;
	}

# 测试

下面是对一千万个随机数据的排序测试

# 稳定性

归并排序是稳定的。

# 五、非比较排序

非比较排序不通过直接比较元素之间的大小关系来排序，而是利用其他方法，如数字或者字符串的特性。

非比较排序往往能达到非常非常高的时间效率，但是也往往受到非常大的使用限制。

# 5.1 计数排序

计数排序使用一个额外的数组来记录每个值的出现次数，然后根据这些计数来组织输出排序结果。

计数排序的步骤：

找出待排序数组中的最大值和最小值，确定计数数组的长度。
创建并初始化计数数组，索引代表原数组中的元素，值代表该元素出现的次数。
遍历原数组，更新计数数组：对于原数组中的每一个元素，将计数数组对应索引的值增加 1。
根据计数数组，重构原数组：遍历计数数组，根据每个索引的计数，在原数组中按顺序填充相应的元素。

# 时间复杂度

计数排序的时间复杂度是 $O(N+K)$ ，其中 K 是数组中数据跨度的范围大小（比方说一个数组中所有数据都是 1，那这个跨度就是 1，如果里面有一个 1 变成了 100 万，那 K 就直接变成了 100 万）。

所以说，如果数据跨度比较小，计数排序的时间复杂度就可以认为是 $O(N)$ ，其效率非常离谱。

# 实现

计数排序

	void CountSort(int* arr, int n)
	{
	int max = arr[0];
	int min = arr[0];
	for (int i = 1; i < n; ++i)
	{
	if (arr[i] > max)
	{
	max = arr[i];
	}
	if (arr[i] < min)
	{
	min = arr[i];
	}
	}
	int range = max - min + 1;
	int* count = (int)malloc(sizeof(int) range);
	if (count == NULL)
	{
	perror("malloc");
	return;
	}
	memset(count, 0, sizeof(int) * range);
	for (int i = 0; i < n; ++i)
	{
	count[arr[i] - min]++;
	}
	int index = 0;
	for (int i = 0; i < range; ++i)
	{
	while (count[i]--)
	{
	arr[index++] = i + min;
	}
	}
	free(count);
	count = NULL;
	}

# 测试

下面是对一千万个随机数据的排序测试（数据在 0 到 32767）：

下面是对一千万个随机数据的排序测试（数据在 0 到十亿）：

# 局限性

就像上面所说，计数排序只有在数据跨度较小时能够获得极高的时间效率。而且计数排序只能用于排序整型数据。另外，其空间复杂度较高。

# 5.2 桶排序

注意：桶排序效率高的离谱，局限性也高的离谱，如果还是随便生成大量数据测试可能导致程序崩溃甚至电脑卡死！

桶排序是基于基数排序和分布的一种排序算法。其基本思想是将一个区间内的数据分散到多个有序的桶中，然后分别对每个桶中的元素进行排序，最后将各个桶中的元素按顺序合并，从而得到一个完全有序的数组。

桶排序的步骤描述起来较难理解，下面在代码部分详细解释。

# 时间复杂度

桶排序时间复杂度最低可达 $O(N)$ ，非常高。但是但凡数据跨度比较大、bucketsize（下面会解释是什么）选取的函数不那么合适，就会导致时间和空间复杂度剧烈变化，可能直接造成代码崩溃。

# 实现

桶排序

	void BucketSort(int* arr, int n)
	{
	int max = arr[0];
	int min = arr[0];
	for (int i = 1; i < n; ++i)
	{
	if (arr[i] > max)
	{
	max = arr[i];
	}
	if (arr[i] < min)
	{
	min = arr[i];
	}
	}
	int range = max - min + 1;
	int bucketSize = 5; // 这里对不同的情形需要设置不同的数字，效率差距非常大
	int bucketCount = range / bucketSize + 1;
	int bucket = (int)malloc(sizeof(int) bucketCount);
	for (int i = 0; i < bucketCount; ++i)
	{
	bucket[i] = (int)malloc(sizeof(int) n);
	}
	int* count = (int)malloc(sizeof(int) bucketCount);
	memset(count, 0, sizeof(int) * bucketCount);
	for (int i = 0; i < n; ++i)
	{
	int index = (arr[i] - min) / bucketSize;
	bucket[index][count[index]++] = arr[i];
	}
	int index = 0;
	for (int i = 0; i < bucketCount; ++i)
	{
	InsertSort(bucket[i], count[i]); // 采用插入排序只是一种方法，这里不唯一
	for (int j = 0; j < count[i]; ++j)
	{
	arr[index++] = bucket[i][j];
	}
	}
	for (int i = 0; i < bucketCount; ++i)
	{
	free(bucket[i]);
	}
	free(bucket);
	bucket = NULL;
	free(count);
	count = NULL;
	}

在上方实现中，我们首先确定了数据范围 range。

然后我们要根据 range 确定每一个桶内我们要存放范围大小为多少的数据，也就是 bucketSize。注意，这不是说每个 bucket 只能放 bucketSize 个数据，而是可以放多少值不同的数据（相同值可以无限叠放）。

随后我们就计算出了桶的数量 bucketCount，并且创建了这么多桶。同时每一个桶都配备了一个计数器（对应到 count 数组里）。

最后就是与计数排序类似的步骤，数据分桶再收集即可。

# 测试

100 万 0~99 的数据，bucketSize = 2：

100 万 0~99 的数据，bucketSize = 5：

100 万 0~99 的数据，bucketSize = 1：

# 5.3 基数排序

基数排序是对计数排序的一个升级方法。只要我们 == 把数组中的数从低位到高位逐次进行只看某一位的计数排序，最终就能得到有序的数组。== 这可能有些难以理解，但是我们可以看一个例子：

数组 =[170,45,75,90,802,24,2,66]

我们将按照十进制的个位、十位、百位等进行排序。这里最大的数字是 802，有三位数字，所以我们将进行三轮排序。

第一轮：按个位排序

170 的个位是 0

45 的个位是 5

75 的个位是 5

90 的个位是 0

802 的个位是 2

24 的个位是 4

2 的个位是 2

66 的个位是 6

按个位排序的结果为：170,90,802,2,24,45,75,66170,90,802,2,24,45,75,66

第二轮：按十位排序

170 的十位是 7

90 的十位是 9

802 的十位是 0

2 的十位是 0（没有十位，视为 0）

24 的十位是 2

45 的十位是 4

75 的十位是 7

66 的十位是 6

按十位排序的结果为：802,2,24,45,66,170,75,90802,2,24,45,66,170,75,90

第三轮：按百位排序

802 的百位是 8

2 的百位是 0（没有百位，视为 0）

24 的百位是 0

45 的百位是 0

66 的百位是 0

170 的百位是 1

75 的百位是 0

90 的百位是 0

按百位排序的结果为：2,24,45,66,75,90,170,8022,24,45,66,75,90,170,802

最终排序结果为：2,24,45,66,75,90,170,8022,24,45,66,75,90,170,802

# 时间复杂度

基数排序的时间复杂度仅为 $O(k\times\,N)$ ，非常高效。

# 实现

基数排序

	void RadixSort(int* arr, int n)
	{
	int max = arr[0];
	for (int i = 1; i < n; ++i)
	{
	if (arr[i] > max)
	{
	max = arr[i];
	}
	}
	int maxDigit = 0;
	while (max)
	{
	max /= 10;
	++maxDigit;
	}
	int* count = (int)malloc(sizeof(int) 10);
	int* bucket = (int)malloc(sizeof(int) n);
	int radix = 1;
	for (int i = 0; i < maxDigit; ++i) //@
	{
	memset(count, 0, sizeof(int) * 10);
	for (int j = 0; j < n; ++j)
	{
	count[(arr[j] / radix) % 10]++;
	}
	for (int j = 1; j < 10; ++j)
	{
	count[j] += count[j - 1];
	}
	for (int j = n - 1; j >= 0; --j)
	{
	bucket[--count[(arr[j] / radix) % 10]] = arr[j];
	}
	memcpy(arr, bucket, sizeof(int) * n);
	radix *= 10;
	}
	free(count);
	count = NULL;
	free(bucket);
	bucket = NULL;
	}

对于上方 @标记的循环体中的 3 个子循环，这里需要给出一些解锁：

第一个 for 循环

循环遍历整个数组，计算当前位的数字（个位、十位、百位等），并对应的增加 count 数组中对应索引的值。这里 $arr[j]/radix\%\,10$ 计算出当前位的值（如个位、十位等），count 数组用来记录每个数字（0-9）在当前位出现的次数。
第二个 for 循环

通过累加前一个索引的 count 值，将 count 数组转化为前缀和数组。这一步是为了在下一个循环中能够直接定位每个元素在 bucket 中的存放位置。每个元素的存放位置取决于它当前位的值，并使用前缀和确定其在 bucket 中的结束位置。
第三个 for 循环

从数组的最后一个元素开始向前遍历，这样可以保持排序的稳定性（即相同值的元素保持原有顺序）。通过查找当前位的数字对应的 count 数组值，确定元素在 bucket 中的位置（使用 --count 是为了下次遇到同样的数时位置向前移动一个单位），然后将元素放在 bucket 中相应的位置。

# 测试

下面是对一千万个随机数据的排序测试（数据在 0 到 32767）：

下面是对一千万个随机数据的排序测试（数据在 0 到十亿）：

# 局限性

可以看到，基数排序一定程度上减除了计数排序对大范围数据处理的劣势，但是也增加了空间复杂度。与此同时，基数排序依旧保留了计数排序只能处理整数的缺点。

椋鸟数据结构笔记#9：排序·上

2024-04-11T16:55:22.000Z

该系列为本人的学习笔记，主要由本人整理书写而成。部分内容来自教材、视频课程等，不能保证完全原创性。

萌新的学习笔记，写错了恳请斧正。

# 排序的稳定性

先介绍一个概念，就是排序的稳定性。

排序算法的稳定性是指，如果待排序的序列中存在值相等的元素，经过排序后这些元素之间的先后顺序不变。简而言之，稳定的排序算法可以保留相等元素原本的相对顺序。

假设有一组人的年龄列表，有些人年龄相同：5,3,8,3,2。

如果我们对这个列表进行稳定排序，那么两个年龄为 3 的人在排序后的列表中，先出现的那个人在原列表中也是先出现的。

如果排序算法是稳定的，排序后我们得到的可能是这样：2,3 (第一个),3 (第二个),5,8。

如果排序算法是不稳定的，排序后可能得到：2,3 (第二个),3 (第一个),5,8，这里 3 的顺序被颠倒了，说明排序算法是不稳定的。

稳定性在某些场合下是很重要的。比如，在处理多关键字排序时，稳定性可以保证前一次排序的结果在后一次排序时不会被打乱。如果一个排序算法是稳定的，那么它可以更容易地被用于复杂的排序任务中。

# 一、插入排序

# 1.1 直接插入排序 (Insertion Sort)

直接插入排序是一种简单直观的排序算法。通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用原地排序，因此适合用于小规模数据。

直接插入排序的步骤：

从第一个元素开始，该元素可以认为已经被排序。
取出下一个元素，在已经排序的元素序列中从后向前扫描。
如果该元素（已排序）大于新元素，将该元素移到下一位置。
重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置。
将新元素插入到该位置后。
重复步骤 2~5。

# 时间复杂度

在最坏的情况下，插入排序的时间复杂度为 $O(N^2)$ ，其中 $N$ 是数组的长度。在最好的情况下，如果数组已经是排好序的，插入排序的时间复杂度可以降低到 $O(N)$ ，平均来说，其复杂度更接近 $O(N^2)$ 。适用于小规模数据的排序或者原本就接近有序的情况。

# 实现

直接插入排序

	void InsertSort(int* arr, int n)
	{
	for (int i = 0; i < n - 1; ++i)
	{
	int end = i;
	int tmp = arr[end + 1];
	while (end >= 0)
	{
	if (tmp < arr[end])
	{
	arr[end + 1] = arr[end];
	--end;
	}
	else
	{
	break;
	}
	}
	arr[end + 1] = tmp;
	}
	}

# 稳定性

直接插入排序是稳定的。

# 1.2 希尔排序 (Shell Sort)

希尔排序是插入排序的一种改进版本，也被称为 “缩小增量排序”。其核心思想是将原来要排序的列表分割成多个子序列，先让这些子序列基本有序，再对整个列表进行一次直接插入排序。这样做的目的是让数据移动的次数减少，从而达到减少排序时间的目的。希尔排序的效率比直接插入排序有显著提升。

希尔排序的步骤：

选择一个增量，我们先称之为 gap。（比方说对序列 {a₁,a₂,a₃,...,a_n}，我们可以取 $gap=\lfloor n/2 \rfloor$ ）
根据选择的增量序列，将待排序列分成多个子序列，每个子序列包含的元素不连续，但相距等于增量的元素归为同一子序列。（那么原序列就会被分为 n/2 个子序列，包括 {a₁,a_1+n/2},{a₂,a_2+n/2} 等）
对每个子序列分别进行直接插入排序。（让分出来的每一个子序列变的有序）
减小增量再次分组，重复第 3 步，直至增量减至 1，整个序列成为一个子序列，进行最后一次直接插入排序。（比方说第二次增量 gap 取 $\lfloor n/4 \rfloor$ ，第三次取 $\lfloor n/8 \rfloor$ ，最后一次则是 gap=1）

gap 的序列不一定要像我这样取（每次是上一次的一半），但是不同的增量序列会对这个算法的时间复杂度产生很大的影响。

# 时间复杂度

希尔排序的时间复杂度计算起来非常困难，或者说数学界都还没有给出一个合适的答案。

有人指出当 $gap=2^{t-k+1}-1$ 时，希尔排序的时间复杂度为 $O(n^{3/2})$ ，其中 $t$ 是排序次数， $1\le k\le t\le \lfloor \log_2 (n+1)\rfloor$ 。

还有人得出希尔排序在某个范围内比较次数约为 n^1.3，当 n 趋于正无穷时，可以减少到 $n(\log_2 n)^2$ 。

如果我们使用 Knuth 提出的序列，即 $gap = \lfloor gap/3\rfloor +1$ ，那么时间复杂度约为 $O(N^{1.25})$ 。

但是我们还是可以知道希尔排序最坏情况下时间复杂度为 $O(N^2)$ ，最好情况时间复杂度高于 $O(N\log N)$ ，一般情况下都远优于时间复杂度为 $O(N^2)$ 的算法。

# 实现

取gap为gap/2 希尔排序

	void ShellSort(int* arr, int n)
	{
	int gap = n;
	while (gap > 1)
	{
	gap /= 2;
	for (int i = 0; i < n - gap; ++i)
	{
	int end = i;
	int tmp = arr[end + gap];
	while (end >= 0)
	{
	if (tmp < arr[end])
	{
	arr[end + gap] = arr[end];
	end -= gap;
	}
	else
	{
	break;
	}
	}
	arr[end + gap] = tmp;
	}
	}
	}

# 稳定性

希尔排序是不稳定的。

# 二、选择排序

# 2.1 直接选择排序

直接选择排序是一种简单直观的排序算法。简单说就是在一堆数中，一次次从头到尾挑出最小的数，然后依次排列起来。

直接选择排序的步骤：

在未排序序列中找到最小（最大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（最大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

# 时间复杂度

时间复杂度为 $O(N^2)$ ，没有最好最坏的说法，效率不高。

# 实现

直接选择排序

	void SelectSort(int* arr, int n)
	{
	for (int i = 0; i < n - 1; ++i)
	{
	int min = i;
	for (int j = i + 1; j < n; ++j)
	{
	if (arr[j] < arr[min])
	{
	min = j;
	}
	}
	if (min != i)
	{
	Swap(&arr[i], &arr[min]);
	}
	}
	}

# 稳定性

直接选择排序是不稳定的。

# 2.2 堆排序

堆排序算法是利用大堆（或小堆）的性质来对数组进行排序的，相关内容在前几篇笔记已详细介绍。

堆排序的步骤：

建立堆： 将给定的无序数组构造成一个最大堆（为了升序排序）或最小堆（为了降序排序）。这个过程是通过将数组视为二叉树，然后从最后一个非叶子节点开始，向上调整每个节点，确保每个节点都遵循堆的性质，即每个父节点的值都大于其子节点的值（最大堆）或每个父节点的值都小于其子节点的值（最小堆）。
堆排序： 由于堆的根节点表示最大（或最小）元素，可以将其与堆的最后一个元素交换，然后将剩下的元素重新调整为最大（或最小）堆。重复这个过程，直到所有元素都被排序。

# 时间复杂度

堆排序的效率非常高，时间复杂度为 $O(N\log N)$ 。

# 实现

堆排序

	void AdjustDown(int* arr, int n, int parent)
	{
	int child = parent * 2 + 1;
	while (child < n)
	{
	if (child + 1 < n && arr[child + 1] > arr[child])
	{
	++child;
	}
	if (arr[child] > arr[parent])
	{
	Swap(&arr[child], &arr[parent]);
	parent = child;
	child = parent * 2 + 1;
	}
	else
	{
	break;
	}
	}
	}
	void HeapSort(int* arr, int n)
	{
	for (int i = n / 2 - 1; i >= 0; --i)
	{
	AdjustDown(arr, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
	Swap(&arr[0], &arr[end]);
	AdjustDown(arr, end, 0);
	--end;
	}
	}

# 稳定性

堆排序是不稳定的。

# 三、交换排序

# 3.1 冒泡排序

冒泡排序是我们的老熟人了，是一种简单的排序算法，重复的遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。越小（或越大）的元素会经过交换慢慢 “浮” 到数列的顶端，因此称为冒泡排序。

冒泡排序的步骤如下：

比较相邻的元素。如果第一个比第二个大（升序），就交换它们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

# 时间复杂度

时间复杂度为 $O(N^2)$ ，而且大 O 表示法省略的常数不小，效率相当低。

# 实现

冒泡排序

	void BubbleSort(int* arr, int n)
	{
	for (int i = 0; i < n - 1; ++i)
	{
	int flag = 0;
	for (int j = 0; j < n - i - 1; ++j)
	{
	if (arr[j] > arr[j + 1])
	{
	Swap(&arr[j], &arr[j + 1]);
	flag = 1;
	}
	}
	if (flag == 0)
	{
	break;
	}
	}
	}

# 稳定性

冒泡排序是稳定的。

# 3.2 快速排序

快速排序是一种非常高效的排序，基本思想是 ==“分而治之”==（将一个大问题分解成小问题）。

快速排序的核心是选择一个 “基准值”，然后将数组分为两部分：一部分包含小于基准值的元素，另一部分包含大于基准值的元素。通过递归不断对这两部分继续进行分区，直到整个序列有序。

快速排序的步骤如下：

选择基准值：从数列中挑出一个元素，称为 “基准”。
分区操作：重新排列数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，基准就处于数列的中间位置。
递归排序：递归将小于基准值的子数列和大于基准值的子数列重复前俩步来实现排序。

# 时间复杂度

快速排序的效率非常高，平均时间复杂度为 $O(N\log\,N)$ ，但最坏情况下会退化到 $O(N^{2})$ 。

但是非常神奇，这个最坏情况与其他排序不同，是在原数组有序或者接近有序的情况下为最坏情况。（越乱排序越快）

但是我们可以通过一些技巧来避免快速排序会取到最坏情况这件事，这会在下面介绍。

# 实现

# 原始的快速排序 - Hoare 法

这是 Hoare 大佬刚提出快速排序时给出的方法。

我们记录排序区间的左下标 left 和右下标 right，并选取基准值 key 的下标（这边我们以 key=left 为例，若选择 key=right 下面反过来想就能得出）。我们使 right 从右往左跑直到找到小于基准值或者遇到 left，然后我们让 left 从左往右跑直到找到大于基准值或者遇到 right，随后交换 left 和 right 标记的值。重复这个过程就能完成一次分区，随后再写入递归即可完成排序。

快速排序 hoare法

	void QuickSort(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	int key = left, begin = left, end = right;
	while (left < right)
	{
	while (left < right && arr[right] >= arr[key])
	{
	--right;
	}
	while (left < right && arr[left] <= arr[key])
	{
	++left;
	}
	Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[key]);
	QuickSort(arr, begin, left - 1);
	QuickSort(arr, left + 1, end);
	}

# 逻辑简洁的快速排序 - 挖坑法

挖坑法在逻辑上更易于理解，不会陷入为什么左右标记不会越过对方、为什么一定要先移动某个标记等问题。

挖坑法就是把基准值单独复制出来放到一个变量里，原本的位置作为一个 “坑位”（还是假设 key=left）。然后右标记左移直到发现小于基准值的数，把这个数 “挖出来” 填到 “坑位” 里。这个时候挖走的形成了一个新的坑位，这时左标记右移直到找到大于基准值的数，再次挖到 “坑位” 里。重复这个过程直到两个指针相遇（数据都分区好了），最后把原本挖出去的基准值再填回来（这个时候坑位正好在中间）。这就成功完成了一次分区过程，递归即可。

快速排序挖坑法

	void QuickSortDigHole(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	int key = left, begin = left, end = right;
	int tmp = arr[key]; // 挖坑
	while (left < right)
	{
	while (left < right && arr[right] >= tmp)
	{
	--right;
	}
	arr[left] = arr[right]; // 此时坑位从左边变为右边
	while (left < right && arr[left] <= tmp)
	{
	++left;
	}
	arr[right] = arr[left]; // 此时坑位从右边变为左边
	}
	arr[left] = tmp;
	QuickSort(arr, begin, left - 1);
	QuickSort(arr, left + 1, end);
	}

# 最好书写的快速排序 - 前后指针法

前后指针法的代码更简洁，也不难理解。

就是一开始把 prev 标记放在 left（还是假设 key=left），cur 标记放在 left+1，然后前指针 cur 一直往前冲，遇到比基准值小的数就和后指针 prev 标记的值对调，再让后指针往前一步。重复这个过程让小于基准的值全部堆到数组的前面（准确说是 prev 的前面），最后把 key 标记的值和 prev 标记的对调就完成了一次分区。递归即可。

快速排序前后指针法

	void QuickSortPrevCur(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	int key = left, begin = left, end = right;
	int prev = left, cur = left + 1;
	while (cur <= right)
	{
	if (arr[cur] < arr[key] && ++prev != cur)
	{
	Swap(&arr[prev], &arr[cur]);
	}
	++cur;
	}
	Swap(&arr[prev], &arr[key]);
	key = prev;
	//[begin, key - 1] [key] [key + 1, end]
	QuickSort(arr, begin, key - 1);
	QuickSort(arr, key + 1, end);
	}

# 不使用递归的方法 - 栈模拟递归

这个方法没怎么好说的，就是用栈模拟递归，里面每一次分区依旧可以选择上面任意一种方法。

快速排序非递归

	void InitStack(pStack pst)
	{
	assert(pst);
	pst->_data = NULL;
	pst->_top = 0;
	pst->_capacity = 0;
	}

	void StackPush(pStack pst, STDataType x)
	{
	assert(pst);
	StackCheck(pst);
	memcpy(&(pst->_data[pst->_top]), &x, sizeof(STDataType));
	pst->_top++;
	}

	void StackPop(pStack pst)
	{
	assert(pst);
	assert(!StackEmpty(pst));
	pst->_top--;
	}

	STDataType StackTop(pStack pst)
	{
	assert(pst);
	return pst->_data[pst->_top - 1];
	}

	void StackDestory(pStack pst)
	{
	assert(pst);
	free(pst->_data);
	pst->_capacity = 0;
	pst->_top = 0;
	pst->_data = NULL;
	}

	void QuickSortNonR(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	Stack st;
	InitStack(&st);
	StackPush(&st, left);
	StackPush(&st, right);
	while (!StackEmpty(&st))
	{
	int end = StackTop(&st);
	StackPop(&st);
	int begin = StackTop(&st);
	StackPop(&st);
	int key = begin;
	int prev = begin, cur = begin + 1;
	while (cur <= end)
	{
	if (arr[cur] < arr[key] && ++prev != cur)
	{
	Swap(&arr[prev], &arr[cur]);
	}
	++cur;
	}
	Swap(&arr[prev], &arr[key]);
	key = prev;
	//[begin, key - 1] [key] [key + 1, end]
	if (begin < key - 1)
	{
	StackPush(&st, begin);
	StackPush(&st, key - 1);
	}
	if (key + 1 < end)
	{
	StackPush(&st, key + 1);
	StackPush(&st, end);
	}
	}
	StackDestory(&st);
	}

# 区别

除了非递归的方法，这几个实现的时间复杂度并没有太多区别，使用非递归的方法会慢一点点。下面是对一千万个随机数据的排序测试（单位毫秒）：

# 优化

# 随机选 Key 优化快速排序

这个方法是在序列中随机选一个值和首元素调换再作为基准值，大大减小了遇到最坏情况（每次选 key 是有序的）的可能。

快速排序随机选key

	void QuickSortRandomKey(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	int key = left, begin = left, end = right;

	// 生成随机数并将该位置与首位调换
	int random = rand() % (right - left + 1) + left;
	Swap(&arr[random], &arr[left]);

	while (left < right)
	{
	while (left < right && arr[right] >= arr[key])
	{
	--right;
	}
	while (left < right && arr[left] <= arr[key])
	{
	++left;
	}
	Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[key]);
	QuickSort(arr, begin, left - 1);
	QuickSort(arr, left + 1, end);
	}

# 三数取中优化快速排序

这个方法是取序列中 left、right、(left+right)/2 所对应的值的中位数与首元素调换作为基准值，这几乎完全避免了最坏情况的可能。

快速排序三数取中法

	int GetMid(int* arr, int left, int right)
	{
	int center = (left + right) / 2;
	if (arr[left] > arr[center])
	{
	Swap(&arr[left], &arr[center]);
	}
	if (arr[left] > arr[right])
	{
	Swap(&arr[left], &arr[right]);
	}
	if (arr[left] > arr[center])
	{
	Swap(&arr[center], &arr[right]);
	}
	return arr[center];
	}

	void QuickSortMidKey(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	int key = left, begin = left, end = right;

	// 三数取中
	int mid = GetMid(arr, left, right);
	Swap(&arr[mid], &arr[left]);

	while (left < right)
	{
	while (left < right && arr[right] >= arr[key])
	{
	--right;
	}
	while (left < right && arr[left] <= arr[key])
	{
	++left;
	}
	Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[key]);
	QuickSort(arr, begin, left - 1);
	QuickSort(arr, left + 1, end);
	}

# 小区间优化快速排序

当递归已经进行到序列变的很短的时候，依旧选择继续递归快速排序的效率其实较低，反而不如将已经较短的序列拿去进行插入排序。所以在递归时加上一个选择语句进行优化：

快速排序小区间优化

	void QuickSortOptimized(int* arr, int left, int right)
	{
	if (left >= right)
	{
	return;
	}
	if (right - left < 10)
	{
	InsertSort(arr + left, right - left + 1);
	}
	else
	{
	int key = left, begin = left, end = right;

	while (left < right)
	{
	while (left < right && arr[right] >= arr[key])
	{
	--right;
	}
	while (left < right && arr[left] <= arr[key])
	{
	++left;
	}
	Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[key]);
	QuickSort(arr, begin, left - 1);
	QuickSort(arr, left + 1, end);
	}
	}

# 优化效果

对于随机序列，随机选 key 和三数取中法并没有太大的作用：

但是如果是有序或者近有序序列，就完爆原版了：

而小区间优化，说实话效果有限：

# 稳定性

快速排序是不稳定的。

未完待续。

	class A
	{
	public:
	A(int a)
	: m_2(a)
	, m_1(m_2)
	{}

	private:
	int m_1; // 声明
	int m_2;
	};

	template <typename T>
	T f<int>(T a, T b)
	_Z1fIiEii

博客

椋鸟Swift笔记#0：学习Swift前

# 关于 Swift 语言

# 你需要准备的

# 1. 你需要一台 Mac

# 2. 你需要一定程度的英文水平

# Xcode 环境搭建

椋鸟Swift笔记#1：常量变量和print

关于解决在iOS的XP3播放器中由汉化组弹窗导致的闪退问题

关于本博客日后更新

解谜游戏-RailBound轨道联结-攻略

转载·算法描述语言ADL

椋鸟C++笔记#7：标准模板库STL初识

# 标准模板库（Standard Template Library）

# STL 的版本

# P.J. 版

# RW 版

# SGI 版

# STL 的组成部分

椋鸟C++笔记#8：标准库中的string类

# C 语言里的字符串

# C++ 中的 string 类

# string 类是什么

# string 类与 STL 的关系

# string 类其实也是一个类模板

# string 类的迭代器 iterator

# string 类常用接口（并不完全）

# string 类常见构造

# string 类常用容器操作

# size 与 length

# capacity

# empty

# clear

# reserve

# resize

# string 类对象的访问和遍历操作

# operator[]

# char& operator[] (size_t pos);

# const char& operator[] (size_t pos) const;

# begin 与 end (包括 r 系与 c 系)

# 范围 for (C++11)

# string 类对象的修改操作

# push_back

# append

# operator+=

# c_str

# find

# rfind

# npos

# substr

# string 类非成员函数

# operator+

# operator>>

# operator<<

# getline

# relational operators(==、!=、<、<=、>、>=)

K&R风格与Allman风格

# K&R 风格（紧凑风）

# Allman 风格（折叠风）

# 如何选择代码风格

椋鸟C++笔记#6：模板的基础用法

# 泛式编程

# 函数模板

# 函数模板的实例化

# 隐式实例化

# 显式实例化

# 模板函数的匹配原则

# 类模板

# 类模板声明与定义分离

# 类模板的实例化

椋鸟C++笔记#5：C++内存管理

# C 语言中的动态内存管理

# C++ 中的动态内存管理

# 使用 new/delete 操作内置类型

# 使用 new/delete 操作自定义类型

# operator new (operator new []) 与 operator delete (operator delete []) 函数

# operator new 函数

# operator delete 函数

# operator new [] 和 operator delete []

# new 与 delete 的实现原理

# `char& operator[] (size_t pos);`

# `const char& operator[] (size_t pos) const;`

# 析构函数（Destructor）