{ "version": "https://jsonfeed.org/version/1", "title": "Jiankychen's Blog", "subtitle": "Never put off till tomorrow what you can do today", "icon": "https://jiankychen.github.io/assets/favicon.ico", "description": "", "home_page_url": "https://jiankychen.github.io", "items": [ { "id": "https://jiankychen.github.io/latex-to-word.html", "url": "https://jiankychen.github.io/latex-to-word.html", "title": "LaTeX 转 Word", "date_published": "2023-02-16T09:26:05.000Z", "content_html": "

# Pandoc

\n

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

\n

# 安装

\n

Pandoc 下载地址：Pandoc

\n

按默认配置安装即可

\n

# 使用

\n

步骤：

\n\n

命令模板（不可执行）：

\n
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

相关命令及参数介绍：

\n\n

详细信息请查看：Pandoc User's Guide

\n

示例：

\n
pandoc input.tex --filter pandoc-crossref -M tableEqns -M autoEqnLabels --bibliography ref.bib --citeproc --csl ieee-wireless-communications-letters.csl --resource-path=.;Figures --number-sections -M reference-section-title=Reference -o output.docx

# 注意事项

\n\n
\n

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

\n
\n

# 参考资料

\n

Pandoc：

\n\n

Aurora：

\n\n

# Acrobat

\n

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

\n

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

\n

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

\n", "tags": [ "Tutorial", "LaTeX" ] }, { "id": "https://jiankychen.github.io/sql-basics.html", "url": "https://jiankychen.github.io/sql-basics.html", "title": "SQL 基础", "date_published": "2023-02-04T14:43:13.000Z", "content_html": "

# SQL 简介

\n

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

\n

SQL 语法特征：

\n\n

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

\n\n

# DDL

\n

# 数据库操作

\n

查看所有数据库

\n
show databases;

查看当前使用的数据库

\n
select database();

创建数据库

\n
create database 数据库名 charset utf8;

删除数据库

\n
drop database 数据库名;

使用数据库

\n
use 数据库名;

# 表操作

\n

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

\n
show tables;

查看表结构

\n
desc 表名;

创建表

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

[] 表示可选的内容

\n
\n

其中，列类型有：

\n\n

修改表–添加字段

\n
alter table 表名 add 列名 类型;

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

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

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

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

删除表–删除字段

\n
alter table 表名 drop 列名;

删除表

\n
drop table 表名;
# 如果表存在，则删除；如不存在，则跳过
drop table if exists 表名;
\n
有些数据库系统不支持  if exists  选项，支持  if exists  选项的有：MySQL，PostgreSQL 和 SQL Server 2016
\n
\n
查看表的创建语句–详细过程
\n
show create table 表名;
# DML
\n
# 数据插入
\n
全列插入：值的顺序与表结构字段的顺序完全对应，此时可以省略列名的列表
\n
insert into 表名 values (...);
部分列插入：值的顺序与给出的列名顺序对应
\n
insert into 表名 (列1, 列2, ...) values (值1, 值2, ...);
全列多行插入
\n
insert into 表名 values (...), (...), ...;
部分列多行插入
\n
insert into 表名 (列1, 列2, ...) values (值1, 值2, ...), (值1, 值2, ...), ...;
\n
注意：如果数据是字符型，必须使用单引号或双引号包围
\n
\n
例如：
\n
# 创建名为 test 的数据库
create database test charset UTF8;
# 使用名为 test 的数据库
use test;
# 创建表
create table student(
\tid int,
\tname varchar(10),
\tage 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);
# 数据删除
\n
清空表（删除整个表中的数据）
\n
delete from 表名;
按特定条件删除数据
\n
delete from 表名 where 条件;
例如：
\n
# 删除 id 为 3 的行
delete from student where id = 3;
# where
\n
where  后面跟条件语句，以进行条件处理
\n
条件语句支持以下运算符：
\n\n
条件的优先级：
\n\n
参考资料：
\n\n
# 数据修改
\n
update 表名 set 列名 = 值 [where 条件];
例如：
\n
# 将 id 为 2 所对应的 name 修改为 Mike
update student set name = 'Mike' where id = 2;
\n
update 表名 set 列名 = 值  会修改整列的数据
\n
\n
# DQL
\n
# 基础查询
\n
查询所有列
\n
select * from 表名;
查询指定列
\n
select 列1，列2，... from 表名;
条件查询
\n
select 列1，列2，... from 表名 where 条件;
例如：
\n
# 查询 id 和 name 两列，年龄小于 35
select id, name from student where age >= 18 and age < 35;
# 分组聚合
\n
select 字段, 聚合函数 from 表名 [where 条件] group by 列名;
聚合函数：
\n\n
注意：
\n\n
例如：
\n
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;
# 排序分页
\n
# 结果排序
\n
可以对查询的结果使用  order by  关键字，指定某个列进行排序
\n
select 列|聚合函数|* from 表名
where ...
group by ...
order by ... [asc / desc];
其中：
\n\n
例如：
\n
# 显示 age > 22 的所有数据（按 age 列降序排列）
select * from person where age > 22 order by age desc;
# 结果分页
\n
可以使用  limit  关键字，对查询结果进行数量限制或者分页显示
\n
select 列|聚合函数|* from 表名
where ...
group by ...
order by ... [asc / desc]
limit n[, m];
其中：
\n\n
注意：
\n\n
例如：
\n
# 按 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;
参考资料：
\n\n",
            "tags": [
                "SQL"
            ]
        },
        {
            "id": "https://jiankychen.github.io/python-oop.html",
            "url": "https://jiankychen.github.io/python-oop.html",
            "title": "Python 面向对象",
            "date_published": "2023-02-02T09:48:52.000Z",
            "content_html": "
Python 是一种面向对象的编程语言
\n
简单理解 面向对象 ：基于模板（类）去创建实体（对象），使用对象完成功能开发
\n
面向对象的三大特征：
\n\n
面向对象技术简介
\n\n
# 类和对象
\n
类的组成：
\n\n
# 类定义
\n
使用关键字  class  定义类：
\n
class Class_Name:
    <statement-1>
    ...
    <statement-N>
其中， Class_Name  表示类的名称，通常需要首字母大写
\n
# 类对象
\n
创建对象（实例化）：
\n
obj = Class_Name()
修改对象属性：
\n
obj.var_name = xx
删除对象属性：
\n
# 使用 del 关键字删除对象的属性
del obj.var_name
删除对象：
\n
# 使用 del 关键字删除对象
del obj
# 类的成员方法
\n\n
在类的内部，使用  def  关键字来定义一个方法，与一般函数定义不同，类的成员方法必须必须有一个额外的第一个参数名称，按照惯例它的名称是  self  ，即：
\n
def func_name(self, parameter_1, ..., parameter_N):
    ...
其中：
\n\n
# 构造方法
\n
Python 类中的  __init__  方法，称之为 构造方法
\n
每次使用类创建新对象时，都会自动调用  __init__  方法，并且会将创建类对象时的传入参数自动传递给  __init__  方法
\n
因此，使用  __init__  方法可以将值赋给对象属性，或者在创建对象时需要执行的其他操作
\n
注意，构造方法 也是 成员方法，因此：
\n\n
例如：
\n
# 定义类
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)
# 魔术方法
\n
魔术方法（Magic Methods）是 Python 中的内置方法，一般以  __  （双下划线）为开头和结尾
\n
例如：
\n\n
之所以称之为魔法方法，是因为这些方法会在进行特定的操作时会被自动调用
\n
如果希望根据自己的程序定制自己特殊功能的类，那么就需要对这些方法进行重写
\n
参考：Python 中类的魔术方法
\n
# pass 语句
\n
pass  是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容
\n
如果因为某种原因写了无内容的函数定义或类定义，需使用  pass  语句来避免错误
\n
例如：
\n
# 继承
class DerivedClassName(BaseClassName):
    pass
参考资料：
\n\n
# 封装
\n
在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来（即，定义成私有成员），在程序外部看不到（即，其他程序无法调用）
\n\n
# 私有成员
\n
类对象无法直接访问私有成员，但类内其它成员可以直接使用私有成员
\n
私有成员变量：
\n\n
私有成员方法（封装的方法）：
\n\n
\n
与 java 等语言不同，Python 的封装并不是真正意义上的外部无法调用。在 Python 中，如果需要在类外调用封装的属性或方法，须采用  对象名._类名__方法名  和  对象名._类名__变量名  的方式（不建议调用）
\n
\n
例如：
\n
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
\n
property 是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值（就是一个装饰器）
\n
将一个类的方法  func_name  用 propery 装饰以后，类对象  obj  可直接通过  obj.func_name  去使用，以遵循统一访问的原则
\n
\n
被 property 装饰的属性会优先于对象的属性被使用
\n
\n
被 propery 装饰的属性分成三种：
\n\n
例如， @property  把类中的方法伪装成属性：
\n
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 不能被赋值
\n
参考资料：
\n\n
# 继承
\n
继承允许我们定义继承（复制）另一个类的所有方法和属性的类
\n
继承可以分为：
\n\n
父类是被继承的类，也称为基类
\n
子类是从另一个类继承所得的类，也称为派生类
\n
# 单继承
\n
\n
任何类都可以是父类，因此，创建父类的语法与创建任何其他类相同
\n
\n
要创建从其他类继承功能的类，只需在创建子类时将父类作为参数传递即可：
\n
class DerivedClassName(BaseClassName):
    <statement-1>
    ...
    <statement-N>
其中， DerivedClassName  为子类名， BaseClassName  为父类名
\n
\n
如果不希望向子类中添加任何其他属性或方法，可使用  pass  关键字
\n
\n
例如：
\n
# 创建 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()
# 多继承
\n
创建子类的语法：
\n
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    ...
    <statement-N>
如果多个父类中含有同名的成员，那么默认按照从左向右顺序依次继承，先继承的保留，后继承的被覆盖
\n
# 方法重写
\n
子类继承父类的成员属性和成员方法后，如果对其 “不满意”，可以在子类重写父类的方法
\n
即：在子类中重新定义同名的属性或方法
\n
例如：
\n
class Parent:           # 定义父类
    def myMethod(self):
        print ('调用父类方法')
class Child(Parent):    # 定义子类
    def myMethod(self):  # 重写父类方法
        print ('调用子类方法')
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
# 调用父类同名成员
\n
一旦在子类中重写父类成员以后，子类的类对象调用成员时将是调用复写后的新成员
\n
如果需要使用被复写的父类的成员，需要特殊的调用方式:
\n\n
如果是单继承的情况，可以直接用父类名调用父类方法
\n
但是，如果是多继承的情况，可能会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题，此时，推荐采用  super()  函数调用，以解决多重继承问题。具体可参考：Python super () 函数
\n
参考资料：
\n\n
# 类型注解
\n
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）
\n\n
有两种注解：
\n\n
需注意：类型注解仅仅是提示性的，不是决定性的，并不会真正地对类型做验证和判断（也就是说：即使注解的数据类型与实际数据类型不一致，程序也不会报错）
\n
# 变量的类型注解
\n
事实上，对于显式的变量定义，一般无需注解。即便不写类型注解，也可以明确知晓变量的类型
\n
一般而言，在无法直接看出变量类型时（例如，将函数返回值赋给一个变量时），才会添加变量的类型注解
\n
# 方式一（常用）
\n
基础语法：
\n
变量: 类型
例如：
\n
基础数据类型注解：
\n
var1: int = 3
var2: float = 3.14
var3: bool = True
类对象类型注解:
\n
class Person:
    pass
p: Person = Person()
容器类型简易注解：
\n
mylist: list = [1, 2, 3]
mytuple: tuple = (1, 2, 3)
myset: set = {1, 2, 3}
mydict: dict = {0: \"a\", 1: \"b\"}
mystr: str = \"Jiankychen\"
容器类型详细注解：
\n\n
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\"}
# 方式二
\n
除了使用  变量: 类型  这种语法做注解外，也可以 在注释中进行类型注解
\n
基础语法：
\n
# type: 类型
例如：
\n
class Person:
    pass
def func():
    return 3.14159
var1 = random.randint(1, 10)    # type: int
var2 = Person()                 # type: Person
var3 = func()                   # type: float
# 函数（方法）的类型注解
\n
# 形参注解
\n
函数（方法）的形参类型注解语法：
\n
def func_name(形参名: 类型, 形参名: 类型, ...)
    statement
例如：
\n
def add(x: int, y: int):
    return x + y
# 返回值注解
\n
函数（方法）的返回值也是可以添加类型注解的，语法如下：
\n
def func_name() -> 返回值类型:
    statement
例如：
\n
def func(data: list) -> list:
    return data
# Union 类型
\n
通过  Union  可以定义联合类型
\n\n
在变量注解、函数（方法）形参和返回值注解中，均可使用  Union  联合类型
\n
例如：
\n
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
参考资料：
\n\n
# 多态
\n
多态：多种状态，即：对于某个行为（函数），使用不同的对象将会得到不同的状态
\n
例如： Cat  类和  Dog  类都有  speak  成员方法， Cat  类对象和  Dog  类对象都能被传入  command  函数；但是由于两个类定义的  speak  方法的功能不一致，传入不同类的对象就会得到不同的状态
\n
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!
多态常作用在继承关系上，比如：定义函数（方法），通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态
\n
例如，可以将上例中的代码修改为：
\n
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!
# 抽象类（接口）
\n
抽象方法：没有具体实现的方法（即：方法体是  pass  语句）
\n
抽象类：包含抽象方法的类，也可以称之为 接口，比如上例中的  Pet  类
\n
抽象类相当于定义一个标准，包含了一些抽象的方法，要求子类必须实现
\n
这种设计的意义在于：
\n\n
参考资料：
\n\n",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/python-pandas.html",
            "url": "https://jiankychen.github.io/python-pandas.html",
            "title": "pandas 基础",
            "date_published": "2023-01-20T13:02:02.000Z",
            "content_html": "
# 安装及导入
\n
# 安装
\n
可以使用 pip 安装
\n
pip install pandas\n
\n
# 导入
\n
import pandas as pd
# 数据结构
\n
# Series
\n
Series 是一种类似于一维数组的对象，它由一组数据（各种 Numpy 数据类型）以及一组与之相关的数据标签（即索引）组成
\n
\n
Series 只有行索引
\n
\n
例如，创建一个 Series 对象：
\n
ser = pd.Series(data = [1, 2, 3], index = ['a', 'b', 'c'])
其内容为：
\n
a   1\nb   2\nc   3\n
\n
Series 的各种方法
\n
# DataFrame
\n
DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）
\n
\n
DataFrame 既有行索引又有列索引
\n
\n
例如，创建一个 DataFrame 对象：
\n
df = pd.DataFrame(data = np.array([[1, 2, 3], [4, 5, 6]]), columns = ['a', 'b', 'c'])
其内容为：
\n
   a  b  c\n0  1  2  3\n1  4  5  6\n
\n
DataFrame 的各种方法
\n
下面将以 DataFrame 对象为例来介绍 pandas 的基本用法
\n
# 数据输入
\n
# 使用 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()
# 数据输出
\n
# 将 DataFrame 对象写入 csv 文件
df.to_csv('file_name')
# 写入 excel 文件
df.to_excel()
# 写入 json 文件
df.to_json()
# 写入 xml 文件
df.to_xml()
pandas 读取 / 写入文件
\n
# 查看数据
\n
# 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()
# 缺失值处理
\n
pandas 主要用  np.nan  表示缺失数据
\n
一般情况下，运算时默认排除缺失值
\n
# 查找缺失值
df.isnull()
# 查找非缺失值
df.notnull()
# 删除所有含缺失值的行
df.dropna(how='any')
# 用 0 填充缺失值
df.fillna(value=0)
# 重复值处理
\n
# 查看 DataFrame 数据中的重复值
df.duplicated()
# 统计 DataFrame 数据中重复值的个数
df.duplicated().sum()
# 删除 DataFrame 数据中的重复值
df.drop_duplicates()
# 索引变换
\n
# 重置索引
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
\n
# 排序
\n
# 按索引排序
df.sort_index()
# 按行列的值排序
df.sort_values()
# 按某一列排序
df.sort_values(by='column_name')
# 按多列排序
df.sort_values(by=['column_name_1', 'column_name_2'])
特别地，如果数据含有空值，可以用  na_position  参数处理空值，例如：
\n
df.sort_values(na_position='first')
# 特征处理
\n
按照数据的值进行离散化
pd.cut()
# 按照数据的数量进行离散化
pd.qcut()
# 替换数据值
df.replace()
# 替换数据值
df.map()
# one-hot 编码
pd.get_dummies()
具体用法请参考 pandas Document
\n
# 数据拼接
\n
# 既可以横向拼接，又可以纵向拼接
pd.concat()
# 横向拼接
pd.merge()
# 横向拼接 DataFrame 对象
df.join()
# 纵向拼接 DataFrame 对象
df.append()
Merge, join, concatenate and compare
\n
# 数据分组
\n\n
具体请参考：Groupby API
\n
# 参考资料
\n\n",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/python-conda.html",
            "url": "https://jiankychen.github.io/python-conda.html",
            "title": "conda 常用命令",
            "date_published": "2023-01-19T03:47:56.000Z",
            "content_html": "
# conda 基本操作
\n
# 查看 conda 版本
\n
conda --version\n
\n
# 更新 conda
\n
conda update conda\n
\n
# 查看 conda 环境配置
\n
conda config --show\n
\n
# 设置镜像源
\n
# 设置清华镜像\nconda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/\nconda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/\nconda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/\nconda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/\n\n# 设置 bioconda\nconda config --add channels bioconda\nconda config --add channels conda-forge\n\n# 设置搜索时显示通道地址\nconda config --set show_channel_urls yes\n
\n
# 查询指定命令的功能
\n
conda command_name --help\n
\n
# 管理环境
\n
# 显示所有虚拟环境
\n
conda env list\n
\n
# 创建虚拟环境
\n
conda create -n env_name package_name\n
\n
如果需要指定 package 版本，可直接在 package_name 之后加上  =  号以及 package 版本号，例如：
\n
conda create -n env_name python=3.x\n
\n
如果需要安装多个 package ，在 env_name 之后用空格分隔多个 package_name 即可，例如：
\n
conda create -n python310 python=3.10 numpy pandas\n
\n
# 激活环境
\n
activate env_name\n
\n
# 退出环境
\n
deactivate env_name\n
\n
# 删除虚拟环境
\n
conda env remove -n env_name\n
\n
# 导出虚拟环境
\n
conda env export --name env_name > environment.yml\n
\n
# 导入虚拟环境
\n
conda env create -n env_name -f environment.yml\n
\n
# 管理 package
\n
# 查看当前环境包含的所有 package
\n
conda list\n
\n
# 更新当前环境包含的所有 package
\n
conda upgrade --all\n
\n
# 更新指定 package
\n
conda update package_name\n
\n
# 安装指定 package
\n
conda install package_name\n
\n
安装装多个 package ：
\n
conda installl package_name_1 package_name_2 package_name_3\n
\n
安装固定版本的 package ：
\n
conda install package_name=package_version_number\n
\n
# 移除指定 package
\n
conda remove package_name \n
\n
参考资料：
\n\n",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/python-modules.html",
            "url": "https://jiankychen.github.io/python-modules.html",
            "title": "Python 异常、模块、包",
            "date_published": "2023-01-15T10:19:13.000Z",
            "content_html": "
# 异常
\n
异常是指程序运行的过程中出现了错误
\n
\n
bug 就是指异常，历史上因为小虫子导致计算机失灵，所以延续至今，bug 就代表软件出现错误
\n
\n
# 异常的捕获
\n
异常处理（捕获异常）：针对可能出现的异常，提前做好准备，当真的出现异常时，可以有后续处置，以免其导致程序无法正常运行
\n
# 捕获常规异常
\n
语法：
\n
try:
    尝试执行的代码
except:
    若出现异常，将会执行本段代码
例如：
\n
# 尝试以 'r' 模式打开文件，如果文件不存在，则以 'w' 方式打开
try:
    f = open('linux.txt', 'r')
except:
    f = open('linux.txt', 'w')
# 捕获指定异常
\n
try:
    尝试执行的代码
except ErrorType as e:
    若出现类型为 ErrorType 的异常，将会执行本段代码
其中，ErrorType 是指要捕获的异常类型
\n
注意：如果 “尝试执行的代码” 的异常类型和要捕获的异常类型不一致，则无法捕获异常
\n
常见的异常类型如下表所示：
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
类名描述
SyntaxError发生语法错误时引发
FileNotFoundError未找到指定文件或目录时引发
NameError找不到指定名称的变量时引发
ZeroDivisionError除数为 0 时的异常
IndexError当使用超出列表范围的索引时引发
KeyError当使用映射不存在的键时引发
AttributeError当尝试访问未知对象属性时引发
TypeError当试图在使用 a 类型的场合使用 b 类型时引发
\n
例如：
\n
try:
    print(name)
except NameError as e:
    print('未定义 name 变量')
# 捕获多个异常
\n
当需要捕获多个异常时，可以把要捕获的异常类型的名字，放到 except 后，并使用元组的方式进行书写
\n
例如：
\n
捕获多个异常（但不输出异常的具体描述）：
\n
try:
    print(1 / 0)
except (NameError, ZeroDivisionError):
    print('错误...')
捕获多个异常并输出异常的具体信息：
\n
try:
    print(num)
except (NameError, ZeroDivisionError) as e:
    print(e)
# 捕获所有异常
\n
try:
    尝试执行的代码
except Exception as e:
    若出现异常，将会执行本段代码
注意： except:  与  except Exception as e:  这两种方式都可以捕获全部的异常
\n
# 异常 else
\n
else  表示没有异常时要执行的代码
\n
try:
    尝试执行的代码
except Exception as e:
    若出现异常，将会执行本段代码
else:
    若没有出现异常，将会执行本段代码
# 异常 finally
\n
finally  表示无论是否异常都要执行的代码，例如关闭文件
\n
try:
    尝试执行的代码
except Exception as e:
    若出现异常，将会执行本段代码
else:
    若没有出现异常，将会执行本段代码
finally:
    无论是否出现异常，都会执行本段代码
# 异常的传递
\n
异常具有传递性：
\n\n
利用异常具有传递性的特点，当我们想要保证程序不会因为异常崩溃的时候，就可以在  main  函数中设置异常捕获，由于无论在整个程序哪里发生异常，最终都会传递到  main  函数中，这样就可以确保所有的异常都会被捕获
\n
# 模块
\n
Python 模块（Module），是一个 Python 文件，以  .py  为后缀名
\n
模块能定义函数、类和变量，模块里也能包含可执行的代码
\n
可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用，以实现各种不同的功能
\n
# 导入模块
\n
在使用模块之前，需要先将模块导入 Python 程序
\n
常用的导入模块方式：
\n
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
其中：
\n\n
注意：导入模块时，module_name 不需要包含  .py  后缀
\n
# import module_name
\n
使用  import  导入模块后，可以通过  '.'  来使用模块中的函数或类
\n
import module_name
module_name.func_name()
module_name.class_name
module_name.var_name
# from module_name import func_name
\n
使用  from … import …  方式导入之后，无需添加前缀，直接调用即可
\n
from module_name import func_name
func_name()
注意，利用  from  把内容从模块中导入后，会导致相同名称的内容被覆盖，也就是说，不同模块的命名空间会在此处重叠
\n
# from module_name import *
\n
导入模块全部内容
\n
from module_name import *
func_name()
class_name
var_name
# as nick_name
\n
# 模块定义别名
import module_name as nick_name
# 功能定义别名
from module_name import func_name as func_nick_name
# 自定义模块
\n
每个 Python 文件都可以作为一个模块，模块的名字就是文件的名字
\n
因此，自定义模块只需在 Python 代码文件中正常写代码即可，通过 import、from 关键字导入（与导入 Python 内置模块一样）即可使用。但是需要注意，自定义模块名必须要符合标识符命名规则
\n
# __main__ 变量
\n
if __main__ == “__main__”  语句的作用：只有当含有该语句的 Python 程序是被直接 run 时，才会进入  if  内部。如果是被导入的，则无法进入  if
\n
该功能常用于测试模块（即，希望某些代码在测试时运行、而在被导入时不运行）
\n
例如：
\n
def test(a, b):
    print(a + b)
# 只在当前文件中调用该函数，其他导入的文件内均不执行 test 函数调用
if __name__ == '__main__':
    test (1, 1)
如果不加  if __name__ == "__main__"  语句：无论是当前文件，还是其他已经导入了该模块的文件，在运行的时候都会自动执行  test  函数的调用
\n
# __all__ 变量
\n
如果一个模块文件中有  __all__  变量（该变量为列表对象），在使用  from xxx import *  导入该模块时，只能导入  __all__  列表中的元素
\n
因此， __all__  变量可以控制  import *  导入模块时的导入内容
\n
注意： __all__  变量 仅影响  from ... import *  这一导入方式
\n
例如，自定义如下模块：
\n
__all__ = ['Test_A']
def Test_A():
    xxx
def Test_B():
    xxx
通过  from ... import *  导入该模块后，只能使用  Test_A  函数，而不能使用  Test_B  函数
\n
# 包
\n
如果 Python 模块太多，可以通过 Python 包（Package）来管理
\n
当我们的模块文件非常多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块
\n\n
# 自定义包
\n
基本步骤：
\n\n
在 Pycharm 中，点击  new --> Python Package  新建包后，包内部会自动创建  __init__.py  文件，这个文件控制着包的导入行为
\n
# 导入包
\n
# import xxx
\n
# 导入所有模块
\n
import package_name
package_name.module_name.func_name()
# 导入指定模块
\n
import package_name.module_name
package_name.module_name.func_name()
其中：
\n\n
# from xxx import
\n
# 导入所有模块
\n
from package_name import *
module_name.func_name()
注意：必须在  __init__.py  文件中添加  __all__  变量，用于控制  from package_name import *  导入的模块列表（类似于模块文件中的  __all__  变量）
\n
# 导入指定模块
\n
from package_name import module_name
module_name.func_name()
# 导入指定模块中的指定函数
\n
from package_name.module_name import func_name
func_name()
# 第三方包
\n
在 Python 程序的生态中，有许多非常多的第三方包（非 Python 官方），可以极大的帮助我们提高开发效率，如：
\n\n
注意，Python 没有内置这些第三方包，需要安装它们才可以导入使用
\n
可通过 Python 内置的 pip 安装指定的第三方包
\n
即，在命令行中输入：
\n
pip install package_name
pip 是连接外网进行下载，若下载速度相对较慢，可考虑通过国内的镜像源下载
\n
例如：
\n
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package_name
",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/python-files.html",
            "url": "https://jiankychen.github.io/python-files.html",
            "title": "Python 文件操作",
            "date_published": "2023-01-14T09:51:32.000Z",
            "content_html": "
# 文件编码
\n
编码：一种规则集合，记录了内容和二进制间进行相互转换的逻辑
\n
计算机中有许多可用编码，例如：
\n\n
UTF-8 是目前全球通用的编码格式
\n
除非有特殊需求，否则，一律以 UTF-8 格式进行文件编码即可
\n
# 文件的读取
\n
# 访问模式
\n
常用的三种基础访问模式：
\n\n
# 打开文件
\n
使用  open  函数可以打开一个已经存在的文件，或者创建一个新文件（使用  'w'  模式时）
\n
open(name, mode, encoding)
其中：
\n\n
操作文件需要通过  open  函数打开文件得到文件对象
\n
例如：
\n
# encoding 不是第三个位置参数，需要采用关键字传参
file_obj = open('python.txt', 'r', encoding='UTF-8')
注意：此时的  file_obj  是  open  函数的文件对象（Python 中一种特殊的数据类型），拥有属性和方法，可以使用  对象.属性  或  对象.方法  对其进行访问
\n
# 关闭文件
\n
close  关闭文件对象，即，关闭对文件的占用
\n
file_obj.close()
如果不调用  close  ，并且程序没有停止运行，那么这个文件将一直被 Python 程序占用（除  with open  语法外）
\n
# 读操作
\n
# read 方法
\n
read  可以读取给定长度的数据
\n
file_obj.read(num)
其中，num 表示要从文件中读取的数据的长度（字节数）。如果没有传入 num，表示读取文件中所有的数据
\n
# readlines 方法
\n
readlines  可以一次性读取整个文件中的内容。 readlines  返回的是一个列表，其中，文件每一行的数据对应列表的一个元素
\n
file_obj.readlines()
# readline 方法
\n
readline  一次读取一行数据
\n
file_obj.readline()
# for 循环读取文件行
\n
可以使用  for  循环遍历读取文件的每一行内容
\n
# 临时变量 line 记录文件的一行数据
for line in open(name, mode, encoding):
    print(line)
# with open 语法
\n
通过在  with open  的语句块中对文件进行操作，可以在操作完成后自动关闭文件，避免因忘记  close  文件对象而导致文件被占用
\n
with open(name, mode, encoding) as file_obj:
    file_obj.readlines()
# 文件的写入
\n
# 打开文件
\n
file_obj = open(name, mode='w', encoding='UTF-8')
使用  'w'  模式时：
\n\n
# 写操作
\n
file_obj.write(content)
content  表示需要写入的内容
\n
注意：调用  write  时，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
\n
当调用  flush  时，内容会真正写入文件
\n
file_obj.flush()
\n
write  写入内容 +  flush  刷新内容到硬盘，这样做是避免因频繁操作硬盘而导致效率下降
\n
\n
# 关闭文件
\n
file_obj.close()
注意： close  方法内置了  flush  的功能
\n
# 文件的追加写入
\n
# 打开文件
\n
file_obj = open(name, 'a', encoding='UTF-8')
使用 'a' 模式时：
\n\n
# 追加写入操作
\n
# 写入内容 content
file_obj.write(content)
# 刷新内容
file_obj.flush()
# 关闭文件
\n
file_obj.close()
参考：黑马程序员
\n",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/job.html",
            "url": "https://jiankychen.github.io/job.html",
            "title": "23 求职笔面试",
            "date_published": "2022-12-07T13:13:47.000Z",
            "content_html": "
# TP-Link（嵌入式软件）
\n
# 笔试
\n
选择题：
\n\n
简答题：
\n\n
编程题：
\n\n
选择题、简答题、编程题一共 60 分钟
\n
行测：（每部分 10 分钟）
\n\n
# 一面
\n
宏
\n
快速排序、选择排序的基本原理
\n
全局变量、局部变量、静态变量
\n
解决哈希冲突的方法
\n
介绍拉链法的原理
\n
OSI 参考模型：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
\n
第一轮面试一共 10 分钟
\n
# 二面
\n
智力题：7g 砝码和 2g 砝码各一个，天平一个，如何用最少次数将 140g 盐分成 50g 和 90g 各一份？
\n\n
算法题：二叉树的最近公共祖先（力扣 236）
\n\n
最后问了项目，大概 10 分钟左右
\n
第二轮面试一共 40 分钟
\n
# 三面
\n
自我介绍
\n
本科成绩是什么情况？是保研的吗？
\n
为嵌入式软件岗做了哪些相关准备？
\n
计算机网络、操作系统、数据结构与算法学过吗？
\n
数据结构与算法刷了多少题？
\n
TCP 与 UDP 有什么区别？
\n
如何理解 TCP 的可靠传输？
\n
TCP/IP 网络模型是怎样的？每一层对应有哪些协议？
\n
如何用两个队列实现一个栈？
\n
研究生课题的主要内容？目的是什么？是不是自己一个人完成的？成果？
\n
有哪些兴趣爱好？是否拿出摄影作品去参加过学校的展览？骑行都去过哪些地方？
\n
父母的工作
\n
兄弟姐妹的情况
\n
反问：
\n\n
最后，面试官建议认真学一下操作系统
\n
第三轮面试一共 18 分钟
\n
# SHEIN（算法工程师 - 运筹预测方向）
\n
# 测评
\n
一共包含四个模块，全都是选择题
\n\n
# 笔试
\n
题型：15 道单选题，2 道算法题，2 道问答题
\n
限时 60 分钟
\n
单选题涉及的知识：
\n\n
算法题：
\n\n
问答题：
\n\n
# 蔚来（智能调度和控制算法工程师）
\n
# 提前批
\n
# 笔试（大数据的试卷）
\n
10 道单选题：设计模式、概率论相关知识点
\n
9 道不定项选择题：操作系统、数据库相关知识点
\n
3 道算法题（核心代码模式）：
\n\n
# 正式批
\n
# 测评（北森系统）
\n
10 道言语理解，每小题有相应限时
\n
10 道图表分析，每小题有相应限时
\n
10 道图形推理，每小题有相应限时
\n
99 道性格测试，每小题有相应限时
\n
# 三一（算法工程师）
\n
# 测评（北森）
\n
行测，每题都有对应的限时：
\n\n
性格测评，不限时：
\n\n
# 笔试
\n
一共 30 道选择题（20 道单选，10 道多选），限时 60 分钟：
\n\n
# 一面
\n
自我介绍
\n
学习成绩
\n
英语六级成绩
\n
用的什么编程语言
\n
简述利用 matlab 实现的一个算法
\n
对汽车有没有什么了解
\n
建议：
\n\n
面试一共 6 分钟（邮件里写的 20 分钟）
\n
# 中兴（算法工程师）
\n
# 测评（北森系统）
\n
行测：
\n\n
性格测评，不限时：
\n\n
# 面试
\n
安排了软件工程师的面试
\n
拒掉了面试
\n
# 用友（运筹优化算法工程师）
\n
# 测评
\n
行测：数量关系、演绎论证、图形推理、图表分析，一共 28 道选择题，限时 30 分钟
\n
性格测评：一共 88 题（每题需从三个选项中选出最符合、最不符合），限时 30 分钟
\n
# 大疆（决策与规划算法工程师）
\n
# 测评
\n
一共 80 道题，限时 80 分钟
\n\n
# 笔试
\n
一共 25 道不定项选择题，限时 60 分钟
\n
内容涉及以下方面：
\n\n
# 杉数科技（算法工程师 - 运筹优化方向）
\n
# 一面
\n
自我介绍
\n
讲解项目（大概聊了 20 分钟）
\n
KKT 条件
\n\n
从 branch-and-bound 、Benders 分解、Largrange 松弛、列生成 四个算法中选择一个算法，讲解其原理以及应用场景
\n
使用的编程语言，有没有使用 C++ 实现算法
\n
给两道场景题，要求建立数学模型（口述）：都是排产、排程相关的场景
\n\n
面试官介绍业务（主要是与工厂的排班排程相关的实际问题），并且主要使用 python
\n
反问：
\n\n
面试一共 50 分钟左右（邮件里写的是 60 分钟）
\n
面试官很友好，并且会及时提供引导。面试体验挺不错，虽然很多都不会 hh
\n
# 笔试
\n
一共两道题，24 小时内做完
\n\n
备注：优先使用 python
\n
# 二面
\n
两个面试官，副总裁和业务总监
\n
首先进行自我介绍，讲一讲对杉数的认识，自己的优势
\n
自己对这一岗位的工作规划，可能遇到的问题以及解决方案
\n
介绍项目
\n
反问
\n
# 顺丰科技（运筹优化算法工程师）
\n
# 测评
\n
言语理解、性格测评、情景题
\n
# 笔试
\n
120 分钟
\n
选择题：单选、多选共 34 道题，一共 70 分：主要考察运筹优化算法、概率论相关
\n
编程题：两道，ACM 模式，每题 15 分
\n\n
# 小米（运筹 / 强化学习算法工程师）
\n
# 测评（北森系统）
\n
行测：
\n\n
性格测评，不限时：
\n\n
性格测评的这两个板块直接复用了之前做过中兴的测评
\n
# 笔试（算法方向）
\n
16 道单选题，每题 2 分，主要涉及以下方面的知识点：
\n\n
17 道多选题，每题 2 分，涉及以下内容：
\n\n
2 道编程题，每题 17 分，均为 ACM 模式：
\n\n\n
# 美团（运筹优化研发工程师）
\n
# 笔试
\n
四道编程题，每题 20 分：
\n\n
三道多项选择题：
\n\n
一共限时 120 分钟
\n
# 一面
\n
面试官首先自我介绍，并介绍事业部的主要工作，介绍面试流程
\n
自我介绍
\n
有没有实习
\n
聊项目
\n
对遗传算法、禁忌搜索等算法有没有了解？
\n
介绍一下遗传算法
\n
如果用遗传算法来求解 TSP 问题要怎么求解？
\n
对禁忌搜索这些算法有没有什么了解？
\n
对机器学习是否有了解？
\n
有没有做相应的机器学习算法实践？
\n
主要用的是什么编程语言？做题用什么语言？
\n
手撕代码，核心代码模式（在牛客上进行的面试，面试官可以直接在系统上出题）
\n\n
反问：
\n\n
面试一共 45 分钟，其中，25 分钟项目、10 分钟代码、5 分钟反问
\n
# 字节跳动（算法工程师 - 运筹优化）
\n
# 笔试
\n
120 分钟
\n
四道编程题，ACM 模式，分值分别为 20，25，25，30
\n\n
# 华为（AI 工程师 - 决策推理方向）
\n
# 一次笔试
\n
一共三题，分值分别为 100、200、300，限时 120 分钟
\n
猪场防疫（第一题）：猪场现有 N 只猪，编号从 0 到 N - 1 （每只猪无论生死都有唯一的编号）。老李在每只猪生产的时候记录了生产的母猪和出生的小猪，格式为 x y1 y2 y3 ... ，其中，x 为母猪，y1、y2、y3... 为新生的小猪，以上编码均在 0 ~ N - 1 范围内，每只猪可以多次生产，每只小猪都只有一个猪妈妈。现需要检查任意两只猪是否有亲戚关系（两只猪具有相同的祖先），并计算出关系亲疏情况（关系距离，若相同编号则距离为 0）
\n\n
速战速决（第二题）：在一个 M 行 N 列的街区中，有一个士兵 S 和一个敌人 E ，标识 X 为无法通过的街区，标识 B 为可以通过的街区；士兵在一个单位时间内可以从一个街区移动到相邻的街区（每次只能水平或垂直方向移动一个街区）；士兵每次改变方向时，需要额外花费一个单位的时间（士兵第一次移动一个街区的时候，不用考虑其初始方向，即，只需要一个单位时间即可到达相邻街区）。计算士兵最少需要多少时间才能到达敌人所在的街区
\n\n
# 二次笔试（时隔一个月）
\n\n
# 京东
\n
# 笔试
\n
选择题，主要考察算法与数据结构、机器学习相关知识
\n
三道编程题：
\n\n
# 百度
\n
# 笔试
\n
15 道单选题，一共 45 分，涉及知识点：
\n\n
5 道不定项选择题，一共 15 分，涉及知识点：
\n\n
3 道编程题，分值分别为 10 分、15 分、15 分，均为 ACM 模式
\n\n
笔试一共限时 120 分钟
\n
# 招银网络科技
\n
# 测评（北森系统）
\n
行测：
\n\n
性格测评，不限时：
\n\n
# 美的（嵌入式软件）
\n
# 笔试
\n
10 道单选，每题 2 分，主要考察操作系统、计算机网络的相关知识
\n
5 道不定项选择题，每题 4 分（少选错选不得分），主要考察操作系统、计算机网络的相关知识
\n
3 道编程题，ACM 模式：
\n\n
# 中信银行信用卡中心
\n
# 测评（TAS 测评系统）
\n
Talent5 大五职业性格测评：共 138 题，不限时
\n
iLogic 言语推理测评：共 15 题，限时 20 分钟（每题有相应限时）
\n
iLogic 数字推理测评：共 15 题，限时 20 分钟（每题有相应限时）
\n
iLogic 逻辑推理测评：共 10 题，限时 17 分钟（每题有相应限时）
\n
iDriver 职业驱动力测评：共 112 题，不限时
\n
Menlth 心理状态扫描：共 50 题，不限时
\n
# 笔试
\n
30 道单项选择题，每题 2 分，考察 Linux 系统、Java、计算机网络、MySQL、数据结构 相关知识
\n
3 道编程题，ACM 模式，一共 40 分
\n\n",
            "tags": []
        },
        {
            "id": "https://jiankychen.github.io/python-container.html",
            "url": "https://jiankychen.github.io/python-container.html",
            "title": "Python 数据容器",
            "date_published": "2022-12-01T11:21:27.000Z",
            "content_html": "
数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为 1 个元素，其中，每一个元素可以是任意类型的数据，如字符串、数字、布尔等
\n
Python 数据容器可以分为 5 类：
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
列表元组字符串集合字典
元素类型任意任意字符任意key-value (key: 除字典外任意类型，value: 任意类型)
下标索引支持支持支持不支持不支持
数据有序是是是否否
重复元素支持支持支持不支持不支持
可修改性是否是是是
\n
\n
在 Python 中，有序是指其中的数据可以通过索引（即下标）进行访问
\n
\n
# 列表
\n
# 列表的定义
\n
# 字面量
[元素1, 元素2, ...]
# 定义变量
变量名 =  [元素1, 元素2, ...]
#定义空列表
变量名称 = []
变量名称 = list()
列表可以同时存储不同的数据类型，并且，列表支持嵌套
\n
例如：
\n
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))
# 列表的方法
\n
# 访问元素
\n
可以通过列表的下标索引 idx 获取对应位置的数据
\n
value = list_name[idx]
其中，列表的下标索引可以分为两种：
\n\n
\n
要注意下标索引的取值范围，超出范围会报错
\n
\n
# 查找元素
\n
查找元素 element 在列表 list_name 中的下标（元素在列表中的第一个匹配位置），如果找不到则报错 ValueError
\n
list_name.index(element)
# 修改元素
\n
修改下标为 idx 的元素的值
\n
list_name[idx] = value
# 插入元素
\n
在下标 idx 处插入元素 element
\n
list_name.insert(idx, element)
# 追加元素
\n
方式一
\n
将元素 element 追加到列表 list_name 的尾部
\n
list_name.append(element)
例如：
\n
name_list = [\"it\", \"its\", \"itself\"]
name_list.append(\"itheima\")
方式二
\n
将其他数据容器的内容取出，依次追加到列表 list_name 的尾部
\n
list_name.extend(Data)
例如：
\n
mylist = [1, 3, 5]
temp_list = [2, 4, 6]
mylist.extend(temp_list)
# 删除指定位置元素
\n
删除下标 idx 处的元素
\n
del list_name[idx]
list_name.pop(idx)      # 该方式可以获取返回值（被删除的元素）
# 删除指定元素
\n
删除指定元素值在列表中的第一个匹配项
\n
list_name.remove(element)   # 删除元素 element 在列表中的第一个匹配项
# 清空列表
\n
清空列表内容
\n
list_name.clear()
# 统计指定元素数量
\n
统计元素 element 在列表 list_name 中的数量
\n
list_name.count(element)
# 其他
\n
# 统计列表元素数量
\n
统计整个列表中的元素总数量
\n
len(list_name)
# 列表的 while 遍历
\n
idx = 0
while idx < len(list_name):
    statement
    idx += 1
# 列表的 for 遍历
\n
for i in range(0, len(list_name)):
    statement
# 元组
\n
元组（tuple）：元组同列表一样，都是一种可以封装多个、不同类型的元素的容器；不同点在于，元素一旦定义完成，就不可以修改
\n
# 元组的定义
\n
定义元组：使用小括号包围数据，其中，每个数据之间用逗号隔开（数据可以是不同的数据类型）
\n
# 定义元组字面量
(元素1, 元素2, ...)
# 定义元组变量
变量名称 = (元素1, 元素2, ...)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
注意：如果元组只有一个数据，需要在这个数据后面添加逗号，否则不是元组类型
\n
例如：
\n
t4 = (\"World\", )
元组也支持嵌套
\n
注意：
\n\n
例如：
\n
mytuple = (1, 2, [\"it\", \"20221124\"])
mytuple[2][0] = \"python\"
# 元组的方法
\n
# 访问元素
\n
元组支持下标索引
\n
element = tuple_name[idx]
# 查找元素
\n
查找指定元素的第一个匹配项
\n
tuple_name.index(element)
# 统计指定元素数量
\n
tuple_name.count(element)
# 其他
\n
# 统计元素数量
\n
len(tuple_name)
# 元组的 while 遍历
\n
idx = 0
while idx < len(tuple_name):
    statement
    idx += 1
# 元组的 for 遍历
\n
for element in tuple_name:
    statement
# 字符串
\n
字符串（str）：字符串是字符的容器，一个字符串可以存放任意数量的字符
\n
字符串是一个 无法修改 的数据容器
\n
# 字符串的定义
\n
使用一对双引号包围一系列字符
\n
str_name = \"Here is the content of string\"
# 字符串的方法
\n
# 访问元素
\n
字符串支持下标索引
\n\n
# 查找子串
\n
查找子串 target_str 在字符串 str_name 中的下标索引值
\n
str_name.index(target_str)
# 替换子串
\n
将字符串 str_name 内的 str1 全部替换为 str2
\n
str_name.replace(str1, str2)
注意，此方法并不是修改字符串本身（字符串是无法修改的），而是得到了一个新的字符串
\n
# 分割子串
\n
按照指定的分隔符字符串 separator，将字符串划分为多个子字符串并存入列表对象中
\n
str_name.split(separator)
注意，此方法并不是修改字符串本身，而是得到了一个列表对象
\n
例如：
\n
my_str = \"hello python itheima and itcast\"
result = my_str.split(\" \")  # 按照空格进行分割，得到一个列表
# 去除前后空格
\n
strip () 方法删除开头和结尾的空白字符
\n
str_name.strip()
例如：
\n
my_str = \"   itheima and itcast   \"
new_my_str = my_str.strip()
# 去除前后指定字符串
\n
通过给 strip () 方法传入参数，可以删除字符串开头和结尾处的指定字符串
\n
str_name.strip(target_str)
需要注意，删除操作是按照单个字符进行的
\n
例如：
\n
my_str = \"12itheima and itcast21\"
new_my_str = my_str.strip(\"12\")     # 传入的是 \"12\"，此时，\"1\" 和 \"2\" 都会移除，即，按照单个字符移除
# 统计指定字符串数量
\n
统计字符串中某子串的出现次数
\n
str_name.count(target_str)
例如：
\n
my_str = \"itheima and itcast\"
cnt = my_str.count('it')
# 其他
\n
# 统计字符串长度
\n
len(str_name)
# 字符串的 while 遍历
\n
idx = 0
while idx < len(str_name)
    statement
    idx += 1
# 字符串的 for 遍历
\n
for element in str_name:
    statement
# 序列
\n
序列是指内容连续、有序，并且可使用下标索引的一类数据容器
\n
序列是字符串、元组、列表的统称
\n
序列支持切片，即：从序列的指定位置开始，依次取出元素，到指定位置结束，得到一个新序列（该操作不会影响原序列，而是生成了一个新的序列）
\n
sequence[start:end:step]
其中：
\n\n
# 集合
\n
集合（set）：不支持元素重复（自带去重功能），并且内容无序
\n
集合是无序的，不支持下标索引访问
\n
集合是可以修改的
\n
# 集合的定义
\n
定义集合：使用大括号包围数据，其中，每个数据之间用逗号隔开
\n
# 定义集合字面量
{元素1, 元素2, ...}
# 定义集合变量
变量名称 = {元素1, 元素2, ...}
# 定义空集合
变量名称 = set()
# 集合的方法
\n
# 添加元素
\n
将指定元素添加到集合内
\n
set_name.add(element)
# 删除元素
\n
将指定元素从集合内移除
\n
set_name.remove(element)
# 随机取出元素
\n
从集合中随机取出一个元素（集合本身被修改，元素被移除）
\n
该操作可以具有返回值
\n
element = set_name.pop()
# 清空集合
\n
set_name.clear()
# 取两集合的差集
\n
取出集合 1 与集合 2 的差集：元素在集合 1 中、但不在集合 2 中
\n
该操作得到一个新集合，集合 1 和集合 2 保持不变
\n
new_set = set1.difference(set2)
# 消除两集合的差集
\n
消除集合 1 与集合 2 的差集：对比集合 1 和集合 2，在集合 1 内，删除与集合 2 相同的元素
\n
该操作修改了集合 2，集合 2 保持不变
\n
set1.difference_update(set2)
# 合并两集合
\n
合并 2 个集合：将集合 1 与集合 2 组成新集合
\n
该操作得到一个新集合，集合 1 与集合 2 保持不变
\n
new_set = set1.union(set2)
# 其他
\n
# 统计集合元素数量
\n
len(set_name)
# 集合的遍历
\n
集合不支持下标索引，不能使用 while 循环遍历
\n
集合可以使用 for 循环遍历
\n
for element in set_name
    statement
# 字典
\n
字典（dict）：存储键值对（即，key-value 对），可以提供基于 key 检索 value 的场景实现
\n
字典不支持重复的 key ，重复添加等同于覆盖原有数据
\n
# 字典的定义
\n
使用大括号 {} 包围元素，其中，每一个元素都是一个键值对（key: value），元素之间用逗号隔开
\n
# 定义字典字面量
{key: value, key: value, ...}
# 定义字典变量
变量名称 = {key: value, key: value, ...}
# 定义空字典
变量名称 = {}
变量名称 = dict()
字典的 key 和 value 可以是任意数据类型（key 不可为字典）
\n
因此可以将 字典 2 作为 字典 1 的 value ，实现字典的嵌套
\n
例如：
\n
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()
# 字典的方法
\n
# 访问元素
\n
字典同集合一样，不支持下标索引。但是，字典可以通过 key 来获取对应的 value
\n
value = dict_name[key]
# 添加 / 更新元素
\n
新增元素 / 更新元素：如果 key 不存在，则新增元素；如果 key 存在，则更新元素（更新 value 值）
\n
dict_name[key] = value
# 删除元素
\n
将 key 所在键值对从字典中删除
\n
该操作具有返回值，可以获取 key 所对应的 value
\n
value = dict_name.pop(key)
# 清空字典
\n
dict_name.clear()
# 获取 key 列表
\n
获取全部的 key
\n
keys = dict_name.keys()
例如：
\n
my_dict = {\"a\": 0, \"b\": 1, \"c\": 2, \"d\": 3}
keys = my_dict.keys()
print(f\"通过 keys 方法获取全部的 key ，结果为：{keys} ，其数据类型为：{type(keys)}\")
# 其他
\n
# 统计元素数量
\n
统计字典的元素数量（一个键值对视为一个元素）
\n
len(dict_name)
# 字典的遍历
\n
方式 1：获取全部的 key ，从而实现遍历
\n
keys = dict_name.keys()
for key in keys:
    statement
方式 2：直接对字典进行 for 循环遍历，每次循环都是直接得到 key
\n
for key in dict_name:
    statement
# 数据容器的通用操作
\n
# 统计元素数量
\n
len(数据容器)
# 获取最大元素
\n
max(数据容器)
# 获取最小元素
\n
min(数据容器)
# 类型转换
\n
# 转为列表
\n
将给定容器转换为列表
\n\n
list(数据容器)
# 转为元组
\n
将给定容器转换为元组
\n\n
tuple(数据容器)
# 转为字符串
\n
将给定容器转换为字符串：整个容器（包括容器的组成括号）均被转换为字符串
\n
str(数据容器)
例如：
\n
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}\"
# 转为集合
\n
将给定容器转换为集合
\n\n
set(数据容器)
\n
转换为集合后，原容器的数据有序性将不再保持
\n
\n
# 排序
\n
将给定容器进行排序：
\n\n
按升序排序（默认按照升序排序）：
\n
sorted(容器)
按降序排序：
\n
sorted(容器, reverse=True)
参考：
\n\n",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/python-basics.html",
            "url": "https://jiankychen.github.io/python-basics.html",
            "title": "Python 基本语法",
            "date_published": "2022-11-30T08:09:05.000Z",
            "content_html": "
# 条件语句
\n
# if
\n
if condition:
    statement
# if - else
\n
if condition:
    statement1
else:
    statement2
# if - eles if - else
\n
if condition1:
    statement1
elif condition2:
    statement2
else:
    statement3
# 循环语句
\n
# while
\n
while condition:
    statement
# for
\n
for 循环无法定义循环条件，只能从 序列 中取出数据处理
\n
for i in sequence:
    statement
# range
\n
range 语句：产生一个序列
\n\n
# continue
\n
continue: 中断本次循环，直接进入下一次循环
\n
continue 可用于 while 和 for 循环
\n
# break
\n
break: 直接结束循环
\n
break 可用于 while 和 for 循环
\n
# 函数
\n
函数的定义：
\n
def func(parameters):
    statement
    return results
函数必须先定义后使用
\n
# 函数的返回值
\n
如果函数没有 return 语句，将默认返回 None
\n
\n
None 可用于声明无初始内容的变量，并且，None 可用于 if 判断
\n
\n
如果函数有多个返回值，则将多个返回值（用逗号分隔）同时放在一个 return 语句中
\n
例如：
\n
def div(x, y):
    quotient = x // y
    remainder = x % y
    return quotient, remainder
# 传参方式
\n
# 位置参数
\n
调用函数时根据函数定义的参数位置来传递参数
\n
注意：实参的顺序及个数必须与形参列表保持一致
\n
# 关键字参数
\n
函数调用时通过 “key=value” 形式传递参数
\n
可以让函数更见清晰，同时也消除了参数的顺序需求（关键字参数之间不存在先后顺序）
\n
注意：在调用函数时，如果混用位置参数与关键字参数，必须将位置参数放在关键字参数的前面
\n
# 缺省参数（默认参数）
\n
定义函数时，如果为参数提供默认值，则在调用函数时可以不传递该默认参数的值
\n
在调用函数时，如果为缺省参数传递值则修改默认参数值，否则，使用默认值
\n
注意：无论是定义函数或者调用函数，所有位置参数都必须出现在默认参数之前
\n
# 不定长参数（可变参数）
\n
不定长参数用于不确定实参数量（不传参也可以）的场景
\n
不定长参数的类型：
\n\n
# 位置不定长
\n
位置不定长传递以 * 号标记一个形式参数，以元组的形式接收传入的实参，形式参数一般命名为 args
\n
例如：
\n
def user_info(*args):
    print(args)
# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)
# 关键字不定长
\n
关键字不定长传递以 ** 号标记一个形式参数，以字典的形式接收传入的实参，形式参数一般命名为 kwargs
\n
传递的所有实参均为 "key=value" 形式
\n
例如：
\n
def user_info(**kwargs):
    print(kwargs)
# ('name': 'TOM', 'age': 18, 'id': 198)
user_info(name='TOM', age=18, id=198)
# 函数作为参数传递
\n
函数本身是可以作为参数传入到另一个函数中使用的
\n
将函数作为参数的作用：传入的是计算逻辑，而不是计算数据
\n
# lambda 匿名函数
\n
函数的两种定义方式：
\n\n
匿名函数的定义：
\n
lambda 传入参数: 函数体
其中：
\n\n
例如：
\n
# 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
# 局部变量与全局变量
\n
局部变量：定义在函数体内部的变量，只在函数体内部生效
\n
全局变量：在函数体内、外都能生效的变量
\n
在函数内无法修改全局变量
\n
\n
如果尝试在函数内部修改全局变量，实际上是定义了一个与全局变量同名的局部变量
\n
\n
使用 global 关键字，可以在函数内部声明变量为全局变量
\n
参考：
\n\n",
            "tags": [
                "Python"
            ]
        },
        {
            "id": "https://jiankychen.github.io/leetcode-analog.html",
            "url": "https://jiankychen.github.io/leetcode-analog.html",
            "title": "LeetCode - 模拟专题",
            "date_published": "2022-10-28T12:35:22.000Z",
            "content_html": "
# LeetCode 463. 岛屿的周长
\n
LeetCode 463. Island Perimeter
\n
给定一个  row x col  的二维网格地图  grid  ，其中： grid[i][j] = 1  表示陆地， grid[i][j] = 0  表示水域
\n
网格中的格子 水平 和 垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）
\n
岛屿中没有 “湖”（“湖” 是指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长
\n
示例 1：
\n
\"\"
\n
输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]\n输出：16\n解释：它的周长是上面图片中的 16 个黄色的边\n
\n
示例 2：
\n
输入：grid = [[1]]\n输出：4\n
\n
示例 3：
\n
输入：grid = [[1,0]]\n输出：4\n
\n
提示：
\n\n
# Method 1: 模拟
\n
# 算法思路
\n
对于一个岛屿格子的每条边：如果这条边为网格的边界，或者这条边是岛屿与水域的分界线，则需将这条边计入岛屿的周长
\n
因此，可以遍历每个岛屿格子，看其四个方向的边是否为网格边界或水域分界线，如果是，则计入岛屿周长
\n
# 代码实现
\n
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;
}
# 复杂度分析
\n
时间复杂度：O(m×n)O(m \\times n)O(m×n)，其中，mmm 和 nnn 分别为网格的行数和列数
\n
空间复杂度：O(1)O(1)O(1)
\n
# Method 2: 深度优先搜索
\n
# 算法思路
\n
可以将方法一改成深度优先搜索遍历的方式（该方式可以拓展至多个岛屿情形）
\n
其中，为避免岛屿格子被重复遍历，需要将已经遍历过的岛屿格子标记。特别地，可以将已经遍历过的岛屿格子的值置为 -1 （不能置为 0，因为置 0 会形成新的 “水域边界线”，进而导致结果出错）
\n
# 代码实现
\n
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;
}
# 复杂度分析
\n
时间复杂度：O(m×n)O(m \\times n)O(m×n)，其中，mmm 和 nnn 分别为网格的行数和列数
\n
空间复杂度：O(m×n)O(m \\times n)O(m×n)
\n
参考：力扣官方题解
\n
# LeetCode 48. 旋转图像
\n
48. Rotate Image
\n
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
\n
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
\n
示例 1：
\n
\"\"
\n
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]\n输出：[[7,4,1],[8,5,2],[9,6,3]]\n
\n
示例 2：
\n
\"\"
\n
输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]\n输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]\n
\n
提示：
\n\n
# Method 1: 原地旋转
\n
经过观察，可以发现：
\n\n
即，对于 matrix[i][j]matrix[i][j]matrix[i][j] 、matrix[j][n−i−1]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−i−1][n−j−1] 、matrix[n−j−1][i]matrix[n - j - 1][i]matrix[n−j−1][i] 而言，每一项旋转后的位置就是下一项所在的位置
\n
因此，可以引入一个临时变量  tmp  ，完成这四项的原地交换
\n
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;
那么，我们应该枚举哪些 iii 和 jjj 呢？
\n
每一次可以交换四个位置的元素：
\n\n
因此，无论 nnn 是奇数还是偶数，均可按照 “ iii 遍历 n/2n / 2n/2 个位置、jjj 遍历 (n+1)/2(n + 1) / 2(n+1)/2 个位置 ” 来处理，即， i  遍历  [0, n / 2)  ， j  遍历  [0, (n + 1) / 2)
\n
代码实现：
\n
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(n2)O(n^2)O(n2)
\n
空间复杂度：O(1)O(1)O(1)
\n
# Method 2: 翻转
\n
算法思路：
\n
首先进行上下翻转，然后进行对角线翻转（即，转置）
\n
理论推导：
\n
对于上下翻转：只需要枚举矩阵上半部分的元素，并将其与下半部分对应位置的元素进行交换，即
\n
matrix[i][j]⟷matrix[n−i−1][j]matrix[i][j] \\longleftrightarrow matrix[n - i - 1][j]\nmatrix[i][j]⟷matrix[n−i−1][j]
\n
对于对角线翻转：只需要枚举对角线左侧的元素，并将其与右侧对应位置的元素进行交换，即
\n
matrix[i][j]⟷matrix[j][i]matrix[i][j] \\longleftrightarrow matrix[j][i]\nmatrix[i][j]⟷matrix[j][i]
\n
联立以上两式可得
\n
matrix[i][j]⟶matrix[n−i−1][j]⟶matrix[j][n−i−1]matrix[i][j] \\longrightarrow matrix[n - i - 1][j] \\longrightarrow matrix[j][n - i - 1]\nmatrix[i][j]⟶matrix[n−i−1][j]⟶matrix[j][n−i−1]
\n
即，实现了将 matrix[i][j]matrix[i][j]matrix[i][j] 旋转 90 度、放到 matrix[j][n−i−1]matrix[j][n - i - 1]matrix[j][n−i−1] 位置
\n
代码实现：
\n
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(n2)O(n^2)O(n2)
\n
空间复杂度：O(1)O(1)O(1)
\n
参考：leetcode-solution
\n
# LeetCode 59. 螺旋矩阵 II
\n
LeetCode 59. Spiral Matrix II
\n
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
\n
示例 1：
\n
\"\"
\n
输入：n = 3\n输出：[[1,2,3],[8,9,4],[7,6,5]]\n
\n
示例 2：
\n
输入：n = 1\n输出：[[1]]\n
\n
\n
提示：
\n\n
# Method: 模拟
\n
思路：模拟 顺时针画矩阵的过程，即
\n\n
由外向内一圈一圈这么画下去
\n
注意：每画一条边都要坚持一致的 左闭右开 ，或者 左开又闭 的原则，这样这一圈才能按照统一的规则画下来
\n
\n
坚持 循环不变量 原则
\n
\n
下图以左闭右开原则为例：每一种颜色，代表一条边，注意每一个拐角处的处理规则，拐角处让给新的一条边来继续画（即，每条边都遵循左闭右开原则）
\n
\"\"
\n
代码实现：
\n
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(n2)O(n^2)O(n2)，需要填充 n2n^2n2 个元素
\n
空间复杂度：O(n2)O(n^2)O(n2)
\n
参考：代码随想录：螺旋矩阵 II
\n
# LeetCode 621. 任务调度器
\n
621. Task Scheduler
\n
给你一个用字符数组  tasks  表示的 CPU 需要执行的任务列表。其中每个字母表示一种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。在任何一个单位时间，CPU 可以完成一个任务，或者处于待命状态。
\n
然而，两个 相同种类 的任务之间必须有长度为整数  n  的冷却时间，因此至少有连续  n  个单位时间内 CPU 在执行不同的任务，或者在待命状态。
\n
你需要计算 完成所有任务所需要的最短时间 。
\n
示例 1：
\n
输入：tasks = ["A","A","A","B","B","B"], n = 2\n输出：8\n解释：\nA -> B -> idle -> A -> B -> idle -> A -> B\n
\n
示例 2：
\n
输入：tasks = ["A","A","A","B","B","B"], n = 0\n输出：6\n解释：在这种情况下，任何大小为 6 的排列都可以满足要求，因为 n = 0\n["A","A","A","B","B","B"]\n["A","B","A","B","A","B"]\n["B","B","B","A","A","A"]\n...\n诸如此类\n
\n
示例 3：
\n
输入：tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2\n输出：16\n解释：一种可能的解决方案：\nA -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A\n
\n
提示：
\n\n
# Method: 桶思想
\n
# 算法思路
\n
使用一个宽为 n+1n + 1n+1 的矩阵来展示任务执行方案，其中，任务按照逐行遍历的顺序执行，空白格子对应 CPU 的待命状态
\n
于是，可以将具有最大数量的任务排布在矩阵的第一列，将其余任务依次排布成列。由于冷却时间为 nnn，上述排列方案可以保证满足题目要求，并且总时间最小
\n\n
因此，需要的最少时间为 max⁡(∣tasks∣,(maxn−1)×(n+1)+cnt)\\max{(\\vert \\textrm{tasks} \\vert, (\\textrm{maxn} - 1) \\times (n + 1) + \\textrm{cnt})}max(∣tasks∣,(maxn−1)×(n+1)+cnt)
\n
具体可参考 popopop
\n
# 代码实现
\n
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);
}
# 复杂度分析
\n
时间复杂度：O(n+∣Σ∣)O(n + \\vert \\Sigma \\vert)O(n+∣Σ∣)，其中，nnn 为数组 tasks 的长度，∣Σ∣\\vert \\Sigma \\vert∣Σ∣ 为数组 tasks 中可能出现的任务种类数
\n
空间复杂度：O(∣Σ∣)O(\\vert \\Sigma \\vert)O(∣Σ∣)
\n
参考：
\n\n",
            "tags": [
                "Coding",
                "模拟"
            ]
        },
        {
            "id": "https://jiankychen.github.io/cpp-classes.html",
            "url": "https://jiankychen.github.io/cpp-classes.html",
            "title": "C++ 类",
            "date_published": "2022-10-25T14:11:12.000Z",
            "content_html": "
# 定义抽象数据类型
\n
类的基本思想是数据抽象（data abstraction）和封装（encapsulation）
\n
数据抽象是一种依赖于接口（interface）和实现（implementation）分离的编程（以及设计）技术
\n\n
封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分
\n
类要想实现数据抽象和封装，需要首先定义一个抽象数据类型（abstract data type）
\n\n
本节将以 Sales_data 类为例，介绍类的定义与使用
\n
# 设计 Sales_data 类
\n
我们希望 Sales_item 类有一个名为 isbn 的成员函数（member function），并且具有一些等效于 + 、= 、+= 、<<和>> 运算符的函数
\n
于是，Sales_data 的接口应该包含以下操作：
\n\n
定义 Sales_data 类如下所示：
\n
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 类的成员
\n
Sales_data 类的使用示例：
\n
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;
}
# 定义成员函数
\n
成员函数的声明必须在类的内部，它的定义既可以在类的内部也可以在类的外部
\n
例如，上述的 isbn 函数定义在 Sales_data 类的内部，combine 和 avg_price 定义在类的外部
\n
和其他函数一样，类的成员函数也由函数类型、函数名、形参列表和函数体组成。以 isbn 函数为例，isbn 函数用于返回 Sales_data 对象的 bookNo 数据成员，其定义为
\n
std::string isbn() const { return bookNo; }
然而，isbn 函数是如何获得 bookNo 成员所依赖的对象的呢？
\n
# this
\n
不妨先观察 isbn 成员函数的调用：使用点运算符访问 trans 对象的 isbn 成员，由此来调用该函数
\n
Sales_data trans;
trans.isbn();
成员函数通过一个名为  this  的隐式参数来访问调用它的那个对象。具体来说，当我们调用一个成员函数时，请求该函数的对象地址 将会被用于初始化  this
\n
例如，如果调用  trans.isbn()  ，编译器将会把 trans 的地址传递给 isbn 函数的隐式形参  this  。可以等价地认为，编译器将  trans.isbn()  这一调用重写成了如下形式：
\n
// 伪代码，用于说明调用成员函数的实际执行过程
Sales_data::isbn(&trans)
其中，调用 Sales_data 的 isbn 成员时传入了 trans 的地址
\n
在成员函数内部，可以直接使用调用该函数的对象的成员，而无须通过成员访问运算符来做到这一点，因为  this  所指的就是当前对象。任何对类成员的直接访问都被看作  this  的隐式引用，也就是说，当 isbn 使用 bookNo 时，它隐式地使用  this  指向的成员，就像我们书写了 this->bookNo 一样
\n
this 形参是隐式定义的。任何自定义名为 this 的参数或变量都是非法的
\n
我们可以在成员函数体内部使用 this （尽管没有必要）
\n
std::string isbn() const { return this->bookNo; }
需要注意， this  是一个常量指针，不允许改变  this  中保存的地址
\n
# const 成员函数
\n
isbn 函数的另一个关键之处：参数列表后的  const  关键字，用于修改隐式  this  指针的类型
\n
默认情况下， this  的类型是指向类类型非常量版本的常量指针。例如，在 Sales_data 的成员函数中，this 的类型是 Sales_data *const
\n
尽管  this  是隐式的，也依然需要遵循初始化规则，这意味着：（在默认情况下）我们不能把  this  绑定到一个常量对象上，即，我们不能在一个常量对象上调用普通的成员函数（不加  const  的成员函数）
\n
于是，我们不禁会想到：如果想要在常量对象上调用普通成员函数，就应该将  this  声明成指向常量的指针（即，const Sales_data *const ）。然而， this  是隐式的，并不会出现在参数列表中。那我们应该在哪里将  this  声明成指向常量的指针呢？
\n
C++ 语言的做法是：允许把  const  关键字放在成员函数的参数列表之后，此时，紧跟在参数列表后面的  const  表示  this  是一个指向常量的指针
\n
像这样使用  const  的成员函数被称作 常量成员函数（const member function）
\n
因为  this  是指向常量的指针，常量成员函数不能改变调用它的对象的内容
\n
常量对象，以及常量对象的引用或指针都只能调用常量成员函数
\n
# 类作用域和成员函数
\n
类本身就是一个作用域，类成员函数的定义嵌套在类的作用域之内
\n
在上例中，isbn 中用到的名字 bookNo 是定义在 Sales_data 内的数据成员，并且，即使 bookNo 定义在 isbn 之后，isbn 也还是能够使用 bookNo
\n
这是因为，编译器分两步处理类：首先编译成员的声明，然后才编译成员函数体（如果有的话）
\n
因此，成员函数体可以随意使用类中的其他成员，无须在意这些成员出现的次序
\n
# 在类的外部定义
\n
当我们在类的外部定义成员函数时，成员函数的定义必须与它的声明匹配
\n\n
并且，类外部定义的成员名字必须包含它所属的类名
\n
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 的成员
\n
# 定义一个返回 this 对象的函数
\n
函数 combine 的设计初衷类似于复合赋值运算符 += 。调用该函数的对象代表的是赋值运算符左侧的运算对象，右侧运算对象则通过显式的实参被传入函数
\n
Sales_data& Sales_data::combine(const Sales_data &rhs) {
    units_sold += rhs.units_sold; // 把 rhs 的成员加到 this 对象的成员上
    revenue += rhs.revenue;
    return *this;                 // 返回调用该函数的对象
}
当我们的程序调用如下函数时，
\n
total.combine(trans);             // 更新变量 total 的值
total 的地址被绑定到隐式的 this 参数上，而 rhs 绑定到了 trans 上
\n
因此，当 combine 执行下面的语句时，
\n
units_sold += rhs.units_sold;
等效于 total.units_sold += trans.unit_sold
\n
一般来说，当我们定义的函数类似于某个内置运算符时，应该令该函数的行为尽量模仿这个运算符
\n\n
如前所述，我们无须使用隐式的  this  指针访问函数调用者的某个具体成员，但是，我们需要使用  this  来把调用函数的对象当成一个整体访问。因此，需要使用
\n
return *this; // 返回调用该函数的对象
以获得执行该函数的对象，其中，解引用  this  指针就是得到了 total 的地址
\n
# 定义类相关的非成员函数
\n
作为接口组成部分的非成员函数，它们的定义和声明都在类的外部，例如 add、read 和 print 等
\n
\n
一般来说，如果非成员函数是类接口的组成部分，则这些函数的声明应该与类在同一个头文件内。在这种方式下，用户使用接口的任何部分都只需要引入一个文件
\n
\n
// 定义 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 类属于不能被拷贝的类型，因此我们只能通过引用来传递它们。而且，因为读取和写入的操作会改变流的内容，两个函数接受的都是普通引用，而非对常量的引用
\n
# 构造函数
\n
每个类都分别定义了它的对象被初始化的方式
\n
类通过一个或几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做 构造函数（constructor）
\n\n
构造函数的任务是初始化类对象的数据成员。无论何时，只要类的对象被创建，就会执行构造函数
\n
类可以包含多个构造函数，但是，不同的构造函数之间必须在参数数量或参数类型上有所区别（类似于函数重载）
\n
不同于其他成员函数，构造函数不能被声明成  const  。当我们创建类的一个  const  对象时，直到构造函数完成初始化过程，对象才能真正取得其 “常量” 属性。因此，构造函数在构造  const  对象的过程中可以向其写值
\n
# 合成的默认构造函数
\n
我们的 Sales_data 类并没有定义任何构造函数，但是之前使用了 Sales_data 对象的程序仍然可以正确编译和运行，因此可以说明，Sales_data 对象执行了默认初始化
\n
Sales_data total; // 没有为 total 提供初始值，执行默认初始化
Sales_data trans; // 没有为 trans 提供初始值，执行默认初始化
类通过一个特殊的构造函数来控制默认初始化过程，这个函数叫做 默认构造函数（default constructor）
\n\n
编译器自动生成的构造函数被称为合成的默认构造函数（synthesized default constructor）
\n
对于大多数类来说，合成的默认构造函数将按照如下规则初始化类的数据成员：
\n\n
struct Sales_data {
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
}
例如，对上面的类而言，因为 Sales_data 为 units_sold 和 revenue 提供了初始值，所以合成的默认构造函数将使用这些值来初始化对应的成员，而 bookNo 并未提供初始值，所以合成的默认构造函数把 bookNo 默认初始化成一个空字符串
\n
然而，合成的默认构造函数只适合非常简单的类，比如现在定义的这个 Sales_data 版本
\n
通常来说，一个类必须定义它自己的默认构造函数，而不能仅依赖于合成的默认构造函数 。这是因为：
\n\n
# 定义构造函数
\n
对于我们的 Sales_data 类来说，我们可根据实际需要而定义不同的构造函数，例如：
\n
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
\n
在 C++ 11 标准中，如果我们需要默认的行为，可以通过在参数列表后面写上  = default  来要求编译器生成默认构造函数，其作用完全等同于之前使用的合成默认构造函数
\n
其中， = default  既可以与声明一起出现在类的内部，也可以作为定义出现在类的外部
\n\n
\n
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.
\n
\n
例如：
\n
Sales_data() = default;
需注意， = default  生成的默认构造函数之所以对 Sales_data 类有效，是因为我们已经为内置类型的数据成员提供初始值。如果编译器不支持类内初始值，默认构造函数就应该使用构造函数初始值列表来初始化类的每个成员
\n
# 构造函数初始值列表
\n
对于以下两个构造函数，其定义中出现了新的部分，即，冒号 以及 冒号与花括号之间的代码。我们把新出现的部分称为 构造函数初始值列表（constructor initialize list）
\n
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) { }
构造函数初始值列表负责为新创建对象的一个或几个数据成员赋初值
\n
构造函数初始值列表的组成：
\n\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
\n
Sales_data(const std::string &s): bookNo(s) { }  ，其只使用  s  来显式初始化 bookNo 。对于 units_sold 和 revenue 这两个成员而言，将利用类内初始值进行隐式初始化（类似于合成默认构造函数的方式）。因此，该构造函数等价于
\n
Sales_data(const std::string &s):
           bookNo(s), units_sold(0), revenue(0){ }
