Jiankychen's Blog

LaTeX 转 Word

2023-02-16T09:26:05.000Z

# Pandoc

利用 Pandoc 读取 tex 源码并输出 docx 文件

# 安装

Pandoc 下载地址：Pandoc

按默认配置安装即可

# 使用

步骤：

配置路径：打开 cmd ，切换到需转换的 LaTeX 文件所在的路径
转换：在 cmd 中输入转换命令

命令模板（不可执行）：

	pandoc main.tex -o output.docx ^
	--reference-doc template.docx ^
	--filter pandoc-crossref -M tableEqns -M autoEqnLabels ^
	--resource-path=.;Figures ^
	--bibliography ref.bib ^
	--citeproc ^
	--csl references_style.csl ^
	-M reference-section-title=Reference ^
	--number-sections ^
	--toc

# 注意事项

带 * 的图表不能正确转化，例如： \begin{figure*} 应改为 \begin{figure}
表格中带子 tabular 的不能正确生成
由于 pandoc-crossref 使用与 citeproc 相同的引用语法，因此，pandoc-crossref 相关命令必须放在 citeproc 前面
LaTeX 伪代码算法无法正常转化，可通过第三方工具实现（例如：Aurora 插件）

经测试，图片、表格、章节的交叉引用可以显示编号，但公式的交叉引用无法显示编号（无论是 \ref 命令还是 \eqref 命令都无法显示）。

# 参考资料

Pandoc：

Aurora：

# Acrobat

直接使用 Adobe Acrobat Pro DC 软件将 PDF 文件转换成 Word 文件

除部分公式无法准确转换外，其余的转换效果都挺不错的

可以考虑将 Acrobat 与 Pandoc 结合使用，取长补短

SQL 基础

2023-02-04T14:43:13.000Z

# SQL 简介

SQL（Structured Query Language），结构化查询语言，用于访问和处理数据库的标准的计算机语言

SQL 语法特征：

大小写不敏感
可以单行或多行书写，最后以 ; 号结束
支持单行、多行注释：
- 单行注释： -- 注释内容 （-- 后面一定要有一个空格）
- 单行注释： # 注释内容 （# 后面可以不加空格，但推荐加上）
- 多行注释： /* 注释内容 */

根据 SQL 语句的功能，可将其分为四类：

数据定义：DDL（Data Definition Language）
- 库的创建删除、表的创建删除等
数据操纵：DML（Data Manipulation Language）
- 新增数据、删除数据、修改数据等
数据控制：DCL（Data Control Language）
- 新增用户、删除用户、密码修改、权限管理等
数据查询：DQL（Data Query Language）
- 基于需求查询和计算数据

# DDL

# 数据库操作

查看所有数据库

show databases;

查看当前使用的数据库

select database();

创建数据库

create database 数据库名 charset utf8;

删除数据库

drop database 数据库名;

使用数据库

use 数据库名;

# 表操作

查看数据库中所有表（需要先选择数据库）

show tables;

查看表结构

desc 表名;