\n
当某个数据成员被构造函数初始值列表忽略时，它将以与合成默认构造函数相同的方式隐式初始化
\n
\n
通常情况下，构造函数使用类内初始值不失为一种好的选择，因为只要这样的初始值存在我们就能确保为成员赋予了一个正确的值。不过，如果你的编译器不支持类内初始值，则所有构造函数都应该显式地初始化每个内置类型的成员
\n
另外，我们需要注意， Sales_data(const std::string &s): bookNo(s) { }  中的  { }  实际是构造函数的函数体。因为我们定义这些构造函数的目的是为数据成员赋初值，其并不需要通过函数体实现，所以将函数体定义成空的
\n
# 在类的外部定义构造函数
\n
与其他几个构造函数不同，以  istream  对象为参数的构造函数  Sales_data(std::istream &)  需要执行一些实际的操作，在它的函数体内调用了 read 函数来给数据成员赋以初值
\n
Sales_data::Sales_data(std::istream &is) {
    read(is, *this); // 从 is 中读取一条信息然后存入 this 对象中
}
和其他成员函数一样，当我们在类的外部定义构造函数时，必须指明该构造函数是哪个类的成员
\n
因此， Sales_data::Sales_data  指出，我们定义了 Sales_data 类的成员 Sales_data 。因为该成员的名字和类名相同，所以它是一个构造函数（构造函数没有返回类型）
\n
由于  Sales_data(std::istream &)  函数定义了函数体，在执行该构造函数时，对象的成员是可以被初始化的（尽管这个构造函数初始值列表是空的）
\n
# 拷贝、赋值和析构
\n
除了定义类的对象如何初始化之外，类还需要控制拷贝、赋值和销毁对象时发生的行为
\n
如果我们不主动定义这些操作，编译器将替我们合成它们。一般来说，编译器生成的版本将对对象的每个成员执行拷贝、赋值和销毁操作
\n
例如：
\n
total = trans;
实际上等价于
\n
// Sales_data 的默认赋值操作等价于
total.bookNo = trans.bookNo;
total.units_sold = trans.units_sold;
total.revenue = trans.revenue;
尽管编译器能替我们合成拷贝、赋值和销毁的操作，但是必须要清楚的一点是，对于某些类来说合成的版本无法正常工作。特别是，当类需要分配类对象之外的资源时，合成的版本常常会失效。例如，管理动态内存的类通常不能依赖于上述操作的合成版本
\n\n
# 访问控制与封装
\n
在 C++ 语言中，我们使用 访问说明符（access specifiers）加强类的封装性：
\n\n
一个类可以包含 0 个或多个访问说明符，而且，某个访问说明符可以出现多次
\n
每个访问说明符指定了接下来的成员的访问级别，其有效范围直到出现下一个访问说明符或者到达类的结尾处为止
\n
再一次定义 Sales_data 类，其新形式如下所示：
\n
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  说明符后面
\n
在上面的定义中我们还做了一个微妙的变化，我们使用了  class  关键字而非  struct  开始类的定义。这种变化仅仅是形式上有所不同，实际上我们可以使用这两个关键字中的任何一个定义类。唯一的一点区别是， struct  和  class  的默认访问权限不太一样
\n
类可以在它的第一个访问说明符之前定义成员，这种成员的访问权限依赖于类定义的方式
\n\n
出于统一编程风格的考虑，如果我们希望定义的类的所有成员是  public  的，使用  struct  ；反之，如果希望成员是  private  的，使用  class 
\n
# 友元
\n
类可以将其他类或者函数声明成为它的 友元（friend），从而允许其他类或者函数访问它的非公有成员
\n
如果类想把一个函数作为它的友元，需要增加一条以  friend  关键字开始的函数声明语句
\n
例如，此前 定义抽象数据类型 时的 read、print 和 add 函数并不是类的成员，但却需要访问 Sales_data 类中  private  的数据成员，因此，我们需要将 read、print 和 add 函数作为 Sales_data 类的友元
\n
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&);
友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限。友元不是类的成员也不受它所在区域访问控制级别的约束
\n
\n
一般来说，最好在类定义开始或结束前的位置集中声明友元
\n
\n
# 友元的声明
\n
友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明
\n
如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明
\n
为了使友元对类的用户可见，我们通常把友元的声明与类本身放置在同一个头文件中（类的外部）
\n
因此，我们的 Sales_data 头文件应该为 read 、print 和 add 提供独立的声明（除了类内部的友元声明之外）
\n
\n
许多编译器并未强制限定友元函数必须在使用之前在类的外部声明
\n
\n
一些编译器允许在尚无友元函数的初始声明的情况下就调用它，不过最好还是提供一个独立的函数声明
\n
# 封装
\n
封装有两个重要的优点：
\n\n
一旦把数据成员定义成  private  的，类的作者就可以比较自由地修改数据了
\n\n
把数据成员的访问权限设成  private  还有另外一个好处：防止由于用户的原因造成数据被破坏。如果我们发现有程序缺陷破坏了对象的状态，则可以在有限的范围内定位缺陷
\n
\n
尽管当类的定义发生改变时无须更改用户代码，但是使用了该类的源文件必须重新编译
\n
\n
参考：C++ Primer 中文版（第 5 版）
\n",
            "tags": [
                "C++"
            ]
        },
        {
            "id": "https://jiankychen.github.io/shoka-opt.html",
            "url": "https://jiankychen.github.io/shoka-opt.html",
            "title": "shoka 主题的若干改动",
            "date_published": "2022-10-19T14:49:50.000Z",
            "content_html": "
相关文章推荐：
\n\n
# 修改主页标签名
\n
打开  themes\\shoka\\languages  路径下的  zh-CN.yml  文件，找到  favicon  板块，修改  show  和  hide
\n
favicon:
  show: Jiankychen
  hide: Jiankychen
\n
本博客根目录 _config.yml 中的语言设置为  language: zh-CN  ，所以这里是修改  zh-CN.yml  文件。若根目录 _config.yml 中的语言设置为  language: en  ，则应修改  en.yml  文件
\n
\n
# 修改加载动画
\n
实现步骤：
\n\n
效果预览：
\n
\n
\n  See the Pen \n  Untitled by Jiankychen (@jiankychen)\n  on CodePen.\n
\n\n
\n
加载动画列表：
\n\n
\n
本加载动画源自于 Dave McCarthy
\n
\n
参考：
\n\n
# 使用外链头像
\n
在采用 Jsdelivr 静态缓存的情况下，由于某种未知原因，博客侧边栏的头像经常无法显示，现考虑使用外部链接的图片作为头像
\n
实现步骤：
\n\n
# 去除首页 subtitle 两侧的 = 号
\n
首页 subtitle 两侧会显示出一个 = 号，这里考虑将其去除
\n
实现方式：
\n
打开  themes\\shoka\\layout\\_partials  路径下的  layout.njk  文件，将第 42 行（  <p class="meta" itemprop="description">= {{ subtitle }} =</p>  ）替换为
\n
<p class=\"meta\" itemprop=\"description\">{{ subtitle }}</p>
效果对比：
\n\n
也可以将 = 号替换成其他字符或图标，例如：
\n
<p class=\"meta\" itemprop=\"description\">~~~ {{ subtitle }} ~~~</p>
效果：
\n
\"\"
\n
# 添加页脚：站点运行时长
\n
实现步骤：
\n\n
效果：
\n
\"\"
\n
# 添加页脚：站点访问量
\n
可以通过 busuanzi 将 站点 / 某个页面的访客数量 添加到 页脚
\n
实现步骤：
\n\n
参考：
\n\n
# 新增页面：访问统计与文章统计
\n
# 添加访问统计页面
\n
按照 Lavender 的文章 Shoka 主题：新增博客访问统计页面 做相应配置
\n
其中，百度商业账号和百度账号的调用方法存在差异，普通用户按照 百度账号接口说明 进行操作，以获取 API Key、Secret Key、Refresh Token、Acess_Token、Site_ID 等信息
\n
一旦 Acess_Token 过期，可根据以下请求更换新的 Acess_Token 和 Refresh_Token ：
\n
http://openapi.baidu.com/oauth/2.0/token?grant_type=refresh_token&refresh_token={REFRESH_TOKEN}&client_id={CLIENT_ID}&client_secret={CLIENT_SECRET}\n
\n
其中：
\n\n
参考：
\n\n
# 添加文章统计功能
\n
具体可参考 Shoka 主题：新增文章统计页面、Hexo 博客文章统计图
\n
# 主题 vendors 链接替换 - 拆分 Jsdelivr
\n
参考：Hexo-Shoka 主题功能介绍补充点：主题插件链接替换思路与案例
\n
\n
另一种方案：shoka 主题速度优化 - 拆分 jsdelivr
\n
\n
# 修改主题配置文件
\n
打开主题配置文件  _config.shoka.yml  ，找到文件最后的  vendors  板块，将其注释，并在其下方新增以下内容
\n
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
与原始版本相比，有以下改动：
\n\n
# 修改 utils.js
\n
打开  themes\\shoka\\source\\js\\_app\\utils.js  ，找到  const assetUrl = function (asset, type) {} （文件第 25~39 行左右），将其替换为
\n
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
\n
打开  themes\\shoka\\scripts\\helpers\\asset.js  ，找到  hexo.extend.helper.register('_vendor_js', () => {})  （第 41~63 行左右），将其替换为
\n
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
\n
打开  themes\\shoka\\scripts\\generaters\\script.js  ，找到 js 和 css 索引代码（第 23~38 行左右），将其替换为
\n
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
\n
打开  themes\\shoka\\source\\js\\_app\\page.js  ，找到  const postFancybox = function(p) {}  中的  vendorCss  和  vendorJs  （第 72~79 行左右），将其替换为
\n
const postFancybox = function(p) {
  if($(p + ' .md img')) {
    vendorCss('justifiedGallery');
    vendorJs('justifiedGallery');
    vendorCss('fancybox');
    vendorJs('jquery','fancybox', function() {
      // ...
# tab 标签卡的红色线条
\n
tab 标签卡中的标签名称下方没有显示红色线条
\n
为显示下画线，可按以下步骤修改：
\n\n
效果：
\n
\n
修改前：
\n
.nav {
    overflow: hidden;
    border-bottom: .0625rem solid var(--grey-1-a7);
    height: 2.6875rem;
    // ...
  }
\n
\n
修改后：
\n
.nav {
    border-bottom: .0625rem solid var(--grey-1-a7);
    height: 2.6875rem;
    // ...
  }
\n
# 调整代码块的高度
\n
修改代码块折叠的阈值为 10 （即，超过 10 行代码即进行折叠），并将代码块（不包括 figcaption）的高度调整为 200px
\n\n",
            "tags": [
                "Tutorial",
                "Hexo"
            ]
        },
        {
            "id": "https://jiankychen.github.io/Dijkstra.html",
            "url": "https://jiankychen.github.io/Dijkstra.html",
            "title": "Dijkstra",
            "date_published": "2022-10-14T03:28:41.000Z",
            "content_html": "
Dijkstra 算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径
\n
定义：
\n\n
流程：
\n\n
最优性证明（为什么被收录的节点已经找到代价最小的路径？）：反证法
\n
特性：
\n\n
算法：
\n
将起点放入 open list\n\n执行循环：\n\n- 如果 open list 为空：搜索失败，结束\n- 取 open list 中代价（即，g(n)）最小的节点（记作 Node1），将其放入 closed list\n- 如果节点 Node1 为终点：找到目标路径，结束\n- 遍历节点 Node1 的（不在 closed list 中的）邻接节点\n    - 记当前遍历的邻接节点为 Node2\n    - 如果节点 Node2 在 open list 中：更新节点 Node2 的代价\n    - 如果节点 Node2 在 open list 中：计算节点 Node2 的代价，并将其加入 open list\n\n待循环结束，即得到从起点到终点的代价最小路径\n
\n
# 朴素 Dijkstra
\n
# 邻接矩阵法
\n
采用邻接矩阵 edges 存储边的有关信息，其中，edges [i][j] 表示 i 到 j 的代价，若 edges [i][j] == INT_MAX ，则表示不存在由节点 i 指向节点 j 的边
\n
/*
@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;
}
# 邻接表法
\n
采用 链式前向星（用数组模拟实现的链表，也就是静态链表）作为邻接表
\n
结构体数组 edges 存储所有边：edges [i] 表示第 i 条边
\n\n
数组 head 存储顶点的第一条边：head [i] 表示以 i 为起点的第一条边（编号最大的边）的编号
\n
/*
@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
\n
可以使用堆（优先级队列）来查找 open list 中的代价最小的节点 idx
\n
定义一个小顶堆：由于  pair<typeA, typeB>  排序时会默认按照  typeA  排序，应将起点到节点的代价作为  typeA  、将节点的编号作为  typeB  ，以便每次可以从堆中取出代价最小的节点
\n
typedef pair<int, int> pii; // 分别存储代价和节点编号
priority_queue<pii, vector<pii>, greater<pii>> pq; // 小顶堆
\n
priority_queue  位于  <queue>  头文件， pair  位于  <utility>  头文件
\n
\n
# 邻接矩阵法
\n
当探索到一个代价最小的节点 idx 时，会遍历 idx 的邻居节点 i ，如果 dist [idx] + edges [idx][i] < dist [i] ，则需更新节点 i 的代价为 dist [idx] + edges [idx][i]
\n
注意，即便堆中可能已经有 {xx, i} 存在，但由于无法对堆进行寻址访问，故而无法直接将堆中已有的 {xx, i} 更新为
\n
因此，我们采用的策略是：
\n\n
/*
@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;
}
# 邻接表法
\n
堆优化也可以采用链式前向星结构
\n
/*
@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
设图中的节点数为 nnn ，边数为 mmm ，其中 n≤mn \\le mn≤m
\n
时间复杂度：
\n\n
空间复杂度：
\n\n
堆优化的时间复杂度优于朴素算法
\n
邻接表法的空间复杂度优于邻接矩阵法
\n
参考：
\n\n",
            "tags": [
                "Data Structure",
                "图"
            ]
        },
        {
            "id": "https://jiankychen.github.io/cpp-functions.html",
            "url": "https://jiankychen.github.io/cpp-functions.html",
            "title": "C++ 函数",
            "date_published": "2022-09-20T08:40:31.000Z",
            "content_html": "
# 函数基础
\n
典型的函数（function）定义包括以下部分：
\n\n
例如：定义一个函数用于求数 n 的阶乘，其中，返回类型为 int 型，函数名字为 fact，形参为 int n，函数体为一对花括号 {} 内的语句
\n
int fact(int n) {
    int ret = 1;
    while (n > 1)
        ret *= n--;
    return ret;
}
# 调用函数
\n
通过 调用运算符（call operator）来执行函数
\n\n
函数的调用完成两项工作：
\n\n
此时，主调函数（calling function）的执行被暂时中断，被调函数（called function）开始执行
\n
当遇到一条 return 语句时，函数结束执行过程
\n
return 语句也完成两项工作：
\n\n
# 形参和实参
\n
实参是形参的初始值。第一个实参初始化第一个形参，第二个实参初始化第二个形参，以此类推
\n
\n
尽管实参与形参存在对应关系，但是并没有规定实参的求值顺序。编译器能以任意可行的顺序对实参求值
\n
\n
实参数量应与形参数量一致，并且，实参的类型必须与对应的形参类型匹配
\n
# 函数的形参列表
\n
函数的形参列表可以为空，但是不能省略
\n\n
void f1() { /* ... */ }     // 隐式地定义空形参列表
void f2(void) { /* ... */ } // 显式地定义空形参列表
形参列表中的形参通常用逗号隔开，其中，每个形参都是含有一个声明符的声明（即使两个形参的类型一样，也必须把两个类型都写出来）
\n
int f3(int v1, v2) { /* ... */ }     // 错误
int f4(int v1, int v2) { /* ... */ } // 正确
任意两个形参都不能同名，而且，函数最外层作用域中的局部变量也与函数形参同名
\n
形参名是可选的。如果函数不会使用到个别形参，通常不命名该形参，以表示其不会在函数体内被使用
\n
\n
注意：即使某个形参不被函数使用，也必须为它提供一个实参
\n
\n
# 函数返回类型
\n
\n
大多数类型都能用作函数的返回类型
\n
\n
一种特殊的返回类型是 void ，它表示函数不返回任何值
\n
函数的返回类型不能是数组类型或函数类型，但可以是指向数组或函数的指针
\n
# 局部对象
\n
在 C++ 语言中，名字有作用域，对象有生命周期（lifetime）
\n\n
形参和函数体内部定义的变量统称为局部变量（local variable）。它们对函数而言是 “局部” 的，仅在函数的作用域内可见
\n
\n
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.
\n
\n
在所有函数体之外定义的对象存在于程序的整个执行过程中。此类对象在程序启动时被创建，直到程序结束才会销毁
\n
局部变量的生命周期依赖于定义的方式。对于普通局部变量对应的对象，当函数的控制路径经过变量定义语句时创建该对象，当到达定义所在的块末尾时销毁它
\n
# 自动对象
\n
只存在于块执行期间的对象被称为 自动对象（automatic object）
\n
当块的执行结束后，块中创建的自动对象的值就变成未定义的了
\n
形参就是一种自动对象：函数开始时为形参申请存储空间，因为形参定义在函数体作用域之内，所以一旦函数终止，形参也就被销毁
\n
自动对象的初始化：
\n\n
\n
内置类型的未初始化局部变量将产生未定义的值
\n
\n
# 局部静态对象
\n
某些时候，有必要令局部变量的生命周期贯穿函数调用及之后的时间。此时，可以将局部变量定义成 static 类型
\n
局部静态对象（local static object）在程序第一次经过对象定义语句时进行初始化，并且直到程序终止才被销毁。在此期间，即使对象所在的函数结束执行，也不会对它有影响
\n
如果局部静态变量没有显式的初始值，它将执行值初始化，内置类型的局部静态变量初始化为 0
\n
# 函数声明
\n
类似于变量，函数只能定义一次，但可以声明多次
\n
\n
唯一的例外是，如果一个函数永远也不会被我们用到，那么它可以只有声明没有定义
\n
\n
函数的声明和函数的定义非常类似，唯一的区别是，函数声明无须函数体，用一个分号替代即可
\n
// 函数声明
void print(vector<int>::const_iterator beg,
           vector<int>::const_iterator end);
函数的声明不包含函数体，所以也就无须形参的名字（事实上，在函数的声明中经常省略形参的名字）
\n
函数的三要素（返回类型、函数名、形参类型）描述了函数的接口，说明了调用该函数所需的全部信息
\n
函数声明也称作函数原型（function prototype）
\n
# 在头文件中进行函数声明
\n
类似于变量，函数也应该在头文件中声明而在源文件中定义
\n
\n
允许把函数的声明直接放在使用该函数的源文件中，但是这么做可能会很烦琐而且容易出错。相反，如果把函数声明放在头文件中，就能确保同一函数的所有声明保持一致。而且，一旦我们想改变函数的接口，只需改变一条声明即可
\n
\n
含有函数声明的头文件应该被包含到定义函数的源文件中
\n
# 分离式编译
\n
为了允许编写程序时按照逻辑关系将其划分开来，C++ 语言支持所谓的分离式编译（separate compilation）
\n
分离式编译允许我们把程序分割到几个文件中去，每个文件独立编译
\n
如果我们修改了其中一个源文件，那么只需重新编译那个改动了的文件
\n
大多数编译器提供了分离式编译每个文件的机制，这一过程通常会产生一个后缀名是 .obj（Windows）或 .o（UNIX）的文件（该文件包含对象代码（object code））
\n
# 参数传递
\n
每次调用函数时都会重新创建它的形参，并用传入的实参对形参进行初始化
\n\n
# 传值参数
\n
函数对形参做的所有操作都不会影响实参
\n
int fact(int val) {
    int ret = 1;
    while (val) {
        ret *= val--;
    }
    return ret;
}
# 指针形参
\n
可以将指针作为函数的形参
\n\n
// 该函数接受一个指针，然后将指针所指的值置 0
void reset(int *ip) { // 指针形参
    *ip = 0;  // 改变指针 ip 所指对象的值
    ip = 0;   // 只改变了 ip 的局部拷贝，实参并未被改变
}
\n
熟悉 C 的程序员常常使用指针类型的形参访问函数外部的对象。在 C++ 语言中，建议使用引用类型的形参替代指针
\n
\n
# 传引用参数
\n
引用形参绑定到对应的实参上
\n
// 该函数接受一个 int 对象的引用，然后将对象的值置为 0
void reset(int &i) { //i 是传给 reset 函数的对象的另一个名字
    i = 0; // 改变了 i 所引对象的值
}
# 使用引用避免拷贝
\n
拷贝大的类类型对象或者容器对象是比较低效的，此时可以通过引用传入参数
\n
// 比较两个 string 对象的长度
bool isShorter(const string &s1, const string &s2) {
    return s1.size() < s2.size();
}
甚至，有的类类型（包括 IO 类型在内）根本就不支持拷贝操作。此时，函数只能通过引用形参访问该类型的对象
\n
\n
如果函数无须改变引用形参的值，最好将其声明为常量引用
\n
\n
# 使用引用形参返回额外信息
\n
一个函数只能返回一个值，然而有时函数需要同时返回多个值，因此可以考虑通过引用形参获取多个结果
\n
// 返回 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 形参和实参
\n
在用实参初始化形参时，会忽略掉形参的顶层 const
\n
换而言之，当形参具有顶层 const 时，传给它常量对象或者非常量对象都是可以的（可参考 const 限定符）
\n
void fcn (const int i) {
    /* fcn 可以读取 i ，但不能向 i 写值 */
}
调用 fcn 函数时，既可以传入 const int ，也可以传入 int
\n
在 C++ 语言中，允许我们定义若干具有相同名字的函数，不过前提是不同函数的形参列表应该有明显的区别，例如：
\n
void helper (string &s, int start) { /* 第一个 helper 函数 */ };
void helper (int n) { /* 第二个 helper 函数 */ };
然而，由于形参的顶层 const 会被忽略，以下两个同名函数不能同时定义
\n
void fcn (const int i) { /* */ };
void fcn (int i) { /* */ }; // 错误：重复定义了 fcn (int)
因为顶层 const 被忽略掉了，所以在上面的代码中传入两个 fcn 函数的参数可以完全一样，因此第二个 fcn 是错误的
\n
# const 与 指针或引用形参
\n
形参的初始化方式和变量的初始化方式是一样的：
\n\n
变量初始化：
\n
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;       // 错误：不能用字面值初始化一个非常量引用
参数传递：
\n
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* 类型的对象
\n
我们能传递一个字符串字面值作为 find_char 的第一个实参，这是因为该函数的引用形参是常量引用，而 C++ 允许我们用字面值初始化常量引用
\n
# 尽量使用常量引用
\n
将函数不会改变的形参定义成（普通的）引用是一种比较常见的错误，这么做会给函数的调用者造成误导，即，函数可以修改它的实参的值
\n
此外，使用引用而非常量引用也会极大地限制函数所能接受的实参类型。例如，我们不能把 const 对象、字面值或者需要类型转换的对象传递给普通的引用形参
\n
# 数组形参
\n
数组 无法直接通过数组名进行拷贝，因此，无法以值传递的方式使用数组参数
\n
由于 数组（通常）会被转换成指针，当我们为一个函数传递一个数组时，实际上传递的是指向数组首元素的指针
\n
尽管不能以值传递的方式传递数组，但是我们可以把形参写成类似数组的形式：
\n
// 尽管表现形式不同，但这三个 print 函数是等价的
// 每个函数都有一个 const int* 类型的形参
void print (const int*)
void print (const int []) // 函数的意图是作用于一个数组
void print (const int [10]) // 这里的维度表示我们期望的数组维度，实际不一定是这个维度
当编译器处理对 print 函数的调用时，只检查传入的参数是否是 const int* 类型
\n
int i = 0, j[2] = {0, 1};
print(&i); // 正确：&i 的类型是 int*
print(j);  // 正确：j 转换成 int* 并指向 j [0]
如果我们传给 print 函数的是一个数组，则实参自动地转换成指向数组首元素的指针。其中，数组的大小对函数的调用没有影响
\n
\n
以数组作为形参的函数必须确保使用数组时不会越界
\n
\n
# 数组指针形参
\n
因为数组是以指针的形式传递给函数的，所以一开始函数并不知道数组的确切尺寸，调用者应该为此提供一些额外的信息
\n
管理指针形参有三种常用的技术：
\n\n
# 使用标记指定数组长度
\n\n
// 遇到空字符停止
void print(const char *cp) {
    if (cp)          // 若 cp 不是一个空指针
        while (*cp)  // 只要指针所指的字符不是空字符
            cout << *cp++; // 输出当前字符并将指针向前移动一个位置
}
# 使用标准库规范
\n
传递指向数组首元素和尾后元素的指针
\n
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 的首元素和尾后元素的指针
# 显式传递一个表示数组大小的形参
\n
即，专门定义一个形参表示数组大小
\n
//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 的指针（即，常量指针）。只有当函数确实要改变元素值的时候，才把形参定义成指向非常量的指针
\n
# 数组引用形参
\n
C++ 允许将变量定义成数组的引用（详见 数组 ），同样地，也允许将形参定义成数组的引用，此时，引用形参绑定到对应的数组上
\n
// 正确：形参是数组的引用，维度是类型的一部分
void print(int (&arr)[10]) {
    for (auto elem : arr)
        cout << elem << endl;
}
注意， &arr  两端的括号必不可少：
\n
f(int &arr [10])   // 错误：将 arr 声明成了引用的数组
f(int (&arr) [10]) // 正确：arr 是具有 10 个整数的整型数组的引用
数组大小是构成数组类型的一部分，只要不超过维度，就可以在函数体内放心地使用数组
\n
然而，这一用法也在无形中限制了 print 函数的可用性，即，只能将函数作用于大小为 10 的数组：
\n
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 个整数的数组
# 传递多维数组
\n
将多维数组传递给函数时，真正传递的是指向数组首元素的指针
\n
因为我们处理的是数组的数组，首元素本身就是一个数组，数组第二维（以及后面所有维度）的大小都是数组类型的一部分，不能省略
\n
//matrix 指向数组的首元素，该数组的元素是由 10 个整数构成的数组
void print(int (*matrix) [10], int rowSize) { /* ... */ } //matrix 是一个指向含有 10 个整数的数组的指针
注意， *matrix  两端的括号必不可少
\n
int *matrix[10];   // 10 个指针构成的数组
int (*matrix)[10]; // 指向含有 10 个整数的数组的指针
我们也可以使用数组的语法定义函数（此时编译器会一如既往地忽略掉第一个维度，所以最好不要把它包括在形参列表内）
\n
//matrix 看似是一个二维数组，实则是指向含有 10 个整数的数组的指针
void print(int matrix[][10], int rowSize) { /* ... */ }
# main: 处理命令行选项
\n
到目前为止，我们定义的 main 函数都只有空形参列表：
\n
int main() { ...}
然而，有时我们确实需要给 main 传递实参。一种常见的情况是，用户通过设置一组选项来确定函数所要执行的操作。例如，假定 main 函数位于可执行文件 prog 之内，我们可以向程序传递下面的选项：
\n
prog -d -o ofile data0\n
\n
这些命令行选项通过两个（可选的）形参传递给 main 函数：
\n
int main(int argc, char *argv[]) { ... }
第二个形参 argv 是一个数组，它的元素是指向 C 风格字符串的指针；第一个形参 argc 表示数组中字符串的数量
\n
因为第二个形参是数组，所以 main 函数也可以定义成：
\n
int main(int argc, char **argv) { ... } //argv 执指向 char*
当实参传给 main 函数之后，argv 的第一个元素指向程序的名字或者一个空字符串，接下来的元素依次传递命令行提供的实参。最后一个指针之后的元素值保证为 0
\n
以上面提供的命令行  prog -d -o ofile data0  为例，argc 等于 5，argv 包含如下 C 风格字符串
\n
argv[0] = \"prog\";   // 或者 argv [0] 也可以指向一个空字符串
argv[1] = \"-d\";
argv[2] = \"-o\";
argv[3] = \"ofile\";
argv[4] = \"data0\";
argv[5] = 0;
\n
当使用  argv  中的实参时，一定要记得可选的实参从  argv[1]  开始； argv[0]  保存程序的名字，而非用户输入
\n
\n
# 含有可变形参的函数
\n
有时我们无法提前预知应该向函数传递几个实参。例如，我们想要编写代码输出程序产生的错误信息，此时最好用同一个函数实现该项功能，以便对所有错误的处理能够整齐划一。然而，错误信息的种类不同，所以调用错误输出函数时传递的实参也各不相同
\n
为了编写能处理不同数量实参的函数，C++ 11 新标准提供了两种主要的方法：
\n\n
C++ 还有一种特殊的形参类型（即省略符），可以用它传递可变数量的实参（这种功能一般只用于与 C 函数交互的接口程序）
\n
# initializer_list 形参
\n
如果函数的实参数量未知、但是全部实参的类型都相同，我们可以使用 initializer_list 类型的形参
\n
initializer_list 是一种标准库类型，用于表示某种特定类型的值的数组
\n
initializer_list 类型定义在同名的头文件中
\n
\"\"
\n
和 vector 一样，initializer_list 也是一种模板类型。定义 initializer_list 对象时，必须说明列表中所含元素的类型
\n
initializer_list<string> ls; //initializer_list 的元素类型是 string
initializer_list<int> li;    //initializer_list 的元素类型是 int
和 vector 不一样的是，initializer_list 对象中的元素永远是常量值，我们无法改变 initializer_list 对象中元素的值
\n
我们使用如下的形式编写输出错误信息的函数，使其可以作用于可变数量的实参：
\n
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 对应的成员
\n\n
initializer_list 包含 begin 和 end 成员，因此可以使用 范围 for 循环处理其中的元素
\n
如果想向 initializer_list 形参中传递一个值的序列，则必须把序列放在一对花括号内
\n
//expected 和 actual 是 string 对象
if (expected != actual)
    error_msg({\"functionX\", expected, actual});
else
    error_msg({\"functionX\", \"okay\"});
含有 initializer_list 形参的函数也可以同时拥有其他形参。例如，调试系统可能有个名为 ErrCode 的类，用来表示不同类型的错误，因此我们可以改写之前的程序，使其包含一个 initializer_list 形参和一个 ErrCode 形参
\n
void error_msg(ErrCode e, initializer_list<string> il) {
    cout << e.msg() << \": \";
    for (const auto &elem : il)
        cout << elem << \" \" ;
    cout << endl;
}
为了调用这个版本的 error_msg 函数，需要额外传递一个 ErrCode 实参
\n
if (expected != actual)
    error_msg(ErrCode(42), {\"functionX\", expected, actual});
else
    error_msg(ErrCode(0), {\"functionX\", \"okay\"});
# 省略符形参
\n
省略符形参是为了便于 C++ 程序访问某些（使用了名为 varargs 的 C 标准库功能的）C 代码而设置的
\n
通常，省略符形参不应用于其他目的
\n
\n
省略符形参应该仅仅用于 C 和 C++ 通用的类型
\n特别应该注意的是，大多数类类型的对象在传递给省略符形参时都无法正确拷贝
\n
\n
省略符形参只能出现在形参列表的最后一个位置，它的形式无外乎以下两种:
\n
void foo(parm_list, ...);
void foo(...);
第一种形式指定了 foo 函数的部分形参的类型，对应于这些形参的实参将会执行正常的类型检查
\n
省略符形参所对应的实参无须类型检查
\n
在第一种形式中，形参声明后面的逗号是可选的
\n
# 返回类型和 return 语句
\n
return 语句：终止当前正在执行的函数，并将控制权返回到调用该函数的地方
\n
return 语句的两种形式：
\n
return; // 无返回值
return expression; // 有返回值
# 无返回值函数
\n
没有返回值的 return 语句只能用在返回类型是 void 的函数中
\n
返回 void 的函数并不一定要有 return 语句，因为这类函数最后会隐式地执行 return
\n
一个返回类型是 void 的函数也能使用 return 语句的第二种形式，不过此时 return 语句的 expression 必须是另一个返回 void 的函数
\n
强行令 void 函数返回其他类型的表达式将产生编译错误
\n
# 有返回值函数
\n
只要函数的返回类型不是 void ，该函数内的每条 return 语句就必须返回一个值
\n
return 语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换成函数的返回类型
\n
# 值是如何被返回的
\n
返回一个值的方式：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果
\n
如果函数返回的类型是局部变量，则会返回该变量的副本
\n
例如，书写一个返回类型是 string 的函数 make_plural，由于该函数的返回类型是 string ，返回值将被拷贝到调用点。即，该函数将返回 word 的副本或者一个未命名的临时 string 对象
\n
string make_plural(size_t ctr, const string &word, const string ending) {
    return (ctr > 1) ? word + ending : word;
}
如果函数返回引用类型，则不需要拷贝其所引对象
\n
例如：书写一个函数，其中形参和返回类型都是 const string 的引用，不管是调用函数还是返回结果都不会真正拷贝 string 对象
\n
// 挑出两个 string 对象中较短的那个，返回其引用
const string &shorterString(const string &s1, const string &s2) {
    return s1.size() <= s2.size() ? s1 : s2;
}
# 不要返回局部对象的引用或指针
\n
函数完成后，它所占用的存储空间也随之被释放掉，因此，不要返回局部对象的引用或指针
\n
const string &manip() { // 严重错误：函数试图返回局部对象的引用
    string ret;
   if (!ret.empty())
       return ret;      // 错误：返回局部对象的引用！
   else
       return \"Empty\";  // 错误：\"Empty\" 是一个局部临时量
}
# 返回类类型的函数和调用运算符
\n
和其他运算符一样，调用运算符也有优先级和结合律
\n
调用运算符的优先级 与 点运算符和箭头运算符 相同，并且也符合左结合律
\n
如果函数返回指针、引用或类的对象，我们就能使用函数调用的结果访问结果对象的成员
\n
例如，我们可以通过如下形式得到较短 string 对象的长度：
\n
// 调用 string 对象的 size 成员，该 string 对象是由 shorterString 函数返回的
auto sz = shorterString(s1, s2).size();
# 引用返回左值
\n
函数的返回类型决定函数调用是否是左值：调用一个返回引用的函数将会得到左值，其他返回类型将得到右值
\n
因此，可以像使用其他左值那样来使用返回引用的函数，特别是，可以给返回类型为非常量引用的函数的结果赋值
\n
例如：
\n
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;
}
如果返回类型是常量引用，则不能给调用的结果赋值
\n
shorterString(\"hi\", \"bye\") = \"X\"; // 错误：返回值是个常量
# 列表初始化返回值
\n
C++ 11 标准规定，函数可以返回花括号包围的值的列表，该列表用来初始化函数调用点处的临时量
\n\n
例如：定义一个返回 vector 对象的函数，其中，vector 对象用来存放表示错误信息的 string 对象
\n
vector<string> process() {
    // . . .
    //expected 和 actual 是 string 对象
    if (expected.empty())
        return {};  // 返回一个空 vector 对象
    else if (expected == actual)
        return {\"functionX\", \"okay\"}; // 返回列表初始化的 vector 对象
    else
        return {\"functionX\", expected, actual};
}
如果函数返回的是内置类型，则花括号包围的列表最多包含一个值，而且该值所占空间不应该大于目标类型的空间
\n
如果函数返回的是类类型，由类本身来定义如何使用初始值
\n
# 主函数 main 的返回值
\n
之前介绍过，如果函数的返回类型不是 void ，那么它必须返回一个值。但是这条规则有个例外：允许 main 函数没有 return 语句而直接结束
\n
这是因为，如果控制到达了 main 函数的结尾处而且没有 return 语句，编译器将隐式地插入一条返回 0 的 return 语句
\n
# 递归
\n
如果一个函数调用了它自身，不管这种调用是直接的还是间接的，都称该函数为递归函数（recursive function）
\n
// 计算 val 的阶乘
int factorial(int val) {
    if (val > 1)
        return factorial(val-1) * val;
    return 1;
}
\n
main 函数不能调用它自己
\n
\n
# 返回数组指针
\n
因此数组不能被拷贝，所以函数不能返回数组。但是，函数可以返回数组的指针或者引用
\n
从语法上来说，要想定义一个返回数组的指针或引用的函数比较烦琐，但是有一些方法可以简化这一任务，其中最直接的方法是使用 类型别名
\n
例如：func 函数返回一个指向包含 10 个整数的数组的指针，其中，arrT 是含有 10 个整数的数组的别名
\n
typedef int arrT[10]; //arrT 是一个类型别名，它表示的类型是含有 10 个整数的数组
using arrT = int[10]; //arrT 的等价声明
arrT* func(int i);    //func 返回一个指向含有 10 个整数的数组的指针
# 声明一个返回数组指针的函数
\n
如果我们想定义一个返回数组指针的函数，并且不希望使用类型别名，则必须满足：
\n\n
因此，返回数组指针的函数形式如下所示：
\n
Type (*function(parameter_list))[dimension]\n
\n
其中，Type 表示元素的类型，dimension 表示数组的大小，(*function (parameter_list)) 两端的括号必须存在（如果没有这对括号，函数的返回类型将是指针的数组）
\n
例如：
\n
int (*func(int i))[10];
可以按照以下的顺序来逐层理解该声明的含义：・
\n\n
# 使用尾置返回类型
\n
在 C++ 11 标准中还有一种可以简化上述 func 声明的方法，就是使用尾置返回类型（trailing return type）
\n
任何函数的定义都能使用尾置返回，但是这种形式对于返回类型比较复杂的函数最有效，比如返回类型是数组的指针或者数组的引用
\n
尾置返回类型跟在形参列表后面，并以一个  ->  符号开头。为了表示函数真正的返回类型跟在形参列表之后，我们在本应该出现返回类型的地方放置一个  auto
\n
例如：
\n
//func 接受一个 int 类型的实参，返回一个指针，该指针指向含有 10 个整数的数组
auto func(int i) -> int(*)[10];
因为我们把函数的返回类型放在了形参列表之后，所以可以清楚地看到 func 函数返回的是一个指针，并且该指针指向了含有 10 个整数的数组
\n
# 使用 decltype
\n
如果我们知道函数返回的指针将指向哪个数组，可以使用  decltype  关键字声明返回类型
\n
例如，下面的函数返回一个指针，该指针根据参数 i 的不同指向两个已知数组中的某一个
\n
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 个整数的数组的指针
\n
注意： decltype  并不负责把数组类型转换成对应的指针，所以 decltype 的结果是个数组，要想表示 arrPtr 返回指针还必须在函数声明时加一个  *  符号
\n
# 函数重载
\n
如果同一作用域内的几个函数名字相同但形参列表不同，我们称之为 重载（overloaded）函数
\n
例如：
\n
void print(const char *cp);
void print(const int *beg, const int *end);
void print(const int ia[], size_t size);
这些函数接受的形参类型不一样，但是执行的操作非常类似。当调用这些函数时，编译器会根据传递的实参类型推断想要的是哪个函数
\n
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*)
\n
main 函数不能重载
\n
\n
# 重载函数的定义与调用
\n
# 定义重载函数
\n
重载的函数应该在形参数量或形参类型上有所不同
\n
// 定义一组函数，分别根据名字、电话、账号等信息查找记录
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 的版本
不允许两个函数除了返回类型外其他所有要素都相同：假设有两个函数，它们的形参列表一样但是返回类型不同，则第二个函数的声明是错误的
\n
Record lookup(const Account&);
bool lookup(const Account&); // 错误：与上一个函数相比只有返回类型不同
# 判断两个形参的类型是否相异
\n
有时候两个形参列表看起来不一样，但实际上是相同的
\n
// 每一对声明都是同一个函数
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 的形参区分开来
\n
Record lookup(Phone);
Record lookup(const Phone);   // 重复声明了 Record lookup (Phone)
Record lookup(Phone*);
Record lookup(Phone* const);  // 重复声明了 Record lookup (Phone*)
如果形参是某种类型的指针或引用，则可区分其指向的是常量对象还是非常量对象（此时考虑的是底层 const ），以实现函数重载
\n
// 对于接受引用或指针的函数而言，常量对象与非常量对象对应的形参不同
// 定义了 4 个独立的重载函数
Record lookup(Account&);       // 函数作用于 Account 的引用
Record lookup(const Account&); // 新函数，作用于 Account 的常量引用
Record lookup(Account*);       // 新函数，作用于 Account 的指针
Record lookup(const Account*); // 新函数，作用于指向 Account 常量的指针
在上面的例子中，编译器可以通过实参是否是常量来推断应该调用哪个函数
\n\n
# 建议：何时不应该重载函数
\n
尽管函数重载能在一定程度上减轻我们为函数起名字、记名字的负担，但是最好只重载那些确实非常相似的操作
\n
有些情况下，给函数起不同的名字能使得程序更易理解
\n
例如，以下是几个负责移动屏幕光标的函数
\n
Screen& moveHome();
Screen& moveAbs(int, int);
Screen& moveRel(int, int, string direction);
乍看上去，似乎可以把这组函数统一命名为 move ，从而实现函数的重载。然而，重载之后这些函数失去了名字中本来拥有的信息（因为这些函数移动光标的具体方式各不相同）
\n
一般来说，是否重载函数要看哪个更容易理解
\n
# const_cast 和重载
\n
const_cast 常常用于有函数重载的上下文中
\n
考虑下面的 shorterString 函数，其参数和返回类型都是 const string 的引用，我们可以对两个非常量的 string 实参调用这个函数，但返回的仍然是 const string 的引用
\n
// 无论实参是常量还是非常量，返回类型都是 const string &
const string &shorterString(const string &s1, const string &s2) { // 形参是 const string & 类型
    return s1.size() <= s2.size() ? s1 : s2;
}
为了实现 “当实参不是常量时，得到的结果是一个普通的引用，即 string &”，可以使用 const_cast 定义一种新的 shorterString 函数：
\n
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 &
\n
# 调用重载的函数
\n
函数匹配（function matching）：把函数调用与一组重载函数中的某一个关联起来。具体而言，编译器首先将调用的实参与重载集合中每一个函数的形参进行比较，然后根据比较的结果决定到底调用哪个函数
\n
函数匹配也叫做重载确定（overload resolution）
\n
调用重载函数时，有三种可能的结果：
\n\n
# 重载与作用域
\n
\n
一般来说，将函数声明置于局部作用域内不是一个明智的选择。但是为了说明作用域和重载的相互关系，我们将暂时违反这一原则而使用局部函数声明
\n
\n
如果我们在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体
\n
因此，在不同的作用域中，无法重载函数名
\n
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 值的那个局部声明。一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体。剩下的工作就是检查函数调用是否有效了
\n
\n
在 C++ 语言中，名字查找发生在类型检查之前
\n
\n
第一个调用 print ("Value:") 传入一个字符串字面值，但是当前作用域内 print 函数唯一的声明要求参数是 int 类型，由于字符串字面值无法转换成 int 类型，这个调用是错误的（虽然外层作用域中的 print (const string&) 函数与本次调用匹配，但是它已经被隐藏掉了，根本不会被考虑）
\n
假设我们把 print (int) 和其他 print 函数声明放在同一个作用域中，则它将成为另一种重载形式：
\n
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)
}
# 特殊用途语言特性
\n
本节我们介绍函数相关的三种语言特性，这些特性对大多数程序都有用，它们分别是：默认实参、内联函数和 constexpr 函数，以及在程序调试过程中常用的一些功能
\n
# 默认实参
\n
有些函数的某个参数在大多数（但不是所有）调用中都被赋予了特定的值。此时，我们可以把这个特定值称为函数的默认实参（default argument）
\n
默认实参作为形参的初始值出现在形参列表中
\n
例如，我们使用 string 对象表示窗口的内容。一般情况下，我们希望该窗口的高、宽和背景字符都使用默认值，但是同时我们也应该允许用户为这几个参数自由指定与默认值不同的数值。因此，我们为每一个形参都提供了默认实参
\n
typedef string::size_type sz;
string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');
我们可以为一个或多个形参定义默认值，不过需要注意的是，一旦某个形参被赋予了默认值，它后面的所有形参都必须有默认值
\n
调用含有默认实参的函数时，可以包含该实参，也可以省略该实参
\n
# 使用默认实参调用函数
\n
如果我们想使用默认实参，只要在调用函数的时候省略该实参就可以了
\n
函数调用时实参按其位置解析，默认实参负责填补函数调用缺少的尾部实参（靠右侧位置）
\n
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 提供实参
\n
window = screen(, , '?'); // 错误：只能省略尾部的实参
window = screen('?');     // 调用 screen ('?', 80, ' ')
                          //char 型的 '?' 可以转换成 string::size_type 类型的值 63
当设计含有默认实参的函数时，需要合理设置形参的顺序，尽量让不怎么使用默认值的形参出现在前面，让那些经常使用默认值的形参出现在后面
\n
# 默认实参声明
\n
对于函数的声明来说，通常的习惯是将其放在头文件中，并且一个函数只声明一次，但是多次声明同一个函数也是合法的
\n
不过有一点需要注意，在给定的作用域中一个形参只能被赋予一次默认实参。换句话说，函数的后续声明只能为之前那些没有默认值的形参添加默认实参，而且该形参右侧的所有形参必须都有默认值
\n
假如给定
\n
// 表示高度和宽度的形参没有默认值
string screen(sz, sz, char = ' ');
我们就不能再修改一个已经存在的默认值
\n
string screen(sz, sz, char = '*'); // 错误：重复赋予默认实参
但是可以按照如下形式添加默认实参
\n
string screen(sz = 24, sz = 80, char); // 正确：添加默认实参
\n
通常，应该在函数声明中指定默认实参，并将该声明放在合适的头文件中
\n
\n
# 默认实参初始值
\n
除了局部变量不能作为默认实参外，只要表达式的类型能转换成形参所需的类型，该表达式就能作为默认实参
\n
//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 () ）会在函数声明所在的作用域内解析，但是会在函数调用时才求值
\n
void f2() {
    def = '*';          // 改变了默认实参的值
    sz wd = 100;        // 隐藏了外层定义的 wd ，但是没有改变默认值
    window = screen();  // 调用 screen (ht (), 80, '*')
}
我们在函数 f2 内部改变了 def 的值，所以对 screen 的调用将会传递这个更新过的值。另一方面，虽然我们的函数还声明了一个局部变量用于隐藏外层的 wd ，但是该局部变量与传递给 screen 的默认实参没有任何关系
\n
# 内联函数和 constexpr 函数
\n
此前我们编写了一个函数 shroterString ，用于比较两个 string 形参的长度并返回长度较小的 string 的引用。将这种规模较小的操作定义成函数，具有以下优点：
\n\n
然而，使用 shorterString 函数也存在一个潜在的缺点：调用函数一般比求等价表达式的值要慢一些
\n
在大多数机器上，一次函数调用其实包含着一系列工作：
\n\n
# 内联函数可以避免函数调用的开销
\n
将函数指定为内联函数（inline），通常就是将它在每个调用点上 “内联地” 展开
\n
假设我们把 shorterString 函数定义成内联函数，则如下调用
\n
cout << shorterString(s1, s2) << endl;
将在编译过程中展开成类似于下面的形式
\n
cout << (s1.size() < s2.size() ? s1 : s2) << endl;
从而消除了 shorterString 函数的运行时开销
\n
在函数返回类型的前面加上加上关键字  inline  ，即可将其声明为内联函数
\n
// 内联版本：寻找两个 string 对象中较短的那个
inline const string & shorterString(const string &s1, const string &s2) {
        return s1.size() <= s2.size() ? s1 : s2;
}
\n
内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求
\n
\n
一般来说，内联机制用于优化规模较小、流程直接、频繁调用的函数
\n
很多编译器都不支持内联递归函数，而且，一个太长的函数也不太可能在调用点 “内联地” 展开
\n
# constexpr 函数
\n
constexpr 函数（constexpr function）是指能用于常量表达式的函数
\n
constexpr 函数的定义：
\n\n
constexpr int new_sz() { return 42; }
constexpr int foo = new_sz();  // 正确：foo 是一个常量表达式
在上面的代码中，我们把 new_sz 定义成一个无参数的 constexpr 函数，于是，new_sz 函数返回的是常量表达式，因此可以用 new_sz 函数来初始化 constexpr 类型的变量 foo
\n
执行该初始化任务时，编译器把对 constexpr 函数的调用替换成其结果值。为了能在编译过程中随时展开，constexpr 函数被隐式地指定为内联函数
\n
\n
constexpr 函数体内也可以包含其他语句，只要这些语句在运行时不执行任何操作就行。例如，constexpr 函数中可以有空语句、类型别名以及 using 声明
\n
\n
constexpr 函数的返回值可以不是一个常量
\n
例如：定义一个 constexpr 函数 scale 。当我们给 scale 函数传入一个形如字面值 2 的常量表达式时，它的返回类型也是常量表达式，此时，编译器用相应的结果值替换对 scale 函数的调用。相反，如果我们用一个非常量表达式调用 scale 函数，比如 int 类型的对象 i ，则返回值是一个非常量表达式
\n
// 如果 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 函数用在需要常量表达式的上下文中时，编译器会负责检查函数的结果是否符合要求。如果结果恰好不是常量表达式，编译器将发出错误信息
\n
\n
constexpr 函数不一定返回常量表达式
\n
\n
# 把内联函数和 constexpr 函数放在头文件内
\n
和其他函数不一样，内联函数和 constexpr 函数可以在程序中多次定义
\n
不过，对于某个给定的内联函数或者 constexpr 函数来说，它的多个定义必须完全一致
\n
因此，内联函数和 constexpr 函数通常定义在头文件中
\n
# 调试帮助
\n
C++ 程序员有时会用到一种类似于 头文件保护 的技术，以便有选择地执行调试代码
\n
基本思想：程序可以包含一些用于调试的代码，这些代码只在开发程序时使用。当应用程序编写完成准备发布时，要先屏蔽掉调试代码
\n
这种方法用到两项预处理功能： assert  和  NDEBUG
\n
# assert 预处理宏
\n
assert 是一种预处理宏（preprocessor marco）
\n
预处理宏是一个行为类似于内联函数的预处理变量
\n
assert 宏使用一个表达式作为它的条件：
\n
assert(expr);
其首先对 expr 求值，如果表达式为假（即，值为 0），assert 输出信息并终止程序的执行。如果表达式为真（即，值不为 0），assert 什么也不做
\n
assert 宏定义在  cassert  头文件中，即：
\n
#include<cassert>
\n
预处理名字由预处理器而非编译器管理，因此我们可以直接使用预处理名字，即，直接使用 assert 而不是 std::assert，也不需要为 assert 提供 using 声明
\n
\n
\n
和预处理变量一样，宏名字在程序内必须唯一。因此，含有 cassert 头文件的程序不能再定义名为 assert 的变量、函数或者其他实体
\n
\n
assert 宏常用于检查 “不能发生” 的条件
\n
例如，一个对输入文本进行操作的程序，可能要求所有给定单词的长度都大于某个阈值
\n
assert(word.size() > threshold);
# NDEBUG 预处理变量
\n
NDEBUG 是一个预处理变量，表示当前不处于调试状态（not debug），可用于控制 assert 的行为：
\n\n
默认状态下，没有定义 NDEBUG
\n
我们可以使用一个 #define 语句定义 NDEBUG ，从而关闭调试状态
\n
#define NDEBUG // 关闭调试状态（必须定义在 cassert 头文件之前）
#include <cassert>
int main(void) {
    int x = 0;
    assert(x);
}
定义 NDEBUG 能避免检查各种条件所需的运行时开销（其实根本就不会执行运行时检查），因此，assert 应该仅用于验证那些确实不可能发生的事情
\n
\n
我们可以把 assert 当成调试程序的一种辅助手段，但是不能用它替代真正的运行时逻辑检查，也不能替代程序本身应该包含的错误检查
\n
\n
除了用于 assert 外，也可以使用 NDEBUG 编写自己的条件调试代码（详见 预处理变量 ）
\n\n
例如：
\n
void print(const int ia[], size_t size) {
#ifndef NDEBUG
//_ _func_ _ 是编译器定义的一个局部静态变量，用于存放函数的名字
cerr << _ _func_ _ << \": array size is \" << size << endl;
#endif
// ...
在这段代码中，我们使用变量  _ _func_ _  输出当前调试的函数的名字（即 "print" ）
\n
编译器为每个函数都定义了  _ _func_ _  ，它是  const char  的一个静态数组，用于存放函数的名字
\n
除了 C++ 编译器定义的  _ _func_ _  之外，预处理器还定义了另外 4 个用于程序调试的名字：
\n\n
可以使用这些常量在错误消息中提供更多信息，例如：
\n
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 对象，将得到下面的错误消息：
\n
Error:wdebug.cc : in function main at line 27\n       Compiled on Jul 11 2012 at 20:50:03\n       Word read was "foo": Length too short\n
\n
# 函数匹配
\n
当重载函数的形参数量相等、并且某些形参的类型可以由其他类型转换得到时，不太容易确定某次调用应该选用哪个重载函数
\n
# 函数匹配
\n
函数匹配：从一组重载函数中选取最佳函数的过程
\n
# 函数匹配的步骤
\n
选定本次调用对应的重载函数集
\n\n
考察本次调用提供的实参，从候选函数中选出能被这组实参调用的函数
\n\n
逐一检查函数调用提供的实参，寻找形参类型与实参类型最匹配的那个可行函数（即，寻找最佳匹配）
\n\n
\n
调用重载函数时应尽量避免强制类型转换，如果在实际应用中确实需要强制类型转换，则说明我们设计的形参列表不合理
\n
\n
# 实例分析
\n
以下面这组函数及其调用为例：
\n
void f();
void f(int);
void f(int, int);
void f(double, double = 3.14);
f(5.6); // 调用 f (double, double)
第一步：可以确定上述 4 个名为 f 的函数均为候选函数
\n
第二步：可以根据实参的数量排除 void f () 和 void f (int, int) ，选出  void f (int) 和 void f (double, double = 3.14) 两个可行函数
\n\n
第三步：逐一考察实参，寻找最佳匹配
\n\n
当实参的数量有两个或更多时，函数匹配就比较复杂了
\n
例如，考察形如 f (42, 2.56) 的调用：
\n
第一步：4 个名为 f 的函数均为候选函数
\n
第二步：确定 void f (int, int) 和 void f (double, double) 为可行函数
\n
第三步：逐一考察实参，寻找最佳匹配
\n\n
\n
看起来我们似乎可以通过强制类型转换其中的一个实参来实现函数的匹配，但是在设计良好的系统中，不应该对实参进行强制类型转换
\n
\n
# 实参类型转换
\n
为了确定最佳匹配，编译器将实参类型到形参类型的转换划分成几个等级，具体排序如下所示（越靠前的，匹配程度越好）：
\n\n
# 需要类型提升和算术类型转换的匹配
\n
小整型一般都会提升到 int 类型或更大的整数类型
\n
例如，假设有两个函数，一个接受 int 、另一个接受 short ，则
\n\n
void ff(int);
void ff(short);
ff('a'); //char 提升成 int ，调用 f (int)
所有算术类型转换的级别都一样
\n
例如，从 int 向 unsigned int 的转换并不比从 int 向 double 的转换级别高
\n
void manip(long);
void manip(float);
manip(3.14); // 错误：二义性调用
# 函数匹配和 const 实参
\n
如果重载函数的区别仅在于函数的引用类型的形参是否为常量引用（或者，指针类型的形参是否为常量指针），编译器将通过实参是否为常量来决定选择哪个函数
\n
\n
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.
\n
\n
例如：
\n
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 精确匹配
\n
第二个调用传入的是非常量对象 b ：对于该调用而言，两个函数都是可行的，因为 b 既可以用来初始化常量引用也可以用来初始化非常量引用。然而，用非常量对象来初始化常量引用需要类型转换，因此，应该选用非常量版本的函数 lookup (Account&)
\n
指针类型的形参也是类似的：如果两个函数的唯一区别是指针形参指向常量或非常量，编译器通过实参是否为常量来决定选用哪个函数
\n\n
# 函数指针
\n
函数指针（function pointer）指向的是函数而非对象
\n
类似于其他指针，函数指针也指向一个特定的类型（即，函数的类型）
\n
函数的类型由它的返回类型和形参类型共同决定，与函数名无关
\n
\n
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.
\n
\n
例如，以下函数的类型是 bool (const string &, const string &)
\n
// 比较两个 string 对象的长度
bool lengthCompare(const string &, const string &);
要想声明一个可以指向该函数的指针，只需要用指针替换函数名即可：
\n
//pf 指向一个函数，该函数的参数是两个 const string 的引用，返回值是 bool 类型
bool (*pf)(const string &, const string &);
针对 bool (*pf)(const string &, const string &) 的分析逻辑：
\n\n
\n
*pf 两端的括号必不可少，如果不写这对括号（即： bool *pf(const string &, const string &);  ），pf 将是一个返回类型为 bool * 的函数
\n
\n
# 使用函数指针
\n
当我们把函数名作为一个值使用时，该函数自动地转换成指针
\n
例如，按照如下形式我们可以将函数 lengthCompare 的地址赋给 pf
\n
pf = lengthCompare;  //pf 指向名为 lengthCompare 的函数
pf = &lengthCompare; // 等价的赋值语句（取地址符是可选的）
我们可以直接使用指向函数的指针来调用该函数，而无须提前解引用指针
\n
bool b1 = pf(\"hello\", \"goodbye\");    // 调用 lengthCompare
bool b2 = (*pf)(\"hello\", \"goodbye\"); // 等价的调用
bool b3 = lengthCompare(\"hello\", \"goodbye\"); // 等价的调用
指向不同函数类型的指针是不可以转换的，但是，我们可以为函数指针赋一个 nullptr 或者值为 0 的整型常量表达式，表示该指针没有指向任何一个函数
\n
\n
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.
\n
\n
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;  // 正确：函数和指针的类型精确匹配
# 重载函数的指针
\n
如果定义了指向重载函数的指针，编译器通过指针类型决定选用哪个函数，指针类型必须与重载函数中的某一个精确匹配
\n
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 的返回类型不匹配
# 函数指针形参
\n
类似于数组，我们不能定义函数类型的形参，但是，可以将指向函数的指针作为形参
\n
我们可以定义一个类似于函数类型的形参，它会自动地转换成指向函数的指针（类似于 数组形参 ）
\n
// 第三个形参是函数类型，它会自动地转换成指向函数的指针
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 &));
如果我们直接将函数作为实参使用，它会自动转换成指针
\n
// 自动将函数 lengthCompare 转换成指向该函数的指针
useBigger(s1, s2, lengthCompare);
由于直接将函数指针类型作为形参（例如，useBigger 的声明语句中的第三个形参）会显得冗长，可以使用 类型别名 和 decltype 来简化函数指针的代码
\n
例如：首先使用 typedef 和 decltype 来定义自己的函数类型和函数指针类型
\n
// 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; // 函数指针类型的等价声明
\n
注意：decltype 返回的是函数类型，不会将函数类型自动转换成指针类型，所以需要再加上  *  才能得到指针
\n
\n
然后重新声明 useBigger 函数：
\n
//useBigger 的等价声明，其中使用了类型别名
void useBigger(const string&, const string&, Func);
void useBigger(const string&, const string&, FuncP2);
这两个声明语句声明的是同一个函数，在第一条语句中，编译器自动地将 Func 表示的函数类型转换成指针
\n
# 返回指向函数的指针
\n
类似于数组，我们不能返回一个函数，但是，可以返回指向函数类型的指针
\n
由于编译器不会自动将函数返回类型当成对应的指针类型处理，我们必须显式地将返回类型写成指针形式
\n
声明一个返回函数指针的函数，最直接的办法是（类似于 返回数组指针 ）：
\n
int (*f1 (int)) (int* , int);
按照由内向外的顺序阅读这条声明语句：
\n\n
声明一个返回函数指针的函数，最简单的办法是使用类型别名：
\n
using F = int(int*, int);     // F 是函数类型
using PF = int(*)(int*, int); // PF 是函数指针类型
必须时刻注意的是，和函数类型的形参不一样，返回类型不会自动地转换成指针，因此，我们必须显式地将返回类型指定为指针
\n
PF f1(int); // 正确：PF 是指向函数的指针，f1 返回指向函数的指针
F f1(int);  // 错误：F 是函数类型，f1 不能返回一个函数
F *f1(int); // 正确：将函数返回类型显式地指定为指向函数的指针
此外，我们也可以使用尾置返回类型的方式来声明一个返回函数指针的函数（可参考 使用尾置返回类型 ）：
\n
auto f1(int) -> int (*)(int*, int);
# 将 auto 和 decltype 用于函数指针类型
\n
如果我们明确知道返回的函数是哪一个，可以使用 decltype 关键字将返回类型声明为 函数指针类型
\n
例如，假定有两个函数，它们的返回类型都是 string::size_type ，并且各有两个 const string& 类型的形参
\n
string::size_type sumLength(const string&, const string&);
string::size_type largerLength(const string&, const string&);
此时，我们可以编写第三个函数，它接受一个 string 类型的参数，返回一个指针，该指针指向前两个函数中的某一个
\n
// 根据其形参的取值，getFcn 函数返回指向 sumLength 或者 largerLength 的指针
decltype(sumLength) *getFcn(const string &);
注意： decltype  并不负责把函数类型转换成对应的指针，所以 decltype 的结果是个函数类型，因此，我们显式地加上  *  以表明我们需要返回指针而不是函数本身
\n
# 术语表
\n
二义性调用（ambiguous call） ：是一种编译时发生的错误。造成二义性调用的原因：在函数匹配时，两个或多个函数提供的匹配一样好，编译器找不到唯一的最佳匹配
\n
实参（argument） ：函数调用时提供的值，用于初始化函数形参
\n
Assert ：是一个预处理宏，作用于一条表示条件的表达式
\n\n
自动对象（automatic object） ：仅存在于函数执行过程中的对象
\n\n
最佳匹配（best match） ：从一组重载函数中为调用选出的一个函数。最佳匹配（如果存在的话）至少在一个实参上比其他所有可行函数更优，同时，在其他实参的匹配上不会更差
\n
传引用调用（call by reference） ：对引用传递的函数的调用
\n
传值调用（call by value） ：对值传递的函数的调用
\n
候选函数（candidate function） ：解析某次函数调用时考虑的一组函数。候选函数的名字应该与函数调用使用的名字一致，并且在调用点候选函数的声明在作用域之内
\n
constexpr ：可以返回常量表达式的函数。一个 constexpr 函数被隐式地声明成内联函数
\n
默认实参（default argument） ：当调用缺少了某个实参时，为该实参指定的默认值
\n
可执行文件（executable file） ；是操作系统能够执行的文件，包含着与程序有关的代码
\n
函数（function） ：可调用的计算单元
\n
函数体（function body） ：是一个块，用于定义函数所执行的操作
\n
函数匹配（function matching） ：编译器解析重载函数调用的过程，在此过程中，实参与每个重载函数的形参列表逐一比较
\n
函数原型（function prototype） ：函数的声明，包含函数名字、返回类型和形参类型。要想调用某函数，在调用点之前必须声明该函数的原型
\n
隐藏名字（hidden name） ：某个作用域内声明的名字会隐藏掉外层作用域中声明的同名实体
\n
initializer_list ：是一个标准类，表示的是一组花括号包围的类型相同的对象，对象之间以逗号隔开
\n
内联函数（inline function） ：请求编译器在可能的情况下在调用点展开函数。内联函数可以避免常见的函数调用开销
\n
链接（link） ：是一个编译过程，负责把若干对象文件链接起来形成可执行程序
\n
局部静态对象（local static object） ：它的值在函数调用结束后仍然存在。在第一次使用局部静态对象前创建并初始化它，当程序结束时局部静态对象才被销毁
\n
局部变量（local variable） ：定义在块中的变量
\n
无匹配（no match） ：是一种编译时发生的错误，原因是在函数匹配过程中所有函数的形参都不能与调用提供的实参匹配
\n
对象代码（object code） ：编译器将我们的源代码转换成对象代码格式
\n
对象文件（object file） ：编译器根据给定的源文件生成的保存对象代码的文件。一个或多个对象文件经过链接生成可执行文件
\n
对象生命周期（object lifetime） ：每个对象都有相应的生命周期
\n\n
重载确定（overload resolution） ：参见函数匹配
\n
重载函数（overloaded function） ：函数名与其他函数相同的函数。多个重载函数必须在形参数量或形参类型上有所区别
\n
形参（parameter） ：在函数的形参列表中声明的局部变量。用实参初始化形参
\n
引用传递（pass by reference） ：描述如何将实参传递给引用类型的形参。引用形参和其他形式的引用工作机理类似，形参被绑定到相应的实参上
\n
值传递（pass by value） ：描述如何将实参传递给非引用类型的形参。非引用类型的形参实际上是相应实参值的一个副本
\n
预处理宏（preprocessor macro） ：类似于内联函数的一种预处理功能。除了 assert 之外，现代 C++ 程序很少再使用预处理宏了
\n
递归循环（recursion loop） ：描述某个递归函数没有终止条件，因而不断调用自身直至耗尽程序栈空间的过程
\n
递归函数（recursive function） ：直接或间接调用自身的函数
\n
返回类型（return type） ：是函数声明的一部分，用于指定函数返回值的类型
\n
分离式编译（separate compilation） ：把一个程序分割成多个独立源文件的能力
\n
尾置返回类型（trailing return type） ：在参数列表后面指定的返回类型
\n
可行函数（viable function） ：是候选函数的子集。可行函数能匹配本次调用，它的形参数量与调用提供的实参数量相等，并且每个实参类型都能转换成相应的形参类型
\n
() 运算符（ () operator） ：调用运算符，用于执行某函数。括号前面是函数名或函数指针，括号内是以逗号隔开的实参列表（可能为空）
\n
参考：C++ Primer 中文版（第 5 版）
\n",
            "tags": [
                "C++"
            ]
        },
        {
            "id": "https://jiankychen.github.io/cpp-statement.html",
            "url": "https://jiankychen.github.io/cpp-statement.html",
            "title": "C++ 语句",
            "date_published": "2022-09-12T02:23:26.000Z",
            "content_html": "
# 语句与语句作用域
\n
# 简单语句
\n
表达式语句（expression statement）：执行表达式并丢弃掉求值结果
\n
空语句（null statement）：空语句中只含有一个单独的分号
\n
例如：
\n
// 重复读入数据直至到达文件末尾或某次输入的值等于 sought
while (cin >> s && s != sought)
    ; // 空语句
\n
使用空语句时应该加上注释，从而令读这段代码的人知道该语句是有意省略的
\n
\n
别漏写分号，也别多写分号：
\n
ival = v1 + v2;; // 正确：第二个分号表示一条多余的空语句
while (iter != svec.end()) ; //while 循环体是那条空语句（无休止循环）
    ++iter;                  // 递增运算不输于循环的一部分
复合语句（compound statement）是指用花括号括起来的（可能为空的）语句和声明的序列，复合语句也被称作 块（block）
\n
一个块就是一个作用域，在块中引入的名字只能在块内部以及嵌套在块中的子块里访问
\n
\n
块不以分号作为结束
\n
\n
while (val <= 10) {
    sum += val;
    ++val;
}
空块：是指内部没有任何语句的一对花括号。空块的作用等价于空语句
\n
while (cin >> s && s != sought)
    { } // 空块
# 语句作用域
\n
可以在 if 、switch 、while 和 for 语句的控制结构内定义变量。但是需要注意，定义在控制结构中的变量只在相应语句的内部可见，一旦语句结束，变量也就超出其作用范围了
\n
while (int i = get_num()) // 每次迭代时创建并初始化 i
    cout << i << endl;
i = 0;  // 错误：在循环外部无法访问 i
如果其他代码也需要访问控制变量，则变量必须定义在语句的外部
\n
// 寻找第一个负值元素
auto beg = v.begin(); // 注意要初始化
while (beg != v.end() && *beg >= 0)
    ++beg;
if (beg == v.end())
    // 此时我们知道 v 中的所有元素都大于等于 0
# 条件语句
\n
C++ 语言提供了两种按条件执行的语句
\n\n
# if 语句
\n
简单 if 语句的语法形式：
\n
if (condition)\n    statement\n
\n
if else 语句的形式：
\n
if (condition)\n    statement\nelse\n    statement2\n
\n
如果 condition 为真，执行 statement 。当 statement 执行完成后，程序继续执行 if 语句后面的其他语句
\n
如果 condition 为假，跳过 statement 。对于简单 if 语句来说，程序继续执行 if 语句后面的其他语句；对于 if else 语句来说，执行 statement2
\n
注意：在这两个版本的 if 语句中，condition 都必须用圆括号包围起来
\n
\n
condition 可以是一个表达式，也可以是一个初始化了的变量声明。不管是表达式还是变量，其类型都必须能转换成布尔类型
\n
\n
# 嵌套 if 语句
\n
例如：把数字形式表示的成绩转换成字母形式，并在合格的成绩后面添加一个加号或减号（如果成绩的末位是 8 或者 9 ，添加一个加号；如果末位是 0 、1 或 2 ，添加一个减号）
\n
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 的成绩添加一个减号
}
\n
注意使用花括号
\n
\n
# 悬垂 else
\n
当一个 if 语句嵌套在另一个 if 语句内部时，很可能 if 分支会多于 else 分支。此时，我们怎么知道某个给定的 else 是和哪个 if 匹配呢？
\n
这个问题通常称作 悬垂 else（dangling else）
\n
C++ 规定 else 与离它最近的尚未匹配的 if 匹配
\n
\n
In C++, the ambiguity is resolved by specifying that each  else  is matched with the closest preceding unmatched  if .
\n
\n
# 使用花括号控制执行路径
\n
要想使 else 分支和外层的 if 语句匹配起来，可以在内层 if 语句的两端加上花括号，使其成为一个块
\n
// 末位是 8 或者 9 的成绩添加一个加号；如果末位是 0 、1 或 2 的成绩添加一个减号
if (grade % 10 >= 3) {
    if (grade % 10 > 7)
        lettergrade += '+';  // 末尾是 8 或者 9 的成绩添加一个加号
} else                  // 花括号强迫 else 与外层 if 匹配
    lettergrade += '-'; // 末位是 0 、1 或 2 的成绩添加一个减号
# switch 语句
\n
switch 语句（switch statement）提供了一条便利的途径使得我们能够在若干固定选项中做出选择
\n
例如，利用 switch 语句统计五个元音字母在文本中出现的次数
\n
// 为每个元音字母初始化其计数值
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 标签的值比较
\n
如果表达式和某个 case 标签的值匹配成功，程序从该标签之后的第一条语句开始执行，直到到达了 switch 的结尾或者是遇到一条 break 语句为止
\n
\n
break 语句的作用是中断当前的控制流。此例中，break 语句将控制权转移到 switch 语句外面
\n
\n
如果 switch 语句的表达式和所有 case 都没有匹配上，将直接跳转到 switch 结构之后的第一条语句
\n
case 关键字和它对应的值一起被称为 case 标签（case label）
\n
case 标签必须是整型常量表达式
\n
char ch = getVal();
int ival = 42;
switch(ch) {
    case 3.14: // 错误：case 标签不是一个整数
    case ival: // 错误：case 标签不是一个常量
    // ...
\n
任何两个 case 标签的值不能相同，否则就会引发错误
\n
\n
default 也是一种特殊的 case 标签
\n
# switch 内部的控制流
\n
如果某个 case 标签匹配成功，将从该标签开始往后顺序执行所有 case 分支，除非程序显式地中断了这一过程，否则，执行到 switch 的结尾处才会停下来
\n
要想避免执行后续 case 分支的代码，我们必须显式地告诉编译器终止执行过程。大多数情况下，在下一个 case 标签之前应该有一条 break 语句
\n
然而，由于每个 case 标签只能对应一个值，有时候我们希望两个或更多个值共享同一组操作。此时，我们就故意省略掉 break 语句，使得程序能够连续执行若干个 case 标签
\n
例如：统计所有元音字母出现的总次数
\n
unsigned vowelCnt = 0;
// ...
switch (ch) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
       ++vowelCnt;
       break;
}
C++ 程序的形式比较自由，所以 case 标签之后不一定非得换行。把几个 case 标签写在一行里，强调这些 case 代表的是某个范围内的值
\n
switch (ch) {
    // 另一种合法的书写形式
    case 'a': case 'e': case 'i': case 'o': case 'u':
       ++vowelCnt;
       break;
}
\n
一般不要省略 case 分支最后的 break 语句。如果没写 break 语句，最好加一段注释说清楚程序的逻辑
\n
\n
\n
尽管 switch 语句不是非得在最后一个标签后面写上 break ，但是为了安全起见，最好这么做。因为这样的话，即使以后再增加新的 case 分支，也不用再在前面补充 break 语句了
\n
\n
# default 标签
\n
如果没有任何一个 case 标签能匹配上 switch 表达式的值，程序将执行紧跟在 default 标签（default label）后面的语句
\n
例如，可以增加一个计数值来统计非元音字母的数量
\n
switch (ch) {
    case 'a': case 'e': case 'i': case 'o': case 'u':
        ++vowelCnt; // 元音字母的数量
        break;
    default:
        ++otherCnt; // 非元音字母的数量
        break;
}
\n
即使不准备在 default 标签下做任何工作，定义一个 default 标签也是有用的。其目的在于告诉程序的读者，我们已经考虑到了默认的情况，只是目前什么也没做
\n
\n
标签不应该孤零零地出现，它后面必须跟一条语句或者另外一个 case 标签。如果 switch 结构以一个空的 default 标签作为结束，则该 default 标签后面必须跟一条空语句或一个空块
\n
# 迭代语句
\n
迭代语句通常称为循环，它重复执行操作直到满足某个条件才停下来
\n\n
# while 语句
\n
只要条件为真，while 语句（while statement）就重复地执行循环体
\n
语法形式为：
\n
while (condition)\n    statement\n
\n
condition 不能为空，如果 condition 第一次求值就得 false ， statement 一次都不执行
\n
condition 可以是一个表达式或者是一个带初始化的变量声明
\n
定义在 while 条件部分或者 while 循环体内的变量，每次迭代都经历从创建到销毁的过程
\n
当不确定到底要迭代多少次时，使用 while 循环比较合适
\n
例如：
\n
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 语句
\n
for 语句的语法形式：
\n
for (init-statement; condition; expression)\n    statement\n
\n
关键字 for 及括号里的部分称为 for 语句头
\n
init-statement 必须是以下三种形式中的一种：声明语句、表达式语句或者空语句。因为这些语句都以分号作为结束，for 语句的语法形式也可以看作：
\n
for (initializer; condition; expression)\n    statement\n
\n
其中：
\n\n
\n
for 语句头中定义的对象只在 for 循环体内可见
\n
\n
# for 语句头中的多重定义
\n
init-statement 可以定义多个对象，但只能有一条声明语句，因此，所有变量的基础类型必须相同
\n
例如：下列代码在 init-statement 里同时定义了索引 i 和循环控制变量 sz
\n
// 记录下 v 的大小，当到达原来的最后一个元素后结束循环
for (decltype(v.size()) i = 0, sz = v.size(); i != sz; ++i)
    v.push_back(v[i]);
# 省略 for 语句头的某些部分
\n
for 语句头能省略掉 init-statement 、condition 和 expression 中的任何一个（或者全部）
\n
如果无须初始化，则我们可以使用一条空语句作为 init-statement ，例如
\n
auto beg = v.begin();
for ( /* 空语句 */; beg != v.end() && *beg >= 0; ++beg)
    ; // 什么也不做
注意，分号必须保留，以表明我们省略掉了 init-statement 。说得更准确一点，分号表示的是一个空的 init-statement
\n
省略 condition 的效果等价于在条件部分写了一个 true 。因为条件的值永远是 true ，所以在循环体内必须有语句负责退出循环，否则循环就会无休止地执行下去
\n
for (int i = 0; /* 条件为空 */ ; ++i) {
    // 对 i 进行处理，循环内部的代码必须能够终止迭代过程
}
我们也能省略掉 for 语句头中的 expression ，但是在这样的循环中就要求条件部分或者循环体必须改变迭代变量的值
\n
vector<int> v;
for (int i; cin >> i; /* 表达式为空 */ )
   v.push_back(i);
因为条件部分能改变 i 的值，所以这个循环无须表达式部分。其中，条件部分不断检查输入流的内容，只要读取完所有的输入或者遇到一个输入错误就终止循环
\n
# 范围 for 语句
\n
C++ 11 新标准引入了一种更简单的 for 语句，这种语句可以遍历容器或其他序列的所有元素
\n
范围 for 语句（range for statement）的语法形式：
\n
for (declaration : expression)\n    statement\n
\n
expression 表示的必须是一个序列，比如用花括号括起来的初始值列表、数组或者 vector 或 string 等类型的对象，这些类型的共同特点是拥有能返回迭代器的 begin 和 end 成员
\n
declaration 定义一个变量，序列中的每个元素都得能转换成该变量的类型
\n\n
每次迭代都会重新定义循环控制变量，并将其初始化成序列中的下一个值，之后才会执行 statement
\n
statement 可以是一条单独的语句也可以是一个块
\n
所有元素都处理完毕后循环终止
\n
例如：把 vector 对象中的每个元素都翻倍
\n
vector<int> v = {0,1,2,3,4,5,6,7,8,9};
// 范围变量必须是引用类型，这样才能对元素执行写操作
for (auto &r : v)   // 对于 v 中的每一个元素
    r *= 2;         // 将 v 中每个元素的值翻倍
其等价于
\n
for (auto beg = v.begin(), end = v.end(); beg != end; ++beg) {
    auto &r = *beg;
    r *= 2;
}
不能通过范围 for 语句增加 vector 对象（或者其他容器）的元素：因为在范围 for 语句中，预存了 end () 的值。一旦在序列中添加（删除）元素，end 函数的值就可能变得无效了
\n
# do while 语句
\n
do while 语句（do while statement）和 while 语句非常相似，唯一的区别是，do while 语句先执行循环体后检查条件
\n
即，不管条件的值如何，do while 语句都至少执行一次循环
\n
do while 语句的语法形式：
\n
do\n    statement\nwhile (condition);\n
\n
do while 语句应该在后面用一个分号表示语句结束
\n
在 do while 语句中，首先执行一次 statement 然后才求 condition 的值（ condition 不能为空）。如果 condition 的值为假，循环终止；否则，重复循环过程
\n
condition 使用的变量必须定义在循环体之外
\n
例如，可以使用 do while 循环（不断地）执行加法运算
\n
// 不断提示用户输入一对数，然后求其和
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 先执行语句（或者块）后判断条件，所以不允许在条件部分定义变量
\n
do {
    // . . .
    mumble(foo);
} while (int foo = get_foo()); // 错误：将变量声明放在了 do while 的条件部分
# 跳转语句
\n
跳转语句用于中断当前的执行过程
\n
C++ 语言提供了 4 种跳转语句：
\n\n
# break 语句
\n
break 语句（break statement）负责终止离它最近的 while 、do while 、for 或 switch 语句，并从这些语句之后的第一条语句开始继续执行
\n
break 语句只能出现在迭代语句或者 switch 语句内部（包括嵌套在此类循环里的语句或块的内部）。break 语句的作用范围仅限于最近的循环或者 switch
\n
例如：
\n
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 语句
\n
标记为 #2 的 break 语句负责终止 switch 语句，但是不能终止 while 循环。执行完这个 break 后，程序继续执行 while 的条件部分
\n
# continue 语句
\n
continue 语句（continue statement）终止最近的循环中的当前迭代并立即开始下一次迭代
\n
continue 语句只能出现在 for 、while 和 do while 循环的内部，或者嵌套在此类循环里的语句或块的内部
\n
和 break 语句类似的是，出现在嵌套循环中的 continue 语句也仅作用于离它最近的循环
\n
和 break 语句不同的是，只有当 switch 语句嵌套在迭代语句内部时，才能在 switch 里使用 continue （即，continue 对循环起作用，而不对 switch 起作用）
\n
continue 语句中断当前的迭代，但是仍然继续执行循环
\n\n
例如：从标准输入中读取单词并处理以下画线开头的单词
\n
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 语句
\n
goto 语句（goto statement）的作用：从 goto 语句无条件跳转到同一函数内的另一条语句
\n
\n
不要在程序中使用 goto 语句，因为它使得程序既难理解又难修改
\n
\n
goto 语句的语法形式：
\n
goto label;\n
\n
其中，label 是用于标识一条语句的标示符
\n
带标签语句（labeled statement）是一种特殊的语句，在它之前有一个标示符以及一个冒号，例如：
\n
end: return; // 带标签语句，可以作为 goto 的目标
标签标示符独立于变量或其他标示符的名字，因此，标签标示符可以和程序中其他实体的标识符使用同一个名字而不会相互干扰
\n
goto 语句和控制权转向的那条带标签的语句必须位于同一个函数之内
\n
和 switch 语句类似，goto 语句也不能将程序的控制权从变量的作用域之外转移到作用域之内：
\n
// . . .
    goto end;
    int ix = 10; // 错误：goto 语句绕过了一个带初始化的变量定义
end:
    // 错误：此处的代码需要 ix，但是 goto 语句绕过了它的声明
    ix = 42;
向后跳过一个已经执行的定义是合法的。跳回到变量定义之前意味着系统将销毁该变量，然后重新创建它。例如：
\n
// backward jump over an initialized variable definition is okay
  begin:
    int sz = get_size();
    if (sz <= 0) {
        goto begin;
    }
在上面的代码中，goto 语句执行后将销毁 sz 。因为跳回到 begin 的动作跨过了 sz 的定义语句，所以 sz 将重新定义并初始化
\n
# try 语句块和异常处理
\n
异常是指存在于运行时的反常行为，这些行为超出了函数正常功能的范围
\n
典型的异常包括失去数据库连接以及遇到意外输入等
\n
异常处理机制包括异常检测和异常处理两个部分
\n
在 C++ 语言中，异常处理包括：
\n\n
# throw 表达式
\n
throw 表达式包含关键字 throw 和紧随其后的一个表达式，其中表达式的类型就是抛出的异常类型
\n
throw 表达式后面通常紧跟一个分号
\n
例如：在执行两个 Sales_item 对象相加时，需要先检查它们是否是关于同一种书籍的
\n
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 的对象）
\n
\n
类型 runtime_error 是标准库异常类型的一种，定义在 stdexcept 头文件中
\n
\n
抛出异常将终止当前的函数，并把控制权转移给能处理该异常的代码
\n
# try 语句块
\n
try 语句块包括关键字 try 以及紧随其后的一个块（花括号括起来的语句序列），其通用语法形式为：
\n
try {
    program-statements
} catch (exception-declaration) {
    handler-statements
} catch (exception-declaration) {
    handler-statements
} // ...
跟在 try 块之后的是一个或多个 catch 子句
\n
catch 字句包括三部分：
\n\n
当选中某个 catch 子句处理异常之后，就会执行与之对应的块
\n
catch 一旦完成，程序将会跳转到 try 语句块对应的最后一个 catch 子句之后，以继续执行后续语句
\n
try 语句块中的 program-statements 可以是任意 C++ 语句，包括声明在内的
\n
\n
try 语句块内声明的变量在块外部无法访问，特别是，在 catch 子句内也无法访问
\n
\n
# 编写 handler-statements
\n
例如：可以将程序原本需要执行的任务放在 try 语句块中（这段代码可能会抛出一个 runtime_error 类型的异常），然后在 try 语句块之后跟一个 catch 字句（用于处理类型为 runtime_error 的异常）
\n
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 对象的副本
\n
在上例中，如果 try 语句块中抛出异常，catch 子句将会输出：
\n
Data must refer to same ISBN\nTry Again? Enter y or n\n
\n
# 函数在寻找处理代码的过程中退出
\n
程序在遇到抛出异常的代码前，可能已经经过了多个 try 语句块（例如，一个 try 语句块可能调用了包含另一个 try 语句块的函数）
\n
此时，寻找 异常处理代码 的过程为：
\n\n
如果最终还是没能找到任何匹配的 catch 子句，程序将会转到名为 terminate 的标准库函数。该函数的行为与系统有关，一般情况下，执行该函数将导致程序非正常退出
\n
如果一段程序没有 try 语句块且发生了异常，系统也会调用 terminate 函数并终止当前程序的执行
\n
# 标准异常
\n
C++ 标准库定义了一组类，用于报告标准库函数遇到的问题
\n
C++ 定义了 4 个包含异常类的头文件：
\n\n
标准库异常类只定义了以下几种运算：
\n\n
对于 exception 、bad_alloc 和 bad_cast 异常类型，只能以默认初始化的方式来初始化这些类型的对象，而不允许为这些对象提供初始值
\n
对于其他异常类型，则应该使用 string 对象或者 C 风格字符串来初始化这些类型的对象，而不允许使用默认初始化的方式
\n\n
每个异常类型都只定义了一个名为 what 的成员函数：
\n\n
# 术语表
\n
块（block）：包围在花括号内的由 0 条或多条语句组成的序列。块也是一条语句，所以只要是能使用语句的地方，就可以使用块
\n
break 语句（break statement）：终止离它最近的循环或 switch 语句。控制权转移到循环或 switch 之后的第一条语句
\n
case 标签（case label）：在 switch 语句中紧跟在 case 关键字之后的常量表达式。在同一个 switch 语句中任意两个 case 标签的值不能相同
\n
catch 子句（catch clause）：由 catch 关键字、括号里的异常声明以及语句块三部分组成。catch 子句的代码负责处理在异常声明中定义的异常
\n
复合语句（compound statement）：块
\n
continue 语句（continue statement）：终止离它最近的循环的当前迭代。控制权转移到 while 或 do while 语句的条件部分、或者范围 for 循环的下一次迭代、或者传统 for 循环头部的表达式
\n
悬垂 else（dangling else）：是一个俗语，指的是如何处理嵌套 if 语句中 if 分支多于 else 分支的情况
\n\n
default 标签（default label）：是一种特殊的 case 标签，当 switch 表达式的值与所有 case 标签都无法匹配时，程序执行 default 标签下的内容
\n
do while 语句（do while statement）：与 while 语句类似，但 do while 语句先执行循环体，再判断条件。循环体代码至少会执行一次
\n
异常类（exception class）：标准库定义的一组类，用于表示程序发生的错误
\n
异常声明（exception declaration）：位于 catch 子句中的声明，指定了该 catch 子句能处理的异常类型
\n
异常处理代码（exception handler）：程序某处引发异常后，用于处理该异常的另一处代码。和 catch 子句是同义词
\n
异常安全（exception safe）：是一个术语，表示的含义是当抛出异常后，程序能执行正确的行为
\n
表达式语句（expression statement）：即一条表达式后面跟上一个分号，令表达式执行求值过程
\n
控制流（flow of control）：程序的执行路径
\n
for 语句（for statement）：提供迭代执行的迭代语句。常常用于遍历一个容器或者重复计算若干次
\n
goto 语句（goto statement）：令控制权无条件转移到同一函数中一个指定的带标签语句。goto 语句容易造成程序的控制流混乱，应禁止使用
\n
if else 语句（if else statement）：判断条件，根据其结果分别执行 if 分支或 else 分支的语句
\n
if 语句（if statement）：判断条件，根据其结果有选择地执行语句。如果条件为真，执行 if 分支的代码；如果条件为假，控制权转移到 if 结构之后的第一条语句
\n
带标签语句（labeled statement）：前面带有标签的语句。所谓标签是指一个标识符以及紧跟着的一个冒号。对于同一个标识符来说，用作标签的同时还能用于其他目的，互不干扰
\n
空语句（null statement）：只含有一个分号的语句
\n
引发（raise）：含义类似于 throw 。在 C++ 语言中既可以说抛出异常，也可以说引发异常
\n
范围 for 语句（range for statement）：在一个序列中进行迭代的语句
\n
switch 语句（switch statement）：一种条件语句
\n\n
terminate ：是一个标准库函数，当异常没有被捕捉到时调用。terminate 终止当前程序的执行
\n
throw 表达式（throw expression）：一种中断当前执行路径的表达式。throw 表达式抛出一个异常并把控制权转移到能处理该异常的最近的 catch 子句
\n
try 语句块（try block）：跟在 try 关键字后面的块，以及一个或多个 catch 子句。如果 try 语句块的代码引发异常并且其中一个 catch 子句匹配该异常类型，则异常被该 catch 子句处理。否则，异常将由外围 try 语句块处理，或者程序终止
\n
while 语句（while statement）：只要指定的条件为真，就一直迭代执行目标语句
\n
参考：C++ Primer 中文版（第 5 版）
\n",
            "tags": [
                "C++"
            ]
        },
        {
            "id": "https://jiankychen.github.io/leetcode-input&output.html",
            "url": "https://jiankychen.github.io/leetcode-input&output.html",
            "title": "常见输入输出",
            "date_published": "2022-09-09T09:08:49.000Z",
            "content_html": "
# 场景一：多组空格分隔的两个正整数
\n
输入描述：
\n
输入包括两个正整数 a, b (1 <= a, b <= 1000)，输入数据包括多组\n
\n
输出描述：
\n
输出 a + b 的结果\n
\n
数据范围：
\n
数据组数 1 <= t <= 100\n
\n
输入示例：
\n
1 5\n10 20\n
\n
输出示例：
\n
6\n30\n
\n
代码实现：
\n
#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;
}
# 场景二：第一行组数接空格分隔的两个正整数
\n
输入描述：
\n
输入第一行包括一个数据组数 t (1 <= t <= 100)\n接下来每行包括两个正整数 a, b (1 <= a, b <= 1000)\n
\n
输出描述：
\n
输出 a + b 的结果\n
\n
数据范围：
\n
数据组数 1 <= t <= 100\n
\n
输入示例：
\n
2\n1 5\n10 20\n
\n
输出示例：
\n
6\n30\n
\n
代码实现：
\n
#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 结束
\n
输入描述：
\n
输入包括两个正整数 a, b (1 <= a, b <= 10^9)，输入数据有多组，如果输入为 0 0 则结束输入\n
\n
输出描述：
\n
输出 a + b 的结果\n
\n
数据范围：
\n
数据组数 1 <= t <= 100\n
\n
输入示例：
\n
1 5\n10 20\n0 0\n
\n
输出示例：
\n
6\n30\n
\n
代码实现：
\n
#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
输入描述：
\n
输入数据有多组，每行表示一组输入数据\n每行的第一个整数为整数的个数 n (1 <= n <= 100)\n接下来 n 个正整数，即需要求和的每个正整数\n
\n
输出描述：
\n
每组数据输出求和的结果\n
\n
数据范围：
\n
数据组数 1 <= t <= 100\n每组数据中整数个数满足 1 <= n <= 100\n每组数据中的值满足 1 <= val <= 100\n
\n
输入示例：
\n
4 1 2 3 4\n5 1 2 3 4 5\n
\n
输出示例：
\n
10\n15\n
\n
代码实现：
\n
#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;
}
# 场景五：第一行组数接个数以及空格分隔的整数
\n
输入描述：
\n
输入的第一行包括一个正整数 t (1 <= t <= 100)，表示数据组数\n接下来 t 行，每行一组数据\n每行的第一个整数为整数的个数 n (1 <= n <= 100)\n接下来 n 个正整数，即需要求和的每个正整数\n
\n
输出描述：
\n
每组数据输出求和的结果\n
\n
数据范围：
\n
数据组数 1 <= t <= 100\n每组数据中整数个数满足 1 <= n <= 100\n每组数据中的值满足 1 <= val <= 100\n
\n
输入示例：
\n
2\n4 1 2 3 4\n5 1 2 3 4 5\n
\n
输出示例：
\n
10\n15\n
\n
代码实现：
\n
#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
输入描述：
\n
输入数据有多组，每行表示一组输入数据\n每行不定有 n 个整数，空格隔开 (1 <= n <= 100)\n
\n
输出描述：
\n
每组数据输出求和的结果\n
\n
输入示例：
\n
1 2 3\n4 5\n0 0 0 0 0\n
\n
输出示例：
\n
6\n9\n0\n
\n
代码实现：
\n
// 借助 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 ）
\n\n
\n
getline (istream&  is, string& str)  ：Extracts characters from  is  and stores them into  str  until the newline character,  '\\n' , is found.
\n
\n
\n
注意：如果在使用  getline()  函数之前已经使用过  cin  ，则需使用  cin.get()  （或者， cin.ignore()  或  getchar()  ）读取缓冲区中的换行符  \\n  ，然后再使用  getline()  （参考：C++ 中 cin 和 getline 使用出错的解决方法 ）
\n\n
\n
或者：
\n
// 每次 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
输入有两行，第一行 n\n第二行是 n 个字符串，字符串之间用空格隔开\n
\n
输出描述：
\n
输出一行排序后的字符串，空格隔开，无结尾空格\n
\n
输入示例：
\n
5\nc d a bb e\n
\n
输出示例：
\n
a bb c d e\n
\n
代码实现：
\n
#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
多个测试用例，每个测试用例一行\n每行通过空格隔开，有 n 个字符，n < 100\n
\n
输出描述：
\n
对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开\n
\n
输入示例：
\n
a c bb\nf dddd\nnowcoder\n
\n
输出示例：
\n
a bb c\ndddd f\nnowcoder\n
\n
代码实现：
\n
// 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;
}
或者：
\n
// 判断换行符 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
多个测试用例，每个测试用例一行\n每行通过 ',' 隔开，有 n 个字符，n < 100\n
\n
输出描述：
\n
对于每组用例输出一行排序后的字符串，用 ',' 隔开，无结尾空格\n
\n
输入示例：
\n
a,c,bb\nf,dddd\nnowcoder\n
\n
输出示例：
\n
a,bb,c\ndddd,f\nnowcoder\n
\n
代码实现：
\n
#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;
}
参考：
\n\n",
            "tags": [
                "Coding"
            ]
        },
        {
            "id": "https://jiankychen.github.io/latex-citation.html",
            "url": "https://jiankychen.github.io/latex-citation.html",
            "title": "LaTeX：跨 tex 文件的交叉引用",
            "date_published": "2022-08-29T12:45:58.000Z",
            "content_html": "
# 教程
\n
如果需要在 response.tex 中引用 revision.tex 的某一段文本，可通过以下步骤实现：
\n
    \n
  1. \n
    在 revision.tex 中，将需要引用的文本放在  %<*tag>  和  %</tag>  之间，即：
    \n
    %<*tag>
    Here is the text to be cited.
    %</tag>
    2. \n
  2. \n
    在 response.tex 中，添加  catchfilebetweentags  这个包，即：
    \n
    \\usepackage{catchfilebetweentags}
    3. \n
  3. \n
    在 response.tex 中，利用  \\ExecuteMetaData  命令引用文本，即：
    \n
    \\ExecuteMetaData[revision]{tag}
    4. \n
\n
然而，如果需要引用的文本中包含了  \\ref  、 \\eqref  、 \\cite  命令，response.tex 将无法正常编译以及显示编号
\n
此时，还需要让 response.tex 获取 revision.tex 所生成的 labels 和 citations ，即，在  response.tex 中添加如下命令：
\n
% copy labels
\\usepackage{xr}
\\externaldocument{revision}
% copy citations
\\usepackage{xcite}
\\externalcitedocument{revision}
这是因为，revision.tex 生成的 labels 和 citations 全都保存在 revision.aux 文件中，而  \\externaldocument  和  \\externalcitedocument  可以分别读取 aux 文件中的 labels 和 citations
\n
执行完以上操作，无论是 revision.tex 中的什么文本，都能在 response.tex 中正常编译并显示（测试使用的是 IEEE 的论文模板）
\n
\n
可能不适用于其余期刊的论文模板，因为其他期刊论文模板可能修改了 aux 文件中 labels 和 citations 的格式（应该是都可以通过编译的，只不过显示效果依赖于期刊模板）
\n
\n
# 示例
\n
例如，在 revision.tex 中写到：
\n
%<*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 的内容：
\n
We have rewritten Lemma 1 as: ``\\ExecuteMetaData[revision]{lemma}''
编译得到的 response.pdf 显示：
\n\"\"
\n可以看到，revision.tex 对公式的引用，即，  \\eqref{eqn:power_low_energy_node} - \\eqref{eqn:power_CH}  ，也能在 response.tex 中正常编译（并且，response.pdf 显示出的公式编号与 revision.pdf 相同）
\n
\n
为了使用  \\blue{}  命令（使  {}  内的文字变蓝色），需要先在导言区定义： \\newcommand{\\blue}[1]{{{\\color{blue} #1}}}
\n
\n
再例如，在 revision.tex 中写到：
\n
%<*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 中引用：
\n
To reveal the data collection mechanism, we have added the following sentence in Section 
IV: ``\\blue{\\ExecuteMetaData[revision]{collection}}''
编译得到的 response.pdf 显示：
\n\"\"
\n可以看到，revision.tex 对参考文献的引用， \\cite{CDG2009}  ，也能在 response.tex 中奏效
\n
类似的，revision.tex 中关于表格（table）、算法（algorithm）、图片（figure）等的引用（通过 \\label 命令打标签、通过 \\ref 命令引用），也能采用以上方式在 response.tex 中正常编译并显示
\n",
            "tags": [
                "Tutorial",
                "LaTeX"
            ]
        },
        {
            "id": "https://jiankychen.github.io/leetcode-sort.html",
            "url": "https://jiankychen.github.io/leetcode-sort.html",
            "title": "LeetCode - 排序专题",
            "date_published": "2022-08-22T05:39:22.000Z",
            "content_html": "
# LeetCode 215. 数组中的第 K 个最大元素
\n
215. Kth Largest Element in an Array
\n
给定整数数组  nums  和整数  k ，请返回数组中第  k  个最大的元素。
\n
请注意，你需要找的是数组排序后的第  k  个最大的元素，而不是第  k  个不同的元素。
\n
你必须设计并实现时间复杂度为 O(n)O(n)O(n) 的算法解决此问题。
\n
示例 1：
\n
输入：nums = [3,2,1,5,6,4], k = 2\n输出：5\n
\n
示例 2：
\n
输入：nums = [3,2,3,1,2,4,5,5,6], k = 4\n输出：4\n
\n
提示：
\n\n
# 思路
\n
数组第 k 个最大元素，即，数组降序排序后的第 k 个元素（或者，升序排序后的倒数第 k 个元素）
\n
对整个数组排序的时间复杂度至少为 O(nlog⁡n)O(n \\log{n})O(nlogn)，其中 nnn 是数组 nums 的长度
\n
有一种基于快速排序的算法，可以确定某一个元素在排序以后的位置，即，快速选择 算法
\n
# Method 1: 基于快速排序的选择方法
\n
算法思路：（以 寻找降序排序后的第 k 个元素 为例）
\n
快速排序的划分操作：从区间 [left, right] 中选择任意一个元素作为基准，调整子数组，使得位置 p 左侧的元素都大于等于基准元素，位置 p 右侧的元素都小于基准元素，于是，基准元素的最终位置就是 p
\n
即，nums [p] 左侧元素全都大于等于 nums [p]，nums [q] 右侧元素全都小于 nums [p]，于是，nums [p] 就是第 p + 1 个最大元素（数组索引从 0 开始）
\n
因此，可按如下方案求解该问题：
\n\n
特别地，我们应随机选择基准元素，使得快速算法算法的时间代价的期望为 O(n)O(n)O(n)
\n
代码实现：
\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)O(n)O(n)，其中 nnn 是数组 nums 的长度
\n
空间复杂度：O(1)O(1)O(1)
\n
参考：
\n\n",
            "tags": [
                "Coding",
                "排序"
            ]
        },
        {
            "id": "https://jiankychen.github.io/leetcode-search.html",
            "url": "https://jiankychen.github.io/leetcode-search.html",
            "title": "LeetCode - 搜索专题",
            "date_published": "2022-08-16T08:38:30.000Z",
            "content_html": "
# LeetCode 200. 岛屿数量
\n
200. Number of Islands
\n
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
\n
岛屿总是被水包围，并且每座岛屿只能由水平方向和 / 或竖直方向上相邻的陆地连接形成。
\n
此外，你可以假设该网格的四条边均被水包围。
\n
示例 1：
\n
输入：grid = [\n  ["1","1","1","1","0"],\n  ["1","1","0","1","0"],\n  ["1","1","0","0","0"],\n  ["0","0","0","0","0"]\n]\n输出：1\n
\n
示例 2：
\n
输入：grid = [\n  ["1","1","0","0","0"],\n  ["1","1","0","0","0"],\n  ["0","0","1","0","0"],\n  ["0","0","0","1","1"]\n]\n输出：3\n
\n
提示：
\n\n
# Method 1: 深度优先搜索
\n
算法思路：
\n
扫描整个二维网格，如果某一个位置为 '1'，则表示查找到一个岛屿，此时需以其为起始位置开始进行深度优先搜索
\n
深度优先搜索的具体操作：
\n\n
代码实现：
\n
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×n)O(m \\times n)O(m×n)，其中 mmm 和 nnn 是二维网格的行数和列数
\n
空间复杂度：O(m×n)O(m \\times n)O(m×n)，最坏情况下，递归的深度为 m×nm \\times nm×n
\n
# Method 2: 广度优先搜索
\n
算法思路：
\n
扫描整个二维网格，每发现一个位置为 '1'，就表示查找到一个岛屿，将该位置加入队列，针对该岛屿开始广度优先搜索，直到队列为空
\n\n
代码实现：
\n
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×n)O(m \\times n)O(m×n)，其中 mmm 和 nnn 是二维网格的行数和列数
\n
空间复杂度：O(min⁡(m×n))O(\\min(m \\times n))O(min(m×n))，在最坏情况下，整个网格均为陆地，队列的大小为 min⁡(m,n)\\min(m, n)min(m,n)
\n
# LeetCode 207. 课程表
\n
207. Course Schedule
\n
你这个学期必须选修  numCourses  门课程，记为  0  到  numCourses - 1  。
\n
在选修某些课程之前需要一些先修课程。 先修课程按数组  prerequisites  给出，其中  prerequisites[i] = [ai, bi]  ，表示如果要学习课程  ai  则 必须 先学习课程   bi  。
\n\n
请你判断是否可能完成所有课程的学习？如果可以，返回  true  ；否则，返回  false  。
\n
示例 1：
\n
输入：numCourses = 2, prerequisites = [[1,0]]\n输出：true\n解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。\n
\n
示例 2：
\n
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]\n输出：false\n解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。\n
\n
提示：
\n\n
# 思路
\n
给定一个包含 n 个节点的有向图 G，我们给出它的节点编号的一种排列，如果满足：
\n\n
那么称该排列是图 G 的 拓扑排序
\n
根据上述定义，有以下结论：
\n\n
在本题中，我们可以将每一门课看成一个节点，如果学习课程 A 之前必须完成课程 B，则可以连接一条从 B 到 A 的有向边，然后判断该图是否存在拓扑排序（也就是判断该图是否为有向无环图）
\n
# Method 1: 广度优先遍历
\n
算法思路：
\n
我们考虑拓扑排序中最前面的节点，该节点一定不会有任何入边，也就是它没有任何的先修课程要求。当我们将一个节点加入答案中后，我们就可以移除它的所有出边，代表着它的相邻节点少了一门先修课程的要求。如果某个相邻节点变成了「没有任何入边的节点」，那么就代表着这门课可以开始学习了。按照这样的流程，我们不断地将没有入边的节点加入答案，直到答案中包含所有的节点（得到了一种拓扑排序）或者不存在没有入边的节点（图中包含环）
\n
算法流程：
\n
使用一个队列来进行广度优先搜索：初始时，所有入度为 0 的节点都被放入队列中，它们就是可以作为拓扑排序最前面的节点，并且，它们之间的相对顺序是无关紧要的
\n
在广度优先搜索的每一步中，我们取出队首的节点 u：
\n\n
在广度优先搜索的过程结束后，如果答案数组中包含了这 numCourses 个节点，那就说明我们找到了一种拓扑排序，否则，说明图中存在环，也就不存在拓扑排序了
\n
\n
特别地，可以只用一个变量来记录入度为 0 的节点个数，而无需将节点实际放入答案数组中。在广度优先搜索结束后，判断该变量的值是否等于课程数，就能知道是否存在一种拓扑排序
\n
\n
代码实现：
\n
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)O(n + m)O(n+m)，其中 nnn 为课程数（即，numCourses），mmm 为先修课程的要求数（即，prerequisites 中一维数组的数量）
\n
空间复杂度：O(n+m)O(n + m)O(n+m)，其中，邻接表所需空间为 O(m)O(m)O(m)，队列所需空间为 O(n)O(n)O(n)
\n
# Method 2: 深度优先搜索
\n
算法思路：
\n
借助一个标志列表 flags，用于判断每个节点 i （课程）的状态
\n\n
对 numCourses 个节点依次执行深度优先搜索，判断以每个节点起步的深度优先搜索是否存在环，若存在环直接返回 false
\n\n
待整个图的深度优先搜索结束，如果未发现环，返回 true
\n
代码实现：
\n
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)O(n+m)
\n
空间复杂度：O(n+m)O(n + m)O(n+m)
\n
参考：leetcode-solution
\n
# LeetCode 399. 除法求值
\n
399. Evaluate Division
\n
给你一个变量对数组  equations  和一个实数值数组  values  作为已知条件，其中  equations[i] = [Ai, Bi]  和  values[i]  共同表示等式  Ai / Bi = values[i]  。每个  Ai  或  Bi  是一个表示单个变量的字符串。
\n
另有一些以数组  queries  表示的问题，其中  queries[j] = [Cj, Dj]  表示第  j  个问题，请你根据已知条件找出  Cj / Dj = ?  的结果作为答案。
\n
返回 所有问题的答案 。如果存在某个无法确定的答案，则用  -1.0  替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用  -1.0  替代这个答案。
\n
注意： 输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。
\n
示例 1：
\n
输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]\n输出：[6.00000,0.50000,-1.00000,1.00000,-1.00000]\n解释：\n    条件：a / b = 2.0, b / c = 3.0\n    问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?\n    结果：[6.0, 0.5, -1.0, 1.0, -1.0 ]\n
\n
示例 2：
\n
输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]\n输出：[3.75000,0.40000,5.00000,0.20000]\n
\n
示例 3：
\n
输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]\n输出：[0.50000,2.00000,-1.00000,-1.00000]\n
\n
提示：
\n\n
# Method 1: 广度优先搜索
\n
# 算法思路
\n
可以将整个问题建模成一个图：将变量字符串视为图的顶点，将两个变量的比值视为两顶点之间边的权值，试对任意两点（两个变量）求其路径长度（两个变量的比值）
\n
首先遍历  equations  数组，将每个不同的变量字符串编号，并通过哈希表建立映射
\n
然后，建立每个顶点的边集并将其存储到数组  vector<vector<pair<int, double>>> edges  中，其中， edges[i]  表示第 i 个顶点的边集， edges[i][j].first  表示顶点 i 的第 j 个邻居节点， edges[i][j].second  表示顶点 i 到其第 j 个邻居节点的路径长度（两个变量的比值）
\n
于是，对于任何一个查询，可以从起点出发，通过广度优先搜索的方式，遍历图中的顶点，并更新起点到当前点的路径长度，直到遍历到终点为止
\n
\n
由于每次查询都需要遍历图中的所有顶点，当查询数量较大时，效率就会非常低。因此，可以对图进行预处理，先计算出每个顶点到其他顶点的路径长度，然后再依次处理每一个查询
\n
\n
# 代码实现
\n
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
\n
# 复杂度分析
\n
时间复杂度：O(ML+Q⋅(L+M))O(M L + Q \\cdot (L + M))O(ML+Q⋅(L+M))，其中 MMM 为 数组  equations  的长度（边的数量），LLL 为字符串的平均长度，QQQ 为数组  queries  的长度（查询的数量）
\n\n
空间复杂度：O(NL+M)O(N L + M)O(NL+M)，其中 NNN 为数组  equations  中的字符串的种类数（图的顶点个数）
\n\n
# Method 2: 带权并查集
\n
参考：leetcode-solution
\n
# LeetCode 695. 岛屿的最大面积
\n
LeetCode 695. Max Area of Island
\n
给你一个大小为  m x n  的二进制矩阵  grid  。
\n
岛屿 是由一些相邻的  1  (代表土地) 构成的组合，这里的「相邻」要求两个  1  必须在 水平或者竖直的四个方向上 相邻。你可以假设  grid  的四个边缘都被  0 （代表水）包围着。
\n
岛屿的面积是岛上值为  1  的单元格的数目。
\n
计算并返回  grid  中最大的岛屿面积。如果没有岛屿，则返回面积为  0  。
\n
示例 1：
\n
\"\"
\n
输入：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]]\n输出：6\n
\n
示例 2：
\n
输入：grid = [[0,0,0,0,0,0,0,0]]\n输出：0\n
\n
提示：
\n\n
# Method 1: 深度优先搜索
\n
计算网格中每个连通形状的面积，然后取最大值。
\n
在一个土地上，向 4 个方向探索与之相连的每一个土地（以及与这些土地相连的土地），那么探索过的土地总数将是该连通形状的面积
\n
为了确保每个土地访问不超过一次，我们每次经过一块土地时，将这块土地的值置为  0 
\n
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×C)O(R \\times C)O(R×C)。其中  R  是给定网格中的行数， C  是列数。访问每个网格最多一次
\n
空间复杂度：O(R×C)O(R \\times C)O(R×C)，递归的深度最大可能是整个网格的大小，因此最大可能使用 O(R×C)O(R \\times C)O(R×C) 的栈空间
\n
# Method 2: 深度优先搜索 + 栈
\n
# Method 3: 广度优先搜索
\n
把方法二中的栈改为队列，每次从队首取出土地，并将接下来想要遍历的土地放在队尾，就实现了广度优先搜索算法
\n
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×C)O(R \\times C)O(R×C)。其中  R  是给定网格中的行数， C  是列数，访问每个网格最多一次
\n
空间复杂度：O(R×C)O(R \\times C)O(R×C)，队列中最多会存放所有的土地，土地的数量最多为  R × C  块
\n
# LeetCode 733. 图像渲染
\n
LeetCode 733. Flood Fill
\n
有一幅以  m x n  的二维整数数组表示的图画  image  ，其中  image[i][j]  表示该图画的像素值大小（索引  i  和  j  均从 0 开始）。
\n
你也被给予三个整数  sr  ， sc  和  newColor  。你应该从像素  image[sr][sc]  开始对图像进行 上色填充 。
\n
为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为  newColor  。
\n
最后返回 经过上色渲染后的图像 。
\n
\n
示例 1：
\n
\"\"
\n
输入：image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, newColor = 2\n输出：[[2,2,2],[2,2,0],[2,0,1]]\n解释：在图像的正中间，(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。注意，右下角的像素没有更改为2，因为它不是在上下左右四个方向上与初始点相连的像素点。\n
\n
示例 2：
\n
输入：image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, newColor = 2\n输出：[[2,2,2],[2,2,2]]\n
\n
提示：
\n\n
# Method 1: 广度优先搜索
\n
每次搜索到一个方格时，如果其与初始位置的方格颜色相同，就将该方格加入队列，并将该方格的颜色更新，以防止重复入队。
\n
注意：因为初始位置的颜色会被修改，所以我们需要保存初始位置的颜色，以便于之后的更新操作。
\n
注意：当目标颜色和初始颜色相同时，我们无需对原数组进行修改。
\n
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×m)O(n \\times m)O(n×m)，其中  n  和  m  分别是二维数组的行数和列数。最坏情况下需要遍历所有的方格一次。
\n
空间复杂度：O(n×m)O(n \\times m)O(n×m)，主要为队列的开销。
\n
# Method 2: 深度优先搜索
\n
从给定的起点开始，进行深度优先搜索。每次搜索到一个方格时，如果其与初始位置的方格颜色相同，就将该方格的颜色更新，以防止重复搜索；如果不相同，则进行回溯。
\n
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×m)O(n \\times m)O(n×m)，最坏情况下需要遍历所有的方格一次。
\n
空间复杂度：O(n×m)O(n \\times m)O(n×m)，主要为栈空间的开销。
\n",
            "tags": [
                "Coding",
                "广度优先搜索",
                "深度优先搜索"
            ]
        }
    ]
}