创建表

	create table 表名(
	列名列类型 [约束条件],
	列名列类型 [约束条件],
	...
	）;

[] 表示可选的内容

其中，列类型有：

int ：整数
float ：浮点数
varchar(长度) ：文本（长度填写整数类型，用于限制文本长度，可填的最大数字为 255）
date ：日期类型
timestamp ：时间戳类型

修改表–添加字段

alter table 表名 add 列名 类型;

修改表–修改字段–重命名版

alert table 表名 change 原名 新名 类型及约束;

修改表–修改字段–不重命名

alter table 表名 modify 列名 类型及约束;

删除表–删除字段

alter table 表名 drop 列名;

删除表

	drop table 表名;

	# 如果表存在，则删除；如不存在，则跳过
	drop table if exists 表名;

有些数据库系统不支持 if exists 选项，支持 if exists 选项的有：MySQL，PostgreSQL 和 SQL Server 2016

查看表的创建语句–详细过程

show create table 表名;

# DML

# 数据插入

全列插入：值的顺序与表结构字段的顺序完全对应，此时可以省略列名的列表

insert into 表名 values (...);

部分列插入：值的顺序与给出的列名顺序对应

insert into 表名 (列1, 列2, ...) values (值1, 值2, ...);

全列多行插入

insert into 表名 values (...), (...), ...;

部分列多行插入

insert into 表名 (列1, 列2, ...) values (值1, 值2, ...), (值1, 值2, ...), ...;

注意：如果数据是字符型，必须使用单引号或双引号包围

例如：

	# 创建名为 test 的数据库
	create database test charset UTF8;

	# 使用名为 test 的数据库
	use test;

	# 创建表
	create table student(
	id int,
	name varchar(10),
	age int
	);

	# 为 id 列插入多行数据
	insert into student(id) values(1), (2), (3);

	# 为 id 列和 name 列插入多行数据
	insert into student(id, name) values(4, 'Ellon'), (5, 'John');

	# 为全部列插入数据
	insert into student values(6, 'Ale', 20);

# 数据删除

清空表（删除整个表中的数据）

delete from 表名;

按特定条件删除数据

delete from 表名 where 条件;

例如：

	# 删除 id 为 3 的行
	delete from student where id = 3;

# where

where 后面跟条件语句，以进行条件处理

条件语句支持以下运算符：

比较运算符
- 等于： =
- 大于： >
- 大于等于： >=
- 小于： <
- 小于等于： <=
- 不等于： != 或 <>
逻辑运算符
- 与： and
- 或： or
- 非： not
使用 like 关键字的模糊查询
- % 通配符：表示任意多个任意字符
- _ 通配符：表示一个任意字符
范围查询
- 连续范围查询： between ... and ...
- 非连续范围查询： in(... , ...)
空判断
- 判断为空： is null
- 判断不为空： is not null

条件的优先级：

优先级由高到低的顺序为：小括号， not ，比较运算符，逻辑运算符
and 比 or 先运算（如果同时出现并希望先算 or ，需要结合 () 使用）

参考资料：

# 数据修改

update 表名 set 列名 = 值 [where 条件];

例如：

	# 将 id 为 2 所对应的 name 修改为 Mike
	update student set name = 'Mike' where id = 2;

update 表名 set 列名 = 值 会修改整列的数据

# DQL

# 基础查询

查询所有列

select * from 表名;

查询指定列

select 列1，列2，... from 表名;

条件查询

select 列1，列2，... from 表名 where 条件;

例如：

	# 查询 id 和 name 两列，年龄小于 35
	select id, name from student where age >= 18 and age < 35;

# 分组聚合

select 字段, 聚合函数 from 表名 [where 条件] group by 列名;

聚合函数：

求和： sum(列)
求平均值： avg(列)
求最小值： min(列)
求最大值： max(列)
求数量： count(列/*)

注意：

一条 SQL 查询语句可以写多个聚合函数，以同时展示多个统计信息
除了聚合函数外， select 字段 中的字段只能包含 GROUP BY 列名 中出现的列名

例如：

	create table person(
	id int,
	name varchar(10),
	age int,
	gender varchar(10)
	);

	insert into person values(1, 'Tom', 23, 'male'), (2, 'Jerry', 22, 'male'),
	(3, 'Morty', 21, 'male'), (4, 'Rick', 26, 'male'), (5, 'Marry', 23, 'female'), (6, 'Angel', 22, 'female');

	# 按性别分组，统计各组人数
	select gender, count(*) from person group by gender;

	# 按性别分组，统计平均年龄
	select gender, avg(age) from person group by gender;

	# 按性别分组，统计最大年龄和最小年龄
	select gender, max(age), min(age) from person group by gender;

# 排序分页

# 结果排序

可以对查询的结果使用 order by 关键字，指定某个列进行排序

	select 列\|聚合函数\|* from 表名
	where ...
	group by ...
	order by ... [asc / desc];

其中：

升序（默认）: asc
降序： desc

例如：

	# 显示 age > 22 的所有数据（按 age 列降序排列）
	select * from person where age > 22 order by age desc;

# 结果分页

可以使用 limit 关键字，对查询结果进行数量限制或者分页显示

	select 列\|聚合函数\|* from 表名
	where ...
	group by ...
	order by ... [asc / desc]
	limit n[, m];

其中：

n 表示：显示 n 条数据
n, m 表示：跳过前 n 条数据，显示后续的 m 条数据

注意：

select 和 from 是必写的， where 、 group by 、 order by 、 limit 均可按需求省略
执行顺序：from -> where -> group by 和聚合函数 -> select -> order by -> limit
limit 后面不可以直接加公式

例如：

	# 按 age 列升序排列，查询结果只保留 5 条数据
	select * from person limit 5;

	# 筛选出年龄最大的 5 人
	select * from person order by age desc limit 5;

	# 按 age 列升序排列，查询结果只保留从第 3 条开始的 2 条数据
	select * from person order by age limit 2, 2;

参考资料：

Python 面向对象

2023-02-02T09:48:52.000Z

Python 是一种面向对象的编程语言

简单理解面向对象：基于模板（类）去创建实体（对象），使用对象完成功能开发

面向对象的三大特征：

封装
继承
多态

面向对象技术简介

类（Class）: 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法
实例化：创建一个类的实例（类的具体对象）
方法：类中定义的函数
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
局部变量：定义在方法中的变量，只作用于当前实例的类
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个 Dog 类型的对象派生自 Animal 类，这是模拟 "是一个（is-a）" 关系（即，Dog 是一个 Animal）

# 类和对象

类的组成：

成员变量：定义在类中的属性（变量）
成员方法：定义在类中的行为（函数）

# 类定义

使用关键字 class 定义类：

	class Class_Name:
	<statement-1>
	...
	<statement-N>

其中， Class_Name 表示类的名称，通常需要首字母大写

# 类对象

创建对象（实例化）：

obj = Class_Name()

修改对象属性：

obj.var_name = xx

删除对象属性：

	# 使用 del 关键字删除对象的属性
	del obj.var_name

删除对象：

	# 使用 del 关键字删除对象
	del obj

# 类的成员方法

函数：定义在类的外部
方法：定义在类的内部

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类的成员方法必须必须有一个额外的第一个参数名称，按照惯例它的名称是 self ，即：

	def func_name(self, parameter_1, ..., parameter_N):
	...

其中：

self 参数是对类的当前实例的引用，用于访问属于该类的变量。它不必被命名为 self ，但它必须是类中任意函数的首个参数
在方法内部，想要访问类的成员变量，必须使用 self 。即，使用 self.var_name 访问成员变量 var_nam
调用类的成员方法时， self 会被自动传入，即，不需要在实参列表中写出 self

# 构造方法

Python 类中的 __init__ 方法，称之为构造方法

每次使用类创建新对象时，都会自动调用 __init__ 方法，并且会将创建类对象时的传入参数自动传递给 __init__ 方法

因此，使用 __init__ 方法可以将值赋给对象属性，或者在创建对象时需要执行的其他操作

注意，构造方法也是成员方法，因此：

定义构造方法时需要在形参列表中写上 self 参数
在构造方法内部访问成员变量需要使用 self.var_name

例如：

	# 定义类
	class Person:
	name = None # 由于定义了 __init__ 方法，可以省略这里的初始化
	age = None # 由于定义了 __init__ 方法，可以省略这里的初始化

	def __init__(self, name, age):
	self.name = name
	self.age = age


	# 创建类对象
	p = Person("John", 24)

	# 打印类对象的属性
	print(p.name)
	print(p.age)

# 魔术方法

魔术方法（Magic Methods）是 Python 中的内置方法，一般以 __ （双下划线）为开头和结尾

例如：

__init__ ：构造方法，当一个实例被创建的时候调用的初始化方法
__del__ ：析构方法，当一个实例被销毁的时候调用的方法
__str__ ：字符串方法，定义当被 str() 调用或者打印对象时的行为
__lt__ ：定义小于号的行为： x < y 调用 x.__lt__(y)
__le__ ：定义小于等于号的行为： x <= y 调用 x.__le__(y)
__eq__ ：定义等于号的行为： x == y 调用 x.__eq__(y)

之所以称之为魔法方法，是因为这些方法会在进行特定的操作时会被自动调用

如果希望根据自己的程序定制自己特殊功能的类，那么就需要对这些方法进行重写

参考：Python 中类的魔术方法

# pass 语句

pass 是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容

如果因为某种原因写了无内容的函数定义或类定义，需使用 pass 语句来避免错误

例如：

	# 继承
	class DerivedClassName(BaseClassName):
	pass

参考资料：

# 封装

在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来（即，定义成私有成员），在程序外部看不到（即，其他程序无法调用）

封装数据：保护隐私
封装方法：隔离复杂度（只保留部分接口对外使用）

# 私有成员

类对象无法直接访问私有成员，但类内其它成员可以直接使用私有成员

私有成员变量：

定义：变量名以 __ （2 个下划线）开头，例如： __private_attrs
声明该属性为私有属性，只能在类的内部使用，不能在类的外部使用或直接访问
在类内部的访问方式为： self.__private_attrs

私有成员方法（封装的方法）：

方法名以 __ （2 个下划线）开头，例如： __private_method
声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用
在类内部的调用方式为： self.__private_method()

与 java 等语言不同，Python 的封装并不是真正意义上的外部无法调用。在 Python 中，如果需要在类外调用封装的属性或方法，须采用 对象名._类名__方法名 和 对象名._类名__变量名 的方式（不建议调用）

例如：

	class Foo:
	def __init__(self, height, weight): # 构造方法
	self.height = height
	self.weight = weight

	def __heightpow(self): # 私有方法
	return self.height * self.height

	def tell_bmi(self):
	return self.weight / self.__heightpow() # 私有成员可以被类内其它成员直接使用

	egon = Foo(1.7, 120)
	print(egon.tell_bmi())
	print(egon._Foo__heightpow()) # 尽管是私有成员方法，但也可以在类外调用以供查看

# property

property 是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值（就是一个装饰器）

将一个类的方法 func_name 用 propery 装饰以后，类对象 obj 可直接通过 obj.func_name 去使用，以遵循统一访问的原则

被 property 装饰的属性会优先于对象的属性被使用

被 propery 装饰的属性分成三种：

property
被装饰的函数名.setter
被装饰的函数名.deleter

例如， @property 把类中的方法伪装成属性：

	from math import pi

	class Circle:
	def __init__(self, radius):
	self.radius = radius

	@property # 装饰器：将一个方法当成一个属性用
	def area(self):
	return self.radius * self.radius * pi

	@property
	def peimeter(self):
	return 2 * pi * self.radius

	c = Circle(10)
	print(c.area) # 当成一个属性来调用（即，不需要加括号）
	print(c.peimeter) # 当成一个属性来调用（即，不需要加括号）

注意：此时的特性 area 和 perimeter 不能被赋值

参考资料：

# 继承

继承允许我们定义继承（复制）另一个类的所有方法和属性的类

继承可以分为：

单继承：一个类继承另一个类
多继承：一个类继承多个类，按照顺序从左向右依次继承

父类是被继承的类，也称为基类

子类是从另一个类继承所得的类，也称为派生类

# 单继承

任何类都可以是父类，因此，创建父类的语法与创建任何其他类相同

要创建从其他类继承功能的类，只需在创建子类时将父类作为参数传递即可：

	class DerivedClassName(BaseClassName):
	<statement-1>
	...
	<statement-N>

其中， DerivedClassName 为子类名， BaseClassName 为父类名

如果不希望向子类中添加任何其他属性或方法，可使用 pass 关键字

例如：

	# 创建 Person 类
	class Person:
	def __init__(self, fname, lname):
	self.firstname = fname
	self.lastname = lname

	def print_name(self):
	print(self.firstname, self.lastname)

	# 创建 Person 类对象，并执行 print_name 方法
	x = Person("Bill", "Gates")
	x.print_name()


	# 创建继承自 Person 类的子类 Student
	class Student(Person):
	def __init__(self, fname, lname, gra):
	self.firstname = fname
	self.lastname = lname
	self.grade = gra

	def print_info(self):
	print(self.firstname, self.lastname, self.grade)

	# 使用 Student 类创建一个对象，然后执行 print_name 和 print_info 方法
	y = Student("Elon", "Musk", 6)
	y.print_name()
	y.print_info()

# 多继承

创建子类的语法：

	class DerivedClassName(Base1, Base2, Base3):
	<statement-1>
	...
	<statement-N>

如果多个父类中含有同名的成员，那么默认按照从左向右顺序依次继承，先继承的保留，后继承的被覆盖

# 方法重写

子类继承父类的成员属性和成员方法后，如果对其 “不满意”，可以在子类重写父类的方法

即：在子类中重新定义同名的属性或方法

例如：

	class Parent: # 定义父类
	def myMethod(self):
	print ('调用父类方法')

	class Child(Parent): # 定义子类
	def myMethod(self): # 重写父类方法
	print ('调用子类方法')

	c = Child() # 子类实例
	c.myMethod() # 子类调用重写方法

# 调用父类同名成员

一旦在子类中重写父类成员以后，子类的类对象调用成员时将是调用复写后的新成员

如果需要使用被复写的父类的成员，需要特殊的调用方式:

方式一：通过父类调用（单继承
- 调用父类成员变量： 父类名.成员变量
- 调用父类成员方法： 父类名.成员方法(self)
方式二：使用 super() 调用
- 调用父类成员变量： super().成员变量
- 调用父类成员方法： super().成员方法()

如果是单继承的情况，可以直接用父类名调用父类方法

但是，如果是多继承的情况，可能会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题，此时，推荐采用 super() 函数调用，以解决多重继承问题。具体可参考：Python super () 函数

参考资料：

Python 继承

# 类型注解

类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）

帮助第三方 IDE 工具（如 PyCharm）对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释

有两种注解：

变量的类型注解
函数（方法）的类型注解

需注意：类型注解仅仅是提示性的，不是决定性的，并不会真正地对类型做验证和判断（也就是说：即使注解的数据类型与实际数据类型不一致，程序也不会报错）

# 变量的类型注解

事实上，对于显式的变量定义，一般无需注解。即便不写类型注解，也可以明确知晓变量的类型

一般而言，在无法直接看出变量类型时（例如，将函数返回值赋给一个变量时），才会添加变量的类型注解

# 方式一（常用）

基础语法：

变量: 类型

例如：

基础数据类型注解：

	var1: int = 3
	var2: float = 3.14
	var3: bool = True

类对象类型注解:

	class Person:
	pass
	p: Person = Person()

容器类型简易注解：

	mylist: list = [1, 2, 3]
	mytuple: tuple = (1, 2, 3)
	myset: set = {1, 2, 3}
	mydict: dict = {0: "a", 1: "b"}
	mystr: str = "Jiankychen"

容器类型详细注解：

元组类型设置类型详细注解：需要将每一个元素都标记出来
字典类型设置类型详细注解：需要 2 个类型，第一个是 key ，第二个是 value

	mylist: list[int] = [1, 2, 3]
	mytuple: tuple[str, int, bool] = ("a", 0, True)
	myset: set[int] = {1, 2, 3}
	mydict: dict[int, str] = {0: "a", 1: "b"}

# 方式二

除了使用 变量: 类型 这种语法做注解外，也可以 在注释中进行类型注解

基础语法：

# type: 类型

例如：

	class Person:
	pass

	def func():
	return 3.14159

	var1 = random.randint(1, 10) # type: int
	var2 = Person() # type: Person
	var3 = func() # type: float

# 函数（方法）的类型注解

# 形参注解

函数（方法）的形参类型注解语法：

	def func_name(形参名: 类型, 形参名: 类型, ...)
	statement

例如：

	def add(x: int, y: int):
	return x + y

# 返回值注解

函数（方法）的返回值也是可以添加类型注解的，语法如下：

	def func_name() -> 返回值类型:
	statement

例如：

	def func(data: list) -> list:
	return data

# Union 类型

通过 Union 可以定义联合类型

导包： from typing import Union
使用： Union[类型, ..., 类型]

在变量注解、函数（方法）形参和返回值注解中，均可使用 Union 联合类型

例如：

	from typing import Union

	mylist: list[Union[str, int]] = [1, 2, "3", "4"] # list 元素的数据类型可能是 str ，也可能是 int

	mydict: dict[str, Union[str, int]] = {"name": "Jiankychen", "age": 24} # value 的数据类型可能是 str ，也可能是 int

	def func(data: Union[int, str]) -> Union[int, str]:
	return data

参考资料：

黑马程序员 Python 教程：类型注解

# 多态

多态：多种状态，即：对于某个行为（函数），使用不同的对象将会得到不同的状态

例如： Cat 类和 Dog 类都有 speak 成员方法， Cat 类对象和 Dog 类对象都能被传入 command 函数；但是由于两个类定义的 speak 方法的功能不一致，传入不同类的对象就会得到不同的状态

	class Cat:
	def speak(self):
	print "meow!"

	class Dog:
	def speak(self):
	print "woof!"

	def command(pet):
	pet.speak()

	cat = Cat()
	command(cat) # 输出：meow!

	dog = Dog()
	command(dog) # 输出：woof!

多态常作用在继承关系上，比如：定义函数（方法），通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态

例如，可以将上例中的代码修改为：

	class Pet:
	def speak(self)
	pass

	class Cat(Pet):
	def speak(self):
	print "meow!"

	class Dog(Pet):
	def speak(self):
	print "woof!"

	def command(pet: Pet): # 函数形参的类型注解
	pet.speak()

	cat = Cat()
	command(cat) # 输出：meow!

	dog = Dog()
	command(dog) # 输出：woof!

# 抽象类（接口）

抽象方法：没有具体实现的方法（即：方法体是 pass 语句）

抽象类：包含抽象方法的类，也可以称之为接口，比如上例中的 Pet 类

抽象类相当于定义一个标准，包含了一些抽象的方法，要求子类必须实现

这种设计的意义在于：

父类用来确定有哪些方法
具体的方法实现，由子类自行决定

参考资料：

黑马程序员 Python 教程：多态

pandas 基础

2023-01-20T13:02:02.000Z

# 安装及导入

# 安装

可以使用 pip 安装

pip install pandas

# 导入

import pandas as pd

# 数据结构

# Series

Series 是一种类似于一维数组的对象，它由一组数据（各种 Numpy 数据类型）以及一组与之相关的数据标签（即索引）组成

Series 只有行索引

例如，创建一个 Series 对象：

ser = pd.Series(data = [1, 2, 3], index = ['a', 'b', 'c'])

其内容为：

a   1
b   2
c   3

Series 的各种方法

# DataFrame

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）

DataFrame 既有行索引又有列索引

例如，创建一个 DataFrame 对象：

df = pd.DataFrame(data = np.array([[1, 2, 3], [4, 5, 6]]), columns = ['a', 'b', 'c'])

其内容为：

   a  b  c
0  1  2  3
1  4  5  6

DataFrame 的各种方法

下面将以 DataFrame 对象为例来介绍 pandas 的基本用法

# 数据输入

	# 使用 read_csv 读取 csv 文件
	df = pd.read_csv('file_name')

	# 或者：使用 read_csv 读取 csv 文件
	# read_csv 默认使用 '\t' 作为数据分隔符，需将分隔符设为 ','
	df = pd.read_table('file_name', sep=',')

	# 读取 excel 文件
	pd.read_excel()

	# 读取 json 文件
	pd.json()

	# 读取 xml 文件
	pd.read_xml()

# 数据输出

	# 将 DataFrame 对象写入 csv 文件
	df.to_csv('file_name')

	# 写入 excel 文件
	df.to_excel()

	# 写入 json 文件
	df.to_json()

	# 写入 xml 文件
	df.to_xml()

pandas 读取 / 写入文件

# 查看数据

	# DataFrame 对象的头部数据（默认显示 5 条数据）
	df.head()

	# DataFrame 对象的尾部数据（默认显示 5 条数据）
	df.tail()

	# DataFrame 对象的索引
	df.index

	# DataFrame 对象的列名
	df.columns

	# DataFrame 对象的统计信息
	df.describe()

	# DataFrame 对象的摘要
	df.info()

	# DataFrame 对象的形状
	df.shape

	# 查看数据是否为空
	df.isnull()

	# 查看各数据类型
	df.dtypes

	# 查看某一列的所有值
	df[['column_name']] # 方法一
	df.loc[:, ['column_name']] # 方法二

	# 查看某一列的变量名及种类
	df['column_name'].value_counts() # 方法一
	df['column_name'].unique() # 方法二

	# 查看满足条件的值
	df[condition]

	# 最大值对应的索引
	df.idxmax()

	# 最小值对应的索引
	df.idxmin()

# 缺失值处理

pandas 主要用 np.nan 表示缺失数据

一般情况下，运算时默认排除缺失值

	# 查找缺失值
	df.isnull()

	# 查找非缺失值
	df.notnull()

	# 删除所有含缺失值的行
	df.dropna(how='any')

	# 用 0 填充缺失值
	df.fillna(value=0)

# 重复值处理

	# 查看 DataFrame 数据中的重复值
	df.duplicated()

	# 统计 DataFrame 数据中重复值的个数
	df.duplicated().sum()

	# 删除 DataFrame 数据中的重复值
	df.drop_duplicates()

# 索引变换

	# 重置索引
	df.reset_index()

	# 将现有的列设为索引
	df.set_index('column_name')

	# 修改索引与列标签
	df.reindex(index=index_labels, columns=column_labels) # 方法一
	df.rename(index=index_labels, columns=column_labels) # 方法二

reindex 和 rename

# 排序

	# 按索引排序
	df.sort_index()

	# 按行列的值排序
	df.sort_values()

	# 按某一列排序
	df.sort_values(by='column_name')

	# 按多列排序
	df.sort_values(by=['column_name_1', 'column_name_2'])

特别地，如果数据含有空值，可以用 na_position 参数处理空值，例如：

df.sort_values(na_position='first')

# 特征处理

	按照数据的值进行离散化
	pd.cut()

	# 按照数据的数量进行离散化
	pd.qcut()

	# 替换数据值
	df.replace()

	# 替换数据值
	df.map()

	# one-hot 编码
	pd.get_dummies()

具体用法请参考 pandas Document

# 数据拼接

	# 既可以横向拼接，又可以纵向拼接
	pd.concat()

	# 横向拼接
	pd.merge()

	# 横向拼接 DataFrame 对象
	df.join()

	# 纵向拼接 DataFrame 对象
	df.append()

Merge, join, concatenate and compare

# 数据分组

分割：按条件把数据分割成多组
应用：为每组单独应用函数
组合：将处理结果组合成一个数据结构

具体请参考：Groupby API

# 参考资料

conda 常用命令

2023-01-19T03:47:56.000Z

# conda 基本操作

# 查看 conda 版本

conda --version

# 更新 conda

conda update conda

# 查看 conda 环境配置

conda config --show

# 设置镜像源

# 设置清华镜像
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/

# 设置 bioconda
conda config --add channels bioconda
conda config --add channels conda-forge

# 设置搜索时显示通道地址
conda config --set show_channel_urls yes

# 查询指定命令的功能

conda command_name --help

# 管理环境

# 显示所有虚拟环境

conda env list

# 创建虚拟环境

conda create -n env_name package_name

如果需要指定 package 版本，可直接在 package_name 之后加上 = 号以及 package 版本号，例如：

conda create -n env_name python=3.x

如果需要安装多个 package ，在 env_name 之后用空格分隔多个 package_name 即可，例如：

conda create -n python310 python=3.10 numpy pandas

# 激活环境

activate env_name

# 退出环境

deactivate env_name

# 删除虚拟环境

conda env remove -n env_name

# 导出虚拟环境

conda env export --name env_name > environment.yml

# 导入虚拟环境

conda env create -n env_name -f environment.yml

# 管理 package

# 查看当前环境包含的所有 package

conda list

# 更新当前环境包含的所有 package

conda upgrade --all

# 更新指定 package

conda update package_name

# 安装指定 package

conda install package_name

安装装多个 package ：

conda installl package_name_1 package_name_2 package_name_3

安装固定版本的 package ：

conda install package_name=package_version_number

# 移除指定 package

conda remove package_name

参考资料：

Python 异常、模块、包

2023-01-15T10:19:13.000Z

# 异常

异常是指程序运行的过程中出现了错误

bug 就是指异常，历史上因为小虫子导致计算机失灵，所以延续至今，bug 就代表软件出现错误

# 异常的捕获

异常处理（捕获异常）：针对可能出现的异常，提前做好准备，当真的出现异常时，可以有后续处置，以免其导致程序无法正常运行

# 捕获常规异常

语法：

	try:
	尝试执行的代码
	except:
	若出现异常，将会执行本段代码

例如：

	# 尝试以 'r' 模式打开文件，如果文件不存在，则以 'w' 方式打开
	try:
	f = open('linux.txt', 'r')
	except:
	f = open('linux.txt', 'w')

# 捕获指定异常

	try:
	尝试执行的代码
	except ErrorType as e:
	若出现类型为 ErrorType 的异常，将会执行本段代码

其中，ErrorType 是指要捕获的异常类型

注意：如果 “尝试执行的代码” 的异常类型和要捕获的异常类型不一致，则无法捕获异常

常见的异常类型如下表所示：

类名	描述
`SyntaxError`	发生语法错误时引发
`FileNotFoundError`	未找到指定文件或目录时引发
`NameError`	找不到指定名称的变量时引发
`ZeroDivisionError`	除数为 0 时的异常
`IndexError`	当使用超出列表范围的索引时引发
`KeyError`	当使用映射不存在的键时引发
`AttributeError`	当尝试访问未知对象属性时引发
`TypeError`	当试图在使用 a 类型的场合使用 b 类型时引发

例如：

	try:
	print(name)
	except NameError as e:
	print('未定义 name 变量')

# 捕获多个异常

当需要捕获多个异常时，可以把要捕获的异常类型的名字，放到 except 后，并使用元组的方式进行书写

例如：

捕获多个异常（但不输出异常的具体描述）：

	try:
	print(1 / 0)
	except (NameError, ZeroDivisionError):
	print('错误...')

捕获多个异常并输出异常的具体信息：

	try:
	print(num)
	except (NameError, ZeroDivisionError) as e:
	print(e)

# 捕获所有异常

	try:
	尝试执行的代码
	except Exception as e:
	若出现异常，将会执行本段代码

注意： except: 与 except Exception as e: 这两种方式都可以捕获全部的异常

# 异常 else

else 表示没有异常时要执行的代码

	try:
	尝试执行的代码
	except Exception as e:
	若出现异常，将会执行本段代码
	else:
	若没有出现异常，将会执行本段代码

# 异常 finally

finally 表示无论是否异常都要执行的代码，例如关闭文件

	try:
	尝试执行的代码
	except Exception as e:
	若出现异常，将会执行本段代码
	else:
	若没有出现异常，将会执行本段代码
	finally:
	无论是否出现异常，都会执行本段代码

# 异常的传递

异常具有传递性：

当函数 / 方法执行出现异常，会将异常传递给函数 / 方法的调用一方
如果传递到主程序，仍然没有异常处理，程序才会被终止

利用异常具有传递性的特点，当我们想要保证程序不会因为异常崩溃的时候，就可以在 main 函数中设置异常捕获，由于无论在整个程序哪里发生异常，最终都会传递到 main 函数中，这样就可以确保所有的异常都会被捕获

# 模块

Python 模块（Module），是一个 Python 文件，以 .py 为后缀名

模块能定义函数、类和变量，模块里也能包含可执行的代码

可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用，以实现各种不同的功能

# 导入模块

在使用模块之前，需要先将模块导入 Python 程序

常用的导入模块方式：

	import module_name
	from module_name import class_name, var_name, func_name
	from module_name import *
	import module_name as nick_name
	from module_name import func_name as nick_name

其中：

module_name 表示模块
class_name 表示模块内的类
var_name 表示模块内的变量
func_name 表示模块内的函数
nick_name 表示为模块自定义的别名

注意：导入模块时，module_name 不需要包含 .py 后缀

# import module_name

使用 import 导入模块后，可以通过 '.' 来使用模块中的函数或类

	import module_name

	module_name.func_name()
	module_name.class_name
	module_name.var_name

# from module_name import func_name

使用 from … import … 方式导入之后，无需添加前缀，直接调用即可

	from module_name import func_name

	func_name()

注意，利用 from 把内容从模块中导入后，会导致相同名称的内容被覆盖，也就是说，不同模块的命名空间会在此处重叠

# from module_name import *

导入模块全部内容

	from module_name import *

	func_name()
	class_name
	var_name

# as nick_name

	# 模块定义别名
	import module_name as nick_name

	# 功能定义别名
	from module_name import func_name as func_nick_name

# 自定义模块

每个 Python 文件都可以作为一个模块，模块的名字就是文件的名字

因此，自定义模块只需在 Python 代码文件中正常写代码即可，通过 import、from 关键字导入（与导入 Python 内置模块一样）即可使用。但是需要注意，自定义模块名必须要符合标识符命名规则

# main 变量

if __main__ == “__main__” 语句的作用：只有当含有该语句的 Python 程序是被直接 run 时，才会进入 if 内部。如果是被导入的，则无法进入 if

该功能常用于测试模块（即，希望某些代码在测试时运行、而在被导入时不运行）

例如：

	def test(a, b):
	print(a + b)

	# 只在当前文件中调用该函数，其他导入的文件内均不执行 test 函数调用
	if __name__ == '__main__':
	test (1, 1)

如果不加 if __name__ == "__main__" 语句：无论是当前文件，还是其他已经导入了该模块的文件，在运行的时候都会自动执行 test 函数的调用

# all 变量

如果一个模块文件中有 __all__ 变量（该变量为列表对象），在使用 from xxx import * 导入该模块时，只能导入 __all__ 列表中的元素

因此， __all__ 变量可以控制 import * 导入模块时的导入内容

注意： __all__ 变量仅影响 from ... import * 这一导入方式

例如，自定义如下模块：

	__all__ = ['Test_A']

	def Test_A():
	xxx

	def Test_B():
	xxx

通过 from ... import * 导入该模块后，只能使用 Test_A 函数，而不能使用 Test_B 函数

# 包

如果 Python 模块太多，可以通过 Python 包（Package）来管理

当我们的模块文件非常多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块

从物理上看：包就是一个文件夹，在该文件夹下包含了一个 __init__.py 文件，该文件夹可包含多个模块文件
从逻辑上看：包的本质依然是模块

# 自定义包

基本步骤：

新建 Python Package
新建 Python 模块

在 Pycharm 中，点击 new --> Python Package 新建包后，包内部会自动创建 __init__.py 文件，这个文件控制着包的导入行为

# 导入包

# import xxx

# 导入所有模块

	import package_name

	package_name.module_name.func_name()

# 导入指定模块

	import package_name.module_name

	package_name.module_name.func_name()

其中：

package_name 表示 Python Package 名称
module_name 表示 Python Package 中的模块名称
func_name 表示模块中的函数名称

# from xxx import

# 导入所有模块

	from package_name import *

	module_name.func_name()

注意：必须在 __init__.py 文件中添加 __all__ 变量，用于控制 from package_name import * 导入的模块列表（类似于模块文件中的 __all__ 变量）

# 导入指定模块

	from package_name import module_name

	module_name.func_name()

# 导入指定模块中的指定函数

	from package_name.module_name import func_name

	func_name()

# 第三方包

在 Python 程序的生态中，有许多非常多的第三方包（非 Python 官方），可以极大的帮助我们提高开发效率，如：

科学计算：numpy
数据分析：pandas
大数据计算：pyspark、apache-flink
图形可视化：matplotlib、pyecharts
人工智能：tensorflow

注意，Python 没有内置这些第三方包，需要安装它们才可以导入使用

可通过 Python 内置的 pip 安装指定的第三方包

即，在命令行中输入：

pip install package_name

pip 是连接外网进行下载，若下载速度相对较慢，可考虑通过国内的镜像源下载

例如：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package_name

Python 文件操作

2023-01-14T09:51:32.000Z

# 文件编码

编码：一种规则集合，记录了内容和二进制间进行相互转换的逻辑

计算机中有许多可用编码，例如：

UTF-8
GBK
Big5

UTF-8 是目前全球通用的编码格式

除非有特殊需求，否则，一律以 UTF-8 格式进行文件编码即可

# 文件的读取

# 访问模式

常用的三种基础访问模式：

'r' ：以只读方式打开文件（默认模式）。文件的指针将会放在文件的开头
'w' ：打开文件只用于写入。如果该文件已存在，则打开文件，并从开头开始编辑（原有内容会被删除）；如果该文件不存在，创建新文件
'a' ：打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后；如果该文件不存在，创建新文件进行写入

# 打开文件

使用 open 函数可以打开一个已经存在的文件，或者创建一个新文件（使用 'w' 模式时）

open(name, mode, encoding)

其中：

name：字符串，表示目标文件的文件名（可以包含文件所在的路径）
mode：设置打开文件的模式（访问模式）：只读、写入、追加等
encoding：编码格式（推荐使用 UTF-8）

操作文件需要通过 open 函数打开文件得到文件对象

例如：

	# encoding 不是第三个位置参数，需要采用关键字传参
	file_obj = open('python.txt', 'r', encoding='UTF-8')

注意：此时的 file_obj 是 open 函数的文件对象（Python 中一种特殊的数据类型），拥有属性和方法，可以使用 对象.属性 或 对象.方法 对其进行访问

# 关闭文件

close 关闭文件对象，即，关闭对文件的占用

file_obj.close()

如果不调用 close ，并且程序没有停止运行，那么这个文件将一直被 Python 程序占用（除 with open 语法外）

# 读操作

# read 方法

read 可以读取给定长度的数据

file_obj.read(num)

其中，num 表示要从文件中读取的数据的长度（字节数）。如果没有传入 num，表示读取文件中所有的数据

# readlines 方法

readlines 可以一次性读取整个文件中的内容。 readlines 返回的是一个列表，其中，文件每一行的数据对应列表的一个元素

file_obj.readlines()

# readline 方法

readline 一次读取一行数据

file_obj.readline()

# for 循环读取文件行

可以使用 for 循环遍历读取文件的每一行内容

	# 临时变量 line 记录文件的一行数据
	for line in open(name, mode, encoding):
	print(line)

# with open 语法

通过在 with open 的语句块中对文件进行操作，可以在操作完成后自动关闭文件，避免因忘记 close 文件对象而导致文件被占用

	with open(name, mode, encoding) as file_obj:
	file_obj.readlines()

# 文件的写入

# 打开文件

file_obj = open(name, mode='w', encoding='UTF-8')

使用 'w' 模式时：

如果文件不存在，会创建新文件
如果文件存在，会将原有内容清空

# 写操作

file_obj.write(content)

content 表示需要写入的内容

注意：调用 write 时，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区

当调用 flush 时，内容会真正写入文件

file_obj.flush()

write 写入内容 + flush 刷新内容到硬盘，这样做是避免因频繁操作硬盘而导致效率下降

# 关闭文件

file_obj.close()

注意： close 方法内置了 flush 的功能

# 文件的追加写入

# 打开文件

file_obj = open(name, 'a', encoding='UTF-8')

使用 'a' 模式时：

如果文件不存在，会创建文件
如果文件存在，会在文件最后追加写入

# 追加写入操作

	# 写入内容 content
	file_obj.write(content)

	# 刷新内容
	file_obj.flush()

# 关闭文件

file_obj.close()

参考：黑马程序员

23 求职笔面试

2022-12-07T13:13:47.000Z

# TP-Link（嵌入式软件）

# 笔试

选择题：

物理层设备
可能会出现进程饿死的进程调度算法
调用 Fork 后，产生的子进程保留了父进程的什么
Huffman 编码
采用 LRU 算法时，进程访问过程中的缺页次数、缺页率
二叉树中序遍历所需栈高度与什么有关
利用栈来执行带括号的算术表达式，对于某个表达式所需的最小栈大小
排序算法的时间复杂度
给出两段程序（递归版本、非递归版本），比较
回文字符串的判断（选出一项，补全代码）

简答题：

内存越界是什么，内存越界是否会导致程序崩溃，为什么，举例说明内存越界会造成那些后果
Java 中的 CAS 机制原理（选做）
双向链表中的节点替换（补全代码）
7 位电话号码，给定超过一百万个的电话号码，对电话号码去重，排序，存储号码的内存 buffer 限制为 1MB

编程题：

环形链表 II （力扣 142）：核心代码模式
乘积最大子数组（力扣 152）：ACM 模式

选择题、简答题、编程题一共 60 分钟

行测：（每部分 10 分钟）

言语理解与表达
判断推理
图形推理
数量关系

# 一面

宏

快速排序、选择排序的基本原理

全局变量、局部变量、静态变量

解决哈希冲突的方法

介绍拉链法的原理

OSI 参考模型：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层

第一轮面试一共 10 分钟

# 二面

智力题：7g 砝码和 2g 砝码各一个，天平一个，如何用最少次数将 140g 盐分成 50g 和 90g 各一份？

正确答案：最少需要操作三次
- 利用天平将 140g 盐分成两份 70g
- 利用 9g 砝码将 70g 盐分成 9g 和 61g
- 利用 2g 砝码与 9g 盐将 61g 盐分成 11g 和 50g

算法题：二叉树的最近公共祖先（力扣 236）

先讲思路，再在自己的 IDE 上编程实现（核心代码模式）

最后问了项目，大概 10 分钟左右

第二轮面试一共 40 分钟

# 三面

自我介绍

本科成绩是什么情况？是保研的吗？

为嵌入式软件岗做了哪些相关准备？

计算机网络、操作系统、数据结构与算法学过吗？

数据结构与算法刷了多少题？

TCP 与 UDP 有什么区别？

如何理解 TCP 的可靠传输？

TCP/IP 网络模型是怎样的？每一层对应有哪些协议？

如何用两个队列实现一个栈？

研究生课题的主要内容？目的是什么？是不是自己一个人完成的？成果？

有哪些兴趣爱好？是否拿出摄影作品去参加过学校的展览？骑行都去过哪些地方？

父母的工作

兄弟姐妹的情况

反问：

部门 / 分组是怎么确定的？入职以后确定
主要用的编程语言是什么？用的最多的是 C/C++ ，会经常使用数据结构与算法、操作系统的相关内容

最后，面试官建议认真学一下操作系统

第三轮面试一共 18 分钟

# SHEIN（算法工程师 - 运筹预测方向）

# 测评

一共包含四个模块，全都是选择题

言语表达，10 题，限时 10 分钟左右
图表分析，10 题，限时 10 分钟左右
图形推理，10 题，限时 10 分钟左右
性格测评，158 题，不限时

# 笔试

题型：15 道单选题，2 道算法题，2 道问答题

限时 60 分钟

单选题涉及的知识：

机器学习
python
排序算法

算法题：

最长回文子序列（力扣 516）：ACM 模式
二叉树的层序遍历（力扣 102）：核心代码模式

问答题：

AUC 的计算
SQL 语句

# 蔚来（智能调度和控制算法工程师）

# 提前批

# 笔试（大数据的试卷）

10 道单选题：设计模式、概率论相关知识点

9 道不定项选择题：操作系统、数据库相关知识点

3 道算法题（核心代码模式）：

合并二叉树（力扣 617）
爬楼梯（力扣 70 ）进阶版：每次可以爬 1 或 2 或 3 个台阶
滑动窗口最大值（力扣 239）

# 正式批

# 测评（北森系统）

10 道言语理解，每小题有相应限时

10 道图表分析，每小题有相应限时

10 道图形推理，每小题有相应限时

99 道性格测试，每小题有相应限时

# 三一（算法工程师）

# 测评（北森）

行测，每题都有对应的限时：

言语理解与表达，一共 11 题
图表分析，一共 10 题
图形推理，一共 10 题

性格测评，不限时：

98 道选择题：每题需从三个选项中选出最符合、最不符合
100 道单选题

# 笔试

一共 30 道选择题（20 道单选，10 道多选），限时 60 分钟：

数据结构与算法：图论（最短路径、最小生成树、有向图、邻接矩阵）、栈、动态规划的基本要素、贪心思想、回溯法
机器学习相关：线性回归、生成模型、基于二次准则函数的 H-K 算法、感知器算法、统计模式识别分类问题、map-reduce 框架及相关算法、K - 均值算法、判别式模型、决策树的启发函数
操作系统：内存管理、线程
运筹优化相关：分支定界、TSP 问题的时间复杂度、路径规划算法、应用 Johnson 法则的流水作业调度所采用的算法、无约束优化问题的相关算法、PnP 问题的求解方法
排列数与组合数
编程语言：C++ 语句、类的静态成员、python 中的复数

# 一面

自我介绍

学习成绩

英语六级成绩

用的什么编程语言

简述利用 matlab 实现的一个算法

对汽车有没有什么了解

建议：

后续要加强对汽车相关知识的学习
要进一步熟悉一下 matlab，尤其是 simulink

面试一共 6 分钟（邮件里写的 20 分钟）

# 中兴（算法工程师）

# 测评（北森系统）

行测：

言语理解与表达，一共 10 题，限时 10 分钟
图形推理，一共 10 题，限时 10 分钟
图表分析，一共 10 题，限时 10 分钟

性格测评，不限时：

98 道选择题：每题需从三个选项中选出最符合、最不符合
100 道单选题

# 面试

安排了软件工程师的面试

拒掉了面试

# 用友（运筹优化算法工程师）

# 测评

行测：数量关系、演绎论证、图形推理、图表分析，一共 28 道选择题，限时 30 分钟

性格测评：一共 88 题（每题需从三个选项中选出最符合、最不符合），限时 30 分钟

# 大疆（决策与规划算法工程师）

# 测评

一共 80 道题，限时 80 分钟

行测：数量关系，演绎论证，15 题左右
性格测试

# 笔试

一共 25 道不定项选择题，限时 60 分钟

内容涉及以下方面：

ROS
git
多项式曲线、B spline、羊角螺线
Dijkstra、A*、RRT、RRT* 路径规划算法（特性比较）
line search、无约束的路径规划、采用邻接矩阵或邻接表的 Dijkstra 算法的复杂度
判断凸函数、判断凸约束
多项式曲线刻画曲率能否为凸约束、庞特里亚金最大化原理、半正定优化是否为凸优化问题
C++ 模板编程、返回值
算法的时间复杂度
链表操作的时间复杂度
unordered_map 的底层实现以及相关特性
SO ()、SE ()、四元数与自由度
计算排列数、计算事件发生的概率、计算数学期望
平面空间索引、K-D tree、R-tree、三维空间索引

# 杉数科技（算法工程师 - 运筹优化方向）

# 一面

自我介绍

讲解项目（大概聊了 20 分钟）

KKT 条件

KKT 条件是最优解的充分条件还是必要条件
在什么情况下 KKT 能作为充分条件
KKT 的具体内容

从 branch-and-bound 、Benders 分解、Largrange 松弛、列生成四个算法中选择一个算法，讲解其原理以及应用场景

使用的编程语言，有没有使用 C++ 实现算法

给两道场景题，要求建立数学模型（口述）：都是排产、排程相关的场景

第一道的大概内容：假设你是某饭店的老板，饭店里有一台冰箱可以存放盒饭（每一份盒饭可以保存两个小时），如果盒饭库存不够就需要现场准备。现场准备所需的成本与提前准备的成本不相等，并且，顾客的数量是随机的（有以往的顾客数量信息）。问：如果规划冰箱存放的盒饭数量以及现场所需准备的盒饭数量，以使得总成本最小？
第二道的大概内容：假设你是某电子工厂的老板，现要在一年内生产 A、B 两类产品各 5 千万个，若当天生产的是 A 产品，则可生产 a 个，若当天生产的是 B 产品，则可生产 b 个。假设：若当天生产 A 类产品且第二天生产 B 类产品，或者，当天生产 B 类产品且第二天生产 A 类产品，两种情况都会产生额外的成本。即，生产产品的类别的变化，会带来额外成本。问：如何确定每一天生产的产品类别，使得生产产品类别的变化次数最少？

面试官介绍业务（主要是与工厂的排班排程相关的实际问题），并且主要使用 python

反问：

会参与 COPT 求解器的研发吗？
面试有多少轮（三轮）

面试一共 50 分钟左右（邮件里写的是 60 分钟）

面试官很友好，并且会及时提供引导。面试体验挺不错，虽然很多都不会 hh

# 笔试

一共两道题，24 小时内做完

现有一家移动运营商（例如中国移动、中国电信）需要为一座城市建造基站，已知该城市终端用户的所在位置和所需的移动流量，可选的基站建造位置，以及不同类型基站的覆盖范围和最大流量。请帮助基站规划员决策需要布置的基站数量，所选的基站位置以及每小时的基站运行状态（无流量需求时基站可关闭，假设基站可随意开关且没有额外成本），使得该家公司的支出总成本最小，包括基站建造成本以及基站运营成本。
- 假设每个时间段内的终端需求都需要被满足，建立数学规划模型，设计最优的基站建设及运营方案。可根据需要添加合理的前提假设。
- 假设每个时间段内的终端需求不需要都被满足，但是未被满足的流量需求会产生额外成本，请修改模型并简述和模型 1 的差异。
- 如果没有可选的基站位置，城市里的任何位置都可建造基站，请简述如何修改你的方案和模型。
- 如果可选的基站点过多，请简述如何修改模型，使得在可接受的时间范围内求解模型。
- 如果每个终端用户的流量需求不确定，请简述如何求解这个问题。
某学生必须在 4 个不同系中选修 10 门课程，每个系至少选 1 门。这个学生将每个系选修课程数目与获得知识量按照 100 分衡量如表格所示。要争取获得的知识量达到最大。
- 针对以上场景：
  - 请使用动态规划求解该问题。（编程）
  - 请使用混合整数规划求解该问题。（调用任意求解器编程）
- 若 C 的选修课数量不得多于 D：
  - 请使用动态规划求解该问题。（编程）
  - 请使用混合整数规划求解该问题。（调用任意求解器编程）

备注：优先使用 python

# 二面

两个面试官，副总裁和业务总监

首先进行自我介绍，讲一讲对杉数的认识，自己的优势

自己对这一岗位的工作规划，可能遇到的问题以及解决方案

介绍项目

反问

# 顺丰科技（运筹优化算法工程师）

# 测评

言语理解、性格测评、情景题

# 笔试

120 分钟

选择题：单选、多选共 34 道题，一共 70 分：主要考察运筹优化算法、概率论相关

编程题：两道，ACM 模式，每题 15 分

幸运数：如果一个数在十进制表示下数字 5 出现了不少于 5 次，则这个数是一个幸运数。求：大于 N 的最小的幸运数
猜排列游戏：小明有一个由 1 到 n 的整数组成的排列，让你来猜出这个排列是什么。每次可以猜测某个位置的数字，小明会告知你的猜想是 “大了”、“小了” 或者 “正确”。求：在最坏情况下，需要猜测几次，才能在排列的所有位置都得到小明的 “正确” 的回复。

# 小米（运筹 / 强化学习算法工程师）

# 测评（北森系统）

行测：

言语理解与表达，一共 10 题，每题都有相应限时
图形推理，一共 10 题，每题都有相应限时
图表分析，一共 10 题，每题都有相应限时

性格测评，不限时：

98 道选择题：每题需从三个选项中选出最符合、最不符合
100 道单选题

性格测评的这两个板块直接复用了之前做过中兴的测评

# 笔试（算法方向）

16 道单选题，每题 2 分，主要涉及以下方面的知识点：

机器学习
图像处理
数字信号处理（滤波器、快速傅里叶变换）
快速排序、链表操作
概率论与数理统计

17 道多选题，每题 2 分，涉及以下内容：

栈操作
动态规划代码
向量范数
快速傅里叶变换
机器学习（监督学习、生成式模型）
矩阵的秩
图像处理过程中的噪声
凸函数

2 道编程题，每题 17 分，均为 ACM 模式：

给定一个数组，每一次可以从数组的最左侧或者最右侧移除一个数，同时，令数字 x 减去移除的这一元素。问：至少需要多少次移除操作，才能使 x 变为 0 。如果无法使得 x 变为 0，则输出 -1
- 输入：一共三行，其中，第一行是一个用 [] 包围一个数字序列（数字与数字之间用逗号分隔），第二行是数字序列的长度，第三行是数字 x
- 输出：一个整数，表示需要的移除次数（无法将 x 变为 0 时输出 -1 ）

给定两个序列，计算两个序列的卷积和互相关
- 输入：一共两行，分别为两个序列，其中，每一行的第一个数表示序列长度，紧接着一个逗号，然后是用空格分隔的序列
- 输出：一共两行，分别为卷积和互相关的结果，其中，每一行的第一个数表示结果序列长度，紧接着一个逗号，然后是用空格分隔的结果序列

# 美团（运筹优化研发工程师）

# 笔试

四道编程题，每题 20 分：

第一题：字符串匹配
第二题：数组、哈希表
第三题：字符串分割
第四题：背包问题

三道多项选择题：

第一题，6 分：下列哪些属于分类任务常用损失函数：Softmax 损失、L2 损失、L1 损失、交叉熵损失
第二题，6 分：目前对于最近邻分类的研究在于：探索更加合理的 K 值、寻求更接近于实际的距离函数、建立高效的索引、运用更加精确的概率估测方法以取代简单的投票机制
第三题，8 分：当想创建新表的时候，hive 输入命令 create table if not exist，以下哪些情况会发生：表名存在时报错、表名不存在时不报错、表名不存在时报错、表名存在时不报错

一共限时 120 分钟

# 一面

面试官首先自我介绍，并介绍事业部的主要工作，介绍面试流程

自我介绍

有没有实习

聊项目

对遗传算法、禁忌搜索等算法有没有了解？

介绍一下遗传算法

如果用遗传算法来求解 TSP 问题要怎么求解？

对禁忌搜索这些算法有没有什么了解？

对机器学习是否有了解？

有没有做相应的机器学习算法实践？

主要用的是什么编程语言？做题用什么语言？

手撕代码，核心代码模式（在牛客上进行的面试，面试官可以直接在系统上出题）

反问：

部门的主要业务
工作内容

面试一共 45 分钟，其中，25 分钟项目、10 分钟代码、5 分钟反问

# 字节跳动（算法工程师 - 运筹优化）

# 笔试

120 分钟

四道编程题，ACM 模式，分值分别为 20，25，25，30

弹珠游戏（动态规划）
三数和赛高数组

# 华为（AI 工程师 - 决策推理方向）

# 一次笔试

一共三题，分值分别为 100、200、300，限时 120 分钟

猪场防疫（第一题）：猪场现有 N 只猪，编号从 0 到 N - 1 （每只猪无论生死都有唯一的编号）。老李在每只猪生产的时候记录了生产的母猪和出生的小猪，格式为 x y1 y2 y3 ... ，其中，x 为母猪，y1、y2、y3... 为新生的小猪，以上编码均在 0 ~ N - 1 范围内，每只猪可以多次生产，每只小猪都只有一个猪妈妈。现需要检查任意两只猪是否有亲戚关系（两只猪具有相同的祖先），并计算出关系亲疏情况（关系距离，若相同编号则距离为 0）

输入：
- 第一行输入总数 N
- 第二行输入后续生产记录行数 M
- 后续 M 行输入生产记录，以空格分隔
- 最后一行输入待检查的两只猪的编号 m1 和 m2
输出：
- 一个整数，表示 m1 和 m2 之间的关系距离，无亲戚关系输出 -1

速战速决（第二题）：在一个 M 行 N 列的街区中，有一个士兵 S 和一个敌人 E ，标识 X 为无法通过的街区，标识 B 为可以通过的街区；士兵在一个单位时间内可以从一个街区移动到相邻的街区（每次只能水平或垂直方向移动一个街区）；士兵每次改变方向时，需要额外花费一个单位的时间（士兵第一次移动一个街区的时候，不用考虑其初始方向，即，只需要一个单位时间即可到达相邻街区）。计算士兵最少需要多少时间才能到达敌人所在的街区

输入：
- 第一行两个数字，分别为街区的大小，M 和 N （1 <= M, N <= 1000，M 、N 不同时为 1）
- 接下来 M 行，每行 N 个字母，字母 S 表示士兵所在街区，字母 E 表示敌人所在街区，字母 X 表示障碍，字母 B 表示可以经过的街区（只有一个 S，一个 E）
输出：
- 最少需要的时间，当士兵永远无法到达敌人所在街区时输出 -1

# 二次笔试（时隔一个月）

字符串压缩，例如，将 "aaBcaBcaBcc" 压缩成 "a3 (aBc) c"、将 "aAABBAABB" 压缩成 "a2 (2 (A) 2 (B))"
三叉树中的最大路径和
多进制计算器

# 京东

# 笔试

选择题，主要考察算法与数据结构、机器学习相关知识

三道编程题：

定义一个字符串为 “好串” ：当且仅当相邻两个字母不相同。对于一个仅由 'r' 、'e'、'd' 三种字符组成的字符串，可以将相邻两个相同的字母同时删除，并在其位置生成任意一个字母（'r'、'e'、'd' 三种中的一种）。例如，对于字符串 "dedd"，可以选择将 "dd" 变成 "r"，字符串即变为 "der" 。现给定一个字符串，问：至少需要多少次操作才能将该字符串变成 “ 好串 ”
- 输入描述：一个长度不超过 200000 的、仅由 'r' 、'e'、'd' 三种字符组成的字符串
- 输出描述：一个整数，代表操作的最小次数
对于一个长度为 n 的数组，现希望将一些数（不少于 2 个数）染红，满足任意两个染红的数之和都是偶数。问：一共有多少种不同的染色方案？答案对 10⁹ + 7 取模。规定：对于两个方案，只要存在某个数的染色情况不同，则认为是两种不同的方案
- 输入描述：第一行输入一个正整数 n，代表数组长度；第二行输入 n 个正整数 a_i ，代表数组的元素
- 数据范围：2 <= n <= 10⁵，1 <= a_i <= 10⁹
- 输出描述：一共整数，代表不同的方案数

# 百度

# 笔试

15 道单选题，一共 45 分，涉及知识点：

SQL
快速排序
二分查找
栈
堆串
ssh 公钥命令
内存分配与释放（最佳适配算法）
linux 系统
同步关系和互斥关系

5 道不定项选择题，一共 15 分，涉及知识点：

linux
C++

3 道编程题，分值分别为 10 分、15 分、15 分，均为 ACM 模式

给定字符串 s ，问：字符串 s 中含有多少个形如 baidu 的子串（即，子串长度为 5，第一、四个字母是辅音字母，第二、三、五个字母是元音字母，并且，子串没有重复字母）
已知字符串 str 仅包含 '0' 和 '1' ，每一次可反转字符串 s 中的两个连续字符（例如，"01" 反转成 "10" ），问：是否可以在有限次数内将 str 变成所有字符均相同的字符串（即，所有字符均为 '1' ，或者，所有字符均为 '0' ）
- 例如，"101" 可以通过 2 次操作变成 "000" ，输出 "Yes" ；"11111" 无需操作即满足条件，输出 "Yes" ；"1011" 无法变成所有字符均相同的字符串，输出 "No"
- 注：输入含有多组样例，需针对每组样例进行判断并输出
给定一个 m 行 n 列的方格，其中，每个小方格有 'r' 、'e' 、'd' 三种字符中的某一个字符。现从左上角出发，每次可以往四个方向（向上、向下、向左、向右）中的某个方向移动一步，但是，不能从字符 'r' 移到字符 'e' 、不能从字符 'e' 移到字符 'd' 、不能从字符 'd' 移到字符 'r' 。问：至少需要移动多少步才能到达右下角。如果无法到达右下角，则输出 -1
- 采用深度优先搜索（回溯）会超时，只能通过 23.08% 的样例
- 需要采用广度优先搜索（没来得及写）

笔试一共限时 120 分钟

# 招银网络科技

# 测评（北森系统）

行测：

言语理解与表达，一共 11 题，每题有相应限时
图形推理，一共 11 题，每题有相应限时
图表分析，一共 11 题，每题有相应限时

性格测评，不限时：

98 道选择题：每题需从三个选项中选出最符合、最不符合
100 道单选题：需从非常不符合、比较不符合、比较符合、非常符合四个选项中选择一个

# 美的（嵌入式软件）

# 笔试

10 道单选，每题 2 分，主要考察操作系统、计算机网络的相关知识

5 道不定项选择题，每题 4 分（少选错选不得分），主要考察操作系统、计算机网络的相关知识

3 道编程题，ACM 模式：

给定一个字符串，删除其中连续的多余空格：15 分
输入一个十六进制数，将其表述成 32 位二进制数然后反转，再将反转得到的二进制数转换成十六进制输出：20 分
给一个数组和一个目标数，判断存在一个组合使得元素和为目标数：25 分

# 中信银行信用卡中心

# 测评（TAS 测评系统）

Talent5 大五职业性格测评：共 138 题，不限时

iLogic 言语推理测评：共 15 题，限时 20 分钟（每题有相应限时）

iLogic 数字推理测评：共 15 题，限时 20 分钟（每题有相应限时）

iLogic 逻辑推理测评：共 10 题，限时 17 分钟（每题有相应限时）

iDriver 职业驱动力测评：共 112 题，不限时

Menlth 心理状态扫描：共 50 题，不限时

# 笔试

30 道单项选择题，每题 2 分，考察 Linux 系统、Java、计算机网络、MySQL、数据结构相关知识

3 道编程题，ACM 模式，一共 40 分

字符串中出现次数不少于 2 次的字母
给定字符串，将元音字母都变成小写，辅音字母都变成大写
给定 n 行 n 列的矩阵，将矩阵水平方向和垂直方向各翻转一次

Python 数据容器

2022-12-01T11:21:27.000Z

数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为 1 个元素，其中，每一个元素可以是任意类型的数据，如字符串、数字、布尔等

Python 数据容器可以分为 5 类：

列表（list）
元组（tuple）
字符串（str）
集合（set）
字典（dict）

	列表	元组	字符串	集合	字典
元素类型	任意	任意	字符	任意	key-value (key: 除字典外任意类型，value: 任意类型)
下标索引	支持	支持	支持	不支持	不支持
数据有序	是	是	是	否	否
重复元素	支持	支持	支持	不支持	不支持
可修改性	是	否	是	是	是

在 Python 中，有序是指其中的数据可以通过索引（即下标）进行访问

# 列表

# 列表的定义

	# 字面量
	[元素1, 元素2, ...]

	# 定义变量
	变量名 = [元素1, 元素2, ...]

	#定义空列表
	变量名称 = []
	变量名称 = list()

列表可以同时存储不同的数据类型，并且，列表支持嵌套

例如：

	my_list = ["iteration", 1234, True]
	nested_list = [[1, 2, 3], [4, 5, 6]]

	print(my_list)
	print(type(my_list))

	print(nested_list)
	print(type(nested_list))

# 列表的方法

# 访问元素

可以通过列表的下标索引 idx 获取对应位置的数据

value = list_name[idx]

其中，列表的下标索引可以分为两种：

正向索引（从左往右）：从 0 开始，依次递增
反向索引（从右往左）：从 -1 开始，依次递减

要注意下标索引的取值范围，超出范围会报错

# 查找元素

查找元素 element 在列表 list_name 中的下标（元素在列表中的第一个匹配位置），如果找不到则报错 ValueError

list_name.index(element)

# 修改元素

修改下标为 idx 的元素的值

list_name[idx] = value

# 插入元素

在下标 idx 处插入元素 element

list_name.insert(idx, element)

# 追加元素

方式一

将元素 element 追加到列表 list_name 的尾部

list_name.append(element)

例如：

	name_list = ["it", "its", "itself"]
	name_list.append("itheima")

方式二

将其他数据容器的内容取出，依次追加到列表 list_name 的尾部

list_name.extend(Data)

例如：

	mylist = [1, 3, 5]
	temp_list = [2, 4, 6]

	mylist.extend(temp_list)

# 删除指定位置元素

删除下标 idx 处的元素

	del list_name[idx]

	list_name.pop(idx) # 该方式可以获取返回值（被删除的元素）

# 删除指定元素

删除指定元素值在列表中的第一个匹配项

list_name.remove(element)   # 删除元素 element 在列表中的第一个匹配项

# 清空列表

清空列表内容

list_name.clear()

# 统计指定元素数量

统计元素 element 在列表 list_name 中的数量

list_name.count(element)

# 其他

# 统计列表元素数量

统计整个列表中的元素总数量

len(list_name)

# 列表的 while 遍历

	idx = 0
	while idx < len(list_name):
	statement
	idx += 1

# 列表的 for 遍历

	for i in range(0, len(list_name)):
	statement

# 元组

元组（tuple）：元组同列表一样，都是一种可以封装多个、不同类型的元素的容器；不同点在于，元素一旦定义完成，就不可以修改

# 元组的定义

定义元组：使用小括号包围数据，其中，每个数据之间用逗号隔开（数据可以是不同的数据类型）

	# 定义元组字面量
	(元素1, 元素2, ...)

	# 定义元组变量
	变量名称 = (元素1, 元素2, ...)

	# 定义空元组
	变量名称 = ()
	变量名称 = tuple()

注意：如果元组只有一个数据，需要在这个数据后面添加逗号，否则不是元组类型

例如：

t4 = ("World", )

元组也支持嵌套

注意：

不可以修改元组的内容，否则会直接报错
如果元组内嵌套了 list 列表，则可以修改 list 列表的内容（修改、增加、删除元素，反转等）

例如：

	mytuple = (1, 2, ["it", "20221124"])
	mytuple[2][0] = "python"

# 元组的方法

# 访问元素

元组支持下标索引

element = tuple_name[idx]

# 查找元素

查找指定元素的第一个匹配项

tuple_name.index(element)

# 统计指定元素数量

tuple_name.count(element)

# 其他

# 统计元素数量

len(tuple_name)

# 元组的 while 遍历

	idx = 0
	while idx < len(tuple_name):
	statement
	idx += 1

# 元组的 for 遍历

	for element in tuple_name:
	statement

# 字符串

字符串（str）：字符串是字符的容器，一个字符串可以存放任意数量的字符

字符串是一个无法修改的数据容器

# 字符串的定义

使用一对双引号包围一系列字符

str_name = "Here is the content of string"

# 字符串的方法

# 访问元素

字符串支持下标索引

从前往后索引：下标从 0 开始
从后往前索引：下标从 -1 开始

# 查找子串

查找子串 target_str 在字符串 str_name 中的下标索引值

str_name.index(target_str)

# 替换子串

将字符串 str_name 内的 str1 全部替换为 str2

str_name.replace(str1, str2)

注意，此方法并不是修改字符串本身（字符串是无法修改的），而是得到了一个新的字符串

# 分割子串

按照指定的分隔符字符串 separator，将字符串划分为多个子字符串并存入列表对象中

str_name.split(separator)

注意，此方法并不是修改字符串本身，而是得到了一个列表对象

例如：

	my_str = "hello python itheima and itcast"
	result = my_str.split(" ") # 按照空格进行分割，得到一个列表

# 去除前后空格

strip () 方法删除开头和结尾的空白字符

str_name.strip()

例如：

	my_str = " itheima and itcast "
	new_my_str = my_str.strip()

# 去除前后指定字符串

通过给 strip () 方法传入参数，可以删除字符串开头和结尾处的指定字符串

str_name.strip(target_str)

需要注意，删除操作是按照单个字符进行的

例如：

	my_str = "12itheima and itcast21"
	new_my_str = my_str.strip("12") # 传入的是 "12"，此时，"1" 和 "2" 都会移除，即，按照单个字符移除

# 统计指定字符串数量

统计字符串中某子串的出现次数

str_name.count(target_str)

例如：

	my_str = "itheima and itcast"
	cnt = my_str.count('it')

# 其他

# 统计字符串长度

len(str_name)

# 字符串的 while 遍历

	idx = 0
	while idx < len(str_name)
	statement
	idx += 1

# 字符串的 for 遍历

	for element in str_name:
	statement

# 序列

序列是指内容连续、有序，并且可使用下标索引的一类数据容器

序列是字符串、元组、列表的统称

序列支持切片，即：从序列的指定位置开始，依次取出元素，到指定位置结束，得到一个新序列（该操作不会影响原序列，而是生成了一个新的序列）

sequence[start:end:step]

其中：

起始下标 start 表示从何处开始，可以省略，省略时视为从头开始
结束下标 end 表示何处结束（不截取结束下标对应元素），可以省略，省略时视为截取至序列末尾（截取最后一个元素）
步长 step 表示依次取元素的间隔，步长可以为负数，表示反向取元素（注意，起始下标和结束下标也要反向标记）

# 集合

集合（set）：不支持元素重复（自带去重功能），并且内容无序

集合是无序的，不支持下标索引访问

集合是可以修改的

# 集合的定义

定义集合：使用大括号包围数据，其中，每个数据之间用逗号隔开

	# 定义集合字面量
	{元素1, 元素2, ...}

	# 定义集合变量
	变量名称 = {元素1, 元素2, ...}

	# 定义空集合
	变量名称 = set()

# 集合的方法

# 添加元素

将指定元素添加到集合内

set_name.add(element)

# 删除元素

将指定元素从集合内移除

set_name.remove(element)

# 随机取出元素

从集合中随机取出一个元素（集合本身被修改，元素被移除）

该操作可以具有返回值

element = set_name.pop()

# 清空集合

set_name.clear()

# 取两集合的差集

取出集合 1 与集合 2 的差集：元素在集合 1 中、但不在集合 2 中

该操作得到一个新集合，集合 1 和集合 2 保持不变

new_set = set1.difference(set2)

# 消除两集合的差集

消除集合 1 与集合 2 的差集：对比集合 1 和集合 2，在集合 1 内，删除与集合 2 相同的元素

该操作修改了集合 2，集合 2 保持不变

set1.difference_update(set2)

# 合并两集合

合并 2 个集合：将集合 1 与集合 2 组成新集合

该操作得到一个新集合，集合 1 与集合 2 保持不变

new_set = set1.union(set2)

# 其他

# 统计集合元素数量

len(set_name)

# 集合的遍历

集合不支持下标索引，不能使用 while 循环遍历

集合可以使用 for 循环遍历

	for element in set_name
	statement

# 字典

字典（dict）：存储键值对（即，key-value 对），可以提供基于 key 检索 value 的场景实现

字典不支持重复的 key ，重复添加等同于覆盖原有数据

# 字典的定义

使用大括号 {} 包围元素，其中，每一个元素都是一个键值对（key: value），元素之间用逗号隔开

	# 定义字典字面量
	{key: value, key: value, ...}

	# 定义字典变量
	变量名称 = {key: value, key: value, ...}

	# 定义空字典
	变量名称 = {}
	变量名称 = dict()

字典的 key 和 value 可以是任意数据类型（key 不可为字典）

因此可以将字典 2 作为字典 1 的 value ，实现字典的嵌套

例如：

	score_dict = {
	"小红": {"语文": 77, "数学": 66, "英语": 33},
	"小明": {"语文": 88, "数学": 86, "英语": 55},
	"小花": {"语文": 99, "数学": 96, "英语": 66}
	}

	print(f"score_dict 的内容为：{score_dict}，类型为：{type(score_dict)}")
	print(f"小红的语文成绩为：{score_dict['小红']['语文']}")
	print(f"小明的数学成绩为：{score_dict['小明']['数学']}")
	print(f"小花的英语成绩为：{score_dict['小花']['英语']}")
	print()

# 字典的方法

# 访问元素

字典同集合一样，不支持下标索引。但是，字典可以通过 key 来获取对应的 value

value = dict_name[key]

# 添加 / 更新元素

新增元素 / 更新元素：如果 key 不存在，则新增元素；如果 key 存在，则更新元素（更新 value 值）

dict_name[key] = value

# 删除元素

将 key 所在键值对从字典中删除

该操作具有返回值，可以获取 key 所对应的 value

value = dict_name.pop(key)

# 清空字典

dict_name.clear()

# 获取 key 列表

获取全部的 key

keys = dict_name.keys()

例如：

	my_dict = {"a": 0, "b": 1, "c": 2, "d": 3}
	keys = my_dict.keys()
	print(f"通过 keys 方法获取全部的 key ，结果为：{keys} ，其数据类型为：{type(keys)}")

# 其他

# 统计元素数量

统计字典的元素数量（一个键值对视为一个元素）

len(dict_name)

# 字典的遍历

方式 1：获取全部的 key ，从而实现遍历

	keys = dict_name.keys()
	for key in keys:
	statement

方式 2：直接对字典进行 for 循环遍历，每次循环都是直接得到 key

	for key in dict_name:
	statement

# 数据容器的通用操作

# 统计元素数量

len(数据容器)

# 获取最大元素

max(数据容器)

# 获取最小元素

min(数据容器)

# 类型转换

# 转为列表

将给定容器转换为列表

若原容器为字符串，则将字符串中的每个字符分别作为列表的一个元素
若原容器为字典，则将字典的每个 key 分别作为列表的一个元素（value 被舍弃）

list(数据容器)

# 转为元组

将给定容器转换为元组

若原容器为字符串，则将字符串中的每个字符分别作为元组的一个元素
若原容器为字典，则将字典的每个 key 分别作为元组的一个元素（value 被舍弃）

tuple(数据容器)

# 转为字符串

将给定容器转换为字符串：整个容器（包括容器的组成括号）均被转换为字符串

str(数据容器)

例如：

	mylist = [1,2,3,4]
	mytuple = (1,2,3,4,5)
	myset = {2,3,4,5}
	mydict = {"a": 1, "b": 2}

	str1 = str(mylist) # '[1, 2, 3, 4]'
	str2 = str(mytuple) # '(1, 2, 3, 4, 5)'
	str3 = str(myset) # '{2, 3, 4, 5}'
	str4 = str(mydict) # "{'a': 1, 'b': 2}"

# 转为集合

将给定容器转换为集合

若原容器为字典，则将字典的每个 key 分别作为集合的一个元素（value 被舍弃）

set(数据容器)

转换为集合后，原容器的数据有序性将不再保持

# 排序

将给定容器进行排序：

排序的结果为列表对象（即，将给定容器的内容进行排序，并将结果放入列表中）

按升序排序（默认按照升序排序）：

sorted(容器)

按降序排序：

sorted(容器, reverse=True)

参考：

Python 基本语法

2022-11-30T08:09:05.000Z

# 条件语句

# if

	if condition:
	statement

# if - else

	if condition:
	statement1
	else:
	statement2

# if - eles if - else

	if condition1:
	statement1
	elif condition2:
	statement2
	else:
	statement3

# 循环语句

# while

	while condition:
	statement

# for

for 循环无法定义循环条件，只能从序列中取出数据处理

	for i in sequence:
	statement

# range

range 语句：产生一个序列

range(num) : 从 0 开始、到 num 结束（不包含 num 本身）
range(num1, num2) : 从 num1 开始、到 num2 结束（不包含 num2 本身）
range(num1, num2, step) : 从 num1 开始、到 num2 结束（不包含 num2 本身），步长为 step

# continue

continue: 中断本次循环，直接进入下一次循环

continue 可用于 while 和 for 循环

# break

break: 直接结束循环

break 可用于 while 和 for 循环

# 函数

函数的定义：

	def func(parameters):
	statement
	return results

函数必须先定义后使用

# 函数的返回值

如果函数没有 return 语句，将默认返回 None

None 可用于声明无初始内容的变量，并且，None 可用于 if 判断

如果函数有多个返回值，则将多个返回值（用逗号分隔）同时放在一个 return 语句中

例如：

	def div(x, y):
	quotient = x // y
	remainder = x % y
	return quotient, remainder

# 传参方式

# 位置参数

调用函数时根据函数定义的参数位置来传递参数

注意：实参的顺序及个数必须与形参列表保持一致

# 关键字参数

函数调用时通过 “key=value” 形式传递参数

可以让函数更见清晰，同时也消除了参数的顺序需求（关键字参数之间不存在先后顺序）

注意：在调用函数时，如果混用位置参数与关键字参数，必须将位置参数放在关键字参数的前面

# 缺省参数（默认参数）

定义函数时，如果为参数提供默认值，则在调用函数时可以不传递该默认参数的值

在调用函数时，如果为缺省参数传递值则修改默认参数值，否则，使用默认值

注意：无论是定义函数或者调用函数，所有位置参数都必须出现在默认参数之前

# 不定长参数（可变参数）

不定长参数用于不确定实参数量（不传参也可以）的场景

不定长参数的类型：

位置传递
关键字传递

# 位置不定长

位置不定长传递以 * 号标记一个形式参数，以元组的形式接收传入的实参，形式参数一般命名为 args

例如：

	def user_info(*args):
	print(args)

	# ('TOM',)
	user_info('TOM')
	# ('TOM', 18)
	user_info('TOM', 18)

# 关键字不定长

关键字不定长传递以 ** 号标记一个形式参数，以字典的形式接收传入的实参，形式参数一般命名为 kwargs

传递的所有实参均为 "key=value" 形式

例如：

	def user_info(**kwargs):
	print(kwargs)

	# ('name': 'TOM', 'age': 18, 'id': 198)
	user_info(name='TOM', age=18, id=198)

# 函数作为参数传递

函数本身是可以作为参数传入到另一个函数中使用的

将函数作为参数的作用：传入的是计算逻辑，而不是计算数据

# lambda 匿名函数

函数的两种定义方式：

def 关键字可以定义带有名称的函数，该函数可以重复使用
lambda 关键字可以定义匿名函数（无名称），该函数只可临时使用一次

匿名函数的定义：

lambda 传入参数: 函数体

其中：

lambda 是关键字，表示定义匿名函数
传入参数表示匿名函数的形式参数（可以传入多个参数）
函数体只能写一行，无法写多行代码

例如：

	# compute 函数作为参数传入 test_func 函数
	def test_func(compute):
	result = compute(1, 2)
	print(result)

	def compute(x, y):
	return x + y

	# 通过 def 定义 compute 函数并传入
	test_func(compute) # 结果：3

	# 通过 lambda 关键字定义匿名函数并传入
	test_func(lambda x, y: x + y) # 结果：3

# 局部变量与全局变量

局部变量：定义在函数体内部的变量，只在函数体内部生效

全局变量：在函数体内、外都能生效的变量

在函数内无法修改全局变量

如果尝试在函数内部修改全局变量，实际上是定义了一个与全局变量同名的局部变量

使用 global 关键字，可以在函数内部声明变量为全局变量

参考：

LeetCode - 模拟专题

2022-10-28T12:35:22.000Z

# LeetCode 463. 岛屿的周长

LeetCode 463. Island Perimeter

给定一个 row x col 的二维网格地图 grid ，其中： grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域

网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）

岛屿中没有 “湖”（“湖” 是指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长

示例 1：

输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边

示例 2：

输入：grid = [[1]]
输出：4

示例 3：

输入：grid = [[1,0]]
输出：4

提示：

row == grid.length
col == grid[i].length
1 <= row, col <= 100
grid[i][j] 为 0 或 1

# Method 1: 模拟

# 算法思路

对于一个岛屿格子的每条边：如果这条边为网格的边界，或者这条边是岛屿与水域的分界线，则需将这条边计入岛屿的周长

因此，可以遍历每个岛屿格子，看其四个方向的边是否为网格边界或水域分界线，如果是，则计入岛屿周长

# 代码实现

	int islandPerimeter(vector<vector<int>>& grid) {
	int m = grid.size();
	int n = grid[0].size();
	vector<vector<int>> dir = <!--swig0-->;
	int res = 0;
	for (int i = 0; i < m; ++i) {
	for (int j = 0; j < n; ++j) {
	if (grid[i][j] == 0) continue;
	for (int k = 0; k < 4; ++k) {
	int x = i + dir[k][0];
	int y = j + dir[k][1];
	if (x == -1 \|\| x == m \|\| y == -1 \|\| y == n) ++res; // 网格边界
	else if (grid[x][y] == 0) ++res; // 水域分界线
	}
	}
	}
	return res;
	}

# 复杂度分析

时间复杂度： $O(m \times n)$ ，其中， $m$ 和 $n$ 分别为网格的行数和列数

空间复杂度： $O(1)$

# Method 2: 深度优先搜索

# 算法思路

可以将方法一改成深度优先搜索遍历的方式（该方式可以拓展至多个岛屿情形）

其中，为避免岛屿格子被重复遍历，需要将已经遍历过的岛屿格子标记。特别地，可以将已经遍历过的岛屿格子的值置为 -1 （不能置为 0，因为置 0 会形成新的 “水域边界线”，进而导致结果出错）

# 代码实现

	vector<vector<int>> dir = <!--swig1-->;

	int dfs(vector<vector<int>>& grid, int x, int y) {
	int m = grid.size();
	int n = grid[0].size();
	if (x == -1 \|\| x == m \|\| y == -1 \|\| y == n) return 1;
	if (grid[x][y] == 0) return 1;
	if (grid[x][y] == -1) return 0;
	grid[x][y] = -1;
	int count = 0;
	for (int k = 0; k < 4; ++k) {
	int newx = x + dir[k][0];
	int newy = y + dir[k][1];
	count += dfs(grid, newx, newy);
	}
	return count;
	}

	int islandPerimeter(vector<vector<int>>& grid) {
	int m = grid.size();
	int n = grid[0].size();
	int ans = 0;
	for (int i = 0; i < m; ++i) {
	for (int j = 0; j < n; ++j) {
	if (grid[i][j] == 1)
	ans += dfs(grid, i, j);
	}
	}
	return ans;
	}

# 复杂度分析

时间复杂度： $O(m \times n)$ ，其中， $m$ 和 $n$ 分别为网格的行数和列数

空间复杂度： $O(m \times n)$

参考：力扣官方题解

# LeetCode 48. 旋转图像

48. Rotate Image

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]

示例 2：

输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

提示：

n == matrix.length == matrix[i].length
$1 \le$ n $\le 20$
$-1000 \le$ matrix[i][j] $\le 1000$

# Method 1: 原地旋转

经过观察，可以发现：

原矩阵中的位置 $matrix[i][j]$ ，旋转后的目标位置为 $matrix[j][n - i - 1]$
原矩阵中的位置 $matrix[j][n - i - 1]$ ，旋转后的目标位置为 $matrix[n - i - 1][n - j - 1]$
原矩阵中的位置 $matrix[n - i - 1][n - j - 1]$ ，旋转后的目标位置为 $matrix[n - j - 1][i]$
原矩阵中的位置 $matrix[n - j - 1][i]$ ，旋转后的目标位置为 $matrix[i][j]$

即，对于 $matrix[i][j]$ 、 $matrix[j][n - i - 1]$ 、 $matrix[n - i - 1][n - j - 1]$ 、 $matrix[n - j - 1][i]$ 而言，每一项旋转后的位置就是下一项所在的位置

因此，可以引入一个临时变量 tmp ，完成这四项的原地交换

	int tmp = matrix[n - j - 1][i];
	matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];
	matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
	matrix[j][n - i - 1] = matrix[i][j];
	matrix[i][j] = tmp;

那么，我们应该枚举哪些 $i$ 和 $j$ 呢？

每一次可以交换四个位置的元素：

当 $n$ 为偶数时，此时需要枚举 $n^2 / 4 = (n / 2) \times (n / 2)$ 个位置。因此， $i$ 和 $j$ 分别遍历 $n / 2$ 个位置，以 $4 \times 4$ 矩阵为例
当 $n$ 为奇数时，由于中心位置始终不变，需要枚举 $(n^2 - 1) / 4 = ((n - 1) / 2) \times ((n + 1) / 2)$ 个位置。因此，i 遍历 $(n - 1) / 2$ 个位置、j 遍历 $(n + 1) / 2$ 个位置，以 $5 \times 5$ 矩阵为例

因此，无论 $n$ 是奇数还是偶数，均可按照 “ $i$ 遍历 $n / 2$ 个位置、 $j$ 遍历 $(n + 1) / 2$ 个位置 ” 来处理，即， i 遍历 [0, n / 2) ， j 遍历 [0, (n + 1) / 2)

代码实现：

	void rotate(vector<vector<int>>& matrix) {
	int n = matrix.size();
	for (int i = 0; i < n / 2; i++) {
	for (int j = 0; j < (n + 1) / 2; j++) {
	int tmp = matrix[n - j - 1][i];
	matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];
	matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
	matrix[j][n - i - 1] = matrix[i][j];
	matrix[i][j] = tmp;
	}
	}
	}

时间复杂度： $O(n^2)$

空间复杂度： $O(1)$

# Method 2: 翻转

算法思路：

首先进行上下翻转，然后进行对角线翻转（即，转置）

理论推导：

对于上下翻转：只需要枚举矩阵上半部分的元素，并将其与下半部分对应位置的元素进行交换，即

$matrix[i][j] \longleftrightarrow matrix[n - i - 1][j]$

对于对角线翻转：只需要枚举对角线左侧的元素，并将其与右侧对应位置的元素进行交换，即

$matrix[i][j] \longleftrightarrow matrix[j][i]$

联立以上两式可得

$matrix[i][j] \longrightarrow matrix[n - i - 1][j] \longrightarrow matrix[j][n - i - 1]$

即，实现了将 $matrix[i][j]$ 旋转 90 度、放到 $matrix[j][n - i - 1]$ 位置

代码实现：

	void rotate(vector<vector<int>>& matrix) {
	int n = matrix.size();
	for (int i = 0; i < n / 2; i++) { // 上下翻转
	for (int j = 0; j < n; j++) {
	swap(matrix[i][j], matrix[n - i - 1][j]);
	}
	}
	for (int i = 0; i < n; i++) { // 对角线翻转
	for (int j = 0; j < i; j++) {
	swap(matrix[i][j], matrix[j][i]);
	}
	}
	}

时间复杂度： $O(n^2)$

空间复杂度： $O(1)$

参考：leetcode-solution

# LeetCode 59. 螺旋矩阵 II

LeetCode 59. Spiral Matrix II

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

$1 \le$ n $\le 20$

# Method: 模拟

思路：模拟顺时针画矩阵的过程，即

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

由外向内一圈一圈这么画下去

注意：每画一条边都要坚持一致的 左闭右开 ，或者 左开又闭 的原则，这样这一圈才能按照统一的规则画下来

坚持 循环不变量 原则

下图以左闭右开原则为例：每一种颜色，代表一条边，注意每一个拐角处的处理规则，拐角处让给新的一条边来继续画（即，每条边都遵循左闭右开原则）

代码实现：

	vector<vector<int>> generateMatrix(int n) {
	vector<vector<int>> matrix(n, vector<int>(n, 0));
	int num = 1; // 填充的数字
	for (int i = 0; i < n / 2; ++i) { // 每次循环填充一圈
	int start = i; // 填充的起点
	int len = n - i * 2 - 1; // 每个方向的填充长度
	for (int j = 0; j < len; ++j) { // 上面一行，从左往右填充
	matrix[start][start + j] = num++;
	}
	for (int j = 0; j < len; ++j) { // 右边一列，从上往下填充
	matrix[start + j][start + len] = num++;
	}
	for (int j = len; j >= 1; --j) { // 下面一行，从右往左填充
	matrix[start + len][start + j] = num++;
	}
	for (int j = len; j >= 1; --j) { // 左边一列，从下往上填充
	matrix[start + j][start] = num++;
	}
	}
	if (n % 2) matrix[n / 2][n / 2] = n * n; //n 为奇数，数组最中间的位置需要单独处理

	return matrix;
	}

时间复杂度： $O(n^2)$ ，需要填充 $n^2$ 个元素

空间复杂度： $O(n^2)$

参考：代码随想录：螺旋矩阵 II

# LeetCode 621. 任务调度器

621. Task Scheduler

给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表。其中每个字母表示一种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。在任何一个单位时间，CPU 可以完成一个任务，或者处于待命状态。

然而，两个 相同种类 的任务之间必须有长度为整数 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。

你需要计算 完成所有任务所需要的最短时间 。

示例 1：

输入：tasks = ["A","A","A","B","B","B"], n = 2
输出：8
解释：
A -> B -> idle -> A -> B -> idle -> A -> B

示例 2：

输入：tasks = ["A","A","A","B","B","B"], n = 0
输出：6
解释：在这种情况下，任何大小为 6 的排列都可以满足要求，因为 n = 0
["A","A","A","B","B","B"]
["A","B","A","B","A","B"]
["B","B","B","A","A","A"]
...
诸如此类

示例 3：

输入：tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
输出：16
解释：一种可能的解决方案：
A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A

提示：

$1 \le$ task.length $\le 10^4$
tasks[i] 是大写英文字母
n 的取值范围为 $[0, 100]$

# Method: 桶思想

# 算法思路

使用一个宽为 $n + 1$ 的矩阵来展示任务执行方案，其中，任务按照逐行遍历的顺序执行，空白格子对应 CPU 的待命状态

于是，可以将具有最大数量的任务排布在矩阵的第一列，将其余任务依次排布成列。由于冷却时间为 $n$ ，上述排列方案可以保证满足题目要求，并且总时间最小

情况一：冷却时间长、任务种类和数量很少，假设所有任务种类中的最大数量为 $\textrm{maxn}$ （即，矩阵的行数），具有最大数量的任务的种类数为 $\textrm{cnt}$ （即，矩阵最后一行的任务数量），则执行任务所需的时间为 $(\textrm{maxn} - 1) \times (n + 1) + \textrm{cnt}$
- 示例 1：
- 示例 3：
情况二：冷却时间短、任务种类或数量很多，可以拓展矩阵的列数，并将任务排布在拓展的列中。此时，每个任务之间都不存在待命时间，因此，执行任务所需的时间就是任务的数量，即 $\vert \textrm{tasks} \vert$

因此，需要的最少时间为 $\max{(\vert \textrm{tasks} \vert, (\textrm{maxn} - 1) \times (n + 1) + \textrm{cnt})}$

具体可参考 popopop

# 代码实现

	int leastInterval(vector<char>& tasks, int n) {
	vector<int> rec(26, 0);
	for (auto c : tasks) // 记录每种任务的数量
	++rec[c - 'A'];
	int maxn = 0; // 任务的最大数量
	int cnt = 0; // 具有最大数量的任务种类数
	for (int num : rec) {
	if (num > maxn) {
	maxn = num;
	cnt = 1;
	} else if (num == maxn) {
	++cnt;
	}
	}
	return max((int)tasks.size(), (maxn - 1) * (n + 1) + cnt);
	}

# 复杂度分析

时间复杂度： $O(n + \vert \Sigma \vert)$ ，其中， $n$ 为数组 tasks 的长度， $\vert \Sigma \vert$ 为数组 tasks 中可能出现的任务种类数

空间复杂度： $O(\vert \Sigma \vert)$

参考：

C++ 类

2022-10-25T14:11:12.000Z

# 定义抽象数据类型

类的基本思想是数据抽象（data abstraction）和封装（encapsulation）

数据抽象是一种依赖于接口（interface）和实现（implementation）分离的编程（以及设计）技术

类的接口：包括用户所能执行的操作
类的实现：包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数

封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分

类要想实现数据抽象和封装，需要首先定义一个抽象数据类型（abstract data type）

在抽象数据类型中，由类的设计者负责考虑类的实现过程
使用该类的程序员则只需要抽象地思考类型做了什么，而无须了解类型的工作细节

本节将以 Sales_data 类为例，介绍类的定义与使用

# 设计 Sales_data 类

我们希望 Sales_item 类有一个名为 isbn 的成员函数（member function），并且具有一些等效于 + 、= 、+= 、<<和>> 运算符的函数

于是，Sales_data 的接口应该包含以下操作：

一个 isbn 成员函数，用于返回对象的 ISBN 编号
一个 combine 成员函数，用于将一个 Sales_data 对象加到另一个对象上（等效于 += 运算符）
一个名为 add 的普通函数，执行两个 Sales_data 对象的加法（等效于 + 运算符）
一个名为 read 的普通函数，将数据从 istream 读入到 Sales_data 对象中（等效于 >> 运算符）
一个名为 print 的函数，将 Sales_data 对象的值输出到 ostream （等效于 << 运算符）

定义 Sales_data 类如下所示：

	struct Sales_data {
	// 数据成员
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
	// 成员函数：关于 Sales_data 对象的操作
	std::string isbn() const { return bookNo; }
	Sales_data& combine(const Sales_data&);
	double avg_price() const;
	};

	// 非成员的普通函数
	Sales_data add(const Sales_data&, const Sales_data&);
	std::ostream &print(std::ostream&, const Sales_data&);
	std::istream &read(std::istream&, Sales_data&);

其中，Sales_data 类的数据成员包括：bookNo 、units_sold 、revenue ，分别表示书本的 ISBN 编号、销量、总销售额；Sales_data 类的成员函数包括 isbn 和 combine ；add、read 和 print 则是普通函数，并未作为 Sales_data 类的成员

Sales_data 类的使用示例：

	Sales_data total;
	if (read(cin, total)) {
	Sales_data trans;
	while(read(cin, trans)) {
	if (total.isbn() == trans.isbn())
	total.combine(trans);
	else {
	print(cout, total) << endl;
	total = trans;
	}
	}
	print(cout, total) << endl;
	} else {
	cerr << "No data?!" << endl;
	}

# 定义成员函数

成员函数的声明必须在类的内部，它的定义既可以在类的内部也可以在类的外部

例如，上述的 isbn 函数定义在 Sales_data 类的内部，combine 和 avg_price 定义在类的外部

和其他函数一样，类的成员函数也由函数类型、函数名、形参列表和函数体组成。以 isbn 函数为例，isbn 函数用于返回 Sales_data 对象的 bookNo 数据成员，其定义为

std::string isbn() const { return bookNo; }

然而，isbn 函数是如何获得 bookNo 成员所依赖的对象的呢？

# this

不妨先观察 isbn 成员函数的调用：使用点运算符访问 trans 对象的 isbn 成员，由此来调用该函数

	Sales_data trans;
	trans.isbn();

成员函数通过一个名为 this 的隐式参数来访问调用它的那个对象。具体来说，当我们调用一个成员函数时，请求该函数的对象地址将会被用于初始化 this

例如，如果调用 trans.isbn() ，编译器将会把 trans 的地址传递给 isbn 函数的隐式形参 this 。可以等价地认为，编译器将 trans.isbn() 这一调用重写成了如下形式：

	// 伪代码，用于说明调用成员函数的实际执行过程
	Sales_data::isbn(&trans)

其中，调用 Sales_data 的 isbn 成员时传入了 trans 的地址

在成员函数内部，可以直接使用调用该函数的对象的成员，而无须通过成员访问运算符来做到这一点，因为 this 所指的就是当前对象。任何对类成员的直接访问都被看作 this 的隐式引用，也就是说，当 isbn 使用 bookNo 时，它隐式地使用 this 指向的成员，就像我们书写了 this->bookNo 一样

this 形参是隐式定义的。任何自定义名为 this 的参数或变量都是非法的

我们可以在成员函数体内部使用 this （尽管没有必要）

std::string isbn() const { return this->bookNo; }

需要注意， this 是一个常量指针，不允许改变 this 中保存的地址

# const 成员函数

isbn 函数的另一个关键之处：参数列表后的 const 关键字，用于修改隐式 this 指针的类型

默认情况下， this 的类型是指向类类型非常量版本的常量指针。例如，在 Sales_data 的成员函数中，this 的类型是 Sales_data *const

尽管 this 是隐式的，也依然需要遵循初始化规则，这意味着：（在默认情况下）我们不能把 this 绑定到一个常量对象上，即，我们不能在一个常量对象上调用普通的成员函数（不加 const 的成员函数）

于是，我们不禁会想到：如果想要在常量对象上调用普通成员函数，就应该将 this 声明成指向常量的指针（即，const Sales_data *const ）。然而， this 是隐式的，并不会出现在参数列表中。那我们应该在哪里将 this 声明成指向常量的指针呢？

C++ 语言的做法是：允许把 const 关键字放在成员函数的参数列表之后，此时，紧跟在参数列表后面的 const 表示 this 是一个指向常量的指针

像这样使用 const 的成员函数被称作 常量成员函数（const member function）

因为 this 是指向常量的指针，常量成员函数不能改变调用它的对象的内容

常量对象，以及常量对象的引用或指针都只能调用常量成员函数

# 类作用域和成员函数

类本身就是一个作用域，类成员函数的定义嵌套在类的作用域之内

在上例中，isbn 中用到的名字 bookNo 是定义在 Sales_data 内的数据成员，并且，即使 bookNo 定义在 isbn 之后，isbn 也还是能够使用 bookNo

这是因为，编译器分两步处理类：首先编译成员的声明，然后才编译成员函数体（如果有的话）

因此，成员函数体可以随意使用类中的其他成员，无须在意这些成员出现的次序

# 在类的外部定义

当我们在类的外部定义成员函数时，成员函数的定义必须与它的声明匹配

返回类型、参数列表和函数名都得与类内部的声明保持一致
如果成员被声明成常量成员函数，那么它的定义也必须在参数列表后明确指定 const 属性

并且，类外部定义的成员名字必须包含它所属的类名

	double Sales_data::avg_price() const {
	if (units_sold)
	return revenue/units_sold;
	else
	return 0;
	}

其中，函数名 Sales_data::avg_price 使用作用域运算符来说明 avg_price 函数被声明在类 Sales_data 的作用域内。因此，当 avg_price 使用 revenue 和 units_sold 时，它实际上是使用了 Sales_data 的成员

# 定义一个返回 this 对象的函数

函数 combine 的设计初衷类似于复合赋值运算符 += 。调用该函数的对象代表的是赋值运算符左侧的运算对象，右侧运算对象则通过显式的实参被传入函数

	Sales_data& Sales_data::combine(const Sales_data &rhs) {
	units_sold += rhs.units_sold; // 把 rhs 的成员加到 this 对象的成员上
	revenue += rhs.revenue;
	return *this; // 返回调用该函数的对象
	}

当我们的程序调用如下函数时，

total.combine(trans);             // 更新变量 total 的值

total 的地址被绑定到隐式的 this 参数上，而 rhs 绑定到了 trans 上

因此，当 combine 执行下面的语句时，

units_sold += rhs.units_sold;

等效于 total.units_sold += trans.unit_sold

一般来说，当我们定义的函数类似于某个内置运算符时，应该令该函数的行为尽量模仿这个运算符

内置的赋值运算符把它的左侧运算对象当成左值返回
为了与它保持一致，combine 函数必须返回引用类型。因为此时的左侧运算对象是一个 Sales_data 的对象，所以返回类型应该是 Sales_data&

如前所述，我们无须使用隐式的 this 指针访问函数调用者的某个具体成员，但是，我们需要使用 this 来把调用函数的对象当成一个整体访问。因此，需要使用

return *this; // 返回调用该函数的对象

以获得执行该函数的对象，其中，解引用 this 指针就是得到了 total 的地址

# 定义类相关的非成员函数

作为接口组成部分的非成员函数，它们的定义和声明都在类的外部，例如 add、read 和 print 等

一般来说，如果非成员函数是类接口的组成部分，则这些函数的声明应该与类在同一个头文件内。在这种方式下，用户使用接口的任何部分都只需要引入一个文件

	// 定义 read 函数
	istream &read(istream &is, Sales_data &item) {
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
	}

	// 定义 print 函数
	ostream &print(ostream &os, const Sales_data &item) {
	os << item.isbn() << " " << item.units_sold << " "
	<< item.revenue << " " << item.avg_price();
	return os;
	}

	// 定义 add 函数
	Sales_data add(const Sales_data &lhs, const Sales_data &rhs) {
	Sales_data sum = lhs; // copy data members from lhs into sum
	sum.combine(rhs); // add data members from rhs into sum
	return sum;
	}

read 函数从给定流中将数据读到给定的对象里，print 函数则负责将给定对象的内容打印到给定的流中。其中，read 和 print 分别接受一个各自 IO 类型的引用作为其参数，这是因为 IO 类属于不能被拷贝的类型，因此我们只能通过引用来传递它们。而且，因为读取和写入的操作会改变流的内容，两个函数接受的都是普通引用，而非对常量的引用

# 构造函数

每个类都分别定义了它的对象被初始化的方式

类通过一个或几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做 构造函数（constructor）

构造函数的名字和类名相同
类似于其他函数，构造函数有一个参数列表（可能为空）和一个函数体（可能为空）
构造函数没有返回类型

构造函数的任务是初始化类对象的数据成员。无论何时，只要类的对象被创建，就会执行构造函数

类可以包含多个构造函数，但是，不同的构造函数之间必须在参数数量或参数类型上有所区别（类似于函数重载）

不同于其他成员函数，构造函数不能被声明成 const 。当我们创建类的一个 const 对象时，直到构造函数完成初始化过程，对象才能真正取得其 “常量” 属性。因此，构造函数在构造 const 对象的过程中可以向其写值

# 合成的默认构造函数

我们的 Sales_data 类并没有定义任何构造函数，但是之前使用了 Sales_data 对象的程序仍然可以正确编译和运行，因此可以说明，Sales_data 对象执行了默认初始化

	Sales_data total; // 没有为 total 提供初始值，执行默认初始化
	Sales_data trans; // 没有为 trans 提供初始值，执行默认初始化

类通过一个特殊的构造函数来控制默认初始化过程，这个函数叫做 默认构造函数（default constructor）

默认构造函数无须任何实参
如果我们的类没有显式地定义构造函数，编译器将会为我们隐式地定义一个默认构造函数

编译器自动生成的构造函数被称为合成的默认构造函数（synthesized default constructor）

对于大多数类来说，合成的默认构造函数将按照如下规则初始化类的数据成员：

如果存在类内的初始值，用类内初始值来初始化成员
否则，默认初始化该成员

	struct Sales_data {
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
	}

例如，对上面的类而言，因为 Sales_data 为 units_sold 和 revenue 提供了初始值，所以合成的默认构造函数将使用这些值来初始化对应的成员，而 bookNo 并未提供初始值，所以合成的默认构造函数把 bookNo 默认初始化成一个空字符串

然而，合成的默认构造函数只适合非常简单的类，比如现在定义的这个 Sales_data 版本

通常来说，一个类必须定义它自己的默认构造函数，而不能仅依赖于合成的默认构造函数 。这是因为：

只有当类没有声明任何构造函数时，编译器才会自动地生成默认构造函数。一旦我们定义了一些其他的构造函数，类将没有默认构造函数（除非我们自己定义一个默认构造函数）
对于某些类来说，合成的默认构造函数可能执行错误的操作。如果类包含有内置类型或者复合类型的成员，则只有当这些成员全都被赋予了类内的初始值时，这个类才适合于使用合成的默认构造函数
有的时候编译器不能为某些类合成默认的构造函数。例如，如果类中包含一个其他类类型的成员且这个成员的类型没有默认构造函数，那么编译器将无法初始化该成员。此外，还有其他一些情况也会导致编译器无法生成一个正确的默认构造函数，我们将在以后讨论

# 定义构造函数

对于我们的 Sales_data 类来说，我们可根据实际需要而定义不同的构造函数，例如：

	struct Sales_data {
	// 数据成员及成员函数
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
	std::string isbn() const { return bookNo; }
	Sales_data& combine(const Sales_data&);
	double avg_price() const;
	// 构造函数
	Sales_data() = default;
	Sales_data(const std::string &s): bookNo(s) { }
	Sales_data(const std::string &s, unsigned n, double p):
	bookNo(s), units_sold(n), revenue(p*n) { }
	Sales_data(std::istream &);
	};

# = default

在 C++ 11 标准中，如果我们需要默认的行为，可以通过在参数列表后面写上 = default 来要求编译器生成默认构造函数，其作用完全等同于之前使用的合成默认构造函数

其中， = default 既可以与声明一起出现在类的内部，也可以作为定义出现在类的外部

如果 = default 在类的内部，则默认构造函数是内联的
如果它在类的外部，则该成员默认情况下不是内联的

If the = default appears inside the class body, the default constructor will be inlined; if it appears on the definition outside the class, the member will not be inlined by default.

例如：

Sales_data() = default;

需注意， = default 生成的默认构造函数之所以对 Sales_data 类有效，是因为我们已经为内置类型的数据成员提供初始值。如果编译器不支持类内初始值，默认构造函数就应该使用构造函数初始值列表来初始化类的每个成员

# 构造函数初始值列表

对于以下两个构造函数，其定义中出现了新的部分，即，冒号以及冒号与花括号之间的代码。我们把新出现的部分称为 构造函数初始值列表（constructor initialize list）

	Sales_data(const std::string &s): bookNo(s) { }
	Sales_data(const std::string &s, unsigned n, double p):
	bookNo(s), units_sold(n), revenue(p*n) { }

构造函数初始值列表负责为新创建对象的一个或几个数据成员赋初值

构造函数初始值列表的组成：

成员名字
成员名字后面的、括号（或者花括号）括起来的成员初始值
不同成员之间的逗号分隔符

以 Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) { } 为例，该函数使用 s 和 n 来分别初始化成员 bookNo 和 units_sold ，并用 p 与 n 的乘积来初始化 revenue

Sales_data(const std::string &s): bookNo(s) { } ，其只使用 s 来显式初始化 bookNo 。对于 units_sold 和 revenue 这两个成员而言，将利用类内初始值进行隐式初始化（类似于合成默认构造函数的方式）。因此，该构造函数等价于

	Sales_data(const std::string &s):
	bookNo(s), units_sold(0), revenue(0){ }

当某个数据成员被构造函数初始值列表忽略时，它将以与合成默认构造函数相同的方式隐式初始化

通常情况下，构造函数使用类内初始值不失为一种好的选择，因为只要这样的初始值存在我们就能确保为成员赋予了一个正确的值。不过，如果你的编译器不支持类内初始值，则所有构造函数都应该显式地初始化每个内置类型的成员

另外，我们需要注意， Sales_data(const std::string &s): bookNo(s) { } 中的 { } 实际是构造函数的函数体。因为我们定义这些构造函数的目的是为数据成员赋初值，其并不需要通过函数体实现，所以将函数体定义成空的

# 在类的外部定义构造函数

与其他几个构造函数不同，以 istream 对象为参数的构造函数 Sales_data(std::istream &) 需要执行一些实际的操作，在它的函数体内调用了 read 函数来给数据成员赋以初值

	Sales_data::Sales_data(std::istream &is) {
	read(is, *this); // 从 is 中读取一条信息然后存入 this 对象中
	}

和其他成员函数一样，当我们在类的外部定义构造函数时，必须指明该构造函数是哪个类的成员

因此， Sales_data::Sales_data 指出，我们定义了 Sales_data 类的成员 Sales_data 。因为该成员的名字和类名相同，所以它是一个构造函数（构造函数没有返回类型）

由于 Sales_data(std::istream &) 函数定义了函数体，在执行该构造函数时，对象的成员是可以被初始化的（尽管这个构造函数初始值列表是空的）

# 拷贝、赋值和析构

除了定义类的对象如何初始化之外，类还需要控制拷贝、赋值和销毁对象时发生的行为

如果我们不主动定义这些操作，编译器将替我们合成它们。一般来说，编译器生成的版本将对对象的每个成员执行拷贝、赋值和销毁操作

例如：

total = trans;

实际上等价于

	// Sales_data 的默认赋值操作等价于
	total.bookNo = trans.bookNo;
	total.units_sold = trans.units_sold;
	total.revenue = trans.revenue;

尽管编译器能替我们合成拷贝、赋值和销毁的操作，但是必须要清楚的一点是，对于某些类来说合成的版本无法正常工作。特别是，当类需要分配类对象之外的资源时，合成的版本常常会失效。例如，管理动态内存的类通常不能依赖于上述操作的合成版本

很多需要动态内存的类能够并且应该使用 vector 对象或者 string 对象来管理必要的存储空间
如果类包含 vector 或者 string 成员，则其拷贝、赋值和销毁的合成版本能够正常工作

# 访问控制与封装

在 C++ 语言中，我们使用 访问说明符（access specifiers）加强类的封装性：

定义在 public 说明符之后的成员可以在整个程序内被访问。 public 成员定义类的接口
定义在 private 说明符之后的成员可以被类的成员函数访问，但是不能被使用该类的代码访问。 private 封装（即，隐藏）类的实现细节

一个类可以包含 0 个或多个访问说明符，而且，某个访问说明符可以出现多次

每个访问说明符指定了接下来的成员的访问级别，其有效范围直到出现下一个访问说明符或者到达类的结尾处为止

再一次定义 Sales_data 类，其新形式如下所示：

	class Sales_data {
	public: // 添加了访问说明符
	Sales_data() = default;
	Sales_data(const std::string &s, unsigned n, double p):
	bookNo(s), units_sold(n), revenue(p*n) { }
	Sales_data(const std::string &s): bookNo(s) { }
	Sales_data(std::istream&);
	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data&);
	private: // 添加了访问说明符
	double avg_price() const
	{ return units_sold ? revenue/units_sold : 0; }
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
	};

作为接口的一部分，构造函数和部分成员函数（即 isbn 和 combine ）紧跟在 public 说明符之后；而数据成员和作为实现部分的函数则跟在 private 说明符后面

在上面的定义中我们还做了一个微妙的变化，我们使用了 class 关键字而非 struct 开始类的定义。这种变化仅仅是形式上有所不同，实际上我们可以使用这两个关键字中的任何一个定义类。唯一的一点区别是， struct 和 class 的默认访问权限不太一样

类可以在它的第一个访问说明符之前定义成员，这种成员的访问权限依赖于类定义的方式

如果我们使用 struct 关键字，则定义在第一个访问说明符之前的成员是 public 的
如果我们使用 class 关键字，则这些成员是 private 的

出于统一编程风格的考虑，如果我们希望定义的类的所有成员是 public 的，使用 struct ；反之，如果希望成员是 private 的，使用 class

# 友元

类可以将其他类或者函数声明成为它的友元（friend），从而允许其他类或者函数访问它的非公有成员

如果类想把一个函数作为它的友元，需要增加一条以 friend 关键字开始的函数声明语句

例如，此前 定义抽象数据类型 时的 read、print 和 add 函数并不是类的成员，但却需要访问 Sales_data 类中 private 的数据成员，因此，我们需要将 read、print 和 add 函数作为 Sales_data 类的友元

	class Sales_data {
	// 为 Sales_data 的非成员函数所做的友元声明
	friend Sales_data add(const Sales_data&, const Sales_data&);
	friend std::istream &read(std::istream&, Sales_data&);
	friend std::ostream &print(std::ostream&, const Sales_data&);
	// 其他成员及访问说明符与之前一致
	public:
	Sales_data() = default;
	Sales_data(const std::string &s, unsigned n, double p):
	bookNo(s), units_sold(n), revenue(p*n) { }
	Sales_data(const std::string &s): bookNo(s) { }
	Sales_data(std::istream&);
	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data&);
	private:
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
	};

	// Sales_data 接口的非成员组成部分的声明
	Sales_data add(const Sales_data&, const Sales_data&);
	std::istream &read(std::istream&, Sales_data&);
	std::ostream &print(std::ostream&, const Sales_data&);

友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限。友元不是类的成员也不受它所在区域访问控制级别的约束

一般来说，最好在类定义开始或结束前的位置集中声明友元

# 友元的声明

友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明

如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明

为了使友元对类的用户可见，我们通常把友元的声明与类本身放置在同一个头文件中（类的外部）

因此，我们的 Sales_data 头文件应该为 read 、print 和 add 提供独立的声明（除了类内部的友元声明之外）

许多编译器并未强制限定友元函数必须在使用之前在类的外部声明

一些编译器允许在尚无友元函数的初始声明的情况下就调用它，不过最好还是提供一个独立的函数声明

# 封装

封装有两个重要的优点：

确保用户代码不会无意间破坏封装对象的状态
被封装的类的具体实现细节可以随时改变，而无须调整用户级别的代码

一旦把数据成员定义成 private 的，类的作者就可以比较自由地修改数据了

当实现部分改变时，我们只需要检查类的代码本身以确认这次改变有什么影响。换句话说，只要类的接口不变，用户代码就无须改变
如果数据是 public 的，所有使用了原来数据成员的代码都可能失效，这时我们必须定位并重写所有依赖于老版本实现的代码，之后才能重新使用该程序

把数据成员的访问权限设成 private 还有另外一个好处：防止由于用户的原因造成数据被破坏。如果我们发现有程序缺陷破坏了对象的状态，则可以在有限的范围内定位缺陷

尽管当类的定义发生改变时无须更改用户代码，但是使用了该类的源文件必须重新编译

参考：C++ Primer 中文版（第 5 版）

shoka 主题的若干改动

2022-10-19T14:49:50.000Z

# 修改主页标签名

打开 themes\shoka\languages 路径下的 zh-CN.yml 文件，找到 favicon 板块，修改 show 和 hide

	favicon:
	show: Jiankychen
	hide: Jiankychen

本博客根目录 _config.yml 中的语言设置为 language: zh-CN ，所以这里是修改 zh-CN.yml 文件。若根目录 _config.yml 中的语言设置为 language: en ，则应修改 en.yml 文件

# 修改加载动画

实现步骤：

打开 themes\shoka\source\css\_common\components\third-party 路径下的 loading.styl 文件，将第 9 行（ $bgColor = var(--grey-1) ）及以后的内容全部删除，新增以下内容：

	+mobile() {
	width: 20px;
	height: 20px;
	}
	+tablet() {
	width: 30px;
	height: 30px;
	}

	.container {
	height: 100vh;
	width: 100vw;
	font-family: Helvetica;
	}

	.loader {
	height: 20px;
	width: 250px;
	position: absolute;
	top: 0;
	bottom: 0;
	left: 0;
	right: 0;
	margin: auto;
	}

	.loader--dot {
	animation-name: loader;
	animation-timing-function: ease-in-out;
	animation-duration: 3s;
	animation-iteration-count: infinite;
	height: 20px;
	width: 20px;
	border-radius: 100%;
	background-color: black;
	position: absolute;
	border: 2px solid white;
	}

	.loader--dot:first-child {
	background-color: #8cc759;
	animation-delay: 0.5s;
	}

	.loader--dot:nth-child(2) {
	background-color: #8c6daf;
	animation-delay: 0.4s;
	}

	.loader--dot:nth-child(3) {
	background-color: #ef5d74;
	animation-delay: 0.3s;
	}

	.loader--dot:nth-child(4) {
	background-color: #f9a74b;
	animation-delay: 0.2s;
	}

	.loader--dot:nth-child(5) {
	background-color: #60beeb;
	animation-delay: 0.1s;
	}

	.loader--dot:nth-child(6) {
	background-color: #fbef5a;
	animation-delay: 0s;
	}

	.loader--text {
	position: absolute;
	top: 200%;
	left: 0;
	right: 0;
	width: 4rem;
	margin: auto;
	}

	.loader--text:after {
	content: "Loading";
	font-weight: bold;
	animation-name: loading-text;
	animation-duration: 2.5s;
	animation-iteration-count: infinite;
	}


	@keyframes loader {
	15% {
	transform: translateX(0);
	}
	45% {
	transform: translateX(230px);
	}
	65% {
	transform: translateX(230px);
	}
	95% {
	transform: translateX(0);
	}
	}

	@keyframes loading-text {
	0% {
	content: "Loading";
	}
	25% {
	content: "Loading.";
	}
	50% {
	content: "Loading..";
	}
	75% {
	content: "Loading...";
	}
	}

打开 themes\shoka\layout\_partials 路径下的 layout.njk 文件，将第 14 行（即 <div class="cat"> ）至第 29 行（即 </div> ）之间的内容（包括第 14 行和第 29 行）替换为

	<div class='container'>
	<div class='loader'>
	<div class='loader--dot'></div>
	<div class='loader--dot'></div>
	<div class='loader--dot'></div>
	<div class='loader--dot'></div>
	<div class='loader--dot'></div>
	<div class='loader--dot'></div>
	<div class='loader--text'></div>
	</div>
	</div>

为适配移动端显示，需修改 themes\shoka\source\css\_common\outline 路径下的 outline.styl 文件：将

	.cat {
	margin-top: 10rem;
	}

替换为

	.loader {
	margin-top: 15rem;
	justify-content: center;
	}

效果预览：

See the Pen Untitled by Jiankychen (@jiankychen) on CodePen.

加载动画列表：

本加载动画源自于 Dave McCarthy

参考：

# 使用外链头像

在采用 Jsdelivr 静态缓存的情况下，由于某种未知原因，博客侧边栏的头像经常无法显示，现考虑使用外部链接的图片作为头像

实现步骤：

打开 themes\shoka\layout\_partials\post 路径下的 post.njk 文件，将

	<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
	<meta itemprop="image" content="{{ url_for(theme.statics + theme.images + '/' + theme.sidebar.avatar) }}">
	<meta itemprop="name" content="{{ author }}">
	<meta itemprop="description" content="{{ subtitle }}, {{ description }}">
	</span>

替换为

	<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
	{%- if 'http' in theme.sidebar.avatar %}
	<meta itemprop="image" content="{{ url_for(theme.sidebar.avatar) }}">
	{%- else %}
	<meta itemprop="image" content="{{ url_for(theme.statics + theme.images + '/' + theme.sidebar.avatar) }}">
	{%- endif %}
	<meta itemprop="name" content="{{ author }}">
	<meta itemprop="description" content="{{ subtitle }}, {{ description }}">
	</span>

打开 themes\shoka\layout\_partials\sidebar 路径下的 overview.njk 文件，将

	<div class="author" itemprop="author" itemscope itemtype="http://schema.org/Person">
	<img class="image" itemprop="image" alt="{{ author }}"
	data-src="{{ url_for(theme.statics + theme.images + '/'+ theme.sidebar.avatar) }}">
	<p class="name" itemprop="name">{{ author }}</p>
	<div class="description" itemprop="description">{{ description }}</div>
	</div>

替换为

	<div class="author" itemprop="author" itemscope itemtype="http://schema.org/Person">
	<img class="image" itemprop="image" alt="{{ author }}"
	{%- if 'http' in theme.sidebar.avatar %}
	data-src="{{ url_for(theme.sidebar.avatar) }}"
	{%- else %}
	data-src="{{ url_for(theme.statics + theme.images + '/'+ theme.sidebar.avatar) }}"
	{%- endif %}
	>
	<p class="name" itemprop="name">{{ author }}</p>
	<div class="description" itemprop="description">{{ description }}</div>
	</div>

打开主题 _config.yml 文件，找到 sidebar 板块，将 avatar 值设为外部链接，例如
avatar: https://s2.loli.net/2023/01/01/hnmYMxBAwF9QelU.jpg

# 去除首页 subtitle 两侧的 = 号

首页 subtitle 两侧会显示出一个 = 号，这里考虑将其去除

实现方式：

打开 themes\shoka\layout\_partials 路径下的 layout.njk 文件，将第 42 行（ <p class="meta" itemprop="description">= {{ subtitle }} =</p> ）替换为

<p class="meta" itemprop="description">{{ subtitle }}</p>

效果对比：

去除前
去除后

也可以将 = 号替换成其他字符或图标，例如：

<p class="meta" itemprop="description">~~~ {{ subtitle }} ~~~</p>

效果：

# 添加页脚：站点运行时长

实现步骤：

打开 themes\shoka\languages 路径下的 zh-CN.yml 文件，找到 footer 板块，添加以下内容：
timing: 本站已运行
days: 天
hours: 时
minutes: 分
seconds: 秒

打开 themes\shoka\layout\_partials 路径下的 footer.njk 文件，在 </div> 与 {%- if theme.footer.count %} 之间插入以下内容：

	<div class="timing">
	<span id="RunTime"></span>
	<script>
	var BootDate = new Date("2021/10/24 23:00:00"); {# 站点起始时间 #}
	function ShowRunTime(id) {
	var NowDate = new Date();
	var RunDateM = parseInt(NowDate - BootDate);
	var RunDays = Math.floor(RunDateM/(2436001000));
	var RunHours = Math.floor(RunDateM%(2436001000)/(3600*1000));
	var RunMinutes = Math.floor(RunDateM%(2436001000)%(36001000)/(601000));
	var RunSeconds = Math.round(RunDateM%(2436001000)%(36001000)%(601000)/1000);
	var RunTime = RunDays + " {{ __('footer.days') }} " + RunHours + " {{ __('footer.hours') }} " + RunMinutes + " {{ __('footer.minutes') }} " + RunSeconds + " {{ __('footer.seconds') }}";
	document.getElementById(id).innerHTML = "{{ __('footer.timing') }} " + RunTime;
	}
	setInterval("ShowRunTime('RunTime')", 1000);
	</script>
	</div>

效果：

# 添加页脚：站点访问量

可以通过 busuanzi 将站点 / 某个页面的访客数量添加到页脚

实现步骤：

打开 themes\shoka\languages 路径下的 zh-CN.yml 文件，找到 footer 板块，添加以下内容
views: 次
visitors: 人

打开 themes\shoka\layout\_partials 路径下的 footer.njk 文件，将 {%- if theme.footer.count %} 至 {%- endif %} 之间的内容替换为

	{%- if theme.footer.count %}
	<script async src="https://cdn.jsdelivr.net/gh/jiankychen/jiankychen.github.io@master/js/busuanzi.pure.min.js"></script>
	<div class="count">
	<span title="{{ __('symbols_count_time.count_total') }}">
	<span class="post-meta-item-icon">
	<i class="ic i-file" aria-hidden="true"></i>
	</span>
	<span class="text">{{ symbolsCountTotal(site) }} {{__('symbols_count_time.word')}}</span>
	</span>
	<span class="post-meta-divider">\|</span>
	<span title="{{ __('footer.total_visitors') }}">
	<span class="post-meta-item-icon">
	<i class="ic i-person" aria-hidden="true"></i>
	</span>
	<span class="views">
	<span id="busuanzi_value_site_uv"></span> {{ __('footer.visitors') }}
	</span>
	</span>
	<span class="post-meta-divider">\|</span>
	<span title="{{ __('footer.total_views') }}">
	<span class="post-meta-item-icon">
	<i class="ic i-eye" aria-hidden="true"></i>
	</span>
	<span class="visitors">
	<span id="busuanzi_value_site_pv"></span> {{ __('footer.views') }}
	</span>
	</span>
	<span class="post-meta-divider">\|</span>
	<span title="{{ __('symbols_count_time.time_total') }}">
	<span class="post-meta-item-icon">
	<i class="ic i-clock" aria-hidden="true"></i>
	</span>
	<span class="text">{{ symbolsTimeTotal(site, config.symbols_count_time.awl, config.symbols_count_time.wpm, __('symbols_count_time.time_minutes')) }}</span>
	</span>
	</div>
	{%- endif %}

参考：

# 新增页面：访问统计与文章统计

# 添加访问统计页面

按照 Lavender 的文章 Shoka 主题：新增博客访问统计页面做相应配置

其中，百度商业账号和百度账号的调用方法存在差异，普通用户按照百度账号接口说明进行操作，以获取 API Key、Secret Key、Refresh Token、Acess_Token、Site_ID 等信息

一旦 Acess_Token 过期，可根据以下请求更换新的 Acess_Token 和 Refresh_Token ：

http://openapi.baidu.com/oauth/2.0/token?grant_type=refresh_token&refresh_token={REFRESH_TOKEN}&client_id={CLIENT_ID}&client_secret={CLIENT_SECRET}

其中：

{REFRESH_TOKEN} 填写 Refresh Token
{CLIENT_ID} 填写 API Key
{CLIENT_SECRET} 填写 Secret Key

参考：

# 添加文章统计功能

具体可参考 Shoka 主题：新增文章统计页面、Hexo 博客文章统计图

# 主题 vendors 链接替换 - 拆分 Jsdelivr

参考：Hexo-Shoka 主题功能介绍补充点：主题插件链接替换思路与案例

另一种方案：shoka 主题速度优化 - 拆分 jsdelivr

# 修改主题配置文件

打开主题配置文件 _config.shoka.yml ，找到文件最后的 vendors 板块，将其注释，并在其下方新增以下内容

	vendors:
	css:
	katex: unpkg.com/katex@0.12.0/dist/katex.min.css
	comment: css/comment.css
	fancybox: unpkg.com/@fancyapps/fancybox@3.5.7/dist/jquery.fancybox.min.css
	justifiedGallery: unpkg.com/justifiedGallery@3.8.1/dist/css/justifiedGallery.min.css
	js:
	pace: unpkg.com/pace-js@1.0.2/pace.min.js
	pjax: unpkg.com/pjax@0.2.8/pjax.min.js
	fetch: unpkg.com/whatwg-fetch@3.4.0/dist/fetch.umd.js
	anime: unpkg.com/animejs@3.2.0/lib/anime.min.js
	algolia: unpkg.com/algoliasearch@4/dist/algoliasearch-lite.umd.js
	instantsearch: unpkg.com/instantsearch.js@4/dist/instantsearch.production.min.js
	lazyload: unpkg.com/lozad@1/dist/lozad.min.js
	quicklink: unpkg.com/quicklink@2/dist/quicklink.umd.js
	jquery: unpkg.com/jquery@3.5.1/dist/jquery.min.js
	fancybox: unpkg.com/@fancyapps/fancybox@3.5.7/dist/jquery.fancybox.min.js
	justifiedGallery: unpkg.com/justifiedGallery@3.8.1/dist/js/jquery.justifiedGallery.min.js
	valine: js/MiniValine.min.js
	copy_tex: unpkg.com/katex@0.12.0/dist/contrib/copy-tex.min.js
	chart: unpkg.com/frappe-charts@1.5.0/dist/frappe-charts.min.iife.js
	echarts: unpkg.com/echarts@5.2.2/dist/echarts.min.js

与原始版本相比，有以下改动：

除了 comment 和 valine 依然使用本地文件外，其余 vendors 元素的链接前缀均修改为 unpkg.com
fancybox 元素被拆分成 fancybox 和 justifiedGallery
新增个人所需的 echarts （用于实现博客统计页面中的图表）

# 修改 utils.js

打开 themes\shoka\source\js\_app\utils.js ，找到 const assetUrl = function (asset, type) {} （文件第 25~39 行左右），将其替换为

	const assetUrl = function (asset, type) {
	var str = CONFIG[asset][type]

	if(str.indexOf('unpkg.com')>-1)
	return "https://" + str;

	if(str.indexOf('http')>-1)
	return str;

	return statics + str;
	}

# 修改 asset.js

打开 themes\shoka\scripts\helpers\asset.js ，找到 hexo.extend.helper.register('_vendor_js', () => {}) （第 41~63 行左右），将其替换为

	hexo.extend.helper.register('_vendor_js', () => {
	const config = hexo.theme.config.vendors.js;
	if (!config) return '';
	//Get a font list from config
	let vendorJs = ['pace', 'pjax', 'fetch', 'anime', 'algolia', 'instantsearch', 'lazyload', 'quicklink'].map(item => {
	if (config[item]) {
	return config[item];
	}
	return '';
	});

	return vendorJs.map(url => {
	if(item !== ''){
	return htmlTag('script', { src: `https://${url}` }, '');
	}
	}).join('');
	});

# 修改 script.js

打开 themes\shoka\scripts\generaters\script.js ，找到 js 和 css 索引代码（第 23~38 行左右），将其替换为

	js: {
	valine: theme.vendors.js.valine,
	chart: theme.vendors.js.chart,
	copy_tex: theme.vendors.js.copy_tex,
	jquery: theme.vendors.js.jquery,
	fancybox: theme.vendors.js.fancybox,
	justifiedGallery: theme.vendors.js.justifiedGallery,
	echarts: theme.vendors.js.echarts
	},
	css: {
	valine: theme.css + "/comment.css",
	katex: theme.vendors.css.katex,
	mermaid: theme.css + "/mermaid.css",
	fancybox: theme.vendors.css.fancybox,
	justifiedGallery: theme.vendors.css.justifiedGallery
	},
	// ...

# 修改 page.js

打开 themes\shoka\source\js\_app\page.js ，找到 const postFancybox = function(p) {} 中的 vendorCss 和 vendorJs （第 72~79 行左右），将其替换为

	const postFancybox = function(p) {
	if($(p + ' .md img')) {
	vendorCss('justifiedGallery');
	vendorJs('justifiedGallery');
	vendorCss('fancybox');
	vendorJs('jquery','fancybox', function() {
	// ...

# tab 标签卡的红色线条

tab 标签卡中的标签名称下方没有显示红色线条

为显示下画线，可按以下步骤修改：

打开 shoka\source\css\_common\components\tags\tabs.styl
删掉第 6 行的 overflow: hidden;

效果：

修改前：

	.nav {
	overflow: hidden;
	border-bottom: .0625rem solid var(--grey-1-a7);
	height: 2.6875rem;
	// ...
	}

修改后：

	.nav {
	border-bottom: .0625rem solid var(--grey-1-a7);
	height: 2.6875rem;
	// ...
	}

# 调整代码块的高度

修改代码块折叠的阈值为 10 （即，超过 10 行代码即进行折叠），并将代码块（不包括 figcaption）的高度调整为 200px

打开 themes\shoka\source\js\_app\page.js
将 code_container && code_container.find("tr").length > 15 中的 15 替换为 10
将 code_container.style.maxHeight = "300px"; 中的 "300px" 替换为 "200px"

Dijkstra

2022-10-14T03:28:41.000Z

Dijkstra 算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径

定义：

代价：F(n) = g(n)
g (n) ：从起点到节点 n 的代价（距离）
open list ：存放当前可到达、且未确定最小代价路径的节点
closed list ：存放已经找到最小代价路径的节点

流程：

从起点开始逐步扩展，每一步为一个节点找到代价最小的路径，即：
- 从 open list 选择代价最小的节点，将其收录到 closed list
- 遍历新收录节点的所有可访问邻节点，更新代价

最优性证明（为什么被收录的节点已经找到代价最小的路径？）：反证法

特性：

完备性：如果在起始点和目标点之间有路径解存在，就一定可以得到解；如果得不到解，就一定说明没有解存在
最优性：对于某个评价指标（一般为路径的长度），规划得到的路径是最优的

算法：

将起点放入 open list

执行循环：

- 如果 open list 为空：搜索失败，结束
- 取 open list 中代价（即，g(n)）最小的节点（记作 Node1），将其放入 closed list
- 如果节点 Node1 为终点：找到目标路径，结束
- 遍历节点 Node1 的（不在 closed list 中的）邻接节点
    - 记当前遍历的邻接节点为 Node2
    - 如果节点 Node2 在 open list 中：更新节点 Node2 的代价
    - 如果节点 Node2 在 open list 中：计算节点 Node2 的代价，并将其加入 open list

待循环结束，即得到从起点到终点的代价最小路径

# 朴素 Dijkstra

# 邻接矩阵法

采用邻接矩阵 edges 存储边的有关信息，其中，edges [i][j] 表示 i 到 j 的代价，若 edges [i][j] == INT_MAX ，则表示不存在由节点 i 指向节点 j 的边

	/*
	@param:
	edges: 邻接矩阵
	n: 节点数
	start: 起始点
	@return:
	起始点到其他点的最小代价
	*/
	vector<int> dijkstra(vector<vector<int>>& edges, int n, int start) {
	vector<int> dist(n, INT_MAX); //dist [i] 表示 start 到 i 的最小代价
	dist[start] = 0; //start 到自身的代价为 0
	vector<int> closedlist(n, 0); //closedlist [i] 表示 i 是否在 closed list 中

	for (int i = 0; i < n; ++i) { // 从起点开始逐步扩展，每一步为一个节点找到代价最小的路径
	int idx = 0; // 不在 closed list 中的、代价最小的节点
	for (int j = 0; j < n; ++j) {
	if (!closedlist[j] && dist[j] <= dist[idx]) {
	idx = j;
	}
	}
	closedlist[idx] = 1; // 将代价最小的节点 idx 添加到 closed list
	for (int j = 0; j < n; ++j) { // 更新 idx 邻居节点的代价
	if (!closedlist[j] && edges[idx][j] < INT_MAX) {
	dist[j] = min(dist[j], dist[idx] + edges[idx][j]);
	}
	}
	}

	return dist;
	}

# 邻接表法

采用链式前向星（用数组模拟实现的链表，也就是静态链表）作为邻接表

结构体数组 edges 存储所有边：edges [i] 表示第 i 条边

edges [i].to 表示第 i 条边的终点
edges [i].next 表示与第 i 条边同起点的下一条边的编号
edges [i].w 表示第 i 条边的权值

数组 head 存储顶点的第一条边：head [i] 表示以 i 为起点的第一条边（编号最大的边）的编号

	/*
	@param:
	edges: 静态链表
	head: 节点数组
	n: 节点数
	start: 起始点
	@return:
	起始点到其他点的最小代价
	*/
	vector<int> dijkstra(Edge& edges[], vector<int>& head, int n, int start) {
	vector<int> dist(n, INT_MAX);
	dist[start] = 0;
	vector<int> closedlist(n, 0);

	for (int i = 0; i < n; ++i) {
	int idx = 0;
	for (int j = 0; j < n; ++j) {
	if (!closedlist[j] && dist[j] <= dist[idx]) {
	idx = j;
	}
	}
	closedlist[idx] = 1;
	for (int j = head[idx]; j != -1; j = edges[j].next) { // 遍历链式前向星
	dist[edges[j].to] = min(dist[edges[j].to], dist[idx] + edges[j].w);
	}
	}

	return dist;
	}

# 堆优化 Dijkstra

可以使用堆（优先级队列）来查找 open list 中的代价最小的节点 idx

定义一个小顶堆：由于 pair<typeA, typeB> 排序时会默认按照 typeA 排序，应将起点到节点的代价作为 typeA 、将节点的编号作为 typeB ，以便每次可以从堆中取出代价最小的节点

	typedef pair<int, int> pii; // 分别存储代价和节点编号
	priority_queue<pii, vector<pii>, greater<pii>> pq; // 小顶堆

priority_queue 位于 <queue> 头文件， pair 位于 <utility> 头文件

# 邻接矩阵法

当探索到一个代价最小的节点 idx 时，会遍历 idx 的邻居节点 i ，如果 dist [idx] + edges [idx][i] < dist [i] ，则需更新节点 i 的代价为 dist [idx] + edges [idx][i]

注意，即便堆中可能已经有 {xx, i} 存在，但由于无法对堆进行寻址访问，故而无法直接将堆中已有的 {xx, i} 更新为

因此，我们采用的策略是：

更新 dist [i] 为 dist [idx] + edges [idx][i]
将 {dist [i], i} 添加到堆（此时，{dist [i], i} 与 {xx, i} 都存在于堆中，但由于 dist [i] < xx ，{dist [i], i} 优先级高于 {xx, i}，因此该操作也等效于更新了堆中的 {xx, i} ）

	/*
	@param:
	edges: 邻接矩阵
	n: 节点数
	start: 起始点
	@return:
	起始点到其他点的最小代价
	*/
	vector<int> Dijkstra(vector<vector<int>>& edges, int n, int start) {
	vector<int> dist(n, INT_MAX);

	typedef pair<int, int> pii;
	priority_queue<pii, vector<pii>, greater<pii>> pq;

	dist[start] = 0;
	pq.emplace(make_pair(0, start));

	while (!pq.empty()) {
	int idx = pq.top().second;
	pq.pop();
	for (int i = 0; i < n; ++i) {
	if (edges[idx][i] < INT_MAX) {
	int cost = dist[idx] + edges[idx][i];
	if (cost < dist[i]) {
	dist[i] = cost; // 实时维护 dist 数组，记录当前搜索到的节点 i 的最小代价
	pq.emplace(make_pair(cost, i)); // 可能已经有 {val, i} 在堆中了，但是 val 必然大于 cost
	}
	}
	}
	}

	return dist;
	}

# 邻接表法

堆优化也可以采用链式前向星结构

	/*
	@param:
	edges: 静态链表
	head: 节点数组
	n: 节点数
	start: 起始点
	@return:
	起始点到其他点的最小代价
	*/
	vector<int> dijkstra(Edge& edges[], vector<int>& head, int n, int start) {
	vector<int> dist(n, INT_MAX);

	typedef pair<int, int> pii;
	priority_queue<pii, vector<pii>, greater<pii>> pq;

	dist[start] = 0;
	pq.emplace(make_pair(0, start));

	while (!pq.empty()) {
	int idx = pq.top().second;
	pq.pop();
	for (int i = head[idx]; i != -1; i = edges[i].next) {
	int cost = dist[idx] + edges[i].w;
	if (cost < dist[edges[i].to]) {
	dist[edges[i].to] = cost;
	pq.emplace(make_pair(cost, edges[i].to));
	}
	}
	}

	return dist;
	}

# 复杂度分析

设图中的节点数为 $n$ ，边数为 $m$ ，其中 $n \le m$

时间复杂度：

朴素 Dijkstra 算法： $O(n^2)$
堆优化的 Dijkstra 算法： $O((n + m) \log{n})$

空间复杂度：

邻接矩阵法： $O(n^2)$
邻接表法： $O(m)$

堆优化的时间复杂度优于朴素算法

邻接表法的空间复杂度优于邻接矩阵法

参考：

C++ 函数

2022-09-20T08:40:31.000Z

# 函数基础

典型的函数（function）定义包括以下部分：

返回类型（return type）
函数名字
由 0 个或多个形参（parameter）组成的列表，其中，形参以逗号隔开，形参的列表位于一对圆括号之内
函数体

例如：定义一个函数用于求数 n 的阶乘，其中，返回类型为 int 型，函数名字为 fact，形参为 int n，函数体为一对花括号 {} 内的语句

	int fact(int n) {
	int ret = 1;
	while (n > 1)
	ret *= n--;
	return ret;
	}

# 调用函数

通过 调用运算符（call operator）来执行函数

调用运算符的形式是一对圆括号，它作用于一个表达式，该表达式是函数或者指向函数的指针；圆括号之内是一个用逗号隔开的实参（argument）列表，我们用实参初始化函数的形参
调用表达式的类型就是函数的返回类型

函数的调用完成两项工作：

（隐式地）定义并用实参初始化函数对应的形参
将控制权转移给被调用函数

此时，主调函数（calling function）的执行被暂时中断，被调函数（called function）开始执行

当遇到一条 return 语句时，函数结束执行过程

return 语句也完成两项工作：

返回 return 语句中的值（如果有的话）
将控制权从被调函数转移回主调函数

# 形参和实参

实参是形参的初始值。第一个实参初始化第一个形参，第二个实参初始化第二个形参，以此类推

尽管实参与形参存在对应关系，但是并没有规定实参的求值顺序。编译器能以任意可行的顺序对实参求值

实参数量应与形参数量一致，并且，实参的类型必须与对应的形参类型匹配

# 函数的形参列表

函数的形参列表可以为空，但是不能省略

要想定义一个不带形参的函数，最常用的办法是书写一个空的形参列表
为了与 C 语言兼容，也可以使用关键字 void 表示函数没有形参

	void f1() { /* ... */ } // 隐式地定义空形参列表
	void f2(void) { /* ... */ } // 显式地定义空形参列表

形参列表中的形参通常用逗号隔开，其中，每个形参都是含有一个声明符的声明（即使两个形参的类型一样，也必须把两个类型都写出来）

	int f3(int v1, v2) { /* ... */ } // 错误
	int f4(int v1, int v2) { /* ... */ } // 正确

任意两个形参都不能同名，而且，函数最外层作用域中的局部变量也与函数形参同名

形参名是可选的。如果函数不会使用到个别形参，通常不命名该形参，以表示其不会在函数体内被使用

注意：即使某个形参不被函数使用，也必须为它提供一个实参

# 函数返回类型

大多数类型都能用作函数的返回类型

一种特殊的返回类型是 void ，它表示函数不返回任何值

函数的返回类型不能是数组类型或函数类型，但可以是指向数组或函数的指针

# 局部对象

在 C++ 语言中，名字有作用域，对象有生命周期（lifetime）

名字的作用域：程序文本的一部分，名字在其中可见
对象的生命周期：程序执行过程中该对象存在的一段时间

形参和函数体内部定义的变量统称为局部变量（local variable）。它们对函数而言是 “局部” 的，仅在函数的作用域内可见

Parameters and variables defined inside a function body are referred to as local variables. They are “local” to that function and hide declarations of the same name made in an outer scope.

在所有函数体之外定义的对象存在于程序的整个执行过程中。此类对象在程序启动时被创建，直到程序结束才会销毁

局部变量的生命周期依赖于定义的方式。对于普通局部变量对应的对象，当函数的控制路径经过变量定义语句时创建该对象，当到达定义所在的块末尾时销毁它

# 自动对象

只存在于块执行期间的对象被称为 自动对象（automatic object）

当块的执行结束后，块中创建的自动对象的值就变成未定义的了

形参就是一种自动对象：函数开始时为形参申请存储空间，因为形参定义在函数体作用域之内，所以一旦函数终止，形参也就被销毁

自动对象的初始化：

形参对应的自动对象：用传递给函数的实参初始化形参对应的自动对象
局部变量对应的自动对象：
- 如果变量定义本身含有初始值，就用这个初始值进行初始化
- 否则，如果变量定义本身不含初始值，执行默认初始化

内置类型的未初始化局部变量将产生未定义的值

# 局部静态对象

某些时候，有必要令局部变量的生命周期贯穿函数调用及之后的时间。此时，可以将局部变量定义成 static 类型

局部静态对象（local static object）在程序第一次经过对象定义语句时进行初始化，并且直到程序终止才被销毁。在此期间，即使对象所在的函数结束执行，也不会对它有影响

如果局部静态变量没有显式的初始值，它将执行值初始化，内置类型的局部静态变量初始化为 0

# 函数声明

类似于变量，函数只能定义一次，但可以声明多次

唯一的例外是，如果一个函数永远也不会被我们用到，那么它可以只有声明没有定义

函数的声明和函数的定义非常类似，唯一的区别是，函数声明无须函数体，用一个分号替代即可

	// 函数声明
	void print(vector<int>::const_iterator beg,
	vector<int>::const_iterator end);

函数的声明不包含函数体，所以也就无须形参的名字（事实上，在函数的声明中经常省略形参的名字）

函数的三要素（返回类型、函数名、形参类型）描述了函数的接口，说明了调用该函数所需的全部信息

函数声明也称作函数原型（function prototype）

# 在头文件中进行函数声明

类似于变量，函数也应该在头文件中声明而在源文件中定义

允许把函数的声明直接放在使用该函数的源文件中，但是这么做可能会很烦琐而且容易出错。相反，如果把函数声明放在头文件中，就能确保同一函数的所有声明保持一致。而且，一旦我们想改变函数的接口，只需改变一条声明即可

含有函数声明的头文件应该被包含到定义函数的源文件中

# 分离式编译

为了允许编写程序时按照逻辑关系将其划分开来，C++ 语言支持所谓的分离式编译（separate compilation）

分离式编译允许我们把程序分割到几个文件中去，每个文件独立编译

如果我们修改了其中一个源文件，那么只需重新编译那个改动了的文件

大多数编译器提供了分离式编译每个文件的机制，这一过程通常会产生一个后缀名是 .obj（Windows）或 .o（UNIX）的文件（该文件包含对象代码（object code））

# 参数传递

每次调用函数时都会重新创建它的形参，并用传入的实参对形参进行初始化

当形参是引用类型时，它将绑定到对应的实参上。此时，我们说它对应的实参被 引用传递（passed by reference）或者函数被 传引用调用（called by reference）
当实参的值被拷贝给形参时，形参和实参是两个相互独立的对象。我们说这样的实参被 值传递（passed by value）或者函数被 传值调用（called by value）

# 传值参数

函数对形参做的所有操作都不会影响实参

	int fact(int val) {
	int ret = 1;
	while (val) {
	ret *= val--;
	}
	return ret;
	}

# 指针形参

可以将指针作为函数的形参

调用函数时，会将指针实参拷贝给形参（形参和实参是两个相互独立的对象）
由于形参和实参具有相同的值，可以通过形参间接地访问实参所指的对象，并且可以可以修改它所指对象的值
改变形参并不会影响实参

	// 该函数接受一个指针，然后将指针所指的值置 0
	void reset(int *ip) { // 指针形参
	*ip = 0; // 改变指针 ip 所指对象的值
	ip = 0; // 只改变了 ip 的局部拷贝，实参并未被改变
	}

熟悉 C 的程序员常常使用指针类型的形参访问函数外部的对象。在 C++ 语言中，建议使用引用类型的形参替代指针

# 传引用参数

引用形参绑定到对应的实参上

	// 该函数接受一个 int 对象的引用，然后将对象的值置为 0
	void reset(int &i) { //i 是传给 reset 函数的对象的另一个名字
	i = 0; // 改变了 i 所引对象的值
	}

# 使用引用避免拷贝

拷贝大的类类型对象或者容器对象是比较低效的，此时可以通过引用传入参数

	// 比较两个 string 对象的长度
	bool isShorter(const string &s1, const string &s2) {
	return s1.size() < s2.size();
	}

甚至，有的类类型（包括 IO 类型在内）根本就不支持拷贝操作。此时，函数只能通过引用形参访问该类型的对象

如果函数无须改变引用形参的值，最好将其声明为常量引用

# 使用引用形参返回额外信息

一个函数只能返回一个值，然而有时函数需要同时返回多个值，因此可以考虑通过引用形参获取多个结果

	// 返回 s 中 c 第一次出现的位置索引
	// 引用形参 occurs 负责统计 c 出现的总次数
	string::size_type find_char(const string &s, char c,
	string::size_type &occurs) {
	auto ret = s.size(); // 第一次出现的位置（如果有的话）
	occurs = 0; // 出现次数置 0
	for (decltype(ret) i = 0; i != s.size(); ++i) {
	if (s[i] == c) {
	if (ret == s.size())
	ret = i; // 记录 c 第一次出现的位置
	++occurs; // 更新出现次数
	}
	}
	return ret; //c 出现次数通过 occurs 隐式地返回
	}

# const 形参和实参

在用实参初始化形参时，会忽略掉形参的顶层 const

换而言之，当形参具有顶层 const 时，传给它常量对象或者非常量对象都是可以的（可参考 const 限定符）

	void fcn (const int i) {
	/* fcn 可以读取 i ，但不能向 i 写值 */
	}

调用 fcn 函数时，既可以传入 const int ，也可以传入 int

在 C++ 语言中，允许我们定义若干具有相同名字的函数，不过前提是不同函数的形参列表应该有明显的区别，例如：

	void helper (string &s, int start) { /* 第一个 helper 函数 */ };
	void helper (int n) { /* 第二个 helper 函数 */ };

然而，由于形参的顶层 const 会被忽略，以下两个同名函数不能同时定义

	void fcn (const int i) { /* */ };
	void fcn (int i) { /* */ }; // 错误：重复定义了 fcn (int)

因为顶层 const 被忽略掉了，所以在上面的代码中传入两个 fcn 函数的参数可以完全一样，因此第二个 fcn 是错误的

# const 与指针或引用形参

形参的初始化方式和变量的初始化方式是一样的：

可以使用非常量来初始化一个底层 const 对象，但是反过来不行
一个引用必须用同类型的对象初始化

变量初始化：

	int i = 42;
	const int *cp = &i; // 正确：但是不能通过 cp 改变 i
	const int &r = i; // 正确：但是不能通过 r 改变 i
	const int &r2 = 42; // 正确
	int *p = cp; // 错误：p 的类型和 cp 的类型不匹配（存在通过 p 改变 cp 所指对象的风险）
	int &r3 = r; // 错误：r3 的类型和 r 的类型不匹配（存在通过 r3 改变 r 所引对象的风险）
	int &r4 = 42; // 错误：不能用字面值初始化一个非常量引用

参数传递：

	int i = 0;
	const int ci = i;
	string::size_type ctr = 0;
	reset(&i); // 调用形参类型是 int * 的 reset 函数
	reset(&ci); // 错误：不能用指向 const int 对象的指针初始化 int * 形参
	reset(i); // 调用形参类型是 int & 的 reset 函数
	reset(ci); // 错误：不能将普通引用绑定到 const 对象 ci 上
	reset(42); // 错误：不能将葡萄引用绑定到字面值上
	reset(ctr); // 错误：类型不匹配，ctr 是无符号类型
	find_char("Hello World!", 'o', ctr); // 正确：find_char 的第一个形参是对常量的引用

要想调用引用版本的 reset ，只能使用 int 类型的对象，而不能使用字面值、求值结果为 int 的表达式、需要转换的对象或者 const int 类型的对象。类似的，要想调用指针版本的 reset，只能使用 int* 类型的对象

我们能传递一个字符串字面值作为 find_char 的第一个实参，这是因为该函数的引用形参是常量引用，而 C++ 允许我们用字面值初始化常量引用

# 尽量使用常量引用

将函数不会改变的形参定义成（普通的）引用是一种比较常见的错误，这么做会给函数的调用者造成误导，即，函数可以修改它的实参的值

此外，使用引用而非常量引用也会极大地限制函数所能接受的实参类型。例如，我们不能把 const 对象、字面值或者需要类型转换的对象传递给普通的引用形参

# 数组形参

数组无法直接通过数组名进行拷贝，因此，无法以值传递的方式使用数组参数

由于数组（通常）会被转换成指针，当我们为一个函数传递一个数组时，实际上传递的是指向数组首元素的指针

尽管不能以值传递的方式传递数组，但是我们可以把形参写成类似数组的形式：

	// 尽管表现形式不同，但这三个 print 函数是等价的
	// 每个函数都有一个 const int* 类型的形参
	void print (const int*)
	void print (const int []) // 函数的意图是作用于一个数组
	void print (const int [10]) // 这里的维度表示我们期望的数组维度，实际不一定是这个维度

当编译器处理对 print 函数的调用时，只检查传入的参数是否是 const int* 类型

	int i = 0, j[2] = {0, 1};
	print(&i); // 正确：&i 的类型是 int*
	print(j); // 正确：j 转换成 int* 并指向 j [0]

如果我们传给 print 函数的是一个数组，则实参自动地转换成指向数组首元素的指针。其中，数组的大小对函数的调用没有影响

以数组作为形参的函数必须确保使用数组时不会越界

# 数组指针形参

因为数组是以指针的形式传递给函数的，所以一开始函数并不知道数组的确切尺寸，调用者应该为此提供一些额外的信息

管理指针形参有三种常用的技术：

使用标记指定数组长度
使用标准库规范
显式传递一个表示数组大小的形参

# 使用标记指定数组长度

要求数组本身包含一个结束标记
这种方法适用于那些有明显结束标记且该标记不会与普通数据混淆的情况
典型示例：C 风格字符串，C 风格字符串存储在字符数组中，并且在最后一个字符后面跟着一个空字符

	// 遇到空字符停止
	void print(const char *cp) {
	if (cp) // 若 cp 不是一个空指针
	while (*cp) // 只要指针所指的字符不是空字符
	cout << *cp++; // 输出当前字符并将指针向前移动一个位置
	}

# 使用标准库规范

传递指向数组首元素和尾后元素的指针

	void print(const int beg, const int end) { // 传入两个指针：一个指向首元素，另一个指向尾元素的下一位置
	// 输出 beg 到 end 之间（不含 end ）的所有元素
	while (beg != end)
	cout << *beg++ << endl; // 输出当前元素并将指针向前移动一个位置
	}

	int j[2] = {0, 1};
	print(begin(j), end(j)); //begin 和 end 函数，分别得到指向数组 j 的首元素和尾后元素的指针

# 显式传递一个表示数组大小的形参

即，专门定义一个形参表示数组大小

	//const int ia [] 等价于 const int* ia
	//size 表示数组的大小，将它显式地传给函数，用于控制对 ia 的访问
	void print(const int ia[], size_t size) {
	for (size_t i = 0; i != size; ++i) {
	cout << ia[i] << endl;
	}
	}

	int j[] = {0, 1, 2}; // 大小为 3 的整型数组
	print(j, end(j) - begin(j));

正如之前所说，当函数不需要对数组元素执行写操作的时候，数组形参应该是指向 const 的指针（即，常量指针）。只有当函数确实要改变元素值的时候，才把形参定义成指向非常量的指针

# 数组引用形参

C++ 允许将变量定义成数组的引用（详见数组），同样地，也允许将形参定义成数组的引用，此时，引用形参绑定到对应的数组上

	// 正确：形参是数组的引用，维度是类型的一部分
	void print(int (&arr)[10]) {
	for (auto elem : arr)
	cout << elem << endl;
	}

注意， &arr 两端的括号必不可少：

	f(int &arr [10]) // 错误：将 arr 声明成了引用的数组
	f(int (&arr) [10]) // 正确：arr 是具有 10 个整数的整型数组的引用

数组大小是构成数组类型的一部分，只要不超过维度，就可以在函数体内放心地使用数组

然而，这一用法也在无形中限制了 print 函数的可用性，即，只能将函数作用于大小为 10 的数组：

	int i = 0, j[2] = {0, 1};
	int k[10] = {0,1,2,3,4,5,6,7,8,9};
	print(&i); // 错误：实参不是含有 10 个整数的数组
	print(j); // 错误：实参不是含有 10 个整数的数组
	print(k); // 正确：实参是含有 10 个整数的数组

# 传递多维数组

将多维数组传递给函数时，真正传递的是指向数组首元素的指针

因为我们处理的是数组的数组，首元素本身就是一个数组，数组第二维（以及后面所有维度）的大小都是数组类型的一部分，不能省略

//matrix 指向数组的首元素，该数组的元素是由 10 个整数构成的数组

void print(int (*matrix) [10], int rowSize) { /* ... */ } //matrix 是一个指向含有 10 个整数的数组的指针

注意， *matrix 两端的括号必不可少

	int *matrix[10]; // 10 个指针构成的数组
	int (*matrix)[10]; // 指向含有 10 个整数的数组的指针

我们也可以使用数组的语法定义函数（此时编译器会一如既往地忽略掉第一个维度，所以最好不要把它包括在形参列表内）

	//matrix 看似是一个二维数组，实则是指向含有 10 个整数的数组的指针
	void print(int matrix[][10], int rowSize) { /* ... */ }

# main: 处理命令行选项

到目前为止，我们定义的 main 函数都只有空形参列表：

int main() { ...}

然而，有时我们确实需要给 main 传递实参。一种常见的情况是，用户通过设置一组选项来确定函数所要执行的操作。例如，假定 main 函数位于可执行文件 prog 之内，我们可以向程序传递下面的选项：

prog -d -o ofile data0

这些命令行选项通过两个（可选的）形参传递给 main 函数：

int main(int argc, char *argv[]) { ... }

第二个形参 argv 是一个数组，它的元素是指向 C 风格字符串的指针；第一个形参 argc 表示数组中字符串的数量

因为第二个形参是数组，所以 main 函数也可以定义成：

int main(int argc, char **argv) { ... } //argv 执指向 char*

当实参传给 main 函数之后，argv 的第一个元素指向程序的名字或者一个空字符串，接下来的元素依次传递命令行提供的实参。最后一个指针之后的元素值保证为 0

以上面提供的命令行 prog -d -o ofile data0 为例，argc 等于 5，argv 包含如下 C 风格字符串

	argv[0] = "prog"; // 或者 argv [0] 也可以指向一个空字符串
	argv[1] = "-d";
	argv[2] = "-o";
	argv[3] = "ofile";
	argv[4] = "data0";
	argv[5] = 0;

当使用 argv 中的实参时，一定要记得可选的实参从 argv[1] 开始； argv[0] 保存程序的名字，而非用户输入

# 含有可变形参的函数

有时我们无法提前预知应该向函数传递几个实参。例如，我们想要编写代码输出程序产生的错误信息，此时最好用同一个函数实现该项功能，以便对所有错误的处理能够整齐划一。然而，错误信息的种类不同，所以调用错误输出函数时传递的实参也各不相同

为了编写能处理不同数量实参的函数，C++ 11 新标准提供了两种主要的方法：

如果所有的实参类型相同，可以传递一个名为 initializer_list 的标准库类型
如果实参的类型不同，我们可以编写一种特殊的函数，也就是所谓的可变参数模板

C++ 还有一种特殊的形参类型（即省略符），可以用它传递可变数量的实参（这种功能一般只用于与 C 函数交互的接口程序）

# initializer_list 形参

如果函数的实参数量未知、但是全部实参的类型都相同，我们可以使用 initializer_list 类型的形参

initializer_list 是一种标准库类型，用于表示某种特定类型的值的数组

initializer_list 类型定义在同名的头文件中

和 vector 一样，initializer_list 也是一种模板类型。定义 initializer_list 对象时，必须说明列表中所含元素的类型

	initializer_list<string> ls; //initializer_list 的元素类型是 string
	initializer_list<int> li; //initializer_list 的元素类型是 int

和 vector 不一样的是，initializer_list 对象中的元素永远是常量值，我们无法改变 initializer_list 对象中元素的值

我们使用如下的形式编写输出错误信息的函数，使其可以作用于可变数量的实参：

	void error_msg(initializer_list<string> il) {
	for (auto beg = il.begin(); beg != il.end(); ++beg)
	cout << *beg << " " ;
	cout << endl;
	}

其中，作用于 initializer_list 对象的 begin 和 end 操作类似于 vector 对应的成员

begin () 成员提供一个指向列表首元素的指针
end () 成员提供一个指向列表尾后元素的指针

initializer_list 包含 begin 和 end 成员，因此可以使用 范围 for 循环处理其中的元素

如果想向 initializer_list 形参中传递一个值的序列，则必须把序列放在一对花括号内

	//expected 和 actual 是 string 对象
	if (expected != actual)
	error_msg({"functionX", expected, actual});
	else
	error_msg({"functionX", "okay"});

含有 initializer_list 形参的函数也可以同时拥有其他形参。例如，调试系统可能有个名为 ErrCode 的类，用来表示不同类型的错误，因此我们可以改写之前的程序，使其包含一个 initializer_list 形参和一个 ErrCode 形参

	void error_msg(ErrCode e, initializer_list<string> il) {
	cout << e.msg() << ": ";
	for (const auto &elem : il)
	cout << elem << " " ;
	cout << endl;
	}

为了调用这个版本的 error_msg 函数，需要额外传递一个 ErrCode 实参

	if (expected != actual)
	error_msg(ErrCode(42), {"functionX", expected, actual});
	else
	error_msg(ErrCode(0), {"functionX", "okay"});

# 省略符形参

省略符形参是为了便于 C++ 程序访问某些（使用了名为 varargs 的 C 标准库功能的）C 代码而设置的

通常，省略符形参不应用于其他目的

省略符形参应该仅仅用于 C 和 C++ 通用的类型
特别应该注意的是，大多数类类型的对象在传递给省略符形参时都无法正确拷贝

省略符形参只能出现在形参列表的最后一个位置，它的形式无外乎以下两种:

	void foo(parm_list, ...);
	void foo(...);

第一种形式指定了 foo 函数的部分形参的类型，对应于这些形参的实参将会执行正常的类型检查

省略符形参所对应的实参无须类型检查

在第一种形式中，形参声明后面的逗号是可选的

# 返回类型和 return 语句

return 语句：终止当前正在执行的函数，并将控制权返回到调用该函数的地方

return 语句的两种形式：

	return; // 无返回值
	return expression; // 有返回值

# 无返回值函数

没有返回值的 return 语句只能用在返回类型是 void 的函数中

返回 void 的函数并不一定要有 return 语句，因为这类函数最后会隐式地执行 return

一个返回类型是 void 的函数也能使用 return 语句的第二种形式，不过此时 return 语句的 expression 必须是另一个返回 void 的函数

强行令 void 函数返回其他类型的表达式将产生编译错误

# 有返回值函数

只要函数的返回类型不是 void ，该函数内的每条 return 语句就必须返回一个值

return 语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换成函数的返回类型

# 值是如何被返回的

返回一个值的方式：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果

如果函数返回的类型是局部变量，则会返回该变量的副本

例如，书写一个返回类型是 string 的函数 make_plural，由于该函数的返回类型是 string ，返回值将被拷贝到调用点。即，该函数将返回 word 的副本或者一个未命名的临时 string 对象

	string make_plural(size_t ctr, const string &word, const string ending) {
	return (ctr > 1) ? word + ending : word;
	}

如果函数返回引用类型，则不需要拷贝其所引对象

例如：书写一个函数，其中形参和返回类型都是 const string 的引用，不管是调用函数还是返回结果都不会真正拷贝 string 对象

	// 挑出两个 string 对象中较短的那个，返回其引用
	const string &shorterString(const string &s1, const string &s2) {
	return s1.size() <= s2.size() ? s1 : s2;
	}

# 不要返回局部对象的引用或指针

函数完成后，它所占用的存储空间也随之被释放掉，因此，不要返回局部对象的引用或指针

	const string &manip() { // 严重错误：函数试图返回局部对象的引用
	string ret;
	if (!ret.empty())
	return ret; // 错误：返回局部对象的引用！
	else
	return "Empty"; // 错误："Empty" 是一个局部临时量
	}

# 返回类类型的函数和调用运算符

和其他运算符一样，调用运算符也有优先级和结合律

调用运算符的优先级与点运算符和箭头运算符相同，并且也符合左结合律

如果函数返回指针、引用或类的对象，我们就能使用函数调用的结果访问结果对象的成员

例如，我们可以通过如下形式得到较短 string 对象的长度：

	// 调用 string 对象的 size 成员，该 string 对象是由 shorterString 函数返回的
	auto sz = shorterString(s1, s2).size();

# 引用返回左值

函数的返回类型决定函数调用是否是左值：调用一个返回引用的函数将会得到左值，其他返回类型将得到右值

因此，可以像使用其他左值那样来使用返回引用的函数，特别是，可以给返回类型为非常量引用的函数的结果赋值

例如：

	char &get_val(string &str, string::size_type ix) {
	return str[ix]; //get_val 假定索引值是有效的
	}

	int main() {
	string s("a value");
	cout << s << endl; // 输出 a value
	get_val(s, 0) = 'A'; // 将 s [0] 的值改为 'A'
	cout << s << endl; // 输出 A value
	return 0;
	}

如果返回类型是常量引用，则不能给调用的结果赋值

shorterString("hi", "bye") = "X"; // 错误：返回值是个常量

# 列表初始化返回值

C++ 11 标准规定，函数可以返回花括号包围的值的列表，该列表用来初始化函数调用点处的临时量

如果列表为空，临时量执行值初始化
否则，返回的值由函数的返回类型决定

例如：定义一个返回 vector 对象的函数，其中，vector 对象用来存放表示错误信息的 string 对象

	vector<string> process() {
	// . . .
	//expected 和 actual 是 string 对象
	if (expected.empty())
	return {}; // 返回一个空 vector 对象
	else if (expected == actual)
	return {"functionX", "okay"}; // 返回列表初始化的 vector 对象
	else
	return {"functionX", expected, actual};
	}

如果函数返回的是内置类型，则花括号包围的列表最多包含一个值，而且该值所占空间不应该大于目标类型的空间

如果函数返回的是类类型，由类本身来定义如何使用初始值

# 主函数 main 的返回值

之前介绍过，如果函数的返回类型不是 void ，那么它必须返回一个值。但是这条规则有个例外：允许 main 函数没有 return 语句而直接结束

这是因为，如果控制到达了 main 函数的结尾处而且没有 return 语句，编译器将隐式地插入一条返回 0 的 return 语句

# 递归

如果一个函数调用了它自身，不管这种调用是直接的还是间接的，都称该函数为递归函数（recursive function）

	// 计算 val 的阶乘
	int factorial(int val) {
	if (val > 1)
	return factorial(val-1) * val;
	return 1;
	}

main 函数不能调用它自己

# 返回数组指针

因此数组不能被拷贝，所以函数不能返回数组。但是，函数可以返回数组的指针或者引用

从语法上来说，要想定义一个返回数组的指针或引用的函数比较烦琐，但是有一些方法可以简化这一任务，其中最直接的方法是使用 类型别名

例如：func 函数返回一个指向包含 10 个整数的数组的指针，其中，arrT 是含有 10 个整数的数组的别名

typedef int arrT[10]; //arrT 是一个类型别名，它表示的类型是含有 10 个整数的数组

using arrT = int[10]; //arrT 的等价声明

arrT* func(int i);    //func 返回一个指向含有 10 个整数的数组的指针

# 声明一个返回数组指针的函数

如果我们想定义一个返回数组指针的函数，并且不希望使用类型别名，则必须满足：

数组的维度跟在函数名字之后
函数的形参列表也跟在函数名字后面，并且形参列表应该先于数组的维度

因此，返回数组指针的函数形式如下所示：

Type (*function(parameter_list))[dimension]

其中，Type 表示元素的类型，dimension 表示数组的大小，(*function (parameter_list)) 两端的括号必须存在（如果没有这对括号，函数的返回类型将是指针的数组）

例如：

int (*func(int i))[10];

可以按照以下的顺序来逐层理解该声明的含义：・

func (int i) 表示调用 func 函数时需要一个 int 类型的实参
(*func (int i)) 意味着我们可以对函数调用的结果执行解引用操作
(*func (int i))[10] 表示解引用 func 的调用将得到一个大小为 10 的数组
int (*func (int i))[10] 表示数组中的元素是 int 类型

# 使用尾置返回类型

在 C++ 11 标准中还有一种可以简化上述 func 声明的方法，就是使用尾置返回类型（trailing return type）

任何函数的定义都能使用尾置返回，但是这种形式对于返回类型比较复杂的函数最有效，比如返回类型是数组的指针或者数组的引用

尾置返回类型跟在形参列表后面，并以一个 -> 符号开头。为了表示函数真正的返回类型跟在形参列表之后，我们在本应该出现返回类型的地方放置一个 auto

例如：

	//func 接受一个 int 类型的实参，返回一个指针，该指针指向含有 10 个整数的数组
	auto func(int i) -> int(*)[10];

因为我们把函数的返回类型放在了形参列表之后，所以可以清楚地看到 func 函数返回的是一个指针，并且该指针指向了含有 10 个整数的数组

# 使用 decltype

如果我们知道函数返回的指针将指向哪个数组，可以使用 decltype 关键字声明返回类型

例如，下面的函数返回一个指针，该指针根据参数 i 的不同指向两个已知数组中的某一个

	int odd[] = {1,3,5,7,9};
	int even[] = {0,2,4,6,8};
	// 返回一个指针，该指针指向含有 5 个整数的数组
	decltype(odd) *arrPtr(int i) {
	return (i % 2) ? &odd : &even; // 返回一个指向数组的指针
	}

arrPtr 使用关键字 decltype 表示它的返回类型是个指针，并且该指针所指对象的类型与 odd 一致。因为 odd 是数组，所以 arrPtr 返回一个指向含有 5 个整数的数组的指针

注意： decltype 并不负责把数组类型转换成对应的指针，所以 decltype 的结果是个数组，要想表示 arrPtr 返回指针还必须在函数声明时加一个 * 符号

# 函数重载

如果同一作用域内的几个函数名字相同但形参列表不同，我们称之为重载（overloaded）函数

例如：

	void print(const char *cp);
	void print(const int beg, const int end);
	void print(const int ia[], size_t size);

这些函数接受的形参类型不一样，但是执行的操作非常类似。当调用这些函数时，编译器会根据传递的实参类型推断想要的是哪个函数

	int j[2] = {0,1};
	print("Hello World"); // 调用 print (const char*)
	print(j, end(j) - begin(j)); // 调用 print (const int*, size_t)
	print(begin(j), end(j)); // 调用 print (const int, const int)

main 函数不能重载

# 重载函数的定义与调用

# 定义重载函数

重载的函数应该在形参数量或形参类型上有所不同

	// 定义一组函数，分别根据名字、电话、账号等信息查找记录
	Record lookup(const Account&); // 根据 Account 查找记录
	Record lookup(const Phone&); // 根据 Phone 查找记录
	Record lookup(const Name&); // 根据 Name 查找记录

	Account acct;
	Phone phone;
	Record r1 = lookup(acct); // 调用接受 Account 的版本
	Record r2 = lookup(phone); // 调用接受 Phone 的版本

不允许两个函数除了返回类型外其他所有要素都相同：假设有两个函数，它们的形参列表一样但是返回类型不同，则第二个函数的声明是错误的

	Record lookup(const Account&);
	bool lookup(const Account&); // 错误：与上一个函数相比只有返回类型不同

# 判断两个形参的类型是否相异

有时候两个形参列表看起来不一样，但实际上是相同的

	// 每一对声明都是同一个函数
	Record lookup(const Account &acct);
	Record lookup(const Account&); // 省略了形参的名字

	typedef Phone Telno;
	Record lookup(const Phone&);
	Record lookup(const Telno&); // Telno 和 Phone 的类型相同（Telno 是 Phone 的别名）

由于顶层 const 不影响传入函数的对象（详见 参数传递 ），一个拥有顶层 const 的形参无法和另一个没有顶层 const 的形参区分开来

	Record lookup(Phone);
	Record lookup(const Phone); // 重复声明了 Record lookup (Phone)

	Record lookup(Phone*);
	Record lookup(Phone* const); // 重复声明了 Record lookup (Phone*)

如果形参是某种类型的指针或引用，则可区分其指向的是常量对象还是非常量对象（此时考虑的是底层 const ），以实现函数重载

	// 对于接受引用或指针的函数而言，常量对象与非常量对象对应的形参不同
	// 定义了 4 个独立的重载函数
	Record lookup(Account&); // 函数作用于 Account 的引用
	Record lookup(const Account&); // 新函数，作用于 Account 的常量引用

	Record lookup(Account*); // 新函数，作用于 Account 的指针
	Record lookup(const Account*); // 新函数，作用于指向 Account 常量的指针

在上面的例子中，编译器可以通过实参是否是常量来推断应该调用哪个函数

因为 const 不能转换成其他类型，所以我们只能把 const 对象（或指向 const 的指针）传递给 const 形参
相反地，因为非常量可以转换成 const ，所以上面的 4 个函数都能作用于非常量对象或者指向非常量对象的指针
不过，当我们要传递一个非常量对象或者指向非常量对象的指针时，编译器会优先选用非常量版本的函数

# 建议：何时不应该重载函数

尽管函数重载能在一定程度上减轻我们为函数起名字、记名字的负担，但是最好只重载那些确实非常相似的操作

有些情况下，给函数起不同的名字能使得程序更易理解

例如，以下是几个负责移动屏幕光标的函数

	Screen& moveHome();
	Screen& moveAbs(int, int);
	Screen& moveRel(int, int, string direction);

乍看上去，似乎可以把这组函数统一命名为 move ，从而实现函数的重载。然而，重载之后这些函数失去了名字中本来拥有的信息（因为这些函数移动光标的具体方式各不相同）

一般来说，是否重载函数要看哪个更容易理解

# const_cast 和重载

const_cast 常常用于有函数重载的上下文中

考虑下面的 shorterString 函数，其参数和返回类型都是 const string 的引用，我们可以对两个非常量的 string 实参调用这个函数，但返回的仍然是 const string 的引用

	// 无论实参是常量还是非常量，返回类型都是 const string &
	const string &shorterString(const string &s1, const string &s2) { // 形参是 const string & 类型
	return s1.size() <= s2.size() ? s1 : s2;
	}

为了实现 “当实参不是常量时，得到的结果是一个普通的引用，即 string &”，可以使用 const_cast 定义一种新的 shorterString 函数：

	string &shorterString(string &s1, string &s2) { // 形参是 string & 类型
	auto &r = shorterString(const_cast<const string&>(s1),
	const_cast<const string&>(s2)); // 调用形参为 const string & 类型的 shorterString 函数
	return const_cast<string&>(r);
	}

在这个版本的函数中，首先将它的实参强制转换成对 const 的引用，然后调用了 shorterString 函数的 const 版本。const 版本返回对 const string 的引用，这个引用事实上绑定在了某个初始的非常量实参上。因此，我们可以再将其转换回一个普通的 string &

# 调用重载的函数

函数匹配（function matching）：把函数调用与一组重载函数中的某一个关联起来。具体而言，编译器首先将调用的实参与重载集合中每一个函数的形参进行比较，然后根据比较的结果决定到底调用哪个函数

函数匹配也叫做重载确定（overload resolution）

调用重载函数时，有三种可能的结果：

编译器找到一个与实参最佳匹配（best match）的函数，并生成调用该函数的代码
找不到任何一个函数与调用的实参匹配，此时编译器发出无匹配（no match）的错误信息
有多于一个函数可以匹配，但是每一个都不是明显的最佳选择。此时也将发生错误，称为二义性调用（ambiguous call）

# 重载与作用域

一般来说，将函数声明置于局部作用域内不是一个明智的选择。但是为了说明作用域和重载的相互关系，我们将暂时违反这一原则而使用局部函数声明

如果我们在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体

因此，在不同的作用域中，无法重载函数名

	string read();
	void print(const string &);
	void print(double); // 重载 print 函数
	void fooBar(int ival) {
	bool read = false; // 新作用域，隐藏了外层作用域中声明的 read
	string s = read(); // 错误：read 是一个布尔对象，而不是函数（因为外层的 read 函数被隐藏了）
	// 通常来说，在局部作用域中声明函数不是一个好的选择
	void print(int); // 新作用域，隐藏了外层作用域中的 print
	print("Value: "); // 错误：print (const string &) 被隐藏掉了
	print(ival); // 正确：当前 print (int) 可见
	print(3.14); // 正确：调用 print (int) （外层的 print (double) 被隐藏了）
	}

当我们调用 print 函数时，编译器首先寻找对该函数名的声明，找到的是接受 int 值的那个局部声明。一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体。剩下的工作就是检查函数调用是否有效了

在 C++ 语言中，名字查找发生在类型检查之前

第一个调用 print ("Value:") 传入一个字符串字面值，但是当前作用域内 print 函数唯一的声明要求参数是 int 类型，由于字符串字面值无法转换成 int 类型，这个调用是错误的（虽然外层作用域中的 print (const string&) 函数与本次调用匹配，但是它已经被隐藏掉了，根本不会被考虑）

假设我们把 print (int) 和其他 print 函数声明放在同一个作用域中，则它将成为另一种重载形式：

	void print(const string &);
	void print(double); //print 函数的重载形式
	void print(int); //print 函数的另一种重载形式
	void fooBar2(int ival) {
	print("Value: "); // 调用 print (const string &)
	print(ival); // 调用 print (int)
	print(3.14); // 调用 print (double)
	}

# 特殊用途语言特性

本节我们介绍函数相关的三种语言特性，这些特性对大多数程序都有用，它们分别是：默认实参、内联函数和 constexpr 函数，以及在程序调试过程中常用的一些功能

# 默认实参

有些函数的某个参数在大多数（但不是所有）调用中都被赋予了特定的值。此时，我们可以把这个特定值称为函数的默认实参（default argument）

默认实参作为形参的初始值出现在形参列表中

例如，我们使用 string 对象表示窗口的内容。一般情况下，我们希望该窗口的高、宽和背景字符都使用默认值，但是同时我们也应该允许用户为这几个参数自由指定与默认值不同的数值。因此，我们为每一个形参都提供了默认实参

	typedef string::size_type sz;
	string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');

我们可以为一个或多个形参定义默认值，不过需要注意的是，一旦某个形参被赋予了默认值，它后面的所有形参都必须有默认值

调用含有默认实参的函数时，可以包含该实参，也可以省略该实参

# 使用默认实参调用函数

如果我们想使用默认实参，只要在调用函数的时候省略该实参就可以了

函数调用时实参按其位置解析，默认实参负责填补函数调用缺少的尾部实参（靠右侧位置）

	string window;
	window = screen(); // 等价于 screen (24, 80, ' ')
	window = screen(66); // 等价于 screen (66, 80, ' ')
	window = screen(66, 256); // 等价于 screen (66, 256, ' ')
	window = screen(66, 256, '#'); // 等价于 screen (66, 256, '#')

要想覆盖 backgrnd 的默认值，必须为 ht 和 wid 提供实参

	window = screen(, , '?'); // 错误：只能省略尾部的实参
	window = screen('?'); // 调用 screen ('?', 80, ' ')
	//char 型的 '?' 可以转换成 string::size_type 类型的值 63

当设计含有默认实参的函数时，需要合理设置形参的顺序，尽量让不怎么使用默认值的形参出现在前面，让那些经常使用默认值的形参出现在后面

# 默认实参声明

对于函数的声明来说，通常的习惯是将其放在头文件中，并且一个函数只声明一次，但是多次声明同一个函数也是合法的

不过有一点需要注意，在给定的作用域中一个形参只能被赋予一次默认实参。换句话说，函数的后续声明只能为之前那些没有默认值的形参添加默认实参，而且该形参右侧的所有形参必须都有默认值

假如给定

	// 表示高度和宽度的形参没有默认值
	string screen(sz, sz, char = ' ');

我们就不能再修改一个已经存在的默认值

string screen(sz, sz, char = '*'); // 错误：重复赋予默认实参

但是可以按照如下形式添加默认实参

string screen(sz = 24, sz = 80, char); // 正确：添加默认实参

通常，应该在函数声明中指定默认实参，并将该声明放在合适的头文件中

# 默认实参初始值

除了局部变量不能作为默认实参外，只要表达式的类型能转换成形参所需的类型，该表达式就能作为默认实参

	//wd、def 和 ht 的声明必须出现在函数之外
	sz wd = 80;
	char def = ' ';
	sz ht();
	string screen(sz = ht(), sz = wd, char = def);

	string window = screen(); // 调用 screen (ht (), 80, ' ')

用作默认实参的名字（例如 ht () ）会在函数声明所在的作用域内解析，但是会在函数调用时才求值

	void f2() {
	def = '*'; // 改变了默认实参的值
	sz wd = 100; // 隐藏了外层定义的 wd ，但是没有改变默认值
	window = screen(); // 调用 screen (ht (), 80, '*')
	}

我们在函数 f2 内部改变了 def 的值，所以对 screen 的调用将会传递这个更新过的值。另一方面，虽然我们的函数还声明了一个局部变量用于隐藏外层的 wd ，但是该局部变量与传递给 screen 的默认实参没有任何关系

# 内联函数和 constexpr 函数

此前我们编写了一个函数 shroterString ，用于比较两个 string 形参的长度并返回长度较小的 string 的引用。将这种规模较小的操作定义成函数，具有以下优点：

便于阅读
可以确保行为的统一
如果我们需要修改计算过程，修改函数要比修改所有等价表达式更容易
可以被其他应用重复利用

然而，使用 shorterString 函数也存在一个潜在的缺点：调用函数一般比求等价表达式的值要慢一些

在大多数机器上，一次函数调用其实包含着一系列工作：

调用前要先保存寄存器，并在返回时恢复
可能需要拷贝实参
程序转向一个新的位置继续执行

# 内联函数可以避免函数调用的开销

将函数指定为内联函数（inline），通常就是将它在每个调用点上 “内联地” 展开

假设我们把 shorterString 函数定义成内联函数，则如下调用

cout << shorterString(s1, s2) << endl;

将在编译过程中展开成类似于下面的形式

cout << (s1.size() < s2.size() ? s1 : s2) << endl;

从而消除了 shorterString 函数的运行时开销

在函数返回类型的前面加上加上关键字 inline ，即可将其声明为内联函数

	// 内联版本：寻找两个 string 对象中较短的那个
	inline const string & shorterString(const string &s1, const string &s2) {
	return s1.size() <= s2.size() ? s1 : s2;
	}

内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求

一般来说，内联机制用于优化规模较小、流程直接、频繁调用的函数

很多编译器都不支持内联递归函数，而且，一个太长的函数也不太可能在调用点 “内联地” 展开

# constexpr 函数

constexpr 函数（constexpr function）是指能用于常量表达式的函数

constexpr 函数的定义：

函数的返回类型及所有形参的类型都必须是字面值类型
函数体中必须有且只有一条 return 语句

	constexpr int new_sz() { return 42; }
	constexpr int foo = new_sz(); // 正确：foo 是一个常量表达式

在上面的代码中，我们把 new_sz 定义成一个无参数的 constexpr 函数，于是，new_sz 函数返回的是常量表达式，因此可以用 new_sz 函数来初始化 constexpr 类型的变量 foo

执行该初始化任务时，编译器把对 constexpr 函数的调用替换成其结果值。为了能在编译过程中随时展开，constexpr 函数被隐式地指定为内联函数

constexpr 函数体内也可以包含其他语句，只要这些语句在运行时不执行任何操作就行。例如，constexpr 函数中可以有空语句、类型别名以及 using 声明

constexpr 函数的返回值可以不是一个常量

例如：定义一个 constexpr 函数 scale 。当我们给 scale 函数传入一个形如字面值 2 的常量表达式时，它的返回类型也是常量表达式，此时，编译器用相应的结果值替换对 scale 函数的调用。相反，如果我们用一个非常量表达式调用 scale 函数，比如 int 类型的对象 i ，则返回值是一个非常量表达式

	// 如果 arg 是常量表达式，则 scale (arg) 也是常量表达式
	constexpr size_t scale(size_t cnt) { return new_sz() * cnt; }

	// 当 scale 的实参是常量表达式时，它的返回值也是常量表达式；反之则不是
	int arr[scale(2)]; // 正确：scale (2) 是常量表达式
	int i = 2; //i 不是常量表达式
	int a2[scale(i)]; // 错误：scale (i) 不是常量表达式

当把 scale 函数用在需要常量表达式的上下文中时，编译器会负责检查函数的结果是否符合要求。如果结果恰好不是常量表达式，编译器将发出错误信息

constexpr 函数不一定返回常量表达式

# 把内联函数和 constexpr 函数放在头文件内

和其他函数不一样，内联函数和 constexpr 函数可以在程序中多次定义

不过，对于某个给定的内联函数或者 constexpr 函数来说，它的多个定义必须完全一致

因此，内联函数和 constexpr 函数通常定义在头文件中

# 调试帮助

C++ 程序员有时会用到一种类似于 头文件保护 的技术，以便有选择地执行调试代码

基本思想：程序可以包含一些用于调试的代码，这些代码只在开发程序时使用。当应用程序编写完成准备发布时，要先屏蔽掉调试代码

这种方法用到两项预处理功能： assert 和 NDEBUG

# assert 预处理宏

assert 是一种预处理宏（preprocessor marco）

预处理宏是一个行为类似于内联函数的预处理变量

assert 宏使用一个表达式作为它的条件：

assert(expr);

其首先对 expr 求值，如果表达式为假（即，值为 0），assert 输出信息并终止程序的执行。如果表达式为真（即，值不为 0），assert 什么也不做

assert 宏定义在 cassert 头文件中，即：

#include<cassert>

预处理名字由预处理器而非编译器管理，因此我们可以直接使用预处理名字，即，直接使用 assert 而不是 std::assert，也不需要为 assert 提供 using 声明

和预处理变量一样，宏名字在程序内必须唯一。因此，含有 cassert 头文件的程序不能再定义名为 assert 的变量、函数或者其他实体

assert 宏常用于检查 “不能发生” 的条件

例如，一个对输入文本进行操作的程序，可能要求所有给定单词的长度都大于某个阈值

assert(word.size() > threshold);

# NDEBUG 预处理变量

NDEBUG 是一个预处理变量，表示当前不处于调试状态（not debug），可用于控制 assert 的行为：

如果没有定义 NDEBUG ，assert 将执行运行时检查
如果定义了 NDEBUG ，则 assert 什么也不做

默认状态下，没有定义 NDEBUG

我们可以使用一个 #define 语句定义 NDEBUG ，从而关闭调试状态

	#define NDEBUG // 关闭调试状态（必须定义在 cassert 头文件之前）
	#include <cassert>

	int main(void) {
	int x = 0;
	assert(x);
	}

定义 NDEBUG 能避免检查各种条件所需的运行时开销（其实根本就不会执行运行时检查），因此，assert 应该仅用于验证那些确实不可能发生的事情

我们可以把 assert 当成调试程序的一种辅助手段，但是不能用它替代真正的运行时逻辑检查，也不能替代程序本身应该包含的错误检查

除了用于 assert 外，也可以使用 NDEBUG 编写自己的条件调试代码（详见 预处理变量 ）

如果 NDEBUG 未定义，将执行 #ifndef 和 #endif 之间的代码
如果定义了 NDEBUG ，则会忽略 #ifndef 和 #endif 之间的代码

例如：

	void print(const int ia[], size_t size) {
	#ifndef NDEBUG
	//_ _func_ _ 是编译器定义的一个局部静态变量，用于存放函数的名字
	cerr << _ _func_ _ << ": array size is " << size << endl;
	#endif
	// ...

在这段代码中，我们使用变量 _ _func_ _ 输出当前调试的函数的名字（即 "print" ）

编译器为每个函数都定义了 _ _func_ _ ，它是 const char 的一个静态数组，用于存放函数的名字

除了 C++ 编译器定义的 _ _func_ _ 之外，预处理器还定义了另外 4 个用于程序调试的名字：

_ _FILE_ _ ：存放文件名的字符串字面值
_ _LINE_ _ ：存放当前行号的整型字面值
_ _LINE_ _ ：存放当前行号的整型字面值
_ _DATE_ _ ：存放文件编译日期的字符串字面值

可以使用这些常量在错误消息中提供更多信息，例如：

	if (word.size() < threshold)
	cerr << "Error: " << _ _FILE_ _
	<< " : in function " << _ _func_ _
	<< " at line " << _ _LINE_ _ << endl
	<< " Compiled on " << _ _DATE_ _
	<< " at " << _ _TIME_ _ << endl
	<< " Word read was \"" << word
	<< "\": Length too short" << endl;

如果我们给程序提供了一个长度小于 threshold 的 string 对象，将得到下面的错误消息：

Error:wdebug.cc : in function main at line 27
       Compiled on Jul 11 2012 at 20:50:03
       Word read was "foo": Length too short

# 函数匹配

当重载函数的形参数量相等、并且某些形参的类型可以由其他类型转换得到时，不太容易确定某次调用应该选用哪个重载函数

# 函数匹配

函数匹配：从一组重载函数中选取最佳函数的过程

# 函数匹配的步骤

选定本次调用对应的重载函数集

集合中的函数称为 候选函数（candidate function）
候选函数具备两个特征：
- 与被调用的函数同名
- 其声明在调用点可见

考察本次调用提供的实参，从候选函数中选出能被这组实参调用的函数

这些新选出的函数称为 可行函数（viable function）
可行函数具备两个特征：
- 形参数量与本次调用提供的实参数量相等（如果函数含有默认实参，在调用该函数时，传入的实参数量可能少于它实际使用的实参数量）
- 每个实参的类型与对应的形参类型相同，或者能转换成形参的类型
如果没找到可行函数，编译器将报告无匹配函数的错误

逐一检查函数调用提供的实参，寻找形参类型与实参类型最匹配的那个可行函数（即，寻找最佳匹配）

如果有且只有一个函数满足下列条件，则匹配成功：
- 该函数每个实参的匹配都不劣于其他可行函数需要的匹配
- 至少有一个实参的匹配优于其他可行函数提供的匹配
下一节将介绍到：实参类型与形参类型越接近，它们匹配得越好
如果在检查了所有实参之后没有任何一个函数脱颖而出，则该调用是错误的。此时，编译器将报告二义性调用的信息

调用重载函数时应尽量避免强制类型转换，如果在实际应用中确实需要强制类型转换，则说明我们设计的形参列表不合理

# 实例分析

以下面这组函数及其调用为例：

	void f();
	void f(int);
	void f(int, int);
	void f(double, double = 3.14);

	f(5.6); // 调用 f (double, double)

第一步：可以确定上述 4 个名为 f 的函数均为候选函数

第二步：可以根据实参的数量排除 void f () 和 void f (int, int) ，选出 void f (int) 和 void f (double, double = 3.14) 两个可行函数

排除的两个函数：我们的调用提供了一个实参，而 void f () 不使用形参，void f (int, int) 使用两个形参
可行的两个函数：void f (int) 使用一个 int 形参，而我们调用传入的 double 实参可以转换成形参类型 int ；void f (double, double = 3.14) 本应接受两个 double 实参，但因为它含有一个默认实参，所以可以只用一个实参来调用它

第三步：逐一考察实参，寻找最佳匹配

调用提供了一个（显式的）double 型实参，如果调用 f (int) ，实参将不得不从 double 转换成 int
相反，可行函数 void (double, double) 则与实参精确匹配
精确匹配比需要类型转换的匹配更好，因此，编译器把 f (5.6) 解析成对函数 void (double, double) 的调用，并使用默认值填补我们未提供的第二个实参

当实参的数量有两个或更多时，函数匹配就比较复杂了

例如，考察形如 f (42, 2.56) 的调用：

第一步：4 个名为 f 的函数均为候选函数

第二步：确定 void f (int, int) 和 void f (double, double) 为可行函数

第三步：逐一考察实参，寻找最佳匹配

考虑第一个实参 42 ：函数 f (int, int) 能精确匹配，而函数 f (double, double) 需要先将 int 类型实参转换成 double 类型。此时，函数 f (int, int) 优于函数 f (double, double)
接着考虑第二个实参 2.56 ：函数 f (double, double) 能精确匹配，而函数 f (int, int) 须将 2.56 从 double 类型转换成 int 型。此时，函数 f (double, double) 优于函数 f (int, int)
由于每个可行函数各自在一个实参上实现了更好的匹配，无法从整体上判断孰优孰劣。编译器最终将因为这个调用具有二义性而拒绝其请求

看起来我们似乎可以通过强制类型转换其中的一个实参来实现函数的匹配，但是在设计良好的系统中，不应该对实参进行强制类型转换

# 实参类型转换

为了确定最佳匹配，编译器将实参类型到形参类型的转换划分成几个等级，具体排序如下所示（越靠前的，匹配程度越好）：

精确匹配，其包括以下情况：
- 实参类型和形参类型相同
- 实参从数组类型或函数类型转换成对应的指针类型
- 向实参添加顶层 const 或者从实参中删除顶层 const
通过 const 转换实现的匹配
通过类型提升实现的匹配
通过算术类型转换或指针转换实现的匹配
通过类类型转换实现的匹配

# 需要类型提升和算术类型转换的匹配

小整型一般都会提升到 int 类型或更大的整数类型

例如，假设有两个函数，一个接受 int 、另一个接受 short ，则

只有当调用提供的是 short 类型的值时才会选择 short 版本的函数
有时候，即使实参是一个很小的整数值，也会直接将它提升成 int 类型，此时使用 short 版本反而会导致类型转换

	void ff(int);
	void ff(short);

	ff('a'); //char 提升成 int ，调用 f (int)

所有算术类型转换的级别都一样

例如，从 int 向 unsigned int 的转换并不比从 int 向 double 的转换级别高

	void manip(long);
	void manip(float);

	manip(3.14); // 错误：二义性调用

# 函数匹配和 const 实参

如果重载函数的区别仅在于函数的引用类型的形参是否为常量引用（或者，指针类型的形参是否为常量指针），编译器将通过实参是否为常量来决定选择哪个函数

When we call an overloaded function that differs on whether a reference or pointer parameter refers or points to const, the compiler uses the constness of the argument to decide which function to call.

例如：

	Record lookup(Account&); // 函数的参数是 Account 的引用
	Record lookup(const Account&); // 函数的参数是 Account 的常量引用

	const Account a;
	Account b;
	lookup(a); // 调用 lookup (const Account&)
	lookup(b); // 调用 lookup (Account&)

第一个调用传入的是 const 对象 a ：因为不能把普通引用绑定到 const 对象上，唯一可行的函数是以常量引用作为形参的函数 lookup (const Account&) ，并且调用该函数与实参 a 精确匹配

第二个调用传入的是非常量对象 b ：对于该调用而言，两个函数都是可行的，因为 b 既可以用来初始化常量引用也可以用来初始化非常量引用。然而，用非常量对象来初始化常量引用需要类型转换，因此，应该选用非常量版本的函数 lookup (Account&)

指针类型的形参也是类似的：如果两个函数的唯一区别是指针形参指向常量或非常量，编译器通过实参是否为常量来决定选用哪个函数

如果实参是指向常量的指针，调用形参为 const* 的函数
如果实参是指向非常量的指针，调用形参是普通指针的函数

# 函数指针

函数指针（function pointer）指向的是函数而非对象

类似于其他指针，函数指针也指向一个特定的类型（即，函数的类型）

函数的类型由它的返回类型和形参类型共同决定，与函数名无关

A function pointer is just that—a pointer that denotes a function rather than an object. Like any other pointer, a function pointer points to a particular type. A function’s type is determined by its return type and the types of its parameters. The function’s name is not part of its type.

例如，以下函数的类型是 bool (const string &, const string &)

	// 比较两个 string 对象的长度
	bool lengthCompare(const string &, const string &);

要想声明一个可以指向该函数的指针，只需要用指针替换函数名即可：

	//pf 指向一个函数，该函数的参数是两个 const string 的引用，返回值是 bool 类型
	bool (*pf)(const string &, const string &);

针对 bool (*pf)(const string &, const string &) 的分析逻辑：

pf 前面有个 * ，表示 pf 是指针
右侧是形参列表，表示 pf 指向的是函数
再观察左侧，发现函数的返回类型是布尔值
因此，pf 就是一个指向函数的指针，其中该函数的参数是两个 const string 的引用，返回值是 bool 类型

*pf 两端的括号必不可少，如果不写这对括号（即： bool *pf(const string &, const string &); ），pf 将是一个返回类型为 bool * 的函数

# 使用函数指针

当我们把函数名作为一个值使用时，该函数自动地转换成指针

例如，按照如下形式我们可以将函数 lengthCompare 的地址赋给 pf

	pf = lengthCompare; //pf 指向名为 lengthCompare 的函数
	pf = &lengthCompare; // 等价的赋值语句（取地址符是可选的）

我们可以直接使用指向函数的指针来调用该函数，而无须提前解引用指针

	bool b1 = pf("hello", "goodbye"); // 调用 lengthCompare
	bool b2 = (*pf)("hello", "goodbye"); // 等价的调用
	bool b3 = lengthCompare("hello", "goodbye"); // 等价的调用

指向不同函数类型的指针是不可以转换的，但是，我们可以为函数指针赋一个 nullptr 或者值为 0 的整型常量表达式，表示该指针没有指向任何一个函数

There is no conversion between pointers to one function type and pointers to another function type. However, as usual, we can assign nullptr or a zero-valued integer constant expression to a function pointer to indicate that the pointer does not point to any function.

	bool (*pf)(const string &, const string &);
	string::size_type sumLength(const string&, const string&);
	bool cstringCompare(const char, const char);

	pf = 0; // 正确：pf 不指向任何函数
	pf = sumLength; // 错误：返回类型不匹配

	pf = cstringCompare; // 错误：形参类型不匹配
	pf = lengthCompare; // 正确：函数和指针的类型精确匹配

# 重载函数的指针

如果定义了指向重载函数的指针，编译器通过指针类型决定选用哪个函数，指针类型必须与重载函数中的某一个精确匹配

	void ff(int*);
	void ff(unsigned int);

	void (*pf1)(unsigned int) = ff; //pf1 指向 ff (unsigned)

	void (*pf2)(int) = ff; // 错误：没有任何一个 ff 与该形参列表匹配
	double (pf3)(int) = ff; // 错误：ff 和 pf3 的返回类型不匹配

# 函数指针形参

类似于数组，我们不能定义函数类型的形参，但是，可以将指向函数的指针作为形参

我们可以定义一个类似于函数类型的形参，它会自动地转换成指向函数的指针（类似于 数组形参 ）

	// 第三个形参是函数类型，它会自动地转换成指向函数的指针
	void useBigger(const string &s1, const string &s2,
	bool pf(const string &, const string &));

	// 等价的声明：显式地将形参定义成指向函数的指针
	void useBigger(const string &s1, const string &s2,
	bool (*pf)(const string &, const string &));

如果我们直接将函数作为实参使用，它会自动转换成指针

	// 自动将函数 lengthCompare 转换成指向该函数的指针
	useBigger(s1, s2, lengthCompare);

由于直接将函数指针类型作为形参（例如，useBigger 的声明语句中的第三个形参）会显得冗长，可以使用类型别名和 decltype 来简化函数指针的代码

例如：首先使用 typedef 和 decltype 来定义自己的函数类型和函数指针类型

	// Func 和 Func2 是函数类型
	typedef bool Func(const string&, const string&); // 函数类型
	typedef decltype(lengthCompare) Func2; // 函数类型的等价声明

	// FuncP 和 FuncP2 是指向函数的指针
	typedef bool (*FuncP)(const string &, const string&); // 函数指针类型
	typedef decltype(lengthCompare) *FuncP2; // 函数指针类型的等价声明

注意：decltype 返回的是函数类型，不会将函数类型自动转换成指针类型，所以需要再加上 * 才能得到指针

然后重新声明 useBigger 函数：

	//useBigger 的等价声明，其中使用了类型别名
	void useBigger(const string&, const string&, Func);
	void useBigger(const string&, const string&, FuncP2);

这两个声明语句声明的是同一个函数，在第一条语句中，编译器自动地将 Func 表示的函数类型转换成指针

# 返回指向函数的指针

类似于数组，我们不能返回一个函数，但是，可以返回指向函数类型的指针

由于编译器不会自动将函数返回类型当成对应的指针类型处理，我们必须显式地将返回类型写成指针形式

声明一个返回函数指针的函数，最直接的办法是（类似于 返回数组指针 ）：

int (*f1 (int)) (int* , int);

按照由内向外的顺序阅读这条声明语句：

f1 有形参列表，所以 f1 是一个函数
f1 前面有 * ，所以 f1 返回的是一个指针
进一步观察发现，指针所指向的类型为 int (int*, int) ，其包含形参列表，因此，该指针指向的是一个返回类型为 int 的函数

声明一个返回函数指针的函数，最简单的办法是使用类型别名：

	using F = int(int*, int); // F 是函数类型
	using PF = int()(int, int); // PF 是函数指针类型

必须时刻注意的是，和函数类型的形参不一样，返回类型不会自动地转换成指针，因此，我们必须显式地将返回类型指定为指针

PF f1(int); // 正确：PF 是指向函数的指针，f1 返回指向函数的指针

F f1(int);  // 错误：F 是函数类型，f1 不能返回一个函数

F *f1(int); // 正确：将函数返回类型显式地指定为指向函数的指针

此外，我们也可以使用尾置返回类型的方式来声明一个返回函数指针的函数（可参考 使用尾置返回类型 ）：

auto f1(int) -> int (*)(int*, int);

# 将 auto 和 decltype 用于函数指针类型

如果我们明确知道返回的函数是哪一个，可以使用 decltype 关键字将返回类型声明为函数指针类型

例如，假定有两个函数，它们的返回类型都是 string::size_type ，并且各有两个 const string& 类型的形参

	string::size_type sumLength(const string&, const string&);
	string::size_type largerLength(const string&, const string&);

此时，我们可以编写第三个函数，它接受一个 string 类型的参数，返回一个指针，该指针指向前两个函数中的某一个

	// 根据其形参的取值，getFcn 函数返回指向 sumLength 或者 largerLength 的指针
	decltype(sumLength) *getFcn(const string &);

注意： decltype 并不负责把函数类型转换成对应的指针，所以 decltype 的结果是个函数类型，因此，我们显式地加上 * 以表明我们需要返回指针而不是函数本身

# 术语表

二义性调用（ambiguous call） ：是一种编译时发生的错误。造成二义性调用的原因：在函数匹配时，两个或多个函数提供的匹配一样好，编译器找不到唯一的最佳匹配

实参（argument） ：函数调用时提供的值，用于初始化函数形参

Assert ：是一个预处理宏，作用于一条表示条件的表达式

当未定义预处理变量 NDEBUG 时，assert 对条件求值
如果 assert 的条件为假，输出一条错误信息并终止当前程序的执行

自动对象（automatic object） ：仅存在于函数执行过程中的对象

当程序的控制流经过此类对象的定义语句时，创建该对象
当到达了定义所在的块的末尾时，销毁该对象

最佳匹配（best match） ：从一组重载函数中为调用选出的一个函数。最佳匹配（如果存在的话）至少在一个实参上比其他所有可行函数更优，同时，在其他实参的匹配上不会更差

传引用调用（call by reference） ：对引用传递的函数的调用

传值调用（call by value） ：对值传递的函数的调用

候选函数（candidate function） ：解析某次函数调用时考虑的一组函数。候选函数的名字应该与函数调用使用的名字一致，并且在调用点候选函数的声明在作用域之内

constexpr ：可以返回常量表达式的函数。一个 constexpr 函数被隐式地声明成内联函数

默认实参（default argument） ：当调用缺少了某个实参时，为该实参指定的默认值

可执行文件（executable file） ；是操作系统能够执行的文件，包含着与程序有关的代码

函数（function） ：可调用的计算单元

函数体（function body） ：是一个块，用于定义函数所执行的操作

函数匹配（function matching） ：编译器解析重载函数调用的过程，在此过程中，实参与每个重载函数的形参列表逐一比较

函数原型（function prototype） ：函数的声明，包含函数名字、返回类型和形参类型。要想调用某函数，在调用点之前必须声明该函数的原型

隐藏名字（hidden name） ：某个作用域内声明的名字会隐藏掉外层作用域中声明的同名实体

initializer_list ：是一个标准类，表示的是一组花括号包围的类型相同的对象，对象之间以逗号隔开

内联函数（inline function） ：请求编译器在可能的情况下在调用点展开函数。内联函数可以避免常见的函数调用开销

链接（link） ：是一个编译过程，负责把若干对象文件链接起来形成可执行程序

局部静态对象（local static object） ：它的值在函数调用结束后仍然存在。在第一次使用局部静态对象前创建并初始化它，当程序结束时局部静态对象才被销毁

局部变量（local variable） ：定义在块中的变量

无匹配（no match） ：是一种编译时发生的错误，原因是在函数匹配过程中所有函数的形参都不能与调用提供的实参匹配

对象代码（object code） ：编译器将我们的源代码转换成对象代码格式

对象文件（object file） ：编译器根据给定的源文件生成的保存对象代码的文件。一个或多个对象文件经过链接生成可执行文件

对象生命周期（object lifetime） ：每个对象都有相应的生命周期

块内定义的非静态对象的生命周期从它的定义开始，到定义所在的块末尾为止
程序启动后创建全局对象
程序控制流经过局部静态对象的定义时创建该局部静态对象
当 main 函数结束时销毁全局对象和局部静态对象

重载确定（overload resolution） ：参见函数匹配

重载函数（overloaded function） ：函数名与其他函数相同的函数。多个重载函数必须在形参数量或形参类型上有所区别

形参（parameter） ：在函数的形参列表中声明的局部变量。用实参初始化形参

引用传递（pass by reference） ：描述如何将实参传递给引用类型的形参。引用形参和其他形式的引用工作机理类似，形参被绑定到相应的实参上

值传递（pass by value） ：描述如何将实参传递给非引用类型的形参。非引用类型的形参实际上是相应实参值的一个副本

预处理宏（preprocessor macro） ：类似于内联函数的一种预处理功能。除了 assert 之外，现代 C++ 程序很少再使用预处理宏了

递归循环（recursion loop） ：描述某个递归函数没有终止条件，因而不断调用自身直至耗尽程序栈空间的过程

递归函数（recursive function） ：直接或间接调用自身的函数

返回类型（return type） ：是函数声明的一部分，用于指定函数返回值的类型

分离式编译（separate compilation） ：把一个程序分割成多个独立源文件的能力

尾置返回类型（trailing return type） ：在参数列表后面指定的返回类型

可行函数（viable function） ：是候选函数的子集。可行函数能匹配本次调用，它的形参数量与调用提供的实参数量相等，并且每个实参类型都能转换成相应的形参类型

() 运算符（ () operator） ：调用运算符，用于执行某函数。括号前面是函数名或函数指针，括号内是以逗号隔开的实参列表（可能为空）

参考：C++ Primer 中文版（第 5 版）

C++ 语句

2022-09-12T02:23:26.000Z

# 语句与语句作用域

# 简单语句

表达式语句（expression statement）：执行表达式并丢弃掉求值结果

空语句（null statement）：空语句中只含有一个单独的分号

例如：

	// 重复读入数据直至到达文件末尾或某次输入的值等于 sought
	while (cin >> s && s != sought)
	; // 空语句

使用空语句时应该加上注释，从而令读这段代码的人知道该语句是有意省略的

别漏写分号，也别多写分号：

	ival = v1 + v2;; // 正确：第二个分号表示一条多余的空语句

	while (iter != svec.end()) ; //while 循环体是那条空语句（无休止循环）
	++iter; // 递增运算不输于循环的一部分

复合语句（compound statement）是指用花括号括起来的（可能为空的）语句和声明的序列，复合语句也被称作块（block）

一个块就是一个作用域，在块中引入的名字只能在块内部以及嵌套在块中的子块里访问

块不以分号作为结束

	while (val <= 10) {
	sum += val;
	++val;
	}

空块：是指内部没有任何语句的一对花括号。空块的作用等价于空语句

	while (cin >> s && s != sought)
	{ } // 空块

# 语句作用域

可以在 if 、switch 、while 和 for 语句的控制结构内定义变量。但是需要注意，定义在控制结构中的变量只在相应语句的内部可见，一旦语句结束，变量也就超出其作用范围了

	while (int i = get_num()) // 每次迭代时创建并初始化 i
	cout << i << endl;
	i = 0; // 错误：在循环外部无法访问 i

如果其他代码也需要访问控制变量，则变量必须定义在语句的外部

	// 寻找第一个负值元素
	auto beg = v.begin(); // 注意要初始化
	while (beg != v.end() && *beg >= 0)
	++beg;
	if (beg == v.end())
	// 此时我们知道 v 中的所有元素都大于等于 0

# 条件语句

C++ 语言提供了两种按条件执行的语句

if 语句：根据条件决定控制流
switch 语句：计算一个整型表达式的值，然后根据这个值从几条执行路径中选择一条

# if 语句

简单 if 语句的语法形式：

if (condition)
    statement

if else 语句的形式：

if (condition)
    statement
else
    statement2

如果 condition 为真，执行 statement 。当 statement 执行完成后，程序继续执行 if 语句后面的其他语句

如果 condition 为假，跳过 statement 。对于简单 if 语句来说，程序继续执行 if 语句后面的其他语句；对于 if else 语句来说，执行 statement2

注意：在这两个版本的 if 语句中，condition 都必须用圆括号包围起来

condition 可以是一个表达式，也可以是一个初始化了的变量声明。不管是表达式还是变量，其类型都必须能转换成布尔类型

# 嵌套 if 语句

例如：把数字形式表示的成绩转换成字母形式，并在合格的成绩后面添加一个加号或减号（如果成绩的末位是 8 或者 9 ，添加一个加号；如果末位是 0 、1 或 2 ，添加一个减号）

	vector<string> scores = {"F", "D", "C", "B", "A", "A++"};
	string lettergrade;
	if (grade < 60) // 成绩不合格，对应的字母是 F
	lettergrade = scores[0];
	else {
	lettergrade = scores[(grade - 50)/10]; // 获得字母形式的成绩
	if (grade != 100) // 只要不是 A++（100 分），就考虑添加加号或者减号
	if (grade % 10 > 7)
	lettergrade += '+'; // 末尾是 8 或者 9 的成绩添加一个加号
	else if (grade % 10 < 3)
	lettergrade += '-'; // 末尾是 0 、1 或者 2 的成绩添加一个减号
	}

注意使用花括号

# 悬垂 else

当一个 if 语句嵌套在另一个 if 语句内部时，很可能 if 分支会多于 else 分支。此时，我们怎么知道某个给定的 else 是和哪个 if 匹配呢？

这个问题通常称作 悬垂 else（dangling else）

C++ 规定 else 与离它最近的尚未匹配的 if 匹配

In C++, the ambiguity is resolved by specifying that each else is matched with the closest preceding unmatched if .

# 使用花括号控制执行路径

要想使 else 分支和外层的 if 语句匹配起来，可以在内层 if 语句的两端加上花括号，使其成为一个块

	// 末位是 8 或者 9 的成绩添加一个加号；如果末位是 0 、1 或 2 的成绩添加一个减号
	if (grade % 10 >= 3) {
	if (grade % 10 > 7)
	lettergrade += '+'; // 末尾是 8 或者 9 的成绩添加一个加号
	} else // 花括号强迫 else 与外层 if 匹配
	lettergrade += '-'; // 末位是 0 、1 或 2 的成绩添加一个减号

# switch 语句

switch 语句（switch statement）提供了一条便利的途径使得我们能够在若干固定选项中做出选择

例如，利用 switch 语句统计五个元音字母在文本中出现的次数

	// 为每个元音字母初始化其计数值
	unsigned aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0;
	char ch;
	while (cin >> ch) {
	// 如果 ch 是元音字母，将其对应的计数值加 1
	switch (ch) {
	case 'a':
	++aCnt;
	break;
	case 'e':
	++eCnt;
	break;
	case 'i':
	++iCnt;
	break;
	case 'o':
	++oCnt;
	break;
	case 'u':
	++uCnt;
	break;
	}
	}
	// 打印结果
	cout << "Number of vowel a: \t" << aCnt << '\n'
	<< "Number of vowel e: \t" << eCnt << '\n'
	<< "Number of vowel i: \t" << iCnt << '\n'
	<< "Number of vowel o: \t" << oCnt << '\n'
	<< "Number of vowel u: \t" << uCnt << endl;

switch 语句首先对括号里的表达式求值，该表达式（可以是一个初始化的变量声明）紧跟在关键字 switch 的后面。表达式的值转换成整数类型，然后与每个 case 标签的值比较

如果表达式和某个 case 标签的值匹配成功，程序从该标签之后的第一条语句开始执行，直到到达了 switch 的结尾或者是遇到一条 break 语句为止

break 语句的作用是中断当前的控制流。此例中，break 语句将控制权转移到 switch 语句外面

如果 switch 语句的表达式和所有 case 都没有匹配上，将直接跳转到 switch 结构之后的第一条语句

case 关键字和它对应的值一起被称为 case 标签（case label）

case 标签必须是整型常量表达式

	char ch = getVal();
	int ival = 42;
	switch(ch) {
	case 3.14: // 错误：case 标签不是一个整数
	case ival: // 错误：case 标签不是一个常量
	// ...

任何两个 case 标签的值不能相同，否则就会引发错误

default 也是一种特殊的 case 标签

# switch 内部的控制流

如果某个 case 标签匹配成功，将从该标签开始往后顺序执行所有 case 分支，除非程序显式地中断了这一过程，否则，执行到 switch 的结尾处才会停下来

要想避免执行后续 case 分支的代码，我们必须显式地告诉编译器终止执行过程。大多数情况下，在下一个 case 标签之前应该有一条 break 语句

然而，由于每个 case 标签只能对应一个值，有时候我们希望两个或更多个值共享同一组操作。此时，我们就故意省略掉 break 语句，使得程序能够连续执行若干个 case 标签

例如：统计所有元音字母出现的总次数

	unsigned vowelCnt = 0;
	// ...
	switch (ch) {
	case 'a':
	case 'e':
	case 'i':
	case 'o':
	case 'u':
	++vowelCnt;
	break;
	}

C++ 程序的形式比较自由，所以 case 标签之后不一定非得换行。把几个 case 标签写在一行里，强调这些 case 代表的是某个范围内的值

	switch (ch) {
	// 另一种合法的书写形式
	case 'a': case 'e': case 'i': case 'o': case 'u':
	++vowelCnt;
	break;
	}

一般不要省略 case 分支最后的 break 语句。如果没写 break 语句，最好加一段注释说清楚程序的逻辑

尽管 switch 语句不是非得在最后一个标签后面写上 break ，但是为了安全起见，最好这么做。因为这样的话，即使以后再增加新的 case 分支，也不用再在前面补充 break 语句了

# default 标签

如果没有任何一个 case 标签能匹配上 switch 表达式的值，程序将执行紧跟在 default 标签（default label）后面的语句

例如，可以增加一个计数值来统计非元音字母的数量

	switch (ch) {
	case 'a': case 'e': case 'i': case 'o': case 'u':
	++vowelCnt; // 元音字母的数量
	break;
	default:
	++otherCnt; // 非元音字母的数量
	break;
	}

即使不准备在 default 标签下做任何工作，定义一个 default 标签也是有用的。其目的在于告诉程序的读者，我们已经考虑到了默认的情况，只是目前什么也没做

标签不应该孤零零地出现，它后面必须跟一条语句或者另外一个 case 标签。如果 switch 结构以一个空的 default 标签作为结束，则该 default 标签后面必须跟一条空语句或一个空块

# 迭代语句

迭代语句通常称为循环，它重复执行操作直到满足某个条件才停下来

while 和 for 语句在执行循环体之前检查条件
do while 语句先执行循环体，然后再检查条件

# while 语句

只要条件为真，while 语句（while statement）就重复地执行循环体

语法形式为：

while (condition)
    statement

condition 不能为空，如果 condition 第一次求值就得 false ， statement 一次都不执行

condition 可以是一个表达式或者是一个带初始化的变量声明

定义在 while 条件部分或者 while 循环体内的变量，每次迭代都经历从创建到销毁的过程

当不确定到底要迭代多少次时，使用 while 循环比较合适

例如：

	vector<int> v;
	int i;
	// 重复读入数据，直至到达文件末尾或者遇到其他输入问题
	while (cin >> i)
	v.push_back(i);
	// 寻找第一个负值元素
	auto beg = v.begin();
	while (beg != v.end() && *beg >= 0)
	++beg;
	if (beg == v.end())
	// 此时我们知道 v 中的所有元素都大于等于 0

# 传统的 for 语句

for 语句的语法形式：

for (init-statement; condition; expression)
    statement

关键字 for 及括号里的部分称为 for 语句头

init-statement 必须是以下三种形式中的一种：声明语句、表达式语句或者空语句。因为这些语句都以分号作为结束，for 语句的语法形式也可以看作：

for (initializer; condition; expression)
    statement

其中：

init-statement 负责初始化一个值，这个值将随着循环的进行而改变
condition 作为循环控制的条件，只要 condition 为真，就执行一次 statement 。如果 condition 第一次的求值结果就是 false ，则 statement 一次也不会执行
expression 负责在每次循环迭代之后修改 init-statement 初始化的变量，这个变量正好就是 condition 检查的对象
statement 可以是一条单独的语句也可以是一条复合语句

for 语句头中定义的对象只在 for 循环体内可见

# for 语句头中的多重定义

init-statement 可以定义多个对象，但只能有一条声明语句，因此，所有变量的基础类型必须相同

例如：下列代码在 init-statement 里同时定义了索引 i 和循环控制变量 sz

	// 记录下 v 的大小，当到达原来的最后一个元素后结束循环
	for (decltype(v.size()) i = 0, sz = v.size(); i != sz; ++i)
	v.push_back(v[i]);

# 省略 for 语句头的某些部分

for 语句头能省略掉 init-statement 、condition 和 expression 中的任何一个（或者全部）

如果无须初始化，则我们可以使用一条空语句作为 init-statement ，例如

	auto beg = v.begin();
	for ( /* 空语句 /; beg != v.end() && beg >= 0; ++beg)
	; // 什么也不做

注意，分号必须保留，以表明我们省略掉了 init-statement 。说得更准确一点，分号表示的是一个空的 init-statement

省略 condition 的效果等价于在条件部分写了一个 true 。因为条件的值永远是 true ，所以在循环体内必须有语句负责退出循环，否则循环就会无休止地执行下去

	for (int i = 0; /* 条件为空 */ ; ++i) {
	// 对 i 进行处理，循环内部的代码必须能够终止迭代过程
	}

我们也能省略掉 for 语句头中的 expression ，但是在这样的循环中就要求条件部分或者循环体必须改变迭代变量的值

	vector<int> v;
	for (int i; cin >> i; /* 表达式为空 */ )
	v.push_back(i);

因为条件部分能改变 i 的值，所以这个循环无须表达式部分。其中，条件部分不断检查输入流的内容，只要读取完所有的输入或者遇到一个输入错误就终止循环

# 范围 for 语句

C++ 11 新标准引入了一种更简单的 for 语句，这种语句可以遍历容器或其他序列的所有元素

范围 for 语句（range for statement）的语法形式：

for (declaration : expression)
    statement

expression 表示的必须是一个序列，比如用花括号括起来的初始值列表、数组或者 vector 或 string 等类型的对象，这些类型的共同特点是拥有能返回迭代器的 begin 和 end 成员

declaration 定义一个变量，序列中的每个元素都得能转换成该变量的类型

确保类型相容最简单的办法是使用 auto 类型说明符
如果需要对序列中的元素执行写操作，循环变量必须声明成引用类型

每次迭代都会重新定义循环控制变量，并将其初始化成序列中的下一个值，之后才会执行 statement

statement 可以是一条单独的语句也可以是一个块

所有元素都处理完毕后循环终止

例如：把 vector 对象中的每个元素都翻倍

	vector<int> v = {0,1,2,3,4,5,6,7,8,9};
	// 范围变量必须是引用类型，这样才能对元素执行写操作
	for (auto &r : v) // 对于 v 中的每一个元素
	r *= 2; // 将 v 中每个元素的值翻倍

其等价于

	for (auto beg = v.begin(), end = v.end(); beg != end; ++beg) {
	auto &r = *beg;
	r *= 2;
	}

不能通过范围 for 语句增加 vector 对象（或者其他容器）的元素：因为在范围 for 语句中，预存了 end () 的值。一旦在序列中添加（删除）元素，end 函数的值就可能变得无效了

# do while 语句

do while 语句（do while statement）和 while 语句非常相似，唯一的区别是，do while 语句先执行循环体后检查条件

即，不管条件的值如何，do while 语句都至少执行一次循环

do while 语句的语法形式：

do
    statement
while (condition);

do while 语句应该在后面用一个分号表示语句结束

在 do while 语句中，首先执行一次 statement 然后才求 condition 的值（ condition 不能为空）。如果 condition 的值为假，循环终止；否则，重复循环过程

condition 使用的变量必须定义在循环体之外

例如，可以使用 do while 循环（不断地）执行加法运算

	// 不断提示用户输入一对数，然后求其和
	string rsp; // 作为循环的条件，不能定义在 do 的内部
	do {
	cout << "please enter two values: ";
	int val1 = 0, val2 = 0;
	cin >> val1 >> val2;
	cout << "The sum of " << val1 << " and " << val2
	<< " = " << val1 + val2 << "\n\n"
	<< "More? Enter yes or no: ";
	cin >> rsp;
	} while (!rsp.empty() && rsp[0] != 'n');

因为 do while 先执行语句（或者块）后判断条件，所以不允许在条件部分定义变量

	do {
	// . . .
	mumble(foo);
	} while (int foo = get_foo()); // 错误：将变量声明放在了 do while 的条件部分

# 跳转语句

跳转语句用于中断当前的执行过程

C++ 语言提供了 4 种跳转语句：

break
continue
goto
return

# break 语句

break 语句（break statement）负责终止离它最近的 while 、do while 、for 或 switch 语句，并从这些语句之后的第一条语句开始继续执行

break 语句只能出现在迭代语句或者 switch 语句内部（包括嵌套在此类循环里的语句或块的内部）。break 语句的作用范围仅限于最近的循环或者 switch

例如：

	string buf;
	while (cin >> buf && !buf.empty()) {
	switch(buf[0]) {
	case '-':
	// 处理到第一个空白为止
	for (auto it = buf.begin()+1; it != buf.end(); ++it) {
	if (*it == ' ')
	break; // #1，离开 for 循环
	// . . .
	}
	//break #1 将控制权转移到这里
	// 剩余的 '-' 处理
	break; // #2，离开 switch 语句
	case '+':
	// . . .
	} // 结束 switch
	//break #2 将控制权转移到这里
	} // 结束 while

标记为 #1 的 break 语句负责终止连字符 case 标签后面的 for 循环。它不但不会终止 switch 语句，甚至连当前的 case 分支也终止不了。接下来，程序继续执行 for 循环之后的第一条语句，这条语句可能接着处理连字符的情况，也可能是另一条用于终止当前分支的 break 语句

标记为 #2 的 break 语句负责终止 switch 语句，但是不能终止 while 循环。执行完这个 break 后，程序继续执行 while 的条件部分

# continue 语句

continue 语句（continue statement）终止最近的循环中的当前迭代并立即开始下一次迭代

continue 语句只能出现在 for 、while 和 do while 循环的内部，或者嵌套在此类循环里的语句或块的内部

和 break 语句类似的是，出现在嵌套循环中的 continue 语句也仅作用于离它最近的循环

和 break 语句不同的是，只有当 switch 语句嵌套在迭代语句内部时，才能在 switch 里使用 continue （即，continue 对循环起作用，而不对 switch 起作用）

continue 语句中断当前的迭代，但是仍然继续执行循环

对于 while 或者 do while 语句来说，继续判断条件的值
对于传统的 for 循环来说，继续执行 for 语句头的 expression
对于范围 for 语句来说，用序列中的下一个元素初始化循环控制变量

例如：从标准输入中读取单词并处理以下画线开头的单词

	string buf;
	while (cin >> buf && !buf.empty()) {
	if (buf[0] != '_')
	continue; // get another input
	// still here? the input starts with an underscore; process buf . . .
	}

# goto 语句

goto 语句（goto statement）的作用：从 goto 语句无条件跳转到同一函数内的另一条语句

不要在程序中使用 goto 语句，因为它使得程序既难理解又难修改

goto 语句的语法形式：

goto label;

其中，label 是用于标识一条语句的标示符

带标签语句（labeled statement）是一种特殊的语句，在它之前有一个标示符以及一个冒号，例如：

end: return; // 带标签语句，可以作为 goto 的目标

标签标示符独立于变量或其他标示符的名字，因此，标签标示符可以和程序中其他实体的标识符使用同一个名字而不会相互干扰

goto 语句和控制权转向的那条带标签的语句必须位于同一个函数之内

和 switch 语句类似，goto 语句也不能将程序的控制权从变量的作用域之外转移到作用域之内：

	// . . .
	goto end;
	int ix = 10; // 错误：goto 语句绕过了一个带初始化的变量定义
	end:
	// 错误：此处的代码需要 ix，但是 goto 语句绕过了它的声明
	ix = 42;

向后跳过一个已经执行的定义是合法的。跳回到变量定义之前意味着系统将销毁该变量，然后重新创建它。例如：

	// backward jump over an initialized variable definition is okay

	begin:
	int sz = get_size();
	if (sz <= 0) {
	goto begin;
	}

在上面的代码中，goto 语句执行后将销毁 sz 。因为跳回到 begin 的动作跨过了 sz 的定义语句，所以 sz 将重新定义并初始化

# try 语句块和异常处理

异常是指存在于运行时的反常行为，这些行为超出了函数正常功能的范围

典型的异常包括失去数据库连接以及遇到意外输入等

异常处理机制包括异常检测和异常处理两个部分

在 C++ 语言中，异常处理包括：

throw 表达式（throw expression）：异常检测部分使用 throw 表达式来表示它遇到了无法处理的问题。通常描述为：throw 引发（raise）了异常
try 语句块（try block）：异常处理部分使用 try 语句块处理异常
- try 语句块以关键字 try 开始，并以一个或多个 catch 子句（catch clause）结束
- try 语句块中代码抛出的异常通常会被某个 catch 子句处理。catch 子句通常也被称作 异常处理代码（exception handler）
一套 异常类（exception class）：用于在 throw 表达式和相关的 catch 子句之间传递异常的具体信息

# throw 表达式

throw 表达式包含关键字 throw 和紧随其后的一个表达式，其中表达式的类型就是抛出的异常类型

throw 表达式后面通常紧跟一个分号

例如：在执行两个 Sales_item 对象相加时，需要先检查它们是否是关于同一种书籍的

	Sales_item item1, item2;
	cin >> item1 >> item2;
	// 首先检查两条数据是否是关于同一种书籍的
	if (item1.isbn() != item2.isbn())
	throw runtime_error("Data must refer to same ISBN");
	// 如果程序执行到这里，则说明两个 ISBN 相同
	cout << item1 + item2 << endl;

在这段代码中，如果 ISBN 不一样，就会抛出一个异常（该异常是类型 runtime_error 的对象）

类型 runtime_error 是标准库异常类型的一种，定义在 stdexcept 头文件中

抛出异常将终止当前的函数，并把控制权转移给能处理该异常的代码

# try 语句块

try 语句块包括关键字 try 以及紧随其后的一个块（花括号括起来的语句序列），其通用语法形式为：

	try {
	program-statements
	} catch (exception-declaration) {
	handler-statements
	} catch (exception-declaration) {
	handler-statements
	} // ...

跟在 try 块之后的是一个或多个 catch 子句

catch 字句包括三部分：

关键字 catch
括号内一个（可能未命名的）对象的声明（称作异常声明，exception declaration）
一个块（用于处理异常）

当选中某个 catch 子句处理异常之后，就会执行与之对应的块

catch 一旦完成，程序将会跳转到 try 语句块对应的最后一个 catch 子句之后，以继续执行后续语句

try 语句块中的 program-statements 可以是任意 C++ 语句，包括声明在内的

try 语句块内声明的变量在块外部无法访问，特别是，在 catch 子句内也无法访问

# 编写 handler-statements

例如：可以将程序原本需要执行的任务放在 try 语句块中（这段代码可能会抛出一个 runtime_error 类型的异常），然后在 try 语句块之后跟一个 catch 字句（用于处理类型为 runtime_error 的异常）

	while (cin >> item1 >> item2) {
	try {
	if (item1.isbn() != item2.isbn())
	throw runtime_error("Data must refer to same ISBN");
	cout << item1 + item2 << endl;
	} catch (runtime_error err) { // 异常类型为 runtime_error ，异常命名为 err
	// 提醒用户两个 ISBN 必须一致，询问是否重新输入
	cout << err.what()
	<< "\nTry Again? Enter y or n" << endl;
	char c;
	cin >> c;
	if (!cin \|\| c == 'n')
	break; // 用户输入 'n'，跳出 while 循环
	// 否则，程序控制权跳回到 while 条件部分，准备下一次迭代
	}
	}

其中，what 是 runtime-error 类的一个成员函数，返回的是（初始化一个具体对象时所用的）string 对象的副本

在上例中，如果 try 语句块中抛出异常，catch 子句将会输出：

Data must refer to same ISBN
Try Again? Enter y or n

# 函数在寻找处理代码的过程中退出

程序在遇到抛出异常的代码前，可能已经经过了多个 try 语句块（例如，一个 try 语句块可能调用了包含另一个 try 语句块的函数）

此时，寻找异常处理代码的过程为：

当异常被抛出时，首先搜索抛出该异常的函数
如果没找到匹配的 catch 子句，则终止该函数，并在调用该函数的函数中继续寻找
以此类推，沿着程序的执行路径逐层回退，直到找到适当类型的 catch 子句为止

如果最终还是没能找到任何匹配的 catch 子句，程序将会转到名为 terminate 的标准库函数。该函数的行为与系统有关，一般情况下，执行该函数将导致程序非正常退出

如果一段程序没有 try 语句块且发生了异常，系统也会调用 terminate 函数并终止当前程序的执行

# 标准异常

C++ 标准库定义了一组类，用于报告标准库函数遇到的问题

C++ 定义了 4 个包含异常类的头文件：

exception 头文件定义了最通用的异常类 exception，它只报告异常的发生，不提供任何额外信息
stdexcept 头文件定义了几种常用的异常类（见表 5.1）
new 头文件定义了 bad_alloc 异常类型
type_info 头文件定义了 bad_cast 异常类型

标准库异常类只定义了以下几种运算：

创建或拷贝异常类型的对象
为异常类型的对象赋值

对于 exception 、bad_alloc 和 bad_cast 异常类型，只能以默认初始化的方式来初始化这些类型的对象，而不允许为这些对象提供初始值

对于其他异常类型，则应该使用 string 对象或者 C 风格字符串来初始化这些类型的对象，而不允许使用默认初始化的方式

当创建此类对象时，必须提供初始值，该初始值含有错误相关的信息

每个异常类型都只定义了一个名为 what 的成员函数：

what 函数没有任何参数，返回值是一个指向 C 风格字符串的 const char* （该字符串的目的是提供关于异常的一些文本信息）
what 函数返回的 C 风格字符串的内容与异常对象的类型有关：如果异常类型有一个字符串初始值，则 what 返回该字符串；对于其他无初始值的异常类型，what 返回的内容由编译器决定

# 术语表

块（block）：包围在花括号内的由 0 条或多条语句组成的序列。块也是一条语句，所以只要是能使用语句的地方，就可以使用块

break 语句（break statement）：终止离它最近的循环或 switch 语句。控制权转移到循环或 switch 之后的第一条语句

case 标签（case label）：在 switch 语句中紧跟在 case 关键字之后的常量表达式。在同一个 switch 语句中任意两个 case 标签的值不能相同

catch 子句（catch clause）：由 catch 关键字、括号里的异常声明以及语句块三部分组成。catch 子句的代码负责处理在异常声明中定义的异常

复合语句（compound statement）：块

continue 语句（continue statement）：终止离它最近的循环的当前迭代。控制权转移到 while 或 do while 语句的条件部分、或者范围 for 循环的下一次迭代、或者传统 for 循环头部的表达式

悬垂 else（dangling else）：是一个俗语，指的是如何处理嵌套 if 语句中 if 分支多于 else 分支的情况

C++ 语言规定，else 应该与前一个未匹配的 if 匹配在一起
使用花括号可以把位于内层的 if 语句隐藏起来，这样就能更好地控制 else 该与哪个 if 匹配

default 标签（default label）：是一种特殊的 case 标签，当 switch 表达式的值与所有 case 标签都无法匹配时，程序执行 default 标签下的内容

do while 语句（do while statement）：与 while 语句类似，但 do while 语句先执行循环体，再判断条件。循环体代码至少会执行一次

异常类（exception class）：标准库定义的一组类，用于表示程序发生的错误

异常声明（exception declaration）：位于 catch 子句中的声明，指定了该 catch 子句能处理的异常类型

异常处理代码（exception handler）：程序某处引发异常后，用于处理该异常的另一处代码。和 catch 子句是同义词

异常安全（exception safe）：是一个术语，表示的含义是当抛出异常后，程序能执行正确的行为

表达式语句（expression statement）：即一条表达式后面跟上一个分号，令表达式执行求值过程

控制流（flow of control）：程序的执行路径

for 语句（for statement）：提供迭代执行的迭代语句。常常用于遍历一个容器或者重复计算若干次

goto 语句（goto statement）：令控制权无条件转移到同一函数中一个指定的带标签语句。goto 语句容易造成程序的控制流混乱，应禁止使用

if else 语句（if else statement）：判断条件，根据其结果分别执行 if 分支或 else 分支的语句

if 语句（if statement）：判断条件，根据其结果有选择地执行语句。如果条件为真，执行 if 分支的代码；如果条件为假，控制权转移到 if 结构之后的第一条语句

带标签语句（labeled statement）：前面带有标签的语句。所谓标签是指一个标识符以及紧跟着的一个冒号。对于同一个标识符来说，用作标签的同时还能用于其他目的，互不干扰

空语句（null statement）：只含有一个分号的语句

引发（raise）：含义类似于 throw 。在 C++ 语言中既可以说抛出异常，也可以说引发异常

范围 for 语句（range for statement）：在一个序列中进行迭代的语句

switch 语句（switch statement）：一种条件语句

首先求 switch 关键字后面表达式的值
如果某个 case 标签的值与表达式的值相等，程序直接跨过之前的代码从这个 case 标签开始执行
当所有 case 标签都无法匹配时，如果有 default 标签，从 default 标签继续执行；如果没有，结束 switch 语句

terminate ：是一个标准库函数，当异常没有被捕捉到时调用。terminate 终止当前程序的执行

throw 表达式（throw expression）：一种中断当前执行路径的表达式。throw 表达式抛出一个异常并把控制权转移到能处理该异常的最近的 catch 子句

try 语句块（try block）：跟在 try 关键字后面的块，以及一个或多个 catch 子句。如果 try 语句块的代码引发异常并且其中一个 catch 子句匹配该异常类型，则异常被该 catch 子句处理。否则，异常将由外围 try 语句块处理，或者程序终止

while 语句（while statement）：只要指定的条件为真，就一直迭代执行目标语句

参考：C++ Primer 中文版（第 5 版）

常见输入输出

2022-09-09T09:08:49.000Z

# 场景一：多组空格分隔的两个正整数

输入描述：

输入包括两个正整数 a, b (1 <= a, b <= 1000)，输入数据包括多组

输出描述：

输出 a + b 的结果

数据范围：

数据组数 1 <= t <= 100

输入示例：

1 5
10 20

输出示例：

6
30

代码实现：

	#include <iostream>
	using namespace std;

	int main() {
	int a = 0, b = 0;
	while (cin >> a >> b) {
	cout << a + b << endl; // 64 位输出请用 printf ("% lld")
	}
	return 0;
	}

# 场景二：第一行组数接空格分隔的两个正整数

输入描述：

输入第一行包括一个数据组数 t (1 <= t <= 100)
接下来每行包括两个正整数 a, b (1 <= a, b <= 1000)

输出描述：

输出 a + b 的结果

数据范围：

数据组数 1 <= t <= 100

输入示例：

2
1 5
10 20

输出示例：

6
30

代码实现：

	#include <iostream>
	using namespace std;

	int main() {
	int t = 0;
	cin >> t;
	int a = 0, b = 0;
	for (int i = 0; i < t; ++i) {
	cin >> a >> b;
	cout << a + b << endl;
	}
	}

# 场景三：空格分隔的两个正整数以 0 0 结束

输入描述：

输入包括两个正整数 a, b (1 <= a, b <= 10^9)，输入数据有多组，如果输入为 0 0 则结束输入

输出描述：

输出 a + b 的结果

数据范围：

数据组数 1 <= t <= 100

输入示例：

1 5
10 20
0 0

输出示例：

6
30

代码实现：

	#include <iostream>
	using namespace std;

	int main() {
	int a = 0, b = 0;
	while (cin >> a >> b) {
	if (a == 0 && b == 0) break;
	cout << a + b << endl;
	}
	return 0;
	}

# 场景四：每行第一个为个数后带空格分割整数以 0 结束

输入描述：

输入数据有多组，每行表示一组输入数据
每行的第一个整数为整数的个数 n (1 <= n <= 100)
接下来 n 个正整数，即需要求和的每个正整数

输出描述：

每组数据输出求和的结果

数据范围：

数据组数 1 <= t <= 100
每组数据中整数个数满足 1 <= n <= 100
每组数据中的值满足 1 <= val <= 100

输入示例：

4 1 2 3 4
5 1 2 3 4 5

输出示例：

10
15

代码实现：

	#include <iostream>
	using namespace std;

	int main() {
	int n = 0;
	while (cin >> n) {
	if (n == 0) break;
	int sum = 0;
	int num = 0;
	for (int i = 0; i < n; ++i) {
	cin >> num;
	sum += num;
	}
	cout << sum << endl;
	}
	return 0;
	}

# 场景五：第一行组数接个数以及空格分隔的整数

输入描述：

输入的第一行包括一个正整数 t (1 <= t <= 100)，表示数据组数
接下来 t 行，每行一组数据
每行的第一个整数为整数的个数 n (1 <= n <= 100)
接下来 n 个正整数，即需要求和的每个正整数

输出描述：

每组数据输出求和的结果

数据范围：

数据组数 1 <= t <= 100
每组数据中整数个数满足 1 <= n <= 100
每组数据中的值满足 1 <= val <= 100

输入示例：

2
4 1 2 3 4
5 1 2 3 4 5

输出示例：

10
15

代码实现：

	#include <iostream>
	using namespace std;

	int main() {
	int t = 0;
	cin >> t;
	for (int i = 0; i < t; ++i) {
	int n = 0;
	cin >> n;
	int sum = 0;
	int num = 0;
	for (int j = 0; j < n; ++j) {
	cin >> num;
	sum += num;
	}
	cout << sum << endl;
	}
	return 0;
	}

# 场景六：多组未知数量的正整数

输入描述：

输入数据有多组，每行表示一组输入数据
每行不定有 n 个整数，空格隔开 (1 <= n <= 100)

输出描述：

每组数据输出求和的结果

输入示例：

1 2 3
4 5
0 0 0 0 0

输出示例：

6
9
0

代码实现：

	// 借助 stringstream，把每行数据输入到一个 string ，再转换成一个流
	#include <iostream>
	#include <string>
	#include <sstream>
	using namespace std;

	int main() {
	string str;
	while (getline(cin, str)) {
	stringstream ss(str); // 将字符串 str 拷贝至 stringstream 流
	int sum = 0;
	int num = 0;
	while (ss >> num) sum += num; // 等效于 while (getline (ss, t, ' ')) sum += stoi (t);
	cout << sum << endl;
	}
	return 0;
	}

其中， getline (istream& is, string& str, char delim) ：（参考：std::getline ）

Extracts characters from is and stores them into str until the delimitation character delim is found.
If the delimiter is found, it is extracted and discarded (i.e. it is not stored and the next input operation will begin after it).
Note that any content in str before the call is replaced by the newly extracted sequence.

getline (istream& is, string& str) ：Extracts characters from is and stores them into str until the newline character, '\n' , is found.

注意：如果在使用 getline() 函数之前已经使用过 cin ，则需使用 cin.get() （或者， cin.ignore() 或 getchar() ）读取缓冲区中的换行符 \n ，然后再使用 getline() （参考：C++ 中 cin 和 getline 使用出错的解决方法）

cin.get() ：可以读入包括空格，跳格，回车符在内的空白字符

cin.ignore() ：丢弃输入的第一个字符。用来防止接收上次输入的回车符

getchar() ：读取一个字符，包括回车，空格

或者：

	// 每次 cin >> 时判断下一位是不是换行符，即 cin.get () == '\n'
	#include <iostream>
	using namespace std;

	int main() {
	int sum = 0;
	int num = 0;
	while (cin >> num) {
	sum += num;
	if (cin.get() == '\n') {
	cout << sum << endl;
	sum = 0;
	}
	}
	return 0;
	}

# 场景七：一行多个空格分隔的字符串

输入描述：

输入有两行，第一行 n
第二行是 n 个字符串，字符串之间用空格隔开

输出描述：

输出一行排序后的字符串，空格隔开，无结尾空格

输入示例：

5
c d a bb e

输出示例：

a bb c d e

代码实现：

	#include <iostream>
	#include <string>
	#include <vector>
	#include <algorithm>
	using namespace std;

	int main() {
	int n = 0;
	cin >> n;
	vector<string> words(n, "");
	for (int i = 0; i < n; ++i) {
	cin >> words[i];
	}
	sort(words.begin(), words.end());
	for (int i = 0; i < n - 1; ++i) {
	cout << words[i] << " ";
	}
	cout << words[n - 1] << endl; // 无结尾空格
	return 0;
	}

# 场景八：多行空格分隔的字符串

输入描述：

多个测试用例，每个测试用例一行
每行通过空格隔开，有 n 个字符，n < 100

输出描述：

对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开

输入示例：

a c bb
f dddd
nowcoder

输出示例：

a bb c
dddd f
nowcoder

代码实现：

	// getline()
	#include <iostream>
	#include <vector>
	#include <string>
	#include <sstream>
	#include <algorithm>
	using namespace std;

	int main() {
	string str1, str2;
	vector<string> words;
	while (getline(cin, str1)) {
	stringstream ss(str1);
	while (getline(ss, str2, ' ')) words.push_back(str2); // 等效于 while (ss>> str2) words.push_back (str2);
	sort(words.begin(), words.end());
	for (int i = 0; i < words.size() - 1; ++i) {
	cout << words[i] << " ";
	}
	cout << words[words.size() - 1] << endl;
	words.clear(); // 清空 words 数组
	}
	return 0;
	}

或者：

	// 判断换行符 cin.get () == '\n'
	#include <iostream>
	#include <vector>
	#include <string>
	#include <algorithm>
	using namespace std;

	int main() {
	string word;
	vector<string> words;
	while (cin >> word) {
	words.push_back(word);
	if (cin.get() == '\n') { // 等效于 if (getchar () == '\n')
	sort(words.begin(), words.end());
	for (int i = 0; i < words.size() - 1; ++i) {
	cout << words[i] << " ";
	}
	cout << words[words.size() - 1] << endl;
	words.clear();
	}
	}
	return 0;
	}

# 场景九：多行逗号分隔的字符串

输入描述：

多个测试用例，每个测试用例一行
每行通过 ',' 隔开，有 n 个字符，n < 100

输出描述：

对于每组用例输出一行排序后的字符串，用 ',' 隔开，无结尾空格

输入示例：

a,c,bb
f,dddd
nowcoder

输出示例：

a,bb,c
dddd,f
nowcoder

代码实现：

	#include <iostream>
	#include <string>
	#include <vector>
	#include <sstream>
	#include <algorithm>
	using namespace std;

	int main() {
	string str1, str2;
	vector<string> words;
	while (getline(cin, str1)) {
	stringstream ss(str1);
	while (getline(ss, str2, ',')) words.push_back(str2);
	sort(words.begin(), words.end());
	for (int i = 0; i < words.size() - 1; ++i) {
	cout << words[i] << ",";
	}
	cout << words[words.size() - 1] << endl;
	words.clear();
	}
	return 0;
	}

参考：

LaTeX：跨 tex 文件的交叉引用

2022-08-29T12:45:58.000Z

# 教程

如果需要在 response.tex 中引用 revision.tex 的某一段文本，可通过以下步骤实现：

在 revision.tex 中，将需要引用的文本放在 %<*tag> 和 %</tag> 之间，即：
%<*tag>
Here is the text to be cited.
%</tag>
在 response.tex 中，添加 catchfilebetweentags 这个包，即：
\usepackage{catchfilebetweentags}
在 response.tex 中，利用 \ExecuteMetaData 命令引用文本，即：
\ExecuteMetaData[revision]{tag}

然而，如果需要引用的文本中包含了 \ref 、 \eqref 、 \cite 命令，response.tex 将无法正常编译以及显示编号

此时，还需要让 response.tex 获取 revision.tex 所生成的 labels 和 citations ，即，在 response.tex 中添加如下命令：

	% copy labels
	\usepackage{xr}
	\externaldocument{revision}

	% copy citations
	\usepackage{xcite}
	\externalcitedocument{revision}

这是因为，revision.tex 生成的 labels 和 citations 全都保存在 revision.aux 文件中，而 \externaldocument 和 \externalcitedocument 可以分别读取 aux 文件中的 labels 和 citations

执行完以上操作，无论是 revision.tex 中的什么文本，都能在 response.tex 中正常编译并显示（测试使用的是 IEEE 的论文模板）

可能不适用于其余期刊的论文模板，因为其他期刊论文模板可能修改了 aux 文件中 labels 和 citations 的格式（应该是都可以通过编译的，只不过显示效果依赖于期刊模板）

# 示例

例如，在 revision.tex 中写到：

	%<*lemma>
	\blue{The transmission energy consumption of an SN can be minimal when constraints
	\eqref{eqn:power_low_energy_node} - \eqref{eqn:power_CH} are met with equality.}
	%</lemma>

在 response.tex 中引用 revision.tex 的内容：

We have rewritten Lemma 1 as: ``\ExecuteMetaData[revision]{lemma}''

编译得到的 response.pdf 显示：

可以看到，revision.tex 对公式的引用，即， \eqref{eqn:power_low_energy_node} - \eqref{eqn:power_CH} ，也能在 response.tex 中正常编译（并且，response.pdf 显示出的公式编号与 revision.pdf 相同）

为了使用 \blue{} 命令（使 {} 内的文字变蓝色），需要先在导言区定义： \newcommand{\blue}[1]{{{\color{blue} #1}}}

再例如，在 revision.tex 中写到：

	%<*collection>
	With CDG scheme \cite{CDG2009}, each SN sends the collected data along the data collection
	route to the CH, and the UAV flies to collect data along the trajectory obtained from the
	configuration phase.
	%</collection>

在 response.tex 中引用：

	To reveal the data collection mechanism, we have added the following sentence in Section
	IV: ``\blue{\ExecuteMetaData[revision]{collection}}''

编译得到的 response.pdf 显示：

可以看到，revision.tex 对参考文献的引用， \cite{CDG2009} ，也能在 response.tex 中奏效

类似的，revision.tex 中关于表格（table）、算法（algorithm）、图片（figure）等的引用（通过 \label 命令打标签、通过 \ref 命令引用），也能采用以上方式在 response.tex 中正常编译并显示

LeetCode - 排序专题

2022-08-22T05:39:22.000Z

# LeetCode 215. 数组中的第 K 个最大元素

215. Kth Largest Element in an Array

给定整数数组 nums 和整数 k ，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 $O(n)$ 的算法解决此问题。

示例 1：

输入：nums = [3,2,1,5,6,4], k = 2
输出：5

示例 2：

输入：nums = [3,2,3,1,2,4,5,5,6], k = 4
输出：4

提示：

$1 \le$ k $\le$ nums.length $\le 10^5$
$-10^4 \le$ nums[i] $\le 10^4$

# 思路

数组第 k 个最大元素，即，数组降序排序后的第 k 个元素（或者，升序排序后的倒数第 k 个元素）

对整个数组排序的时间复杂度至少为 $O(n \log{n})$ ，其中 $n$ 是数组 nums 的长度

有一种基于快速排序的算法，可以确定某一个元素在排序以后的位置，即，快速选择 算法

# Method 1: 基于快速排序的选择方法

算法思路：（以寻找降序排序后的第 k 个元素为例）

快速排序的划分操作：从区间 [left, right] 中选择任意一个元素作为基准，调整子数组，使得位置 p 左侧的元素都大于等于基准元素，位置 p 右侧的元素都小于基准元素，于是，基准元素的最终位置就是 p

即，nums [p] 左侧元素全都大于等于 nums [p]，nums [q] 右侧元素全都小于 nums [p]，于是，nums [p] 就是第 p + 1 个最大元素（数组索引从 0 开始）

因此，可按如下方案求解该问题：

如果某次划分的 p 为 k - 1 时，即找到了第 k 个最大元素，可直接返回 nums [p]
如果 p 小于 k - 1，则需要查找值更小的元素，即，继续划分 p 右侧的子区间
如果 p 大于 k - 1，则需要查找值更大的元素，即，继续划分 p 左侧的子区间

特别地，我们应随机选择基准元素，使得快速算法算法的时间代价的期望为 $O(n)$

代码实现：

	// 划分子序列
	int partition(vector<int>& nums, int left, int right) { // 随机选择基准，以该基准作为分界线
	int x = left + rand() % (right - left + 1); // 随机生成一个位于区间 [left, right] 内的数
	int pivot = nums[x]; // 划分子序列的基准
	swap(nums[x], nums[right]); // 将基准移至最右侧
	int pos = left - 1; // 分界线 pos 及其左边的元素一定大于等于 pivot
	for (int i = left; i < right; ++i) { // 划分子序列
	if (nums[i] >= pivot)
	swap(nums[++pos], nums[i]);
	}
	swap(nums[++pos], nums[right]); // 将 pivot 放到分界线位置
	return pos; // 分界线
	}

	// 快速选择
	int quickSelect(vector<int>& nums, int left, int right, int index) { // 寻找降序排列后下标为 index 的元素
	while (true) { // 为降低空间复杂度，这里采用 while 循环，而不采用递归
	int pos = partition(nums, left, right); //nums [pos] 为第 pos + 1 个最大元素（数组索引从 0 开始）
	if (pos == index) // 寻找到目标下标，该位置元素值即为第 k 个最大元素
	return nums[pos];
	else if (pos < index) // 分界线在目标下标左侧
	left = pos + 1;
	else // 分界线在目标下标右侧
	right = pos - 1;
	}
	}

	int findKthLargest(vector<int>& nums, int k) {
	srand(time(0));
	return quickSelect(nums, 0, nums.size() - 1, k - 1);
	}

时间复杂度： $O(n)$ ，其中 $n$ 是数组 nums 的长度

空间复杂度： $O(1)$

参考：

LeetCode - 搜索专题

2022-08-16T08:38:30.000Z

# LeetCode 200. 岛屿数量

200. Number of Islands

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和 / 或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

示例 2：

输入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
输出：3

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 '0' 或 '1'

# Method 1: 深度优先搜索

算法思路：

扫描整个二维网格，如果某一个位置为 '1'，则表示查找到一个岛屿，此时需以其为起始位置开始进行深度优先搜索

深度优先搜索的具体操作：

将搜索到的 '1' 重新标记为 '0'
从该位置出发，向 4 个方向探索与之相连的位置

代码实现：

	vector<vector<int>> directions = <!--swig0-->;

	void helper(vector<vector<char>>& grid, int i, int j) {
	int m = grid.size();
	int n = grid[0].size();
	grid[i][j] = '0'; // 标记 (i, j) 位置，表示已访问过该位置
	for (int k = 0; k < 4; ++k) { // 向四个方向进行搜索
	int newi = i + directions[k][0];
	int newj = j + directions[k][1];
	if (newi >= 0 && newi < m && newj >= 0 && newj < n) {
	if (grid[newi][newj] == '1')
	helper(grid, newi, newj);
	}
	}
	}

	int numIslands(vector<vector<char>>& grid) {
	int m = grid.size();
	int n = grid[0].size();
	int ans = 0;
	for (int i = 0; i < m; ++i) { // 遍历起点位置
	for (int j = 0; j < n; ++j) {
	if (grid[i][j] == '1') { // 发现一座岛屿
	helper(grid, i, j); // 扫描整块岛屿
	++ans; // 岛屿数量加 1
	}
	}
	}
	return ans;
	}

时间复杂度： $O(m \times n)$ ，其中 $m$ 和 $n$ 是二维网格的行数和列数

空间复杂度： $O(m \times n)$ ，最坏情况下，递归的深度为 $m \times n$

# Method 2: 广度优先搜索

算法思路：

扫描整个二维网格，每发现一个位置为 '1'，就表示查找到一个岛屿，将该位置加入队列，针对该岛屿开始广度优先搜索，直到队列为空

将搜索到的 '1' 重新标记为 '0'
从该位置出发，向 4 个方向探索与之相连的位置

代码实现：

	int numIslands(vector<vector<char>>& grid) {
	int m = grid.size();
	int n = grid[0].size();
	int ans = 0;
	vector<vector<int>> directions = <!--swig1-->;
	for (int i = 0; i < m; ++i) {
	for (int j = 0; j < n; ++j) {
	if (grid[i][j] == '1') {
	++ans;
	grid[i][j] = '0';
	queue<pair<int, int>> que;
	que.push({i, j});
	while (!que.empty()) {
	auto neighbor = que.front();
	que.pop();
	int x = neighbor.first;
	int y = neighbor.second;
	for (int k = 0; k < 4; ++k) {
	int newx = x + directions[k][0];
	int newy = y + directions[k][1];
	if (0 <= newx && newx < m && 0 <= newy && newy < n) {
	if (grid[newx][newy] == '1') {
	que.push({newx, newy});
	grid[newx][newy] = '0';
	}
	}
	}
	}
	}
	}
	}
	return ans;
	}

时间复杂度： $O(m \times n)$ ，其中 $m$ 和 $n$ 是二维网格的行数和列数

空间复杂度： $O(\min(m \times n))$ ，在最坏情况下，整个网格均为陆地，队列的大小为 $\min(m, n)$

# LeetCode 207. 课程表

207. Course Schedule

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则必须先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

提示：

$1 \le$ numCourses $\le 2000$
$0 \le$ prerequisites.length \le 5000$
prerequisites[i].length == 2
$0 \le$ ai , bi $<$ numCourses
prerequisites[i] 中的所有课程对互不相同

# 思路

给定一个包含 n 个节点的有向图 G，我们给出它的节点编号的一种排列，如果满足：

对于图 G 中的任意一条有向边 (u, v)，u 在排列中都出现在 v 的前面

那么称该排列是图 G 的 拓扑排序

根据上述定义，有以下结论：

如果图 G 中存在环（即图 G 不是 有向无环图 ），图 G 不存在拓扑排序
如果图 G 是有向无环图，它的拓扑排序可能不止一种

在本题中，我们可以将每一门课看成一个节点，如果学习课程 A 之前必须完成课程 B，则可以连接一条从 B 到 A 的有向边，然后判断该图是否存在拓扑排序（也就是判断该图是否为有向无环图）

# Method 1: 广度优先遍历

算法思路：

我们考虑拓扑排序中最前面的节点，该节点一定不会有任何入边，也就是它没有任何的先修课程要求。当我们将一个节点加入答案中后，我们就可以移除它的所有出边，代表着它的相邻节点少了一门先修课程的要求。如果某个相邻节点变成了「没有任何入边的节点」，那么就代表着这门课可以开始学习了。按照这样的流程，我们不断地将没有入边的节点加入答案，直到答案中包含所有的节点（得到了一种拓扑排序）或者不存在没有入边的节点（图中包含环）

算法流程：

使用一个队列来进行广度优先搜索：初始时，所有入度为 0 的节点都被放入队列中，它们就是可以作为拓扑排序最前面的节点，并且，它们之间的相对顺序是无关紧要的

在广度优先搜索的每一步中，我们取出队首的节点 u：

将 u 放入答案数组中
移除 u 的所有出边，也就是将 u 的所有相邻节点的入度减少 1。如果某个相邻节点 v 的入度变为 0，就将 v 放入答案数组中

在广度优先搜索的过程结束后，如果答案数组中包含了这 numCourses 个节点，那就说明我们找到了一种拓扑排序，否则，说明图中存在环，也就不存在拓扑排序了

特别地，可以只用一个变量来记录入度为 0 的节点个数，而无需将节点实际放入答案数组中。在广度优先搜索结束后，判断该变量的值是否等于课程数，就能知道是否存在一种拓扑排序

代码实现：

	bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
	vector<vector<int>> edges; // 有向图的边（邻接表）
	vector<int> indeg; // 节点的入度
	edges.resize(numCourses);
	indeg.resize(numCourses);
	for (auto info : prerequisites) {
	edges[info[1]].push_back(info[0]); // 建立一条从 info [1] 到 info [0] 的有向边
	++indeg[info[0]]; // 更新节点 info [0] 的入度
	}

	queue<int> que; // 存放入度为 0 的节点
	for (int i = 0; i < numCourses; ++i) {
	if (indeg[i] == 0) que.push(i);
	}

	int visited = 0; // 入度为 0 的节点个数（可选修的课程数）
	while (!que.empty()) {
	++visited;
	int u = que.front();
	que.pop();
	for (int v : edges[u]) { // 移除 u 的所有出边
	--indeg[v];
	if (indeg[v] == 0) que.push(v);
	}
	}

	return visited == numCourses;
	}

时间复杂度： $O(n + m)$ ，其中 $n$ 为课程数（即，numCourses）， $m$ 为先修课程的要求数（即，prerequisites 中一维数组的数量）

空间复杂度： $O(n + m)$ ，其中，邻接表所需空间为 $O(m)$ ，队列所需空间为 $O(n)$

# Method 2: 深度优先搜索

算法思路：

借助一个标志列表 flags，用于判断每个节点 i （课程）的状态

未被访问：flags [i] == 0
被其他节点启动的深度优先搜索访问过：flags [i] == -1
被当前节点启动的深度优先搜索访问过：flags [i] == 1

对 numCourses 个节点依次执行深度优先搜索，判断以每个节点起步的深度优先搜索是否存在环，若存在环直接返回 false

终止条件：
- 当 flag [i] == -1，说明当前访问节点已被其他节点启动的深度优先搜索访问过，无需再重复搜索，直接返回 true
- 当 flag [i] == 1，说明在本轮深度优先搜索中节点 i 被第 2 次访问，即，有环存在，直接返回 false
将当前访问节点 i 对应 flag [i] 置 1
递归访问当前节点 i 的所有邻接节点 j，若发现环则直接返回 false
当前节点所有邻接节点已被遍历，并没有发现环，将当前节点 flag 置为 -1 并返回 true

待整个图的深度优先搜索结束，如果未发现环，返回 true

代码实现：

	vector<vector<int>> edges;
	vector<int> flags;

	bool DFS(int i) { // 判断是否存在以 i 起始的拓扑排序
	if (flags[i] == -1) return true;
	if (flags[i] == 1) return false;
	flags[i] = 1;
	for (int j : edges[i]) {
	if (DFS(j) == false) return false;
	}
	flags[i] = -1;
	return true;
	}

	bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
	edges.resize(numCourses);
	flags.resize(numCourses);
	for (auto info : prerequisites) {
	edges[info[1]].push_back(info[0]);
	}
	for (int i = 0; i < numCourses; ++i) {
	if (flags[i] == 0) {
	if (DFS(i) == false) return false;
	}
	}
	return true;
	}

时间复杂度： $O(n + m)$

空间复杂度： $O(n + m)$

参考：leetcode-solution

# LeetCode 399. 除法求值

399. Evaluate Division

给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。

另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。

返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -1.0 替代这个答案。

注意： 输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。

示例 1：

输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
输出：[6.00000,0.50000,-1.00000,1.00000,-1.00000]
解释：
    条件：a / b = 2.0, b / c = 3.0
    问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
    结果：[6.0, 0.5, -1.0, 1.0, -1.0 ]

示例 2：

输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
输出：[3.75000,0.40000,5.00000,0.20000]

示例 3：

输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
输出：[0.50000,2.00000,-1.00000,-1.00000]

提示：

1 <= equations.length <= 20
equations[i].length == 2
1 <= Ai.length, Bi.length <= 5
values.length == equations.length
0.0 < values[i] <= 20.0
1 <= queries.length <= 20
queries[i].length == 2
1 <= Cj.length, Dj.length <= 5
Ai, Bi, Cj, Dj 由小写英文字母与数字组成

# Method 1: 广度优先搜索

# 算法思路

可以将整个问题建模成一个图：将变量字符串视为图的顶点，将两个变量的比值视为两顶点之间边的权值，试对任意两点（两个变量）求其路径长度（两个变量的比值）

首先遍历 equations 数组，将每个不同的变量字符串编号，并通过哈希表建立映射

然后，建立每个顶点的边集并将其存储到数组 vector<vector<pair<int, double>>> edges 中，其中， edges[i] 表示第 i 个顶点的边集， edges[i][j].first 表示顶点 i 的第 j 个邻居节点， edges[i][j].second 表示顶点 i 到其第 j 个邻居节点的路径长度（两个变量的比值）

于是，对于任何一个查询，可以从起点出发，通过广度优先搜索的方式，遍历图中的顶点，并更新起点到当前点的路径长度，直到遍历到终点为止

由于每次查询都需要遍历图中的所有顶点，当查询数量较大时，效率就会非常低。因此，可以对图进行预处理，先计算出每个顶点到其他顶点的路径长度，然后再依次处理每一个查询

# 代码实现

	vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
	// 给变量字符串编号
	int varNum = 0; // 变量字符串的数量
	unordered_map<string, int> vars; // 以变量字符串为 key ，以其编号为 value
	for (int i = 0; i < equations.size(); ++i) {
	if (vars.count(equations[i][0]) == 0) {
	vars[equations[i][0]] = varNum;
	varNum++;
	}
	if (vars.count(equations[i][1]) == 0) {
	vars[equations[i][1]] = varNum;
	varNum++;
	}
	}

	// 将变量视为图的顶点，将两个变量的比值视为两顶点之间边的权值
	vector<vector<pair<int, double>>> edges(varNum); // 存储每个点的邻居及其对应的权值
	for (int i = 0; i < equations.size(); ++i) {
	int vertexA = vars[equations[i][0]];
	int vertexB = vars[equations[i][1]];
	edges[vertexA].push_back({vertexB, values[i]});
	edges[vertexB].push_back({vertexA, 1.0 / values[i]});
	}

	vector<double> res;
	for (const auto& q : queries) { // 遍历每一个问题
	// 已知条件中没有出现字符串 q [0] 或 q [1]
	if (vars.count(q[0]) == 0 \|\| vars.count(q[1]) == 0) {
	res.push_back(-1.0); // 结果为 -1.0
	continue;
	}

	//q [0] 与 q [1] 均出现在已知条件中
	// 采用广度优先搜索
	int vertexA = vars[q[0]]; // 起点的编号
	int vertexB = vars[q[1]]; // 终点的编号
	queue<int> que; // 队列，存放待访问的顶点
	que.push(vertexA); // 将起点入队
	vector<double> ratios(varNum, -1.0); // 存放起点 vertexA 到各顶点的路径长度
	ratios[vertexA] = 1.0; //vertexA 到其自身的路径长度为 1.0 （自身与自身的比值为 1.0 ）
	while (!que.empty() && ratios[vertexB] < 0) { // 未访问过终点 vertexB
	int u = que.front(); // 当前访问的顶点
	que.pop(); // 将当前顶点出队
	for (const auto [v, val] : edges[u]) { // 处理顶点 u 的每一条边
	if (ratios[v] < 0) {// 未访问过顶点 v
	ratios[v] = ratios[u] * val; // 起点 vertexA 到顶点 v 的路径长度（对应两个变量的比值）
	que.push(v); // 将顶点 v 入队
	}
	}
	}
	// 循环结束时，ratios [vertexB] 即为 vertexA 与 vertexB 对应变量的比值
	// 若终点 vertexB 不可达（当队列为空时，仍未访问过 vertexB ），则结果为 -1.0
	res.push_back(ratios[vertexB]);

	}

	return res;
	}

其中， ratios[u] 表示顶点 vertexA 与顶点 u 对应变量的比值， val 表示顶点 u 与顶点 v 对应变量的比值，因此，顶点 vertex A 与顶点 v 对应变量的比值为 ratios[u] * val ，即， ratios[v] = ratios[u] * val

# 复杂度分析

时间复杂度： $O(M L + Q \cdot (L + M))$ ，其中 $M$ 为数组 equations 的长度（边的数量）， $L$ 为字符串的平均长度， $Q$ 为数组 queries 的长度（查询的数量）

构建图时，需要处理 $M$ 条边，每条边都涉及到 $O(L)$ 的字符串比较，时间复杂度为 $O(M L)$
处理每次查询时都要进行一次 $O(L)$ 的字符串比较、遍历 $O(M)$ 条边（最坏情况下），时间复杂度为 $O((L + M) \cdot Q)$

空间复杂度： $O(N L + M)$ ，其中 $N$ 为数组 equations 中的字符串的种类数（图的顶点个数）

存储每个变量字符串的编号，需要的空间为 $O(N L)$
存储图中所有的边及其权重，需要的空间为 $O(M)$
广度优先搜索过程中，存放待访问的顶点，需要的空间为 $O(N)$

# Method 2: 带权并查集

参考：leetcode-solution

# LeetCode 695. 岛屿的最大面积

LeetCode 695. Max Area of Island

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0 （代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6

示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示：

m == grid.length
n == grid[i].length
$1 \le$ m , n $\le 50$
grid[i][j] 为 0 或 1

# Method 1: 深度优先搜索

计算网格中每个连通形状的面积，然后取最大值。

在一个土地上，向 4 个方向探索与之相连的每一个土地（以及与这些土地相连的土地），那么探索过的土地总数将是该连通形状的面积

为了确保每个土地访问不超过一次，我们每次经过一块土地时，将这块土地的值置为 0

	private:
	int DFS(vector<vector<int>>& grid, int cur_i, int cur_j) { // 深度优先搜索
	if (cur_i < 0 \|\| cur_i == grid.size() \|\| cur_j < 0 \|\| cur_j == grid[0].size() \|\| grid[cur_i][cur_j] == 0) return 0; //cur_i cur_j 超出边界或 grid [cur_i][cur_j] 为 0 时，返回 0
	grid[cur_i][cur_j] = 0; // 已经访问过的位置置 0，以免重复访问
	int ans = 1; // 岛屿面积
	const int di[4] = {-1,1,0,0};
	const int dj[4] = {0,0,-1,1};
	for (int index = 0; index < 4; index++) {
	int next_i = cur_i + di[index], next_j = cur_j + dj[index];
	ans += DFS(grid,next_i,next_j);
	}
	return ans;
	}

	public:
	int maxAreaOfIsland(vector<vector<int>>& grid) {
	int ans = 0;
	for (int i = 0; i < grid.size(); i++)
	for (int j = 0; j< grid[0].size(); j++)
	ans = max(ans, DFS(grid,i,j));
	return ans;
	}

时间复杂度： $O(R \times C)$ 。其中 R 是给定网格中的行数， C 是列数。访问每个网格最多一次

空间复杂度： $O(R \times C)$ ，递归的深度最大可能是整个网格的大小，因此最大可能使用 $O(R \times C)$ 的栈空间

# Method 2: 深度优先搜索 + 栈

# Method 3: 广度优先搜索

把方法二中的栈改为队列，每次从队首取出土地，并将接下来想要遍历的土地放在队尾，就实现了广度优先搜索算法

	int maxAreaOfIsland(vector<vector<int>>& grid) {
	int ans = 0;
	for (int i = 0; i != grid.size(); ++i) {
	for (int j = 0; j != grid[0].size(); ++j) {
	int cur = 0;
	queue<int> queuei;
	queue<int> queuej;
	queuei.push(i);
	queuej.push(j);
	while (!queuei.empty()) {
	int cur_i = queuei.front(), cur_j = queuej.front();
	queuei.pop();
	queuej.pop();
	if (cur_i < 0 \|\| cur_j < 0 \|\| cur_i == grid.size() \|\| cur_j == grid[0].size() \|\| grid[cur_i][cur_j] != 1) {
	continue;
	}
	++cur;
	grid[cur_i][cur_j] = 0;
	int di[4] = {0, 0, 1, -1};
	int dj[4] = {1, -1, 0, 0};
	for (int index = 0; index != 4; ++index) {
	int next_i = cur_i + di[index], next_j = cur_j + dj[index];
	queuei.push(next_i);
	queuej.push(next_j);
	}
	}
	ans = max(ans, cur);
	}
	}
	}

时间复杂度： $O(R \times C)$ 。其中 R 是给定网格中的行数， C 是列数，访问每个网格最多一次

空间复杂度： $O(R \times C)$ ，队列中最多会存放所有的土地，土地的数量最多为 R × C 块

# LeetCode 733. 图像渲染

LeetCode 733. Flood Fill

有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小（索引 i 和 j 均从 0 开始）。

你也被给予三个整数 sr ， sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行上色填充。

为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newColor 。

最后返回经过上色渲染后的图像。

示例 1：

输入：image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, newColor = 2
输出：[[2,2,2],[2,2,0],[2,0,1]]
解释：在图像的正中间，(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。注意，右下角的像素没有更改为2，因为它不是在上下左右四个方向上与初始点相连的像素点。

示例 2：

输入：image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, newColor = 2
输出：[[2,2,2],[2,2,2]]

提示：

m == image.length
n == image[i].length
$1 \le$ m , n $\le 50$
$0 \le$ image[i][j] , newColor < $2^{16}$

# Method 1: 广度优先搜索

每次搜索到一个方格时，如果其与初始位置的方格颜色相同，就将该方格加入队列，并将该方格的颜色更新，以防止重复入队。

注意：因为初始位置的颜色会被修改，所以我们需要保存初始位置的颜色，以便于之后的更新操作。

注意：当目标颜色和初始颜色相同时，我们无需对原数组进行修改。

	const int dx[4] = {1, 0, 0, -1}; // 四个方向
	const int dy[4] = {0, 1, -1, 0};
	vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
	int currColor = image[sr][sc];
	if (currColor == newColor) return image; // 目标颜色和初始颜色相同
	int n = image.size(), m = image[0].size();
	queue<pair<int, int>> que; // 待搜索位置的队列
	que.emplace(sr, sc); // 初始化
	image[sr][sc] = newColor;
	while (!que.empty()) {
	int x = que.front().first, y = que.front().second;
	que.pop();
	for (int i = 0; i < 4; i++) {
	int mx = x + dx[i], my = y + dy[i];
	if (mx >= 0 && mx < n && my >= 0 && my < m && image[mx][my] == currColor) {
	que.emplace(mx, my);
	image[mx][my] = newColor;
	}
	}
	}
	return image;

时间复杂度： $O(n \times m)$ ，其中 n 和 m 分别是二维数组的行数和列数。最坏情况下需要遍历所有的方格一次。

空间复杂度： $O(n \times m)$ ，主要为队列的开销。

# Method 2: 深度优先搜索

从给定的起点开始，进行深度优先搜索。每次搜索到一个方格时，如果其与初始位置的方格颜色相同，就将该方格的颜色更新，以防止重复搜索；如果不相同，则进行回溯。

	const int dx[4] = {1, 0, 0, -1};
	const int dy[4] = {0, 1, -1, 0};
	void dfs(vector<vector<int>>& image, int x, int y, int color, int newColor) {
	if (image[x][y] == color) {
	image[x][y] = newColor;
	for (int i = 0; i < 4; i++) {
	int mx = x + dx[i], my = y + dy[i];
	if (mx >= 0 && mx < image.size() && my >= 0 && my < image[0].size()) {
	dfs(image, mx, my, color, newColor); // 递归，深度优先搜索
	}
	}
	}
	}

	vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
	int currColor = image[sr][sc];
	if (currColor != newColor) {
	dfs(image, sr, sc, currColor, newColor);
	}
	return image;
	}

时间复杂度： $O(n \times m)$ ，最坏情况下需要遍历所有的方格一次。

空间复杂度： $O(n \times m)$ ，主要为栈空间的开销。

	timing: 本站已运行
	days: 天
	hours: 时
	minutes: 分
	seconds: 秒