RubitCat

原子类型: 是编译器可以操作的最基本数据类型
- char: 字符型1U
- short, 短整型2U
- int: 整形4U
- long: 长整型4U (注意long类型仍然是4U, long long才是8字节)
- float: 单精度浮点型4U
- double: 双精度浮点型8U
结构类型: 是由原子类型和指针类型复合而成的自定义类型. 大小不固定.
- struct struID{ /*def*/}: 结构体类型, struID是类型标识符, 若仅使用一次可忽略
- union uionD{/*def*/}: 联合体类型, unionD是类型标识符, 若仅使用一次可忽略
- enum enumID{/*def*/}: 枚举类型, enumID是类型标识符, 若仅使用一次可忽略
- Type [N]: 数组类型, 数组中每个元素都是Type类型
指针类型: 该类型的对象用来存储计算机内存地址, 指针类型的大小取决于CPU的位数.
- 原子类型指针: Type*
- 结构类型指针: 一般Type*, 数组是Type(*)[N]
- 多级指针: 即指向指针的指针, 高级指针使用多个*表示
typedef: 作用是为复杂数据类型取别名, 同时增强代码的可阅读性和可移植性.
- 一般语法: typedef Type Alias
- 数组语法: Type (alias)[N]

变量与常量

变量: 即状态不断发生变化的量. C语言的变量有数据类型, 且可以寻址.
- 一般语法: Type objName, 指针Type *objName
- 数组语法: Type arrName[N], 指针Type(*arrName)[N]
常量: 即状态不会发生变化的量. C语言的常量有数据类型, 且可以寻址.
- 一般语法: Type const objName, 指针Type * const objName
- 数组语法: const Type arrName[N], 指针Type(* const arrName)[N]
数值字面量: 即代码中直接书写的数值量. 它们编译成立即数成为指令的一部分, 不可寻址.
- 整形字面量默认为int类型, 加上L可以声明为long类型
- 浮点字面量默认是double类型, 加上F可以声明为float类型
字符串字面量: 即代码中双引号(串)和单引号(字符)对象. 它们被解释成常量字符数组, 程序加载时载入常量区, 可以寻址.
初始化: 初始化发生在对象创建时, 可以使用变量、常量或字面量初始化. 后面还可以用表达式的返回值、函数的返回值进行初始化。
- 一般语法: Type objName = val
- 结构类型的语法: … = {val1, val2, …} 数组需要所有值的类型相同
对象命名: 指定命名规范能够提升开发效率, 对后期维护和修改都是有重大意义的. 根据自己的特点选择合适的命名规范. 当下的命名规范主要有三种
- 匈牙利命名法: 全局变量用 g_ 修饰; 常量用 c_ 修饰; 成员变量用 m_ 修饰静态变量用 s_ 修饰, 常用于变量名和常量名, 标识其属性
  - e.g.
- 小驼峰法: 首单词首字母小写, 其他字母首字母都大写. 通常包含类型和描述至少两个单词, 常用于变量名、函数名
  - e.g.
- 大驼峰法: 每个单词首字母都大写. 通常包含类型和描述至少两个单词, 常用于类名、结构体名和命名空间
  - e.g.
- 系统编码风格: 为了避免与用户变量的冲突, 系统内部的变量名都是类似 _xxx的形式给出的.
  - e.g.

常量指针与指针常量: 前者属于指向常量的指针, 后者说明指针是常量 - e.g. 常量指针const int* p; 指针常量int* const p - | | 变量(非常量左值) | const变量(常量左值) | | —- | —- | —- | | 变量指针| 可以 | 强制类型转换后可以 | | 常量指针| 可以 | 可以 |

表达式

Tue, 18 Jun 2019 00:00:00 +0000

表达式

表达式由运算对象(变量、常量、字面量、数返回值) 和运算符(运算对象的操作符)组成.

表达式的结果

左值与右值: 左值指表达式的值进行内存寻址与修改的量. 例如变量、常量、字符串字面量. 右值指表达式的值不能进行内存寻址与修改. 例如数值字面量、函数返回值、类型转换
数据类型: 指的是表达式结果数据类型.
类型转换: 不同数据类型间进行运算, 可能需要对数据进行转换. 数据类型的转换可能产生精度和安全性问题.
- 隐式类型转换:
  - 运算时不同类型运算对象参与运算低类型会往向高类型转换;
  - 赋值时右值类型会转换成左值类型, 在进行赋值.
- 强制类型转换: 用括号显式指定类型互转, 忽略任何警告.
- 注意事项:
  - 有符号负数转换为无符号数时, 由于符号位的启用, 它比任何有符号数都大!!!!! 有符号负数与无符号数比较时, 很容易出现问题
  - 需要格外注意指针的隐式转换, 容易造成越界
  - 任何数据类型的转换最好都使用强制类型转换, 代码可读性会好一点.

运算符

结构运算符:
结构运算符使用形式含义返回值下标运算符: [ ] 数组名[常量表达式] 定义数组元素个数或数组元素值引用数组某元素常量优先级运算符: () (表达式)或函数指针(参数) 声明表达式的优先级, 或函数调用成员选择运算符: . -> 对象.成员
对象指针->成员选择结构体对象的成员属性常量结构运算符参与到构造一个变量, 是从左往右结合的
算数运算符
第一级: 单目运算符使用形式含义返回值负号运算符: - -变量返回变量的相反数常量自增(减)运算符: ++ – ++(–)变量或变量++(–) 变量自增或者自减1个单位 ++(–)变量: 返回自增(自减)后的值变量++(–) : 返回自增(自减)前的值位反运算符: ~ ~变量返回变量的位反值常量指针运算符: & , * &变量, *变量指针取变量地址, 取指针指向的值取址返回的是更高级的指针常量, 取值返回的是更低级的指针常量. (特别)逻辑非: ! !表达式表达式返回结果取非 0返回常量1, 非0返回常量0 强转运算符: (类型) (类型)表达式将表达式返回的常量强制转换常量为特定的数据类型长度运算符: sizeof() sizeof(数据类型)或sizeof(变量) 测量表达式返回值数据类型的大小 unsigned int常量

函数

Tue, 18 Jun 2019 00:00:00 +0000

函数

定义函数: Return_type func(arg1,arg2,...) {...}
函数的参数: 函数参数作为函数执行的初始参数, 可以为void, 当形参和实参类型不同时会自动隐式类型转换.
- 形参: 函数运行前的初始参数, 它和函数调用者没有任何关系
- 实参: 函数调用者传入的参数, 它是属于调用者的
传参方式: 调用者调用函数时传入实参, 函数执行前会用实参初始化形参(此过程类似于赋值),
- 值传递: 使用值作为参数传递, 操作的是原始数据的副本, 对原始数据不影响. 开销较大, 安全.
- 地址传递: 使用指针作为参数传递, 操作的是同一块内存空间. 开销较小, 较不安全.
- 函数指针作为参数: 使用函数指针作为参数的好处是可以模块化编程, 对于核心功能的改变, 不用修改源代码, 只需修改传入的函数指针即可.
递归调用: 递归就是自己调用自己, 写递归时要考虑中断函数怎么写, 不然一定会栈溢出.
- 中断函数: 指的是再继续递归调用前用于终止调用的代码
- 递归示意图:
静态代码体: 静态代码体定义在函数中的一对{ }内, 它是一个不带参数的匿名函数, 只能执行.
main函数: 是整个程序执行的入口, 它的参数固定为(int argc, int * argv[])表示参数的个数与存放参数的指针数组
函数实现原理: 函数是使用栈结构来实现的. 每一个进程都有一个函数栈.
- 主调函数将函数的形式参数按照调用惯例压栈创建
  - cdecl 压栈顺序是从右到左，主调函数出栈清理下划线+函数名
  - stdcall 压栈顺序是从右到左，被调函数出栈清理下划线+函数名+@+参数
  - fastcall 压栈顺序是从右到左，被调函数出栈清理 @+函数名+@+参数的字节数
- 将返回时执行的下一条指令压栈
- 进入被调函数，新声明的函数变量压栈创建
- 函数返回前将执行期间的变量弹栈. 函数参数按照调用惯例确定清理方, 返回值通过exa寄存器返回
可变参数：待填坑http://c.biancheng.net/view/344.html

变量的作用域

局部变量：定义在函数内部的变量, 作用在到函数结束位置, 根据函数的实现原理它会在函数执行结束时释放.
静态局部变量: 使用static修饰, 它被保存在静态区, 程序退出时才会释放
全局变量：定义在函数外部的变量, 作用在整个项目中. 它只有在程序退出时才会被释放.

声明和定义

声明即表明对象的存在性, 定义是精确定义对象的内部细节, 在声明时进行. 通常将未定义的声明称为声明, 它不占用任何内存空间, 仅仅指明对象的存在性已定义的声明称为定义, 它占用内存空间, 指明了对象的存在性, 也进行了定义注意前边定义的变量不管有没有初始化都叫定义!!!! 2. static与extern: ->extern声明扩展到外部使用的函数或全局变量(其他文件能使用, 使用前需要先声明) ->C语言的函数和全局变量默认外部扩展省略了extern ->static声明内部连接使用的函数, 全局变量或局部变量(其他文件不能使用) ->静态变量存在于静态区,程序执行期间都有效,不会被释放 ->变量同名时局部变量优先于全局变量

虚拟内存地址

Tue, 18 Jun 2019 00:00:00 +0000

虚拟地址空间

每个进程使用的内存地址是与物理内存地址无关的虚拟内存地址, 虚拟内存地址通过MMU映射到物理内存地址. 内核空间通过MMU映射到一块相同的物理内存中, 不同进程是通过PCB加以区分

内核地址空间

用户地址空间

用户空间通过MMU映射到不同的物理空间, 不同进程间是不可见的.

环境变量区:
命令行参数区:
栈区(stack):
- 存放除了全局变量和静态变量的区域. 栈区空间是向低地址方向申请的.
- 大小固定由内核决定, 栈溢出会导致程序崩溃.
- 堆区很小, 结构体等大数据一般往堆区存放.
内存映射段: 存放
堆区(heap):
- 堆区也成为动态存储空间, 需要动态申请与释放. 堆区空间是向高地址方向申请的.
- 大小不固定, 由计算机内存决定, 若数据没有被释放, 系统会一直保留, 直到程序结束.
- 若堆区地址丢失会导致内存泄漏, 经常内存泄漏会导致程序占用内存较大的情况
BSS区: 存放未初始化的全局变量和静态局部变量, 未初始化的变量自动初始化为0.
DATA区: 存放已经初始化的全局变量和静态局部变量
TEXT区: 存放可执行代码、字符串字面值、只读变量
保留区:

预处理器

Tue, 18 Jun 2019 00:00:00 +0000

预处理器指令

include指令

include指令用于将指定文件中的内容包含到本文件.

 #include<headerfile.h> //gcc中只会查找系统头文件库(一般/usr/include、/usr/local/include)
#include"headerfile.h" //gcc会从工作目录中查找, 然后再从系统头文件库中找.

define指令

define指令可以声明宏常量以及宏函数.

宏常量: 宏常量预处理时都转为相应的值,编译器看不到这个变量名
- 常用的内置宏常量.
  - __FILE__ 替换成一个字符串, 内容是当前文件的路径
  - __LINE__ 替换成一个整形 ,内容表示这个宏出现的行,常用在错误编译错误输出
  - __TIME__ 替换成字符串, 内容是编译的时间
  - __DATE__ 替换成字符串,内容是编译的日期
- 注意事项
  - 将名称替换成后面的值
  - 支持含有已经定义的宏常量的表达式.
  - 例如已经定义PX , PY .那么可以定义#define OO PX*PY
  - 宏常量名应该大写,区分普通变量
宏函数不是真正的函数, 它在预编译阶段对使用到宏函数的地方按表达式展开
- 常用宏函数: 一些标准的宏函数封装在stddef.h中
  - offsetof(structName, structMember);结构体成员变量偏移值函数
    - 第一个参数是结构体完整的名字：struct 结构体名//注意：没有结构体名字的不能使用该宏函数
    - 第二个参数是成员变量名字
    - 注意: 宏函数近在预编译阶段展开处理, 展开后可能导致结合顺序的改变
- 注意事项

 //宏常量定义
#define marcoName valjue
#undefine marcoName
//宏函数定义
#define marcoFunc(arg1,arg2,...) expression //例如#define SUM(x , y) ((x)+(y))

ifdef指令

ifdef指令条件编译

数据编码

Tue, 18 Jun 2019 00:00:00 +0000

字符编码与存储编码

计算机只能处理二进制数字, 为了满足计算机处理自然语言的需求, 需要对自然语言的字符编码成二进制数字.

字符编码: 将字符编码成二进制数的过程称为字符编码, 而存储字符与二进制值关系的表叫做字符集.
存储编码: 将字符编码产生的二进制值再进行编码, 使之适用于存储的过程叫做存储编码

ANSI(ASCII)编码集

ASCII是美国信息交换标准代码, 字符编码方式为1个字节编码128种字符, 存储编码方式为1字节直接存储. ANSI则扩展ASCII使用1个字节的其他数值编码其他字符, 扩展到255个字符. 一般ANSI和ASCII同等对待.

UCS字符集

UCS(Universal Char Set), 即通用字符集, 包含世界各国的文字和符号, 应对单字节编码带来的字符空间有限问题.
早期的UNICODE即UCS-2编码方式集采用2字节编码, 存储方式为2字节直接存储, 得到普及但是字符空间有限
后期的UNICODE即UCS-4编码方式采用4字节编码, 存储方式也是4字节直接存储, 但存储空间较大没有得到普及 UNICODE中广泛采用的是如今的UTF-8存储编码, UTF-8是可变长编码, 一个英文占据1字节, 一个中文占据3字节.

转义字符

ASCII码表虽然用0-255的数字表示特定字符, 但对人类记忆有一定的困难. 转义字符就是为了解决这个问题而产生的.
一个字符串中, 一个字符使用其ASCII值存储, 但若通过 ‘'就可以转译为其他字符并存储其ASCII值例如: ’n’输出的ASCII值是110，而’\n’输出的ASCII值为10，是制表符.

stdlib

Tue, 18 Jun 2019 00:00:00 +0000

1. stdlib.h

1.1 数据结构

1.2 函数

 void *malloc(size_t size): 在内存的动态存储区(堆区)中分配一块长度为size, 返回开辟的堆空间首地址，失败返回NULL.
void *calloc（size_t nmemb, size_t size): 按块分配内存，自动初始化内存为0, 返回祖宗指针void*；失败返回NULL；
void *realloc（void * ptr, size_t size): 重新分配size大小空间, 源空间数据拷贝到新空间并释放原空间. 返回祖宗指针void*；失败返回NULL；ptr=NULL时和malloc等价
void free(void *ptr):释放ptr对应地址的空间，通常和malloc()成对出现
- size: 设置新内存空间字节数
- nmeber: 第一个是分配的块个数

 void srand(unsigned int seed)用来设置rand()函数的种子, 常使用time(NULL)的返回值作为随机变数
int rand(void);返回一个int类型的随机数,注意若没有设置随机数种子，只能输出一个固定的随机数
time_t time(time_t * tloc) 返回自Epoch到tloc时间戳(秒数)
- tloc: 指定一个long型时间戳, 函数返回自Epoch到tloc的时间戳(秒数),系统当前时间, 返回值也会被写到传入参数t中

stdio

Tue, 18 Jun 2019 00:00:00 +0000

1. stdio.h

1.1 数据结构

标准IO库提供一些简单高效的IO流接口, 输入输出被映射到本地数据流, 对物理接口进行屏蔽. 标准IO库实现了三个流: 标准输入流stdin(带有流缓存). 标准输出流stdout(带有流缓存)、标准错误流stderr(不带有流缓存)

流缓存: 文件流都有缓存, 而且几乎所有编译器都只在缓冲区满时才刷新缓冲区
流光标: 文件光标是char* 类型的指针, 显示时是相对于文件首字节的位移值.
流状态: 当文件流函数读取到文件末尾时, 再尝试读取时文件流状态置为false并返回EOF

 #define EOF -1 //意为文件结尾
typedef struct{
	short			level;	 //流缓冲区"满"或者"空"的程度 
	unsigned char	flags;	 //文件状态标志 
	char			fd;		 //文件描述符
	unsigned char hold;	 //如无缓冲区不读取字符
	short			bsize;	 //流缓冲区的大小
	unsigned char*	buffer; //流缓冲区的指针 
	unsigned char*	curp ;	 //当前活动指针 
	unsigned		istemp;	 //临时文件，指示器
	short			token;	 //用于有效性的检查 
 }FILE;

1.2 函数

 FILE* fopen(const char * filename, const char * mode)
int fclose(FILE * stream)关闭先前fopen()打开的文件.此动作让缓冲区的数据写入文件中，并释放系统所提供的文件资源
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream): 将ptr位置开始的size*nmemb字节拷贝到文件流中, 返回成功写入的块个数
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);将流光标位置size*nmemb字节的拷贝到ptr指向的位置
int fseek(FILE *stream, long offset, int )
long ftell(FILE *stream)返回文件光标值（可以认为是光标跨过的字节数）
void rewind(FILE *stream)将光标的值设为0，回到文件首部
int feof(FILE * stream)判断文件流状态, 最近一次读取失败时文件流会置false, 之后feof才会返回false, 所以foef有滞后性.
void perror(const char *str)
- filename: 文件路径是操作系统给定的逻辑路径, 由系统前缀、字段分隔符和字段组成. 不同的操作系统字段分隔符不同, Windows下'\'
	- 绝对路径: 是文件的完整全局逻辑路径 例如: "c:\\test\\passwd.txt"
	- 相对路径: 是文件相对于当前目录的简写路径, 当前目录指的是可执行程序所在目录 例如:".\\passwd.txt"表示程序当前文件夹下
- mode: 
	- r或rb: 输入模式(只读模式)，文件不存在会报错
	- w或wb: 输出模式(只写模式), 创建文件, 若文件已存在则之直接覆盖
	- a或ab: 追加输出模式(追加模式), 向文件追加内容, 若文件不存在则创建文件
	- r+或rb+: 输入输出模式(读写模式), r模式的基础上增加写功能
	- w+或wb+: 输入输出模式(读写模式), w模式的基础上增加读功能
	- a+或ab+: 追加输入输出模式(带读功能的追加模式), a模式的基础上增加读功能
	- 二进制模式: 将数据源解读为二进制数据, 无差别读写数据源.
	- 文本模式: 将数据源解读为文本, 不同操作系统对\n有不同的处理方式
		- Window系统文本的行结束符为\r\n. 文本模式下的输出\n将替换成\r\n, 输入\r\n将替换成\n. 二进制模式原样输出. 
		- Linux系统的文本的行结束符就是\n, 文本模式不会替换, 文本模式和二进制模式是完全一致的
		- Mac系统 …
- offset: 位移量，可以是负数
- whence 光标起始位置
	- SEEK_SET (0) 文件开头光标值为0
	- SEEK_CUR (1) 文件当前光标值
	- SEEK_END (2) 文件结尾光标值移动到了EOF前面

//单字符IO函数
int getchar(void)从stdin读取一个字符, 返回这个字符的ASCII整形值
int putchar(int char): 将一个字符输出到 stdout, 输出的字符的ASCII整形值
int fgetc(FILE * stream)从文件读1个字符, 返回字符的ASCII值, 若读取失败返回EOF并设置流状态
int fputc(int ch, FILE * stream)写1个字符到文件中, 成功时返回写入字符ASCII值 
	while( (ch=fgetc(fp) )!=EOF) { putchar(ch); }

//字符串IO函数
char* gets(char* buff , int buffSize)读取stdin中第一个\n前所有字符并追加\0, 并清除stdin中的\n .
int puts (const char * buff) 向stdout输出一个字符串(不包含\0)，并换行
char* fgets(char *s, int count, FILE *stream): 从相应的流中读入count-1个字符, 当(1)读到换行符（写入）、(2)读到EOF（不写入）、(3)或是已读了size - 1个字符为. 止最后会预留的一个字符写入'\0'作为字符串结束
int fputs(const char * string, FILE *stream): 将string所指定的字符串写入到stream指定的文件中， 字符串结束符'\0'不写入文件, 该函数为puts的文件操作版本，输出的时候不自带换行
	- fgets只接受size-1个字符, 执行一次, 光标最长移动size-1
	- 文件光标的值可以看作是已读字符个数

//输入转换函数
int scanf(const char* restrict format,...)根据format规定的格式读取stdin中数据赋值给相应的变量
int sscanf(const char *str, const char *format, ...)根据format规定的格式读取str中数据赋值给相应的变量
int fscanf(FILE * stream, const char * format, ...);
- str: 字符串的首地址
- format: 
	- 字符占位符: %nc 读取n(缺省为1)域宽任意字节, 不追加\0. 可能读到\n!!!!!
	- 字符串占位符: %ns 读取第一个\n或空格的前n(缺省为无限)个字符, 并追加\0. 不清除\n!!!! 
		- %[^a-c] 排除abc的所有字符
		- %[0-9] 只要0-1的字符
		- %[abc] 只扫描abc
		- %[^\n] 接收换行符, 适合字符串中含有空格的
	- 数值型占		- 符: %nd 读取第一个非数字字符的前n(缺省为无限)个数字, 将其转换为整形. 不清除\n!!!!
		- %nx 或 %nX : 读取16进制数
		- %no :读取8进制数
		- %nf 和%nlf: 读取n位单精度或双精度浮点数(注意这个占位符接收 '.' 号!!!!) 
	- 示例: 输入"hello world"（带空格）
		- scanf("%[^\n]",arr);//默认空格也是可以作为变量赋值结束符的，但是使用通配符可以只让回车作为结束符
		- 多变量输入
		- scanf("%d%d%d",&a,&b,&c);
		- scanf("%d\n%d\n%d",&a,&b,&c);
		- scanf("%d %d %d",&a,&b,&c);//这三种方法都是正确的，都可以用空格或者回车来分隔变量输入
		- 定长输入
		- scanf("%2d%2d%2d",&a,&b,&c);//等距定长输入：123456，abc分别是12，34，56
		- scanf("%1d%2d%3d",&a,&b,&c);//不等距输入：123456，abc分别是1，23，456
		- scanf函数中%d表示的值是什么类型的在输入缓存中就拿那个类型的

//输出转换函数
int printf(const char *format, ...): 将内容输出到 输出流缓冲区win下直接输出. 
int sprintf(char *str, const char *format, ...);将内容输出到 字符串 保存
int fprintf(FILE * stream, const char * format, ...);
- format: 
	- 数值占位符: 
			%d 整形int
			%o 八进制int
			%x 小写十六进制int
			%X 大写十六进制int 
			%e 科学计数法 只接受double数据类型
			%lf 双精度浮点数double 
			%f 单精度浮点数float 
	- 字符占位符: 
			%c 字符输出 整形（int、short、long int、unsigned int、char……）
			%s 字符数组指针 char* 
			printf("你的文字在这里%-7.4lf", a );
			//你的文字在这里a，其中a的格式为7列保留4为有效数字左对齐
			//其中小数和小数点也占列数，但整个数据列数没占够7列时左补空格，
			//若 - 改为 0 则左补0

 int remove(const char *pathname);删除文件
int rename(const char *oldpath, const char *newpath);删除原文件，创造新文件根据这个特性，可以用来重命名文件或者移动文件

string

Tue, 18 Jun 2019 00:00:00 +0000

1. string.h

1.1 数据结构

1.2 函数

 char* strcpy(char *dest, const char *src);返回目标字符数组首地址, 会复制'\0'，到‘\0’结束复制，而strncpy是否拷贝结束符看指定的长度是否包含'\0'
char* strncpy(char *dest, const char *src, size_t n)将指定字符串复制到指定字符数组，原有的值会被覆盖,

char* strcat(char *dest, const char *src);
char* strncat(char *dest, const char *src, size_t n);

char* strstr(const char *haystack, const char *needle)在字符串haystack中查找字符串needle出现的位置
char* strchr(const char *s, int c)返回第一次出现这个字符的地址，这个函数推荐使用在字符查找上
char* strtok(char *str, const char *delim)将字符串分割成一个个片段. strtok()在参数s的字符串中发现参数delim中包含的分割字符时, 则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0. 当第一次使用这个函数时必须指定目标字符串地址，若往后还需要对同一个字符串继续进行切割，可将目标字符串地址设置成NULL
//示例
char a[100] = "adc*fvcv*ebcy*hghbdfg*casdert";
char *s = strtok(a, "*");//将"*"分割的子串取出,注意使用的是双引号！！
while (s != NULL){
	printf("%s\n", s);//因为是字符串，可以使用%s打印
	s = strtok(NULL, "*");//每次返回切割的下一部分的首地址
}

基础概念

Sat, 15 Feb 2020 00:00:00 +0000

数据类型差异

原始类型增强

const类型:
- C语言的全局常量为默认外部链接, C++默认为内部链接(static).
- C语言的常量是可以寻址, C++常量是不可以寻址(编译期符号表维护)
  - 运行期对const常量进行初始化的, const常量能进行寻址, 修改内存值影响常量值
    - e.g. 使用变量进行初始化const int a=b; 结构体常量const T a ={val1,val2…}
  - 对全局const常量声明为外部扩展时, const常量能进行寻址, 修改内存值影响常量值.
    - e.g. extern const int a =100 ;
  - 对const常量取地址(取地址, 引用定义), 会提供临时内存地址. 修改内存值不影响常量值
    - e.g. const int a =100; int* ptr = &a;
struct类型:
- C语言使用结构体时必须加上struct关键字, C++可加可不加.
- C语言结构体内不能定义函数, C++结构体内不仅可以定义函数, 还可以定义命名空间

新增类型

class类型: class是c++面向对象特性的重要实现.
bool类型: C语言需要使用bool.h来实现bool数据类型, C++原生支持bool类型占用一个字节大小
引用类型: 引用即被引用对象本身, 内部由指针实现, 所以它的占用和指针一致.
- 左值引用: 即左值对象的引用, 语法 Type &A = B
  - 左值往往是变量, 左值引用的用法和原变量完全一致, 所以左值引用相当于变量别名
  - 非常量左值引用不能引常量左值, 有背常量不可变规则.
  - 常量左值可以引用引右值, 创建临时空间进行引用, 非常量左值引用不能引右值
- 右值引用: 即右值对象的引用, 语法Type &&A=B
  - 右值往往是临时对象, 右值引用的用法和临时对象完全一致, 所以右值引用相当于延长临时变量的生命周期.
  - 非常量右值引用不能引常量右值, 有背常量不可变规则.
  - 右值引用不能引左值
- 链式编程: 如果函数的返回值是引用, 那么这个函数可以作为左值, 实现链式编程.
  - 例如: person & test(){ return *this} ; p.test().test().test(); 返回值为对象, 就可以再调用它的成员.

表达式差异

三目运算符增强: C语言的三目运算符返回右值, C++的三目运算符返回左值
自增自减运算符增强: C语言中++a返回右值, C++中++a返回左值
指针转换增强: C语言的指针存在隐式类型转换风险, C++指针必须强制类型转换

新增特性

namespace关键字: namespace相当于一个新的作用域, 支持在里边定义变量、函数和结构体, 或者嵌套另一个namespace
- 语法: namespace spaceID{…}
- 作用域选择: 域::对象,
  - 域缺省为全局范围, 就近原则被排除;
  - 域可以是namespace、class、struct
- 注意事项:
  - 注意命名空间是开放的, 同名命名空间会合并元素.
  - 无名空间元素,退化成静态(static)全局变量,只能给本文件使用
  - 别名语法: namespace A = B ;一般很少人会使用
using关键字:
new关键字:

封装

Sat, 15 Feb 2020 00:00:00 +0000

封装概述

封装指隐藏抽象实体的实现细节, 对外提供访问和使用方式的编程思想

C语言中的分文件编写的方式、结构体也属于封装

C++的封装支持封装函数、支持权限定义，是C语言结构体的加强版.

完全解放定义能力, 使之能够拥有C语言基本数据类型的所有特性.

C++类

C语言的结构体可以封装一个事物的属性, 但不可以封装函数(方法), 方法只能在结构体外定义. C++在C语言struct的基础上添加了封装方法的特性, 更能体现面向对象的设计思想.

 class person
{
权限类型: 
	成员;
};

类的组成

成员类型: 包含非静态成员和静态成员, 成员可以是变量也可以是函数.
- 非静态成员: 属于某个对象而不属于类. 非静态成员的调用必须于指定特定的对象, 对象指针- 非静态成员或对象.非静态成员
  - 非静态成员函数: 不在对象内存中、单备份. 有个className* const this的隐藏参数, 指向调用函数的对象. 所有对非静态成员变量的修改都通过this指针
    - 构造函数: 用于在对象创建时对对象进行初始化
    - 析构函数: 用于对象删除时对对象的进行清理, 典型场景就是对象有指向堆内存的指针, 析构函数用于释放堆内存防止内存泄漏.
    - 普通函数: 针对对象提供的函数, 若希望被常对象调用还需要对this指针添加const修饰. 格式 void test() const {……..}
  - 非静态成员变量: 唯一存在于对象内存中的成员
- 静态成员: 属于类. 静态成员的调用可以是类也可以是对象, 它支持类似非静态成员的调用方法, 还支持类名调用类名::静态成员. 静态成员使用static关键字修饰
  - 静态成员函数: 不在对象内存中、单备份. 没有className* const this的隐藏参数, 不能修改非静态成员变量
  - 静态成员变量: 不在对象内存中、单备份. 静态成员变量必须类内定义类外初始化.
  - 静态内部类: 定义在类内部的类, 也叫内部类. 必须使用域运算符指明所属的类才能调用.
成员权限: C++中的类成员有private, protected, public, 三种类型,
- private: 只有本类的成员可以使用, class的成员的默认权限
- protected: 供本类和继承类成员使用
- public: 所有位置都可以访问, struct的成员的默认权限
友元: 类的私有成员只对类成员能够访问, 如果希望非类成员也能够访问则需要在类中声明为友元
- 友元函数: 将 friend修饰的函数声明写入类中 , 如果是类中的函数需要用作用域运算符指明所在类. 如果在类内实现的话会自动上升为全局函数.
- 友元类: 将 friend修饰的类声明写到类中
- 注意事项: 声明友元时要确定前面已经定义, 或者声明过一次让编译器知道这东西的存在

构造函数

构造函数用来初始化一个新类对象, 它没有返回值也不能有返回值, 函数名要和类名相同构造函数是有权限的, 只有定义在public下才能被外部调用去创建对象!!!

继承

Sat, 15 Feb 2020 00:00:00 +0000

继承概述

继承是代码编写的一种思想, 是一种抽象思维. 通过类继承的方式, 共享父类的一些特性, 达到减少代码冗余的目的

C++类继承

单继承

继承语法: class 子类名字 : public|protected|private 基类名
继承的原理: 派生类通过调用基类的构造函数在派生类的内存空间初始化基类的变量来实现继承所以继会将基类所有成员继承下来. 逐级继承就涉及到递归的概念: A->B->C, C调用B的构造函数, 而B的构造函数又调用 A的构函数. 逐级在自己的作用域内初始化基类的变量. 编译器会自动调用基类默认构造函数, 要确保基类默认构造函数存在且非私有. 否则必显式调用基类的构造函数!!!!!!! 示例: class Base_class { public: Base_class(){}//基类构造函数 } class Derive_class : public Base_class { public: Derive_class() : Base_class(){}//派生类构造函数显式调用基类的构造函数 }
继承模式公有继承(public): 父类的public和protected成员权限不变保护继承(protected): 父类的public和protected成员权限都是protected 私有继承(private): 父类的public和protected成员权限都是private 所有继承方式下, 父类的private成员子类都不可访问!!!!!!!

 - 测试代码
父类:
class person
{
public:
	//person(){.......} //默认构造
	person(int a) {....} //此时已经没有默认构造
	person(const person & p){......} //拷贝构造
	void CommentFunction(){..... } //非静态成员函数
	static void StaticFunction(){.....} //静态成员函数
	void operator=(){ .........} //赋值运算符重载
	~person(){} //析构函数
private:
	static int StaticVariate ; //静态成员变量
public:
	 int CommentVariate ; //非静态成员变量: 4U
}
子类
class son : public person
{
public:
	son(int a) : person(a) {} // 1.当基类没有默认构造时,要用参数列表法显示调用基类的构造
pubic:
	 int CommentVariate ;
}
	2. 派生类的内存结构
SON_Structure 
{
	base class person//2.调用基类构造, 派生类不继承基类的构造和析构还有"'="'重载函数
	{
	private:
		CommentVariate //3. 基类的非静态成员由基类的构造函数初始化, 只继承非静态成员(重名也继承!!!!!)
	}
public:
	CommentVariate // 4.派生类非静态成员变量由派生类构造函数初始化
}
				
	3. 派生类的成员调用
->非静态成员变量的调用:
	son s1;
	s1.CommentVariate;//5.直接调用优先调用派生类的成员, 找不到时才往基类里找, 找不到就报错
	s1.person :: CommentVariate;//6.重名想调用父类成员必须加作用域限定. 基类为私有所以这个是不能访问的

->静态成员变量的调用: 
	person :: StaticVariable
	基类实例.StaticVariable 
	son :: person :: staticVariate //7.基类的静态成员被派生类所有实例共享
	son :: staticVariate (不重名时)
	派生类实例.staticVariate

多继承

多继承的语法: class 子类名字 : 继承模式基类名1, 继承模式基类名2 ……
多继承的问题: ->二义性: 当多继承的两个类中含有相同声明的成员, 子类调用时会出现二义性 ->菱形继承问题: 当多继承的两个类具有相同的基类, 那么这个基类的构造函数会被调用两次造成冗余
解决方法: 两个问题都可以通过作用域运算符指明基类作用域解决, 菱形继承问题还可以通过虚继承解决

 class father1
{
public:
	int a;
}
class father2
{
public:
	int a;
}
class son : public father1, public father2
{
}
void test(void)
{
	son s1;
	s1.a;//编译器并不知道要调用那个父类的a
	s1.father1::a;
	s1.father2::a;//添加作用域就能区分了
}

虚继承

虚基类: 基类在派生类中是无形的, 是形式意义上的. 它是通过指针去访问的.
虚继承: 将基类当作虚基类继承 class 类名 : virtual public|protected|private 基类名
虚继承的原理: 编译器对虚基类的派生类添加一个调用虚基类构造函数的限制条件: 对于一个虚基类的派生类, 虚基类的构造函数交由这个类完成调用, 忽略其继承链上其他类对虚基类构造函数调用也就是说虚基类的派生类不仅要调用直接基类的构造函数, 还要调用虚基类的构造函数可以从以下四个例子理解这个规则, 体会派生类与基类之间的构造函数函数调用关系 (1)B是虚基类A的直接派生类, 所以他要调用A的构造函数

(2)C是虚基类A的间接派生类, 它不仅要调用直接基类B的构造函数, 还要调用A的构造函数. 忽略B对A的调用.

多态

Sat, 15 Feb 2020 00:00:00 +0000

多态概述

C++多态

函数重载

函数重载是只要同名函数的参数列表不同就表示不同的函数, 使用的时候通过传递的参数区分不同的函数.

 void test(int a , int b=10){}
void test(int a){}
test(10);//当只传一个10时, 两个函数都是合法的, 产生了二义性
- 常引用的函数和普通引用的函数的重载
void test(int &a){}
void test(const int &a){}
test(10);编译器是能区分这两个函数的

重载原理: 相同的函数名通过不同的参数列表实现了复用, 其实编译器编译的时候偷偷换了其他名字, 用来区分不同的函数
- 例如:void fun(){}换成 void _fun(){}， void fun(int a){}换成void _fun_int(int a){}
extern C关键字:基于函数重载的处理方式, 在源文件中定义的函数在编译后标识符会发生变化, 导致头文件的声明失效. C++引入extern "C" 修饰的函数声明或定义, 该关键字修饰的函数在编译期间不会更改标识符, 同时也不能进行重载. 值得注意的是, extern “C” 必须在全局范围内使用.

 extern "C" 单个函数声明或函数定义;
extern "C"{
	多个函数声明或函数定义;
}
----------------------------
extern "C"关键字一般使用宏操作来让编译器自行判断是否添加
#ifdef __cplusplus
extern "C"{
#endif

/*函数声明或函数定义*/

#ifdef __cplusplus
}
#endif

注意事项: 当函数有默认值的时候可能会产生二义性

运算符重载

C++提供了符号重载, 拓展自定义数据类型的运算操作.

异常

Sat, 15 Feb 2020 00:00:00 +0000

异常概述

C++异常

语法实现: C++通过try 来运行可能产生异常的代码, 用catch来捕获代码抛出的异常变量
- 主调函数中: try{ 引发异常的代码; }catch(异常变量类型可选:接收异常变量){异常处理;} catch(异常变量类型可选:接收异常变量){异常处理2;} … catch(…){异常处理;}
- 被调函数中: throw 异常变量
异常的处理过程
- 第一步: 主调函数通过try尝试调用函数
- 第二步: 当被调函数 throw异常变量之前, 会先释放从try到throw异常变量之间建立的所有数据对象(栈解旋), 然后throw异常变量.
- 第三步: 主调函数通过catch捕获异常变量, 并根据异常变量的类型匹配异常处理代码(所以异常变量可以不用填).
  - 若存在匹配的异常处理代码, 则进入异常处理代码完成异常处理. 若异常处理失败则可以继续向上抛出此异常
  - 若不存在匹配的异常处理代码, 则自动向上抛出此异常直到匹配异常处理代码. 若异常上升到main函数仍未解决则程序终止运行.
异常变量的接收: 异常变量用来存储引发异常的位置或原因, 为异常处理代码提供参考.
- 若被调函数的异常变量是以值或引用方式返回, 和普通函数不同的是编译器不会释放这个异常变量直到异常处理结束.
- 若被调函数的异常变量是以指针方式返回, 和普通函数一样编译器会释放这个异常变量, 可以通过开辟到堆上返回指针解决, 但要注意释放内存!!!
异常与多态: C++的异常类型可以存在继承与多态关系, 但子类必须写在父类的前面. 例如: class exception_BaseClass{ virtual printError(){} } class exceptions_nullptr :public exception_BaseClass{ virtual printError(){cout « “空指针异常” «endl; }; } void test(int * p){if(NULL == p ){throw exception_nullptr();}} int main(){ try{test();}catch(exception_BaseClass e){e.printError();//根据传入的类型调用相应的重写函数}}

泛型

Sat, 15 Feb 2020 00:00:00 +0000

泛型概述

C++泛型

使用抽象数据类型定义的通用函数或通用类就是模板. 模板编程思想就是泛型编程.

编译器只对模板进行语法检查, 并不编译成指令. 模板实例化后才会生成指令.
模板实例化: 确定抽象类型并产生相应具体的模板函数或模板类的过程. 实例化后编译器会对模板实例进行检查并生成指令

函数模板


//函数模板
template <class/typename absType, ...> 注: 定义时class和typename功能完全相同, typename还有另外的用途
_RetType funcName(arg1,..){
	//function define
}

函数模板实例化
- 直接实例化: template<> 返回值类型函数名<参数类型列表>(参数列表){函数定义} 调用方式和普通函数一致.
  - 注意: 显式实例化法的模板函数优先级是高于隐式具体法的模板函数的!!!!!!!!!!!
- 参数类型列表: function<absType,...>(arg1,...); 调用时通过参数类型列表实例化特定的函数模板.
- 自动类型推导: function(arg1,...); 调用时根据函数参数列表推导抽象数据类型, 实例化特定函数模板.
模板函数与重载: 模板函数与普通函数间可以发生函数重载. 发生重载时优先调用普通函数. 可以使用参数类型列表(可空), 强制调用模板函数 (3)函数模板的局限性: 函数模板并不是万能的, 若抽象数据类型是自定义数据类型, 函数包含一些特殊操作, 编译器是不知道如何执行的. 一个办法就是类中对特定操作符进行重载, 另一个办法就是使用显式具体化方法重写一个模板函数.

类模板


template <class T1, class T2>
class Class_template
{
	class memberClass; //类模板中的成员类
	(static) void classFunction(); //类模板的成员函数
	T1 variable; //非静态成员变量
	static T2 static_variable; //静态成员变量
};
//1. 类模板的成员类类外实现:(类模板的成员类也是类模板)
template<class T1, class T2 >
class Class_template<T1, T2>::memberClass {类模板的类模板定义}

//2. 类模板的成员函数的类外实现: (类模板的成员函数也是函数模板)
template <class T1 , class T2>
void Class_template<T1, T2>::classFunction(){ 类模板的函数模板定义 } 

//3. 类模板静态变量的类外初始化: 
template <class T1 , class T2>
T1 person<T1, T2>::staticMember = xxx;

//4. 类模板的友元函数: 首先要明白, 类模板的友元函数应该是一个全局函数并且需要访问类模板的成员变量, 所以它应该是一个全局函数模板
// 类内声明并实现友元函数, 这个友元函数直接上升为全局函数
template<class T1, class T2>
class Class_template{
	friend void Function_template(){
	//function define
	}
}
// 类内声明类外实现友元函数, 有一定的难度. 
/*声明相应类模板*/
template<class T1, class T2>
class Class_template;

/*声明友元函数模板*/
template<class T1, class T2>
void Function_template(Class_template<T1, T2> p); 

/*friend声明自动上升为全局函数, 为了确保声明的是函数模板需要加尖括号*/
template<class T1, class T2>
class Class_template{
	friend Function_template<>(Class_template);
}

/*实现友元函数*/
template <class T1,class T2> 
void Function_template(){
	//function define
}

类模板的实例化:

cpp11

Sat, 15 Feb 2020 00:00:00 +0000

1. C++11特性

1.1 Lambda表达式

[ /*captrue-list*/ ]( /*arg-list*/ ){ /*function define*/ }

捕获列表: 捕获列表局部位置可见的局部变量.
- 值传递: a,b,…可以指定特定变量、=可以指定所有变量. 值传递变量为只读变量, mutable修饰才能该.
- 引用传递：&a,&b,…可以指定特定变量、/&可以指定所有变量.
返回值: 单行Lambda表达式可以不用写返回值, 表达式的返回值就是Lambda的返回值. 多行表达式可以在中括号后用->type声明
注意事项:
- 每一个lambda表达式的类型的都是唯一的, 只能通过auto关键字赋值到一个变量上.
- 函数模板的拥有自动类型推导特性, 所以它能使用lambda表达式作为参数进行传递.
- 捕获列表非空的Lambda表达式不能转换为函数指针, 空捕获列表的可以转化为同返回值和参数列表的函数指针

1.2 右值引用

2. 编译器优化

c++开启内联和编译器优化循环会放大低效操作的影响，所以尽量将低效操作放在循环外部对象参数使用引用或指针，移动语义，当传入参数是一个临时参数并且返回一个该临时参数时，直接在栈中创建该对象不建议使用const string&(除非调用方确保有现有的string对象) string不建议在循环中反复创建，建议在循环外创建并使用clear函数刷新，减少内存管理函数的调用次数

STL简介

Sat, 15 Feb 2020 00:00:00 +0000

STL简介

为了建立数据结构和算法的一套标准, 从而降低他们之间的耦合关系, 以提升各自的独立性、弹性、交互操作性, 惠普实验室为C++开发了STL(Standard Template Library), 即标准模板库. 如名字所言, STL几乎所有的代码使用了C++的类模板技术, 具有极高的代码复用性. C++标准程序库中隶属于STL的占到80%以上.

容器模板: 是封装数据结构的类模板, 用于组织和存放数据.
迭代器模板: 是封装容器数据访问方法的类模板, 用于访问容器数据并返回引用. 迭代器的出现使得容器和算法相互独立, 算法可以不用理解容器的具体实现.
算法模板: 是一些成熟的函数模板, 使用迭代器访问容器并完成相应的功能.
函数对象模板: 是重载了()运算符的类模板, 它的对象叫做函数对象, 使用行为类似函数.
适配器模板: 也是重载了()运算符的类模板, 但我们称它的对象为适配器. 适配器用来对接口进行扩展.
空间适配器模板: 是实现容器动态存储空间管理的类模板, 它的对象叫做空间适配器.

容器模板

STL容器类是封装数据结构的类模板, 它的对象叫做容器, 用来组织存放数据.

容器分类:
序列式容器: 数据元素是按序逻辑相邻的线性结构, 所有数据元素通过空间分配器在堆上存储
关联式容器: 数据元素是物理不相邻的非线性结构(树), 所有数据元素通过空间分配器在堆上存储
迭代器类: 迭代器类是封装容器数据访问方法的类模板, 它的对象迭代器能够访问容器数据并返回其引用. 迭代器类内嵌于容器类中, 使用时需要通过作用域运算符.
前向迭代器: 只支持自增操作的迭代器.
反向迭代器: 自增方向为从尾到头的迭代器, 名称中带有"reverse_".
双向迭代器: 只支持自增和自减操作的迭代器
只读迭代器: 这类迭代器限制进行只读操作, 名称中带有 “const_“字样, 操作的容器也必须加const修饰
随机访问迭代器: 序列式容器特有, 支持类似数组下标的随机访问方式, 也支持自增和自减操作的迭代器, 是功能最全的迭代器!

string

string容器类封装了字符数组和一系列管理函数. 相对于以\0为结束符的传统C字符数组, 无需管理内存空间, 更适合开发大型程序. 设计上的复杂性也导致性能没有传统C字符串高.

iostream

Sat, 15 Feb 2020 00:00:00 +0000

1. istream

包含头文件#include<iostream>

1.1 成员变量

fail标志位: 流析取失败时(流析取类型不匹配、者读到流末尾没有内容了和流指针设置错误), 会将fail标志位值1
eof标志位: 流析取到末尾时, 会将eof标志位置1. 注意流缓存的两种情况使"a" 和"a “, 第二种用析取符时并没有读到末尾!!!

1.2 成员函数

 //构造函数
系统提供istream的默认流对象cin(), 注意程序前台运行期间, 标准输入不会关闭, 因此eof判断流末尾的方法将会失效.

//成员函数: 
istream& operator>>(…)流析取运算符, 忽略开头的空格和换行读到空格、换行和文件末尾停止, 并将数据转换为目标类型. 
istream& read(char* buff , int count)读入流缓冲区count个字节到字符数组, 读完count个字节或读到文件末尾终止. 
istream& get(char* buff , int count)读取流缓冲区count-1个字节到字符数组并添加\0, 读完count-1个字节、读到\n或读到文件末尾终止. 参数缺省等同于getchar()函数
int& peek()读取流缓存中的一个字符, 但不清除它, 适用于判断流指针当前的字符类型
istream& ignore(int Num=1, char delm=EOF)忽略到字符delm前的Num个字节. 默认delm为EOF即读到文件末尾
istream& seekg(int pos)将读(g)指针移动到pos位置, 设置错误则将fail标志位置1. 
int tellg()返回读(g)指针当前的位置, 若流标志位被置位, 则返回-1. 
bool fail()输入流的fail标志位被置位时, 函数返回true,
bool eof()输入流的eof标志位被置位时, 函数返回true. 
void clear()重置输入流的标志位包含fail、eof和bad标志位. 当流标志位置位时, 必须使用clear函数才能继续操作

2. ostream

2.1 成员变量

ios::left 和ios::right 设置输出左对齐和右对齐
ios::oct 8进制, ios::dec 10进制, ios::hex 16进制, ios::showbase 显示进制前缀, ios::fixed 定点数表示模式所有的流标志都配置了相应的函数, 在cout中可以直接使用位移运算符设置

2.2 成员函数

 //构造函数：
系统提供ostream的默认流对象cout(不同的编译器对cout的实现有差别, seekp, tellp函数是没有意义的)　

//成员函数
ostream& operator<<(…)流插入运算符, 将参数类型按特定的格式转换为字符输出到流缓存中
ostream& write(char* buff, int count)将字符数组中的count个字节值写入流缓存
ostream& put(char ch)和putchar()函数一致
	
precision(int p)设置输出流浮点有效数字, 若数超出有效数字个数, 则使用科学计数法表示. 定点模式下为小数点后小数个数 
width(int w)设置cout输出的列宽, 只对下一条cout语句有效
fill(char ch)设置cout输出的空白区域填充字符, 只对下一条cout语句有效
int seekp(int pos)将写(p)指针移动到pos位置
int tellp()返回写(p)指针当前的位置
istream& flush()刷新流缓冲区, 立即执行实际I/O操作, windows下cout立即执行
setf(ios::xxx) 和 usetf(ios::xxx)装载和卸载流标志, 所有的流标志可以不通过setf设置, 可以通过流插入运算符设置

2. ifstream

文件流包含在fstream头文件中关键的ifstream、ofstream和fstream继承关系如下：

事件接口

Sat, 15 Feb 2020 00:00:00 +0000

1. event简介

2. event2/event

2.1 数据结构

2.2 函数

 //框架
struct event_base* event_base_new(void)申请事件处理框架
void event_reinit()重新初始化, 在子进程中, 必须重新初始化
int event_base_dispath(struct event_base* base)事件循环
int event_base_loopexit(struct event_base* base, const struct timeval* tv)等待正在处理的事件处理完毕后退出监听, 可以设置延迟触发
int event_base_loopbreak(struct event_base* base)强制退出监听. 
void event_base_free(struct event_base* base); 释放事件处理框架

//事件
struct event* event_new(struct event_base* base, evutil_socket_t fd, short what, event_callback_fn cb, void* arg) 创建新事件
int event_add(struct event*ev, const struct timeval* tv) 事件提交, 可设置超时自动触发
int event_del(struct event* ev)事件挂起
void event_free(struct event* event)删除事件
- base: 事件处理框架
- fd: 文件描述符
- what:
	- EV_READ 读 
	- EV_WRITE 写
	- EV_SIGNAL 信号
	- EV_PERSIST 持续触发. 框架默认只处理一次该事件, 处理完后自动del. 若设置该选线则持续处理.
	- EV_ET 边沿模式
- cb: 回调函数typedef void(*event_callback_t)(evutil_socket_t, short, void*)
- arg: 回调参数

3. event2/bufferevent

3.1 数据结构

3.2 函数

bufferevent是libevent为IO缓冲操作提供的一种通用机制, 由一个底层的传输接口以及一个读缓冲区和一个写缓冲区组成, 与event不同的是bufferevent在读取或写入足够多的数据后才调用用户回调.
在套接字通信中, 不是用event, 而是用evconnlistener以及bufferevent. evconnlistener负责封装用于监听的套接字, bufferevent用于封装与客户端通信的套接字.

基础接口

Sat, 15 Feb 2020 00:00:00 +0000

1. unistd.h

1.1 数据结构

1.2 函数

 //文件操作
ssize_t read(		//成功返回读到字节数(读到末尾返回0), 失败返回-1设置errno
	int fd, 
	void* buff, 
	size_t count)
	
ssize_t write(		//成功返回写入的字节数(未写入返回0), 失败返回-1设置errno
	int fd, 
	void* buff, 
	size_t count)
	
off_t lseek(		//设置文件指针为whence+offset, 成功返回文件指针位置, 失败返回-1设置errno, 使用lseek扩展文件时需要进行一次写操作.
	int fd, 
	off_t offset, 
	int whence)		// SEEK_SET(文件开始) SEEK_CUR(文件当前位置) SEEK_END(文件结尾)
	
int close(int fd)	//关闭文件描述符, 成功返回0, 失败返回-1并设置errno
int dup(int fd)					//创建一个文件描述符, 指向fd
int dup2(int oldfd,int newfd)	//newfd指向oldfd

int truncate(				//截断
	const char *path, 
	off_t length)

ssize_t readlink(			// 读取软连接
	const char *pathname, 
	char *buf, 
	size_t bufsiz)
	
int unlink(const char *pathname)//删除软硬连接, 当有进程在使用时会暂时不删, 待进程释放后删除

 //进程
pid_t fork(void)			//创建子进程, 成功父进程返回子进程id, 子进程返回0, 失败返回-1设置错误码.
pid_t getppid()				//获取父进程id
pid_t getpid()				//获取进程id
void exit(int status)		//退出进程, 函数不会返回

int chdir(				//改变工作目录, 工作路径进程唯一, 程序调用不会改变shell的工作路径, 更改工作目录需要目录的执行权限
	const char *path)	//工作目录字符串
char *getcwd(			//获取当前工作路径.成功字符串指针, 失败返回NULL
	char *buf,			//传出参数, 存储传出的工作路径
	size_t size)		//buf的大小

pid_t wait(			//阻塞等待一个子进程终止, 返回处理的子进程. -1代表回收失败(无子进程或发生错误)
	int* status)	//是一个记录子进程状态的传出参数,使用xxx函数查看

pid_t waitpid(		//比wait强大, 能指定任意子进程或设置非阻塞等待
	pid_t pid, 		//小于-1代表等待特定组id的子进程, 等于1代表任意子进程(和wait一致), 等于0代表回收进程组id和调用进程组id相同的子进程, 大于0代表特定子进程
	int* status, 	//是一个记录子进程状态的传出参数,使用xxx函数查看
	int option)		//0代表阻塞, 3(WNOHAND)代表非阻塞


	
//进程组
pid_t getpgrp (void)	//获取进程组id
int setpgid(			//设置进程组id
	pid_t pid, 			//
	pid_t pgid);		//

//会话
pid_t getsid(pid_t pid)	//获取进程会话id
pid_t setsid(void)		//设置会话id, 常用于创建新的会话.

 //exec函数，替换进程的data和text段, 然后从text的第一条指令开始执行
int excel(				//使用绝对路径定位程序
	const char *path, 
	const char* argv, 
	...)
	
int excelp(				//使用PATH环境变量定位程序
	const char *path,	//
	const char* argv,	//
	...)				//
	
int excele(				//
	const char *path, 	//
	const char* argv, 	//
	..., 				//
	const char* env[]);	//
	
excev、excevp、exceve和前三个函数类似, 使用指针数组传递参数(最终前三个函数都要调用这三个函数)

 //管道操作
/*
1)当写端全部关闭, 读端read函数读到末尾返回0; 当部分关闭, 读端read函数阻塞, 非阻塞read设置错误代码
2)当读端全部关闭, 写端调用write函数时, 进程会收到SIGPIPE信号而异常终止; 当读端部分关闭, 写端可以正常调用write函数, 若缓冲区满了则阻塞
特点: 简单, 只能由有血缘关系的进程(父子关系\共同祖先)使用
*/
int pipe(int fildes[2])//获取管道的读写文件描述符, 分别存储于fildes[0]和fildes[1]. fork场景下父子进程拥有相同的文件描述符, 为了稳定性考虑一般父子进程各关闭一个方向上的文件描述符

2. sys/mmap.h

2.1 数据结构

2.2 函数

 void* mmap(					//将文件特定区域映射到内存中, 返回映射区首地址.
	void* addr,				//一般传NULL让内核自动分配
	size_t length,			//映射区长度
	int prot, 				//PORT_READ或PORT_WRITE映射区读写权限
	int flags,				//设置映射区是否影响文件(MAP_SHAREG共享|MAP_PRIVATE私有)
	int fd, 				//文件描述符
	off_t offset)			//指定文件的偏移值(mmap使用offset+length的区块初始化映射区)

int munmap(					//释放内存映射区
	void *addr, 			//mmap返回的映射区地址
	size_t length);			//映射区长度

3. sys/shm.h

共享内存可以通过ipcs查看，Linux对共享内存管理是通过 shmid+进程引用计数实现的. 当一个共享内存被打开时, 它处于public状态, 任何进程都可以绑定到该共享内存上, 当有其中一个进程对共享内存执行了shmctl设置了IPC_RMDI, 该共享内存的shmid会发生变化, 并处于private状态, 此时不接受其他进程加入.

文件接口

Sat, 15 Feb 2020 00:00:00 +0000

1. sys/stat.h

1.1 数据结构

 struct stat { 
	dev_t     st_dev;         /* ID of device containing file */ 
	ino_t     st_ino;         /* Inode number */ 
	mode_t    st_mode;        /* File type and mode */ 
	nlink_t   st_nlink;       /* Number of hard links */ 
	uid_t     st_uid;         /* User ID of owner */ 
	gid_t     st_gid;         /* Group ID of owner */ 
	dev_t     st_rdev;        /* Device ID (if special file) */ 
	off_t     st_size;        /* Total size, in bytes */ 
	blksize_t st_blksize;     /* Block size for filesystem I/O */ 
	blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */ 
	struct timespec st_atim;  /* Time of last access (read) */ 
	struct timespec st_mtim;  /* Time of last modification (write) */ 
	struct timespec st_ctim;  /* Time of last status change (property change) */
};
//st_mode是一个16位的整形数, 1-3表示其他人权限4-6表示组权限7-9表示拥有者权限10-12表示特殊权限13-16表示文件类型

struct timespec { 
	__kernel_time_t tv_sec;   /* seconds */ 
	long tv_nsec;  /* nanoseconds */
}

//常用配合函数
struct passwd getpwuid(uid_t uid)			//
struct group getgrgid(gid_t gid)			//
struct tm* localtime(const time_t* timep)	//可来处理st_atim.tv_sec

1.2 函数

 int stat(					//成功返回0, 失败返回-1设置errno, stat参数是一个传出参数
	const char *pathname, 
	struct stat *statbuf). 
int chmod(
	const char *path, 
	mode_t mode)
int access(
	const char *path , 
	int mode)				//R_OK(判断读权限)\W_OK(判断写权限)\X_OK(判断执行权限)\F_OK(判断文件存在)

int mkfifo(					//创建fifo管道文件.针对fifo管道, 使用open打开时若只读或只写打开会阻塞, 直到另一个进程或线程打开对应的写或读
	const char *pathname, 
	mode_t mode)

2. fcntl.h

2.1 数据结构

  struct flock { 
  ... 
  short l_type;    /* Type of lock: F_RDLCK, F_WRLCK, F_UNLCK */ 
  short l_whence;  /* How to interpret l_start: SEEK_SET, SEEK_CUR, SEEK_END */ 
  off_t l_start;   /* Starting offset for lock */ 
  off_t l_len;     /* Number of bytes to lock */ 
  pid_t l_pid;     /* PID of process blocking our lock(set by F_GETLK and F_OFD_GETLK) */ 
};

2.2 函数

 int open(//打开一个文件, 返回一个最小可用的文件描述符
	const char* path, 
	int flag): 				//是一个int型位图, 其中O_RDONLY、O_WRONLY和O_RDWD必选其一
							//- O_RDONLY: 只读打开
							//- O_WRONLY: 只写打开
							//- O_RDWD: 读写打开
							//- O_APPEND: 打开时文件指针指向文件末尾
							//- O_CREAT: 打开时文件不存在则创建, O_EXCL补充打开时文件存在, 返回-1并设置errno
							//- NO_BLOCK: 非阻塞文件描述符

int fcntl(//获取或设置文件描述符的标志位(即open函数中使用的那个)
	int fd, 
	int cmd,...): 			//文件描述符	
							//- F_GETFLAG
							//- F_SETFLAG
							//- F_SETLG

3. sys/dirent.h

3.1 数据结构

 struct dirent {
	ino_t d_ino; /* Inode number 目录项ino编号*/
	off_t d_off; /* Not an offset; see below 目录项偏移*/
	unsigned short d_reclen; /* Length of this record 目录项的大小*/
	unsigned char d_type; /* Type of file; not supported by all filesystem types */
	char d_name[256]; /* Null-terminated filename 目录项名称*/
};

3.2 函数

 int mkdir(							//创建目录, mkdir命令默认给的是0777&~umask权限
	const char *pathname, 
	mode_t mode)
DIR *opendir(const char *name)		//
struct dirent *readdir(DIR *dirp):	//返回一个目录项结构体指针, 目录结尾返回NULL, 或错误返回NULL并设置errno 
int closedir(DIR *dirp): 			//关闭目录流指针
rewindir(DIR *dirp): 				//目录流指针指向开头
telldir(DIR *dirp): 				//返回目录流指针位置
seekdir(DIR *dirp): 				//指定目录流指针

网络接口

Sat, 15 Feb 2020 00:00:00 +0000

1. sys/socket.h

1.1 数据结构

 //sockaddr是一个bind默认接受的地址结构体，使用其他地址结构需要强转
struct sockaddr { 
	sa_family_t sa_family; 
	char        sa_data[14]; 
}

 //sockaddr_un记录本地套接字地址，本地套接字和IP套接字的区别只有地址的不同
struct sockaddr_un { 
	__kernel_sa_family_t sun_family; /* AF_UNIX 协议簇，本地通信使用AF_UNIX*/ 
	char sun_path[UNIX_PATH_MAX];   /* pathname socket伪文件名，若文件不存在会自动创建*/ 
};

 //sockaddr_in记录IPv4套接字地址
struct sockaddr_in { 
 __kernel_sa_family_t  sin_family;     /* Address family 协议粗，IPv4通信使用AF_INET*/ 
 __be16                sin_port;       /* Port number 大端存储的short变量，表示一个端口. 需要使用htons将小端数转为大端*/ 

/*struct in_addr {__be32 s_addr;}*/
 struct in_addr        sin_addr;       /* Internet address 大端存储的的int变量，表示一个IPv4地址，需要使用htonl将小端数转为大端 */ 
 
 /* Pad to size of `struct sockaddr'. 一个数组*/ 
 unsigned char         __pad[__SOCK_SIZE__ - sizeof(short int) - sizeof(unsigned short int) - sizeof(struct in_addr)]; 
};


//sockaddr_in6记录v6套接字地址
struct sockaddr_in6 { 
	unsigned short int      sin6_family;    /* AF_INET6 协议簇，IPv6通信使用AF_INET6*/ 
	__be16                  sin6_port;      /* Transport layer port # 大端存储的short变量，表示一个端口*/ 
	__be32                  sin6_flowinfo;  /* IPv6 flow information */ 
/*
struct in6_addr { 
	union { 
	__u8            u6_addr8[16]; 
	#if __UAPI_DEF_IN6_ADDR_ALT 
	__be16          u6_addr16[8]; 
	__be32          u6_addr32[4]; 
	#endif
}
*/
	struct in6_addr         sin6_addr;      /* IPv6 address 大端存储的128位整形变量，表示一个地址*/ 
	__u32                   sin6_scope_id;  /* scope id (new in RFC2553) */ 
};



//arpa/inet.h是配合IP协议使用的一个工具库
uint32_t htonl(uint32_t hostlong)	//小端长整形转大端长整形
uint16_t htons(uint16_t hostshort)	//小端短整形转大端短整形
uint32_t ntohl(uint32_t netlong)	//大端长整形转小端长整形
uint16_t ntohs(uint16_t netshort)	//大端短整形转小端短整形
int inet_pton(						//点分十进制IP地址转大端int整形，使用dst传出
	int af, 
	const char *src, 
	void *dst)	
const char *inet_ntop(				//大端int整形转点分十进制字符串
	int af, 
	const void *src, 
	char *dst, 
	socklen_t size)

待验证条目:

并发接口

Sat, 15 Feb 2020 00:00:00 +0000

1. pthread.h

1.1 数据结构

早期的linux并没有设计线程的概念, 线程概念是到后来借鉴windows才引入的. linux的线程与和进程底层都是使用clone()函数创建的, 但线程具有高并发\低占用\通信方便的优点

使用多线程尽量避免使用信号, 多线程对信号支持不好
多线程时, 线程的errno每个线程独立
多线程时, 若主线程return则进程退出, 其他线程也会退出. 主线程return前使用pthread_exit()-
查看线程库版本getconf GNU_LIBPTHREAD_VERSION

1.2 函数

 // 线程的创建与销毁
int pthread_create(
	pthread_t *restrict thread, 			//线程id结构体指针
	const pthread_attr_t *restrict attr, 	//设置线程属性,NULL表示不指定属性. 若需要指定属性则可以创建该结构体, 并使用pthread_attr_init()初始化, pthread_attr_destroy销毁, 可以掌握setdetachstate()进行创建时分离
	void *(*start_routine)(void *), 		//设置线程执行函数, 注意线程执行函数的参数固定为void*
	void *restrict arg)						//设置线程执行函数的参数, 注意该参数应该线程唯一, 否则会发生线程安全问题.

int pthread_join(		//回收线程资源, 和wait比较类似它是阻塞的
	pthread_t thread, 	//传出的thread参数
	void retval): 		//注意线程函数的返回值是一个指针, 这里传一个二级指针用于将线程返回参数传出

int pthread_detach(pthread_t thread)				//线程分离, 分离后的线程不需要要join回收. 调用join报错
int pthread_cancel(pthread_t thread)				//杀死线程
int pthread_equal(pthreadd_t t1 , pthreadd_t t2 )	//比较两个线程的
void pthread_exit(void *retval)						//退出线程, 该函数不会返回

 //互斥量
int pthread_mutex_init(								//初始锁(互斥量),互斥量在任意时刻只能由一个线程获取. 简便方式: pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;可以这样初始化
	pthread_mutex_t *restrict mutex, 				//
	const pthread_mutexattr_t *restrict attr); 
int pthread_mutex_lock(pthread_mutex_t *mutex)		//已经加锁的阻塞等待 
int pthread_mutex_trylock(pthread_mutex_t *mutex)	//尝试加锁, 枷锁失败立即返回
int pthread_mutex_unlock(pthread_mutex_t *mutex)	//解锁
int pthread_mutex_destroy(pthread_mutex_t *mutex)	//释放锁资源

//读写锁
int pthread_rwlock_init(							//初始化读写锁, 读写锁具有读时共享、写时独占、写优先级高的特点. 简便书写形式 pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER
	pthread_rwlock_t *restrict rwlock, 				//
	const pthread_rwlockattr_t *restrict attr)		//
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)	

//条件变量
int pthread_cond_init(							// 初始化条件变量, 注意条件变量不是锁, 简便书写形式 pthread_cond_t cond = PTHREAD_COND_INITIALIZE
	pthread_cond_t *restrict cond, 				//
	const pthread_condattr_t *restrict attr)	//
int pthread_cond_wait(							//调用该时, 需要先获得锁, 若获得锁后未满足条件则自动释放锁, 并阻塞在该函数中, 注意条件变量不是锁, 调用该函数需要一个锁变量
	pthread_cond_t *restrict cond, 				//
	pthread_mutex_t *restrict mutex)			//
int pthread_cond_signal(pthread_cond_t *cond)	//释放信号, 调用该函数时会唤醒一个被条件变量阻塞的线程
int pthread_cond_destroy(pthread_cond_t *cond)	//

2. semaphore.h

信号量

基础概念

Tue, 06 Jul 2021 00:00:00 +0000

数据类型

原子类型: java的原子类型规定只能创建在栈上

字节型: byte, 1字节
布尔型: boolean, 1字节
字符型: char, 2字节: java的字符或字符串使用UCS2编码集, 采用UTF-16编码存储, 所以java的char是2字节 javac采用UTF-8读取外部字符和字符串.
短整型: short, 2字节
整形: int, 4字节
长整型: long, 8字节
浮点型: float, 4字节
双精度浮点型: double, 8字节

引用类型: java的引用和C++引用有些不同. 左值时是指针, 右值时是引用. java规定结构类型必须通过new开辟在堆上使用引用访问

数组的引用: int[] arr = new int[N或缺省]{元素或缺省};
类对象的引用: className target = new className();

变量与常量

变量: Basic_type 变量名 注意变量必须赋值后才能使用, 而且不能超过类型范围
- 默认值:
常量: 常量分整形常量1、浮点常量2.2、布尔常量true、空常量null.
- 整形默认int类型, 数值后加L声明为long型. 浮点默认double类型, 数值后加F声明为float型
final常量: 类似于c++的const常量, 意为最后的、不可变动的。它用来修饰类还有其他用途。
- java的final常量和c++不同, 它可以不用初始化, 只需要保证它仅有一次赋值即可

运算符与表达式

Java的运算符与C++大体一致

面向对象

Tue, 06 Jul 2021 00:00:00 +0000

Class

Java类可以和C++一样，可以封装属性和方法，Java是纯面向对象语言，一切逻辑交由类完成。


public class MyClass {
	/*非静态成员变量: 隶属对象，必须通过具体对象调用。
	*/
 private Integer noneStaticVariable;

	/*非静态成员方法：隶属对象，必须通过具体对象调用。
	- 构造方法中，super调用父类构造方法必须在第一行
	*/
 private void noneStaticFunction(){return;}

	/*非静态内部类：
	- 隶属对象，其实例必须通过具体对象进行创建。
	- 非静态内部类只能拥有非静态成员
	- 非静态内部类的非静态成员方法可以访问外部类对象的所有非静态成员(重名时需要通过`外部类.this.变量名`指定)
	*/
 private class NoneStaticInnerClass {}

	/*静态成员变量：隶属类，可通过类或类对象调用。*/
 public static Integer staticVariable;

	/*静态成员方法：隶属类，可通过类或类对象调用。*/
 public static void staticFunction(String[] args) {return;}

	/*静态内部类：隶属类，其实例可通过类或类对象创建。*/
 public static class InnerClass{}

	/* 定义在方法中的类叫做局部类, 它只能在方法内使用.
	- 不能限定权限
	- 不能拥有静态成员
	- 局部类内的方法可以只读访问外部方法中的final常量或只进行过一次赋值的变量
	*/
 public static void function(){
 final Integer finalVariable = 1;
 class InnerClass{
 public void function(){
 System.out.println(finalVariable);
				//finalVariable = 2; //sytnx ERROR.
 }
 }
 }
}

info

局部类是Java语言的一种语法糖，它可以在方法内部定义一个类并使用。方法中的Lambda函数定义和函数式接口的都是在进行局部类的定义。

反射机制

Tue, 06 Jul 2021 00:00:00 +0000

Refect

类加载过程

java类的生命周期: java类从定义到对象创建需要经历三个阶段
Source阶段里, JVM将java源代码编译成Java字节码文件(class文件)
Class阶段里, ClassLoader对象将字节码文件加载进内存并产生Class对象
Runtime阶段里, 由Java Class对象创建指定类的对象
java类对象的创建 注意: 类的数组默认值为null, 不自动调用构造方法, 需要手动调用并赋值
普通创建: className target = new className(参数或缺省);
匿名对象创建: new className(参数或缺省)
Class对象创建: Class.forName(“类名”).getConstructor().newInstance() Class类是描述class字节码文件的类. 封装了维护字节码文件的一些方法. 每个类的字节码文件通过ClassLoader加载进内存后会生成一个唯一的Class类对象. 可以通过类名.class 或对象名.getClass()获取这个对象, 还可以通过Class类的静态方法forName(类的全引用)来加载Class对象

 //构造方法:
Class()

//成员方法: 获取类的成员之后调用
String getName(): 获取类的全名
String getSimpleName(): 获取简单类名
Field[] getFields(): 获取所有public修饰的成员变量
	- Field getField(): 
	- Field类中由get()和set()方法设置该字段值
Constructor<?>[] getConstructors() 
	- Constructor<T> getConstructor(类<?>... parameterTypes) 
	- Constructor类中有newInstance()方法创建创建类对象
Method[] getMethods() 
	- Method getMethod(String name, 类<?>... parameterTypes) 

Field[] getDeclearFields(): 获取所有成员变量, 不考虑修饰符
	- Field getDeclearField()
Constructor<?>[] getDeclaredConstructors() 
	- Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) 
Method[] getDeclaredMethods() 
	- Method getDeclaredMethod(String name, 类<?>... parameterTypes) 

//静态方法
forName(String className): 尝试查找该类的字节码文件, 并加载到内存中返回该类的Class对象

 //构造方法

//成员方法
URL getResource(String name); 获取根路径下资源的绝对路径

//静态方法

异常捕获

Mon, 01 Jan 0001 00:00:00 +0000

java的异常处理机制

异常抛出与捕捉


try{
	可能产生异常的代码
}catch(异常类型 异常变量)…
finally{无论是否发生异常都会执行的代码}
//----------------------------------
public void function() throws 异常类型,...{
	trow 异常变量
}

父类方法的异常子类只能抛出小于或等于父类方法抛出的异常, 若等于父类抛出的异常可以不写异常
java在异常处理中加入的finally代码块一般用来释放try中占用的资源, 一般不做return返回

异常类型

java的异常类型必须继承自Exception类, 并实现Throwable接口.

运行期异常(例如NullPointerException)的处理过程和C++一致, 可不使用throws声明
编译期异常(例如FileNotFoundException)调用者必要须要处理, 若处理不了需手动向上抛出异常, 必须在方法声明处使用throws声明编译期异常

异常与多态

和C++一致

内置异常

Exception类实现了Throwable, 它含有以下常用方法


public String getMessage() 简短信息
public String toString() 详细信息
public void printStackTrace(), 若对象抛给了jvm则默认调用的是该方法, 异常信息是最全面的

自定义异常


public class RegisterException extends Exception { 
	public RegisterException() {
		/*空参构造*/ 
	}
	public RegisterException(String message) { 
		/*有参构造*/ 
		super(message); 
	} 
}
public class Main{
	public static void main(String[] args){
		try{
			throw new RegisterException("自定义异常");
		}catch(RegisterException e){
			e.printStackTrace();
		}
	}
}

并发编程

Tue, 06 Jul 2021 00:00:00 +0000

线程控制

Thread类

Java通过Thread类开启并管理线程. 线程上下文是通过Runable接口的run方法定义, 而Thread实现了空run方法. 一种实现线程的方式是继承Thread类实现run方法，通过调用自身的run方法创建线程另一种实现线程的方式是实现Runable接口，通过Thread类构造方法创建Thread类对象并调用run方法创建.

线程的创建:
- 继承Thread类并重写run方法, 其对象调用继承的start方法开启线程.
- 实现Runable接口, 通过Thread类的构造方法封装成Thread类对象并调用其start方法开启线程(推荐)
线程的生命周期: java的线程调度采用抢占式调度, 其线程状态转换如图所示
线程安全: java使用锁机制来实现同步机制. java的锁对象也称为线程监视器, 可以是任意对象. 获得锁的线程可以执行, 否则阻塞.
- 对象监视器: 对象监视器(对象锁)用来协调线程间的同步, 它可以是任意的对象.
  - public void wait() 或 public void wait(long) 当前线程进入无限等待状态或计时休眠状态, 并放弃锁.
  - public void notify() 或public void notifyAll(): 唤醒一个或全部正在等待的线程
- 同步代码块: synchronized(对象监视器){同步代码块}
- 同步方法: 使用synchronized修饰的方法. 非静态方法的锁对象是对象本身, 静态同步方法的锁对象是类(反射会讲)
线程池: 线程池是一个用来存储已经创建的线程集合, 集中为线程分配任务和销毁线程. 使用线程池可以降低频繁创建和销毁线程的资源消耗. jdk1.5以后提供了维护线程池的类ThreadPoolExecutor. 不熟悉的强烈推荐使用其接口Executors提供的工具方法创建和使用线程池.
```
 public ExecutorServer newFixThreadPoolExecutor(int nThread) 创建一个指定大小的线程池
使用ExecutorServer接口中的public void submit(Runable task)方法提交任务
使用ExecutorServer接口中的public void shutdown()方法来销毁线程池(不建议使用) 
 
```

成员变量

成员方法

 //构造函数
public Thread(Runable r); 实现了Runable接口的类对象都可以作为参数传入, 线程创建时运行对象的run方法.

//成员函数
public void run() 从Runable接口实现的方法(空操作), 它是线程执行的代码
public void start() 使用start方法来创建一个线程并开始执行run中的代码, 一个Thread对象不能重复调用start方法
public String getName() 使用该方法获取线程的名称

//静态函数: 
public static Thread currentThread()使用该方法获取当前正在执行的线程
public static void sleep(long t) 正在运行的线程阻塞t毫秒

ReentrantLock类

这个类包含在java.util包中

基础库

Tue, 06 Jul 2021 00:00:00 +0000

基础类型封装

java定义了一些基本数据类型的包装类, 它们可以执行一些有用的方法。

自动拆箱: 从jdk1.5开始, 可以直将接基本数据类型赋值给包装类对象, 解释器自动装箱
自动装箱: 从jdk1.5开始, 基本数据类型和包装类之间可以直接参与运算, 解释器自动拆箱.

 //常见的方法: 
public Integer(int val)
public Integer(String s)
public static Integer valueOf(int val )
publc static Integer valueOf(Stirng s)
public intValue()
public int praseInt(String s)
public static String toString(int val)

字符串封装

java代码中双引号引用的内容都是String类型, String封装的是一个被final修饰的byte数组. 可以使用StringBuilder构建一个字符串

 //初始化新创建的 String对象，以使其表示空字符序列。
String()
//通过当前参数中的字符数组来构造新的String。
String(char[] value)	
//通过使用平台的默认字符集解码当前参数中的字节数组来构造新的
String(byte[] bytes)	

//返回此字符串的长度。
int length ()	

//将指定的字符串连接到该字符串的末尾。
String concat (String str)	

//返回指定索引处的 char值。
char charAt (int index)			

//返回指定子字符串第一次出现在该字符串内的索引。
int indexOf (String str)			

//返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
String substring (int beginIndex)		

//返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
String substring (int start, int end)	

//判断是否字符串是否包含str(CharSequence是一个接口, String同样实现了它)
boolean contains(CharSequence str)		

startWith(String s);

//将此字符串转换为新的字符数组。
char[] toCharArray ()		

//使用charset字符集将 String编码转换为新的字节数组, 缺省默认平台的默认字符集将.
byte[] getBytes (String charset)		

//替换所有
String replace (
	CharSequence target, 
	CharSequence replacement)
String replaceAll (CharSequence target, CharSequence replacement) 
String[] split(String regex) 将此字符串按照给定的regex（规则）拆分为字符串数组。
String valueOf(int val) 将基本数据类型转换为String类型

 //构造一个空的StringBuilder容器。
public StringBuilder()
//构造一个StringBuilder容器，并将字符串添加进去。
public StringBuilder(String str)：

系统功能封装

包含与系统相关的大量静态方法

封装

Mon, 01 Jan 0001 00:00:00 +0000

python类

定义类: class className
成员类型:
- 非静态成员
  - 非静态成员函数: 非静态成员函数的参数中带有self参数(注意self参数位于参数列表首位且名字可以更改, 但不建议更改)
    - 构造函数: __init__(self,)
    - 析构函数: __del__(self,)
    - 普通函数: __str__(self,), print函数会调用的方法; 还有很多类似的函数
  - 非静态成员变量: Python的非静态成员变量是跟随对象动态绑定的, 意味着需要时才绑定. 通常我们为了达到一创建对象时马上绑定, 所以会在__init__函数中绑定.
- 静态成员:
  - 类函数: 类函数的参数列表中带有cls参数, 且需要使用@classmethod修饰器修饰(意为类名调度时自动将类对象传入)
  - 类变量: 静态成员变量在类中直接定义, 注意有别于其他语言的非静态成员变量.
  - 静态函数: 普通函数的参数列表不带cls和self参数, 且需要使用@staticmethod修饰器修饰, 注意静态函数无法使用类变量, 因为没有类对象
1. 成员权限: 严格上讲, python没有权限划分, 只要有想法私有变量也是可以访问的.
  - 名称带双下划线前缀: 只有本类可以使用
  - 缺省不写: 所有位置都可以访问

python类对象的创建

1. **普通创建**: 变量 = className(…),

基础概念

Mon, 01 Jan 0001 00:00:00 +0000

数据类型

Python的基础数据类型只有引用类型, 丰富的自定义类型由类提供. 官方内置了一些基础的类作为基本类型。

Number类

int
float
complex

str类

python解析器中. 单引号、双引号和三引号都代表str类的一个实例

构造函数:
- str()
成员函数:
- find(str_str, int_start, int_end ) , 查找字符串的起始位置, 没找到时返回-1. 还有rfind()版本
- index(str_str, int_start, int_end), 查找字符串的起始位置, 没找到时抛出异常. 还有rindex()版本
- replace(str_old, str_new, int_count ), 替换old为new, count设置替换次数,缺省全部替换
- count(str_str) 查找字符串出现的次数,
- split(str_delimiter , int_count) 按delimiter分割字符串并保存在list中返回
- partition(str_delimiter) 按delimiter将字符串分为三部分, 它能保留分割字符串
- join(iterable_object) 使用调用者作为连接符, 连接可迭代实体(例如str, list等)的每一个元素, 返回连接后的新字符串单元素不连接
- startswith(str_start) 判断字符串是否是以start开头
- endswith(str_end) 判断字符串是不是以end结尾
- isupper() 判断字符串是不是全大写, 还有很多is类型的函数
- upper() 转换大写
- lowwe() 转换小写
- title() 控制字符分割开的单词, 首字母大写

继承

Mon, 01 Jan 0001 00:00:00 +0000

类继承

Python默认继承object类, Python类支持多继承

语法格式: class className(baseClass,…)
注意事项: Python的子类若提供构造函数则需要手动调用父类的构造函数, 解释器不会自动调用
- BaseClass.init(self,…) : 不考虑MRO顺序, 手动指定执行对象
- super(BaseClass, self).init(…) 等价于 super().init(…): 根据MRO顺序调用, 能解决Python的菱形继承问题

多态

Mon, 01 Jan 0001 00:00:00 +0000

python和编译型语言不同, 它的函数调用是动态绑定的, 这就意味着Python对调用函数时能直接调用实际对象的相应方法这就是其他语言所要实现的多态

异常

Mon, 01 Jan 0001 00:00:00 +0000

NameError TypeError ValueError AttribitueError SyntaxError IndexError

python的异常处理机制和c++一致 try: 测试代码 raise 异常类 except: 抛出的异常或多个异常使用元组表示 as 别名处理代码 finally:

语法糖： with open

并发

Mon, 01 Jan 0001 00:00:00 +0000

Process类

Process类继承自BaseProcess类, 它的主要函数来自BaseProcess类, 进程间拥有相同的主进程内定义的变量, 但数据并不共享. 主进程等待所有子进程执行结束才中止, 可以手动中止进程或设置子进程为守护进程使用processing模块中的current_process函数获取当前位置获得的进程

构造函数:
- init(self, group=None, target=None, name=None, args=(),kwargs={}, *, daemon=None)
成员函数:
- start(): 开启进程
- join(): 等待进程中止
- terminate(): 中止进程

Thread类

线程共享当前进程内定义的变量, 数据共享使用threading模块中的current_thread函数获取当前位置获得的线程

构造函数:
- Thread(self, group=None, target=None, name=None, args=(),kwargs={}, *, daemon=None)
成员函数:
- start(): 开启进程
- join(): 等待进程中止
- terminate(): 中止进程

2. Lock类

构造函数:
成员函数:
- lock()
- release()

coroutine

协程使用async标识
协程只能使用await调用等待对象，可等待对象有协程、任务、future
- await asyncio.sleep(1)

可等待对象

协程、
任务: 任务可以封装并调度协程，用来并行调度协程，也可以取消协程
future

DDL

Fri, 01 Oct 2021 00:00:00 +0000

CREATE

CREATE DATABASE


CREATE DATABASE database_name ;

CREATE TABLE


CREATE TABLE "tableName"(
	["colName" DATATYPE [DEFAULT defVal] [[NOT] NULL] [col_cONstraint],]
	["colName" DATATYPE [DEFAULT defVal] [[NOT] NULL] [col_cONstraint],]
	...
	"colName" DATATYPE [DEFAULT defVal] [[NOT] NULL] [col_cONstraint]
	[,table_cONstraint]
);

-- col_cONstraint
[ CONSTRAINT <constraintName> ]{
	PRIMARY KEY 
	| UNIQUE 
	| CHECK(predicate) 
	| REFERENCES tbName [(colName)][[ON [DELETE|UPDATE] CASCADE] | SET NULL] } 

-- table_cONstraint
[ CONSTRAINT <constraintName> ] {
	PRIMARY KEY (colName,...) 
	| UNIQUE ( colName,...] ) 
	| CHECK(predicate)
	| FOREIGN KEY (colname,...) REFERENCES tbName [(colname,...)][ON [DELETE|UPDATE] CASCADE | SET NULL]

DATETYPE

字符串: CHAR(n), 定长字符串; VARCHAR(n), 可变长字符串
整形: INT, 有些系统写作INTEGER
浮点: NUMERIC(p. q), 小数点左边p位,右边p-q位; REAL:有些系统写作float(n)n是小数点位数
日期: DATA, 日期(如2003-09-12)
时间: TIME, 时间(如23:15:003)

1.2.2 CONSTRAINT

DEFAULT: 默认值
[NOT] NULL: 是否允许空值
域完整性约束可以取一个名字方便日后进行修改
PRIMARY KEY是主键, 约束非空唯一
UNIQUE是唯一约束, 可空唯一, 且只能有一个null值
CHECK(CHECK_cONditiON)是条件约束, 条件和where中的语法一致
reference是外键约束, 当外键和参照表主键同名时可省略, 不同名要加上!!! 当参照表删除记录时, 这个外键做相应的处理, CASCADE时级联删除, SET NULL置空

CREATE VIEW


CREATE VIEW "viewName" [(
	["colName",]
	["colName"],
	...
	"colName"
)] 
As( select_statement ) 
[WITH CHECK OPTION]

WITH CHECK OPTION: 当要修改数据时, 检查是否满足子查询中定义的条件表达式
视图注意事项:
- 如果视图的select目标列包含聚集函数,则不能更新
- 如果视图的select子句使用了UNIQUE或distinct ,则不能更新
- 如果视图中包括了group by子句,则不能更新
- 如果视图中包括经算术表达式计算出来的列,则不能更新
- 如果视图是由单个表的列构成,但并没有包括主键,则不能更新(添加主键可更新)

CREATE TRIGGER

SQL实现Dynamic CONstraint使用的是触发器Trigger机制 Trigger是一种过程完整性约束(相比之下, Create Table中定义的都是非过程性约束), 它是一段程序,该程序可以在特定的时刻被自动触发执行


- 语法格式: 
Create Trigger trigger_name 
{Before | After} {Insert | DELETE | UPDATE | [OF colname [,colname][,colname].......] 
ON table_name [Referencing corr_name_def[,corr_name_def][,corr_name_def].... ]}
[FOR EACH ROW | FOR EACH STATEMENT] //针对更新事件中的行触发还是语句触发
[WHEN (检索条件) ] 
statement | [Begin statement1; statement2; statement3;..... end] 


//定义程序(R)(O), 多个statement要是有Begin...end表示, 单个statement可以不用
//定义检索条件(P),满足条件执行下面的程序, 缺省默认执行程序
对于UPDATEEvent的定义如下:
 //指定更新的操作

DBMS能区分将写(Before)和已写(After)两个时刻

执行触发器操作需处理两组值:更新前的值和更新后的值,由corr_name_def定义
Old [Row] [As] Old_Row_name | New [Row] [As] New_Row_name |
Old Table [As] Old_ Table_name | New Table [As] New_Table_name
corr_name_def 就是定义更新前和更新后的元组或者表变量
注意: UPDATE可以定义Old 和 New, DELETE 只能定义Old, Insert 只能定义New

DML

Fri, 01 Oct 2021 00:00:00 +0000

INSERT INTO


INSERT INTO tableName [(
	[colName1,] 
	[colName2,]
	...
	colNamen
)]
VALUES([value1,][values2,]...valuesn) | select_statement

如果写了列名, 请按自己写的顺序安排值, 否则请按定义表的顺序排列值当插入数据时会检查完整性约束, 否则不能够执行插入操作

DELETE FROM


DELETE FROM table_name
[WHERE check_condition ]

删除满足查询条件的元组, 省略查询条件直接删除整个表

UPDATE


UPDATE tableName
SET colname = expression | (SELECT…)
	[, colName = expression | (SELECT…)]
	[, colName = expression | (SELECT…)]
	...
[WHERE 查询条件]

就是将满足条件的元组的列名值替换为表达式或者子查询返回的结果 where条件省略默认是这个表达全部元组都进行更新

DQL

Fri, 01 Oct 2021 00:00:00 +0000

SELECT


SELECT 
	[[ALL|DISTINCT]"colName1" [AS] "alias",]
	[[ALL|DISTINCT]"colName2" [AS] "alias",]
	...
	[ALL|DISTINCT]"colNamen" [AS] "alias"
FROM 
	["tableName1" [[natural] [{right|left outer}|inner] join "tableName"' on join_predicate|using([c1,]...,cn) [AS] "alias",]
	["tableName2" [[natural] [{right|left outer}|inner] join "tableName'" on join_predicate|using([c1,]...,cn) [AS] "alias",]
	...
	"tableNamen" [[natural] [{right|left outer}|inner] join "tableName'" on join_predicate|using([c1,]...,cn) [AS] "alias"
[WHERE predicate ] ; 
[GROUP BY 
	["colName1",]
	["colName2",]
	...
	"colNamen" 
	[HAVING predicate]]
[ORDER BY 
	["colName1" [ASC|DESC],]
	["colName2" [ASC|DESC],]
	...
	colNamen [ASC|DESC]]

SELECT字段

选择投影字段, 可以对字段进行表达式处理. – ALL|DISTINCT: DISTINCT会去除重复元组 – AS: 别名

Oracle

Fri, 01 Oct 2021 00:00:00 +0000

DDL

数据类型：
- CHAR(n): 定长字符串
- VARCHAR2(n): 可变长字符串，对中文支持比较好
- LONG: 可变长字符数据，最大2G
- NUMBER(m,n): 可变长数值列m是有效数字位数(默认11), n是保留小数位数, Oracle保留int和double它们是NUMBER子集，
- DATE: 默认的显示和匹配格式是’日-月-年'
  - alter session set NLS_DATE_FORMAT = ‘yyyy-mm-dd’修改会话中date类型数据的显示格式
  - 步进是一天，支持减法操作
- BLOB: 二进制数据 CLOB: 字符型数据 BFILE: 二进制文件
- ROWID: 行地址

 - delete是逐条删除表内容，truncate是直接摧毁表然后重建，
- delete是dml语言（支持闪回），truncate是ddl语言（不支持闪回）
- delete会产生碎片，truncat不会产生碎片
- delete不会释放空间，truncate会释放空间，所以当确定表不再使用后应该使用truncate

 - alter talbe t1 rename xxx to xxx 重命名列名
- alter table t1 drop column xxx 删除列
- alter table t1 modify 列 类型 --当存在多列时, 用括号

 - rename t2 to t2 重命名表名，rename可以重命名oracle中的其他对象，所以不需要加table

flashback table t2 to before drop; 可以闪回处于回收站中的表
drop table t2 purge;表示永久删除表
purge recyclebin 清空回收站
注意sys用户没有回收站，只有普通用户有回收站
alter table xxx add xxx date default sysdate;增加一行，默认值是系统时间
create table <tablename> as select * from <tablename> where 1=2表示创建一个相同表结构的空表

DML

DELETE是dml语言, 逐行删除, 支持回滚, 不会释放空间, 会产生碎片 TRUNCAT是ddl语言, 摧毁表后重建, 不支持回滚, , 会释放空间, 不会产生碎片 insert into <tablename> valuse(&arg1, &arg2,…)这种插入方式可以，所有dml语句都可以

算法简介

Sat, 01 Feb 2025 00:00:00 +0000

check_circle

作者编写本系列教程的目的在于固定技术资产，力求用最少语言写下相关算法的核心思想，方便查阅和温习。

本系列教程所有源码均已采用MIT协议开源，您的建议对我十分重要，欢迎电邮或提交Github Issues。

Python

数据结构简介

Sat, 01 Feb 2025 00:00:00 +0000

数据结构简介

数据：所有能输入到计算机中，且能被计算机处理的符号集合
数据元素：数据中的一个个体，数据元素可以使用数据项描述
数据对象：具有相同性质的若干数据元素，数据元素需要具有相同的结构
数据结构：数据对象内部，数据元素间的逻辑结构。数据结构可以使用一个二元组$B=(D,R)$表示，其中D是数据元素集合，R是关系的集合(有的结构需要多个关系表示，所以应该是关系的集合)。
数据类型：是一个值的集合和定义在此集合上的一组操作的总称。数据类型就是已经实现的数据结构。
抽象数据类型：不考虑计算机实现, 从求解问题的数学模型中抽象出来的数据逻辑结构和运算。实际上是对一个求解问题的形式化描述，可以在理解的基础上实现它。

数据结构目录

线性数据结构

非线性数据结构

数组
数组是一些系列相同类型的存储在内存连续位置的元素的集合。数组的作用在于我们可以使用一个变量来存储和表示一组相关的变量。数组作为基础的数据类型十分重要，几乎所有的现代计算机编程语言中都会提供。

对于数组我们关注以下几个概念：
- 索引(index)：数组元素可以被索引定位和识别，索引从0开始。
- 长度(length)：数组长度代表数组的可存储容量。
- 维度(dimensions)：数组元素内部进行逻辑分组可划分多个维度。
对于数组我们关注以下几个操作：
- traversal：访问所有元素依次(遍历)。
- insert：将元素插入数组指定下标。
- delete：删除指定下标的元素。
- search：指定下标开始搜索指定元素。
数组具有如下优点：
- 高效数据访问：数组通过索引访问元素，能实现常数时间复杂度。
- 对内存友好：元素存储在连续内存区域，减少内存碎片。
- 用途广泛：可以存储各种基础数据类型，甚至复杂的复合封装类型。
数组具有如下缺点：
- 固定容量：创建时容量固定，扩容涉及元素拷贝。
- 增删效率低：增删需要子序列移动，效率较低。
- 同元素类型限制：数组内的元素必须是同类型。
封装示例

C++ Java Python

简单链表

Sun, 01 Dec 2024 00:00:00 +0000

链表(Linked List)

矩阵简介

Sun, 01 Dec 2024 00:00:00 +0000

字符串简介

Sun, 01 Dec 2024 00:00:00 +0000

线性搜索

Sun, 02 Mar 2025 00:00:00 +0000

线性搜索(Linear Search)

线性搜索通过遍历数组中的所有元素判断并返回等于目标值的元素。

二分搜索

Sun, 02 Mar 2025 00:00:00 +0000

二分搜索(Binary Search)

二分搜索适用于已排序数组，时间复杂度为$O(\log n)$

排序简介

Sun, 02 Mar 2025 00:00:00 +0000

排序简介

排序算法用于重新整理一个序列，使之按照特定的要求进行排列。

基于比较的排序算法

基于比较的算法依赖数据元素间权重比较，排序算法的库默认基于权重的升序排序实现，权重小的元素被排在前面(优先级更高)。

设元素$x$,$y$为被比较元素，$w(x)$为权重计算函数，如下对比较函数$cmp(x,y)$进行了定义

$ cmp(x,y)= \begin{cases} 1 & w(x) > w(y) \\ -1 & w(x) < w(y) \\ 0 & w(x) = w(y) \end{cases} $

以排序算法实现作者的角度来看，可以通过$cmp(x,y)=1$判断$y$的权重更小，或者通过$cmp(x,y)=-1$判断$x$的权重更小，本项目实现的排序算法是基于前一种方式进行的判断。下面以自然数为例解释如何设计比较函数。

👉升序排序：$x<y$时，$x$排在$y$的前面。
表明当$x<y$时，$x$的权重小于$y$，则$x>y$时，$x$的权重大于$y$
$ cmp(x,y)= \begin{cases} 1 & x > y \\ -1 & x < y \\ 0 & x = y \end{cases} $

👉降序排序：$x>y$时，$x$排在$y$的前面。
表明当$x>y$时，$x$的权重小于$y$ ，则$x<y$时，$x$的权重大于$y$
$ cmp(x,y)= \begin{cases} 1 & x < y \\ -1 & x > y \\ 0 & x = y \end{cases} $。

选择排序

Sun, 02 Mar 2025 00:00:00 +0000

选择排序(Selection Sort)

选择排序是一种基于比较的排序，每次迭代对无序列中最小元素与首部互换来完成该最小元素的位置矫正，直至序列中不存在无序列。

以升序为例介绍它的处理步骤:

$i$指针表示无序列最小元素的正确位置。迭代范围$[0, n-1)$，注意最后一个位置不需要处理，因为这个位置已经正确。
$j$指针用于识别无序列最小元素实际位置。迭代范围$[i+1, n)$。
循环寻找最小元素将其至于正确位置完成排序，直至序列中不存在无序列。

冒泡排序

Sun, 02 Mar 2025 00:00:00 +0000

冒泡排序(Bubble Sort)

冒泡排序是一种基于比较的排序，每次迭代将无序列中元素最大的部分通过临近互换方式移动到尾部来完成最大元素位置矫正，直至序列中不存在无序列。

以升序为例介绍它的处理步骤:

$i$指针指示已排序数量。迭代范围$[0,n)$。
$j$指针用于在无序部分比较移动最大值元素到末尾。迭代范围$[0,n-i-1)$。
循环移动最大元素至末尾，直至序列不存在无序列。若移动过程中发现元素未发生移动即代表该部分元素已有序可提前退出。

插入排序

Sun, 02 Mar 2025 00:00:00 +0000

插入排序(Insertion Sort)

插入排序是一种基于比较的排序，每次迭代将无序列第一个元素插入到有序列中正确位置，直至序列中不存在无序列。

以升序为例介绍它的处理步骤:

$i$指针指示无序列第一个元素。迭代范围$[1, n)$。
$j$用于指示有序列中正确位置。从$i-1$往回迭代，记录正确位置。
循环寻找正确位置并插入，直至序列不存在无序列。

快速排序

Sun, 02 Mar 2025 00:00:00 +0000

快速排序(Quick Sort)

快速排序是一种基于比较的排序，选取一个支点(pivot)进行分组，支点元素左边的元素小于支点元素，支点右边元素大于支点元素，然后递归处理两个分组直到分组不可再分。

以升序为例介绍它的处理步骤:

支点可取任意值，一般选取序列最后一个元素。
指针$i$用于指示小于支点元素的边界。
$j$用于识别小于支点的元素，迭代范围$[0, n)$。
识别到小于支点的元素则利用$i$进行元素互换，完成左右分组。
分组完成后递归小于支点的分组和大于支点的分组，直至分组不可再分(分组长度等于1或首指针大于尾指针)。

堆排序

Sun, 02 Mar 2025 00:00:00 +0000

堆排序(Heap)

堆排序是一种基于比较的排序，原理和选择排序相似，但无序列选取最值的方式是通过堆实现的。

以升序为例介绍它的处理步骤:

对无序列还原成完全二叉树，从最后一个节点的父节点往回每个节点进行堆化。
堆弹出(堆尾与根节点互换并对根节点堆化)最大值插入到队列末尾的有序列，重复操作直到堆中元素全部弹出。

归并排序

Sun, 02 Mar 2025 00:00:00 +0000

归并排序(Merge Sort)

归并排序是一种基于比较的排序，通过将分组分成两部分分别排序，排序完成之后再进行合并。

设$l$代表当前数组左指针，$r$代表当前数组右指针
当$l<r$时计算中点坐标$m=(l+r)/2$，递归排序$[l, m]$和$[m+1, r]$
当递归排序结束之后两部分数组有序，再进行一次合并。


import java.io.*;

class MergeSort {
 // Merges two subarrays of arr[].
 // First subarray is arr[l..m]
 // Second subarray is arr[m+1..r]
 void merge(int arr[], int l, int m, int r) {
 // Find sizes of two subarrays to be merged
 int n1 = m - l + 1;
 int n2 = r - m;

 // Create temp arrays
 int L[] = new int[n1];
 int R[] = new int[n2];

 // Copy data to temp arrays
 for (int i = 0; i < n1; ++i)
 L[i] = arr[l + i];
 for (int j = 0; j < n2; ++j)
 R[j] = arr[m + 1 + j];

 // Merge the temp arrays

 // Initial indices of first and second subarrays
 int i = 0, j = 0;

 // Initial index of merged subarray array
 int k = l;
 while (i < n1 && j < n2) {
 if (L[i] <= R[j]) {
 arr[k] = L[i];i++;
 }
 else {
 arr[k] = R[j];j++;
 }
 k++;
 }

 // Copy remaining elements of L[] if any
 while (i < n1) {
 arr[k] = L[i]; i++; k++;
 }

 // Copy remaining elements of R[] if any
 while (j < n2) {
 arr[k] = R[j]; j++; k++;
 }
 }

 // Main function that sorts arr[l..r] using
 // merge()
 void sort(int arr[], int l, int r) {
 if (l < r) {
 // Find the middle point
 int m = l + (r - l) / 2;

 // Sort first and second halves
 sort(arr, l, m);
 sort(arr, m + 1, r);

 // Merge the sorted halves
 merge(arr, l, m, r);
 }
 }

 // A utility function to print array of size n
 static void printArray(int arr[]) {
 int n = arr.length;
 for (int i = 0; i < n; ++i)
 System.out.print(arr[i] + " ");
 System.out.println();
 }

 // Driver code
 public static void main(String args[]) {
 int arr[] = { 12, 11, 13, 5, 6, 7 };

 System.out.println("Given array is");
 printArray(arr);

 MergeSort ob = new MergeSort();
 ob.sort(arr, 0, arr.length - 1);

 System.out.println("\nSorted array is");
 printArray(arr);
 }
}

哈希函数

Wed, 21 May 2025 00:00:00 +0000

哈希函数

一个好的哈希函数需要满足以下要求：

高效快速
将键均匀的映射到哈希表的所有索引
最小化哈希冲突
较低负载系数

除法哈希(Division Method)

$h(k)=k \mod n$

或

$h(k)=(n-1)\ \& \ k$

乘法哈希(Multiplication Method)

$h(k)=\lfloor m * (kA \mod 1) \rfloor$

哈希冲突

键的数量要远大于哈希表索引的数量，哈希函数在对键值映射到哈希表索引时，时不可避免的会发生碰撞。哈希冲突对数据的增删和修改产生困扰。

单独链接(Separate Chaining)

哈希表每个单元指向一个链表，相同哈希值的元素存储在链表中。

开放寻址(Open Addressing)

开放寻址即元素仍存储在哈希表，发生哈希冲突时采用逐个探测的方法寻找空位置。

线性探测(Linear Probing)

从原始哈希位置往下线性探测，如果位置被占据则继续下探直至寻找到空位置。

计算键的哈希索引 $i=h(k)$。
若$ht[i]$不为空，则循环$i = (i+1) \% n$直至$ht[i]$为空。
存储数据$ht[i]=data$。

平方探测(Quadratic Probing)

从原始哈希位置往下以某个二次函数的步进跳跃探测寻找空位置。

计算键的哈希索引 $i=h(k)$。
若$ht[i]$不为空，则循环$i = (i+x^{2}) \% n, x=1,2,…,n-1$，直至$ht[i]$为空。
存储数据$ht[i]=data$。

HashMap

Wed, 21 May 2025 00:00:00 +0000

HashMap

哈希映射旨在解决快速查找和访问一个集合中的元素的问题。常用于数据库索引、基于磁盘的数据结构以及数据压缩算法，在密码学上常用于密码的存储。
对于哈希我们关注以下概念：

键(key)：键可以是整形、字符串甚至是更复杂的复合类型，用于输入哈希函数生成哈希索引。
哈希函数(hash function)：输入键并生成键对应的哈希索引，该索引用于哈希表寻址。
哈希表(hash table)：哈希表通常为一个列表数组，存储与键对应的值。
负载系数(load factor)：哈希表的负载系数为哈希表元素个数与哈希表大小的比值。默认值为0.75。

哈希具有如下优点：

增删和搜索的时间复杂度为$O(1)$

JDK中的HashMap实现

我们通过几个问题回答一下实现原理：

哈希映射是怎么存储的?

哈希映射采用哈希表存储，哈希表每个槽(Solt)为一个集装箱(Bin),取哈希表容量与键的哈希值比值的余数获取哈希表索引进行存储。

哈希映射以2整数次方大小创建哈希表，根据公式$h \mod 2^n = h \& (2^n-1)$取余运算可以转化为按位与运算，$(2^n-1)$代表n位二进制数的最大值，按位与该值等同于取原值的后$n$位二进制数，和取余是等价的。位运算的速度相对更快，哈希映射源码中使用位运算i = (n - 1) & hash来计算哈希表集装箱位置，提高运算效率。

当哈希表的元素个数超过负载系数规定的阈值时进行哈希表扩容，每次扩容为原来的2倍。源码中使用位运算newThr = oldThr << 1生成新的阈值。

哈希映射是如何解决哈希冲突的?

当集装箱元素个数小于阈值时采用链表存储数据，当元素个数大于阈值时采用红黑树存储数据。树化阈值TREEIFY_THRESHOLD默认为8。

哈希映射是如何在红黑树中插入一个键的?

哈希映射优先使用键的哈希值进行比较，若哈希值不可比较（哈希冲突）则检查键类型是否实现Comparable接口并进行比较，若仍不可比较则使用决胜局算法tieBreakOrder比较。在采用决胜局算法比较前会先调用红黑树搜索算法查找，以确认待插入键不在数据集内。

HashSet

Mon, 09 Jun 2025 00:00:00 +0000

HashSet

哈希集合旨在解决快速判断一个元素是否在一个数据集中的问题。哈希集合使用红黑树或哈希映射作为底层数据存储结构，提供高效的查询性能。

HashSet实现

LinkedHashSet实现

HashTable

Wed, 21 May 2025 00:00:00 +0000

HashTable

哈希映射表是一个二维映射关系表，它底层依托HashMap实现。哈希映射表可以用于实现图的邻接矩阵底层实现。

HashTable实现

LinkedHashTable实现

双指针简介

Mon, 01 Jan 0001 00:00:00 +0000

双指针

双指针用于同时标记两个元素或者一段数据的边界，例如可变滑动窗口方法中就是使用双指针划定边界的。

假设左指针为$i$，右指针为$j$

$i$的初始位置通常分布于开头。$j$的初始位置可分布于开头或结尾，根据问题背景确定分布。
$i$和$j$的移动一般是单向的，迭代需要注意确保不会漏掉任一情况。

使用示例

双指针示例1

升序数组arr中是否有两个元素的和等于目标值k
传统的思路是数组中元素两两配对求和与k进行比较，这个方法的时间复杂度为$O(n^2)$。可以发现并没有使用到升序数组的特性，使用双指针方法合理忽略相对应的元素可以提高计算效率。


def two_sum(arr, target):
 arr.sort()
 left, right = 0, len(arr) - 1
 while left < right:
 if arr[left] + arr[right] == target:
 # we reach find the answer
 return True
 elif arr[left] + arr[right] < target:
 # this means arr[left] can't pair 
 # the elements before arr[right],
 # safely igonre the element arr[left]
 left += 1
 elif arr[left] + arr[right] > target:
 # this means arr[right] can't pair 
 # the elements after arr[left],
 # safely igonre the element arr[right]
 right -= 1
 return False
# Driver Code
arr = [2, 5, 8, 11, 12, 30]
result = two_sum(arr, 23)
print(result)

滑动窗口

Mon, 01 Jan 0001 00:00:00 +0000

滑动窗口

窗口的作用在于标记区间的元素并存储窗口当前的数据状态，窗口滑动时利用相邻窗口的相关性计算下一个窗口的数据状态来提高计算效率。

滑动窗口适用于以下问题情形：

需要重复计算重叠区间数据的数据状态。
重复区间数据具备数据相关性。

定长滑动窗口

定长滑动窗口适用于重叠数据区间长度一致的情况。

确定窗口大小，假设为$w$。
计算第一个窗口的结果并进行存储。
通过循环逐步移动窗口并通过上个窗口的计算结果计算出当前窗口的结果。

可变滑动窗口

可变滑动窗口适用于重叠数据区间长度不一致的情况，可变滑动窗口使用了双指针来操作窗口的大小以及移动窗口。

通过移动窗口右指针扩展窗口，通过移动左指针缩小窗口，直至窗口计算结果符合条件。
如果计算结果符合条件，进行相应的处理后，移动左指针重复步骤1。
重复步骤1和步骤2，直到所有数据被处理。(结束条件根据问题需求而定)

使用示例

滑动窗口示例1

非负数组arr长度为k的子组数中，求和的最大值 传统的思路是循环所有子数组起始位置时内嵌循环进行子数组的求和叠加并进行最大值比较，假设子数组长度为$k$,这个方法的时间复杂度为$O(k*n)$。可以发现子数组间存在数据重叠求和进行了很多重复的加法计算，优化的思路是使用定长滑动窗口的思想缓存和复用累加结果，优化后的时间复杂度为$O(n)$。


def subarr_max_sum(arr, k):
 n = len(arr)
 if n <= k:
 return -1
 window_sum = 0
 max_sum = window_sum
 # cache current window result
 window_sum = sum(arr[0:k])
 for i in range(n-k):
 window_sum = window_sum - arr[i] + arr[i+k]
 max_sum = max(window_sum, max_sum)
 return max_sum
# Driver code
arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
k = 4
print(subarr_max_sum(arr, k))

滑动窗口示例2

非负数组arr求和大于k的子数组中，长度的最小值
传统的思路是循环所有子数组起始位置时循环累加起始位置后面的元素至求和刚大于k时，比较并记录当前长度，这个方法的时间复杂度为$O(n^2)$。可以发现子数组累加时进行了很多重复的加法计算，优化的思路是使用可变滑动窗口的思想缓存和复用累加结果，但这里使用的是可变滑动窗口求解，优化后的时间复杂度为$O(n)$。

前缀和

Mon, 01 Jan 0001 00:00:00 +0000

前缀和

前缀和将元素的前缀特性提取并存储到一个数组中方便检索，利用元素的前缀特性能够提高某些问题的处理效率。

假设$arr$为输入的数据：

声明一个前缀数组$pf$。
对$arr$进行循环，对$arr$当前元素和$pf$的上一个元素(或$pf$当前元素)求和然后赋值给$pf$当前元素(或$pf$的下一个元素)

使用示例

前缀和示例1

非负数组任意区间的求和(起始索引为1)


def interval_sum(arr, query):
 n = len(arr)
 pf = [0 for i in range(n+1)]
 for i in range(n):
 pf[i+1] = pf[i] + arr[i]
 
 for i in range(len(query)):
 print(pf[query[i][1]] - pf[query[i][0]-1])

# Driver code
arr = [10, 4, 16, 20]
query = [
 [2,3], # 20
 [1,2], # 14
]
interval_sum(arr, query)

前缀和示例2

给定一个初始值为0的数组$arr$，进行$m$轮对区间$[a_x,b_x]$元素叠加100操作后，求arr中的最大值(起始索引为1)

递归

Mon, 01 Jan 0001 00:00:00 +0000

递归

一个函数直接或间接调用自身完成任务处理时，这个函数称为递归函数。递归函数朝解决问题的方向前进时，调用自身进行更深层次的问题处理，当最深层次的问题被解决时函数终止返回。递归常用于可以将问题拆解成具有更小数据规模的相同问题的处理。

确定基本不可拆解情况或条件，基本情况用于防止递归函数持续调用自身。
确定递归情况或条件，识别问题中相同背景的子问题，进行递归调用。
确保递归基本条件能够到达并终止递归调用。
联立子问题的处理结果完成原始问题的处理。

递归的优势：

帮助更好的构建逻辑处理流程。
递归思想帮助实现动态规划和分治相关算法。

使用示例

递归示例1

自然数的阶乘


def fact(n):
 if n == 0:
 return 1
 return n * fact(n - 1)
# Driver code
print(fact(5)) # 120

递归示例2

斐波那契数列
$ fib(n)= \begin{cases} n & n=0,n=1 \\ fib(n-1)+fib(n-2) & n > 1 \end{cases} $

简单栈

Mon, 01 Jan 0001 00:00:00 +0000

栈(Stack)

栈是一种线性数据结构，遵循元素后进先出的元素访问原则。

对于栈我们关注以下几个操作：

push：将元素插入到栈顶。
pop：将元素从栈顶删除。
top | peek：获取栈顶元素。
isEmpty：判断栈是否为空。
isFull：判断栈是否已满。

基于数组实现

初始化数组相关变量$data$、$size$(初始0)、$capacity$以及栈顶指针$top$(初始-1)。
编写溢出判断函数时，$size==0$判定栈空，$size==capacity$判定栈满。
编写插入函数时，上溢判断后对$size$和$top$进行加1操作在$top$指针位置插入元素。
编写弹出函数时，下溢判断后对$size$和$top$进行减1操作。

基于链表实现

封装带$data$(初始为空)和$next$(初始为空)变量的节点类型，初始化栈顶指针$top$(初始为空)。
编写溢出函数时，栈顶指针$top==null$判定栈空。
编写插入函数时，新节点指向栈顶节点，栈顶指针更新为指向新节点。
编写弹出函数时，下溢判断后将栈顶指针指向下下个节点。

简单队列

Mon, 01 Jan 0001 00:00:00 +0000

简单队列(Queue)

队列是一种线性数据结构，遵循元素先进先出的元素访问原则。

对于队列我们关注以下概念：

队头(front | head)：队列中准备出队的一端。
队尾(rear | tail)：队列中元素入队的一端。
队长(size)：队列中元素的个数。
容量(capacity)：队列可容纳的最大元素数量。

对于队列我们关注以下几个操作：

enqueue：将元素插入队尾。
dequeue：将元素从队头删除。
front | head | peek：获取队头元素。
rear | tail：获取队尾元素。
isEmpty：判断队列是否为空。
isFull：判断队列是否已满。

基于数组实现

初始化数组相关变量$data$、$size$(初始0)、$capacity$以及队头指针$front$(初始0)。
编写溢出函数时，$size==0$判定队空，$size==capacity$判定队满。
编写插入函数时，进行上溢判断后计算队尾坐标$rear=(front+size)\%capacity$插入元素，并对size加1。
编写弹出函数时，进行下溢判断后更新队头坐标$front=(front+1)\%capacity$，并对size减少1。

基于链表实现

封装带$data$(初始为空)和$next$(初始为空)变量的节点类型，初始化队头指针$front$(初始为null)和队尾指针$rear$(初始为null)。
编写溢出函数时，$front==rear==null$判定队空。
编写插入函数时，队空时队头和队尾指针指向新节点即可，否则队尾节点指向新节点然后队尾指针指向新节点。
编写弹出函数时，下溢判断后将队头指针指向下下个节点。

双端队列

Mon, 01 Jan 0001 00:00:00 +0000

双端队列(Double ended Queue)

双端队又叫双队列(Deque)，

优先级队列

Mon, 01 Jan 0001 00:00:00 +0000

优先级队列(Priority Queue)

基于数组实现

基于链表实现

二叉树

Mon, 01 Jan 0001 00:00:00 +0000

树(Tree)

graph TB
subgraph Tree
 direction TB
 A((0))-->B((1))
 A-->C((2))
 A-->D((3))
 B-->E((4))
 B-->F((5))
 B-->G((6))
 C-->H((7))
 D-->I((8))
 D-->J((9))
end

对于树我们关注以下几个概念：

根节点(root node)：树中最顶层的节点。
内部节点(internal node)：至少一个子节点的节点。
叶子节点(leaf node)：没有子节点的节点。
节点的深度(depth of a node)：从节点到根节点的边数。也称节点层级，根节点的深度为0。
树的高度(height of a tree)：最深层叶子节点到根节点的节点个数(包含叶子节点和根节点)。

树的性质

节点个数等于所有节点度数和加1，即$m$叉树满足$n=1+\sum_{x=1}^{m}xn_{x}$。
具有$n$个节点的$m$叉树最小高度为$\log_m{n(m-1)+1}$，最大高度为$n-(m-1)$。
高度为$h$的$m$叉树至多有$\frac{m^{h}-1}{m-1}$个节点, 第$i$层至多有$m^{i-1}$个节点。

二叉树(Binary Tree)

graph TB;
subgraph Perfect Binary Tree
 direction TB
 A((0))-->B((1))
 A-->C((2));
 B-->E((3))
 B-->F((4))
 C-->H((5))
 C-->I((6))
end

内部节点都包含两个子节点，叶子节点全部排列在最后一层的树称为完美二叉树(Perfect Binary Tree)。

二叉搜索树

Mon, 01 Jan 0001 00:00:00 +0000

二叉搜索树(Binary Search Tree)

graph TB
subgraph Binary Search Tree
 direction TB
 A((50))-->B((30))
 A-->C((70))

 B-->D((20))
 B-->E((40))
 C-->F((60))
 C-->G((80))
end

每个节点的左子树仅包含小于节点值的节点，右子树仅包含大于节点值的节点的树称为二叉搜索树(Binary Search Tree)。二叉搜索树具有以下特点：

二叉搜索树适用于存储有序列，它能以$O(H)$时间复杂度完成插入、删除、搜索、最值操作。
最坏情况下节点完全向一方倾斜，退化成链表时树高以$O(n)$为上界，操作的时间复杂度为$O(n)$。
最好情况下节点平衡因子小于等于1，平衡二叉树高以$O(\log n)$为下界，操作时间复杂度为$O(\log n)$。

自平衡二叉搜索树(Self-balancing BST)是一类在二叉搜索树插入和修改操作后通过轮换保持平衡性质以控制树高优化查询性能的树，常用的自平衡二叉搜索树有AVL树和红黑树。

info

当我们仅需要插入、删除和搜索操作时应使用哈希表，哈希表对这些操作的平均时间复杂度为$O(1)$。

二叉搜索树的插入和删除

二叉搜索树的插入操作一定在叶子结点，操作的步骤即根据二叉搜索树的从根节点向下寻找适合的叶子节点进行插入。

从根节点开始往下搜索，若数据小于当前节点则移动到左子树，若数据大于当前节点则移动到右子树。
若搜索期间发现数据等于当前节点说明数据已存储于二叉树中，中断插入流程返回。
寻找到最底部的叶子节点并插入数据，设置左节点还是右节点取决于当前数据与叶子节点的值。

二叉搜索树的删除操作需要从根节点向下搜索寻找待删除节点，根据待删除节点的子节点数量分三种情况处理：

待删除节点有0个子节点：其父节点的左或右指针置空后直接删除。
待删除节点有1个子节点：其父节点的左或右指针指向待删除节点的子节点后直接删除。
待删除节点有2个子节点：寻找其右子树中的最小值节点(右子树中最靠左且没有左子树的节点)覆盖待删除节点的值，然后按0或1个子节点的情况删除最小值节点。

二叉搜索树的封装

AVL树

Mon, 01 Jan 0001 00:00:00 +0000

AVL树(AVL Tree)

graph TB
subgraph AVL Tree
 direction TB
 A((50))-->B((30))
 A-->C((70))

 B-->D((20))
 B-->E((40))
 C-->F((60))
 C-->G((80))
 D-->H((10))
end

AVL树是一种自平衡二叉搜索树(Self-balancing BST)。在二叉搜索树进行插入和删除操作后，进行一些额外的轮换操作同时保持二叉树搜索树的结构和平衡二叉树的结构。

AVL树的插入和删除

AVL树的封装

红黑树

Mon, 01 Jan 0001 00:00:00 +0000

红黑树(Red-Black Tree)

红黑树中的节点不是黑色就是红色。
根节点和叶子节点的空节点都是黑色节点。
红色节点的子节点不能是红色子节点(红色节点的子节点一定是黑色节点)。
黑色节点到任一叶子节点的路径上所包含的黑色节点数量相同。

这些特点保持从根节点到叶子节点的最长路径不会超过最短路径的两倍，保持树的平衡和高效。

红黑树的插入和删除

红黑树的封装

堆

Mon, 01 Jan 0001 00:00:00 +0000

堆(Heap)

堆是一种完全二叉树，树中节点的值大于子节点值时称为大根堆，树中节点的值小于子节点值时称为小根堆。

堆的插入和删除

堆的封装

并查集

Fri, 13 Jun 2025 00:00:00 +0000

并查集(Union-Find Set)

并查集用于快速判断两个对象是否处于同一组中。假设一个实例场景，一个人的朋友的朋友同样认为是该人的朋友，若给定两个人判断两人是否是朋友关系，在该场景中并查集就可以发挥作用。

并查集实现

图简介

Fri, 06 Jun 2025 00:00:00 +0000

图(Graph)

对于图我们关注以下概念：

度(degree)：节点连接的边数。入度(in degree)，节点连接的入边数。出度(out degree)，节点连接的出边数。
顶点(vertex)：顶点是图的基本组成部分，有时也叫节点(Node)
边(edge): 边用于连接图中的两个顶点。
行走路径(walk)：行走路径是一个节点序列，节点前驱后继需要有边进行连接。
路径(path): 路径是一个特殊的行走路径，他不包含重复节点。

info

在某些书籍中，行走路径(walk)称为路径(path)，而路径(path)则称为简单路径(simple path)本质上是一样的。

图的分类

空图(Null Graph): 不包含边的图。
单点图(Trivial Graph): 仅包含1个节点的图
无向图(Undirected Graph): 图中的边无确定方向的图。
有向图(Directed Graph)：图中的边有确定方向的图。
连通图(Connected Graph): 通过图中任一节点可以访问图中其他任意节点的图。
k-常规图(K Regular Graph): 图中任一节点的度都为k的图。若$k=v-1$则称为完全图，它包含最多的边数。
环图(Cycle/Cyclic Graph): 图中所有节点包围成一个环称为环图(Cycle Graph)，图中节点至少形成1个环的图称为(Cyclic Graph)有环图。
二分图(Bipartite Graph): 图中节点可分为两分区，分区内节点间不通过边进行连接。
加权图(Weighted Graph)：图中边进行赋权的图。

图的性质

有向图中节点数量$V_{n} = D_{out} = D_{in}$，最大边数$E_{max} = V_{n} * (V_{n} - 1)$
无向图中最大边数$E_{max} = \frac{V_{n} * (V_{n} - 1)}{2}$

最短路径算法

Thu, 12 Jun 2025 00:00:00 +0000

Dijkstra算法

Dijkstra算法用于计算加权图中一个顶点到其他顶点的最短距离。

Dijkstra算法不支持权值包含负值的加权图，因为算法每次都是取距离最小的顶点更新其邻接顶点的，若邻接顶点存在一个负数边，当前顶点$v$到邻接顶点$u$的距离会比当前顶点的距离更小，导致下一迭代会从$u$开始又更新$v$的距离为一个更小的距离，算法陷入死循环。

若所有边同时加上一个固定数值结果将不再正确，因为在所有到其他顶点的最短路径中，所包含的边数量并不一定一致。

Dijkstra算法实现

Dijkstra算法的核心思想是初始化一个源顶点到其他顶点的距离映射表(源顶点到源顶点的距离为0，到其他节点为无穷大)，每次从集合中取出距离源顶点最小的顶点$v$，若由v到其邻接顶点的距离更短则更新邻接顶点的在集合中的距离值，直到所有顶点从集合中取出来。我们可以通过最小堆快速取出距离最小的顶点，通过哈希映射来维护顶点的距离值。值得注意的是，使用编程语言提供的最小堆一般不支持动态调整堆中元素的大小，我们只需重复插入距离更短的顶点即可，并不会影响我们取出的最小值。

时间复杂度：$O(E*\log V)$，在$O(1)$复杂度内建立最小堆Heap，堆中至多$O(E)$个顶点，至多进行$O(E)$次pop()操作和$O(E)$次push()操作，而pop()和push()的时间复杂度均为为$O(\log E)=O(\log V^2)=O(\log V)$。HashMap在良好的哈希函数下能做到$O(1)$复杂度的插入和更新操作。
空间复杂度：$O(V)$，我们使用了一个Heap和一个HashMap额外存储顶点信息。

Floyd Warshall算法

Floyd Warshall算法用于计算加权图所有顶点间的最短距离。Floyd Warshall算法可以计算是包含负值的加权图，但不支持闭环为权重之和为负数的加权图。

Floyd Warshall算法实现

时间复杂度：$O(V^3)$，算法中包含三个相互嵌套的循环。
空间复杂度：$O(V)$, 我们使用了一个HashTable存储各顶点间的距离。

Bellman Ford算法

前面讨论的Dijkstra算法有一个限制条件是图中不能包含权重为负数的边，因为再次访问已访问的顶点，否则将导致死循环。Bellman Ford算法不是从最短距离节点开始更新邻接顶点的最短路径，而是通过遍历所有边并更新从边对端的最短路径，他可以解决Dijkstra算法不能计算包含权重为负数的边的问题。图中不能包含权重之和为负数的闭环，因为围绕环绕一圈，距离就会变小，最短路径不存在。

最小生成树算法

Tue, 10 Jun 2025 00:00:00 +0000

最小生成树算法(MST Algorithm)

生成树(Spanning Tree)是无向连通图中所有顶点以及部分边所构成的一个树状无向无环连通图。生成树的权重等于生成树中所有边的权重之和，权重最小的生成树被称为最小生成树。

生成树的特点：

生成树的顶点数量与原图一致。$V_{mst} = V_{g}$
生成树的边的数量等于原图顶点数量减1。$E_{mst} = V_{g} -1$
生成树必须是连通的。
生成树必须是无环的。
生成树可能有多个。

最小生成树的特点：

当图中所有边的权重都相等时，所有的生成树都是最小生成树，权重都相等。
图中权重最小的边一定包含在所有最小生成树中，最大的边一定不包含在最小生成树中。
若图中顶点分成两个不相交集合，集合间相连的边中权重最小的边一定包含在最小生成树中。
若图中形成环，如果一个边的权重严格大于其他边，则该边不会包含在任一最小生成树中。
若图中所有边的权重都是唯一的，则最小生成树只有一种情况。
生成树是最小连通图，对最小生成树移除边将成为非连通图。
生成树是最小无环图，往最小生成树添加边将导致环的产生。

Kruskal’s Algorithm实现

Kruskal’s Algorithm是一个常用的寻找无向连通图最小生成树的算法。它的核心思想是对边进行权重排序，从权重最小的边开始遍历，若边不构成闭环则添加到新图中，否则对该边进行忽略。值得注意的是，生成树边的数量满足关系式$E_{mst} = V_{g} -1$，最后一个边不需要处理（从这里可以看出权重最大的边一定不会包含在最小生成树中）。Kruskal算法的关键在于闭环检测，在选取边的时候若该边的两个端点同属于一个集合即发生了闭环，我们可以使用并查集快速判断两个元素是否处在同一集合下。

Prim’s Algorithm实现

Prim’s Algorithm是另外一个寻找无向连通图最小生成树的算法，它利用了生成树的不相交割集间权重最小的边一定包含在最小生成树中这条性质。核心思想是创建一个集合$S$用于跟踪已加入最小生成树的顶点，每次迭代选取$S$和$V-S$间的最小权重边加入到新图，并将其对端顶点加入到$S$，循环迭代直到所有顶点加入到$S$。$S$与$V-S$相连的边由最小权重边的对端顶点的邻接顶点中产生，一般使用小根堆来跟踪这些边并快速提取最小权重边。

闭环

Sun, 15 Jun 2025 00:00:00 +0000

闭环检测算法(Cycle Detecte)

闭环检测算法是从DFS或BFS中修改而来的。DFS或BFS需要针对图中的每个孤岛进行遍历，而闭环检测算法则在此基础上添加一个数组用于存储沿路顶点信息。

有向无环图

Sun, 15 Jun 2025 00:00:00 +0000

有向无环图(Directed Acyclic Graph)

graph TB
subgraph Directed Acyclic Graph
 direction TB
 A((0))
 B((1))
 C((2)) --> D
 D((3)) --> B
 E((4)) --> A
 F((5)) --> A
 F --> C
 E --> B
end

拓扑排序

在有向无环图(DAG)中，若一条边确定由A指向B，则遍历结果中A将始终排在B的前面的排序方式称为拓扑排序。它的核心思想是跟踪顶点的入度(In Degree), 当入度为0时可以访问当前节点(代表当前顶点的前驱顶点已经访问完毕)，访问当前节点之后对邻接顶点的入度减1，循环迭代直至所有节点入度为0。我们可以使用队列存储入度为0的顶点，当对邻接顶点入度减少到0时入队，队列为空时代表所有节点入度为0。

若希望找到所有的拓扑排序，需要配合递归和回溯思想。每次遍历取入度为0且未被发现的顶点v，更新v的的邻接顶点的入度，添加v到路径列表path，然后进行归查找。函数在达到递归最深层时(所有节点被发现)，准备返回时判断path的长度等于顶点数量则输出路径到结果。当递归返回时需要恢复v邻接顶点的入度，并将v从l中移除。

git

Sun, 01 Jun 2025 00:00:00 +0000

基本概念

Git是世界上最先进的分布式版本控制系统.

git跟踪文本内容而不是文件, git的add命令将新文件或新修改的文件快照暂存到index中, 准备好下一次提交
commit对象
tree对象: 一个tree实体关联一个或多个blob实体, 一个tree实体可以关联两外一个tree实体, 从而构建目录结构
blob对象
tag对象

 adduser -r -c 'git version control' -d /home/git -m git
# 设置用户名和邮箱，在~/.gitconfig文件中保存以下信息
git config --global user.name "xxxxx"
git config --global user.email "xxxxx@xxxxx"
git config --get remote.origin.url # 查看远程仓库地址
git config -l # 查看仓库参数


git push -u origin main

单分支管理

 # 创建仓库有两种方式，一是通过git初始化一个仓库，二是通过git克隆一个远程仓库到本地
git clone xxx
git init # --bare指定一个没有工作目录的仓库, 一般用于服务器仓库，用作其他仓库的数据共享

# 修改工作目录文件，并添加文件到暂存区.
git add xxxx
git diff --cached #查看暂存区即将被提交的修改
git status #查看git管理状态o

# 提交暂存区内容到版本库, git每次提交都需要输入改动注释。:commit注释最好以一行短句子作为开头，来简要描述一下这次
# commit所作的修改(最好不要超过50个字符)；然后空一行再把详细的注释写清楚。这样就可以很方便的用工具把
# commit释变成email通知，第一行作为标题，剩下的部分就作email的正文.
git commit # -a选项可以未保存到暂存区的已修改文件(不包含新建文件)存入暂存区并进行一次提交

# 分支创建、切换、合并、冲突处理
git branch #查看所有分支,后面如果指定了分支名则创建分支，-d参数可以删除一个已合当前分支合并的分支，-D表示删除没合并的分支
git checkout xxx # 切换分支
git merge xxx # 分支合并，隐含一个提交操作。若没有冲突则自动合并完毕,若合并失败，暂存区会进入特殊状态，直到你把冲突解决和才能提交成功。
git diff # 若分支合并失败，使用该命令查看冲突位置，手动解决后通过commit进行一次提交
gitk # 该命令可以以图形化方式展示git信息

# 差异比较
git diff 分支1..分支2
git diff 分支 # 查看当前工作目录与指定分支间的差异
git diff --cached # 查看暂存区与上次提交的差异
git diff HEAD # 查看工作目录与上次提交的差异

# 回滚
git reset --hard HEAD # reset命令可以回退版本库状态，并重置暂存库和工作区。--hard模式直接重置暂存区将工作区会退到版本库状态。已经提交合并操作可以使用--hard ORIG_HEAD模式回退
git revert # 迭代回滚，他和reset的区别是revert是向前迭代进行回滚的，会记录信息，而reset是删除信息。

# 日志
git log # 显示git提交记录，--stat显示文件更改信息，--pretty可以格式化日志,--graph会有一个终端图形效果

# 远程仓库同步
git remote add xxx xxxx # 给远程仓库起别名，该别名可以在pull和push中使用
git pull 仓库别名或仓库地址 分支
git push 仓库别名或仓库地址 分支

git fetch 仓库别名/分支 
git merge 仓库别名/分支

多分支管理

git-merge

git-rebase

变基自动分析当前分支与上游分支的共同提交与差异提交，设置当前分支以上游分支为基础并尝试将当前分支上的差异提交应用进来。若当前分支与上游分支的不同提交有冲突时，则需要进行冲突修正之后才能继续进行变基，变基的过程中还可以操控当前分支不同提交应用到上游分支的过程(例如修改某个当前分支不同提交中的某个提交的提交日志）。

make

Mon, 17 Jun 2019 00:00:00 +0000

1. make

make命令默认使用当前目录下的makefile或Makefile作为配置文件, 可以使用-f参数更改

1.1 make命令

make [OPTION]... [TARGET]...
make执行流程: make默认对配置文件的第一个目标进行生成, 使用-o指定生成目标make只对目标文件不存在或依赖文件的修改时间比目标文件新的情况进行更新生成. 若更新是发现依赖不满足, 则会在配置文件下寻找生成该依赖的方案, 直至完成生成.

1.2 make脚本

变量: 文件集合字符串, 可以直接书写文件名, 也可以通过函数生成
- 内置变量
  - $@ 表示目标文件的名称，包含扩展名
  - $^ 表示所有的依赖文件，以空格隔开，不重复
  - $< 表示第一个依赖文件的名称
  - $+ 表示所有的依赖文件，空格隔开，可以重复
  - $* 表示目标文件的名称，不包含扩展名
  - $? 依赖项中，所有比目标文件新的依赖文件
- 自定义变量: 变量名=$(表达式) 表达式可以是直接文件, 也可以是函数
- 系统变量: $@ $^ $< $?
函数: 处理生成文件
- wildcard 正则表达式: 通配符匹配
- patsubst 目标模式, 匹配模式, 匹配集合 : 匹配集合种符合匹配模式的替换称目标模式
构造用例:
- 目标: make所要生成的目标.
  - 伪目标: 使用.PHONY: 目标名声明伪目标, 伪目标的依赖处理规则一定会执行.
- 目标依赖项:
- 依赖处理规则: 依赖处理规则使用@修饰则不会输出执行的命令

maven

Sat, 14 Aug 2021 00:00:00 +0000

Maven简介

maven是一个项目管理和理解工具, 基于项目对象模型(POM, project object model)提供项目构建、文档、报告、依赖管理等功能。

maven的配置读取

maven会自动根据mvn命令定位MAVEN_HOME的路径值, 查找配置文件顺序是先: 用户配置->全局配置

全局settings.xml: $MAVEN_HOME/conf/settings.xml
用户settings.xml: $HOME/.m2/settings.xml

settings.xml文件结构

settings.xml文件的xml约束

 <?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
 <!--> config your serttings here <-->
</settings>

本地仓库路径配置, 默认使用用户路径${user.home}/.m2/repository

 <localRepository>/path/to/local/repo</localRepository>

交互模式(未理解)

This will determine whether maven prompts you when it needs input. If set to false, maven will use a sensible default value, perhaps based on some other setting, for the parameter in question. Default: true

ER建模

Fri, 01 Oct 2021 00:00:00 +0000

ER概念模型

世界是由一组称作实体(Entity)的基本对象和这些对象之间的联系(Relationship)构成的。

实体

现实世界中客观存在(可以是可触摸的实物, 也可以是无形的虚物)并可相互区分的事物. 实体有两个抽象层次.

具象层实体: 指代具体的一个实体, 具象实体也称为实例. 一个读者, 一个水杯, 一个鼠标, 毛泽东思想等
- 属性: 实体具有的性质(由事物所决定的事实). 性质可以是物理性质(质量\高度)、化学性质(酸性\碱性)、名称、交流、合作等
  - 单一属性与复合属性: 属性不可再分的为单一属性, 否则为复合属性. 例如家庭住址
  - 单值属性与多值属性: 属性值只能取一个的为单值属性, 否则为多值属性. 例如电话号码
  - 导出属性: 该属性能通过其他属性计算得到.
- 属性值: 属性的描述参数叫做属性值, 例如姓名: 张三, 性别:男 , 年龄:18 身高: 169cm, 体重: 60kg , 肤色: 黄种人
- 具象实体的的刻画: 具象概念实体用一个或若干个属性值刻画, 只需列出具象实体所要研究的属性的值即可例如: 实例1(001, 45092XXX, 张三, 男, 18, 169cm, 60kg…..)
抽象层实体: 具有一些相同属性的具象实体的抽象描述, 例如每一个具象读者都有借书证号, 姓名, 年龄, 住址等属性, 将这些具象实体抽象为读者实体.
- 实例: 实例是与抽象实体相对应一个具象实体
- 抽象实体的刻画: 抽象实体用一个或者多个属性刻画, 不需要列出所有属性, 但要求列出一个主键
  - e.g. 读者(借书证号, 身份证号, 姓名,性别, 年龄, 身高, 体重…..)
- 候选键/关键字/码: 指抽象实体的一个属性或者属性组合, 它能唯一标识抽象实体中的每一个实例.
  - e.g. 借书证号和身份证号都是候选键
- 主候选键(或叫主键)/主关键字/主码: 一个抽象实体可以有多个候选键, 但是必须选择唯一一个作为主键. 用下划线标注出来
  - e.g. 身份证号
- 泛化: 对具有相似属性的抽象实体再抽象的过程, 会产生一个更加抽象的一般实体. 一般实体描述了一些共拥有的属性.
  - e.g. 工人(工号, 身份证号, …..)和读者(借书证号, 身份证号, …..)进行抽象, 形成了中国人民(身份证号, …..)实体
- 细化: 对一个抽象实体进行相对详细描述的过程, 会产生一个相对具体的抽象实体或叫分类实体. 分类实体一定要产生与原实体不同的属性, 否则细化是没有意义的
  - e.g. 中国人民(身份证号, …..)可以进行细化医生(医生号, 身份证号, …..)
- 外键(继承属性): 即继承自其他实体关键字的属性. 例如医生的身份证号是继承自中国人民的身份证号
  - 外键的取值必须为NULL或者其他实体的实例的主键值

💡对于实体的理解, 可以参考整数, 我们可以将1说成整数, 也可一说成1,2,3,4,5….是整数, 这里的整数和实体有着十分相似的关系

UML建模

Fri, 01 Oct 2021 00:00:00 +0000

UML简介

事物：
- 结构事物：类、接口、协作、用例、组件、节点
- 行为事物：交互、状态机、活动
- 分组事物：也称组织事物，是UML模型的组织部分，用来组织系统设计的事物
- 注释事物：也称辅助事物，是UML模型的解释部分，用来没描述、说明和标注模型中的任何元素
关系：
- 关联：描述不同类元实例间的连接。关联关系中一种特殊的关系是聚合关系(我中有你的意思)
- 依赖：描述一对模型元素之间的内在联系. 若元素的某些特性受其他元素影响，则这个元素与其他元素构成依赖关系.
- 泛化：类元以便描述与具体描述之间的关系. 一种特殊到一般中的归纳和分类关系.
- 实现：规格说明与其实现元素之间的关系.
机制：
- 规格说明: UML元素背后有一段描述来说明构造模块的语言, 来对元素细节进行描述. 例如类中的属性、操作描述
- 修饰: UML元素大都有唯一直接的图形符号。
- 通用划分: 类型-实例划分、接口-实现划分
- 构造型: 根据已有的模型进行修改和精化, 可以创造出新的模型元素, 如接口元素就是类元素通过<<interface>>声明出来的
- 标记值: 关于模型本身的属性定义, 他一般定义在注释元素中通过属性名=值的方式定义, 如作者属性author=zhangsan
- 约束: 陈述句表达与条件或限制, 通常约束可以附加在任何元素上以表达元素上的额外语义.
UML图:当事物及其关系确定后，需要将模型展示出来，通过UML定义的几个图来实现.
- 结构图：捕获事物间的静态关系，描述系统的静态结构. 类图、对象图、包图、组件图、部署图
- 行为图：捕获事物的交互过程如何产生系统的行为，描述系统的动态行为. 用例图、顺序图、通信图、状态机图、活动图

UML与软件工程

在软件生命周期的各个阶段对软件进行建模, 从不同视角对系统进行解读, 从而形成同一的软件过程叫描述在软件建模的过程中, 常使用的是RUP"4+1"架构方法, 该方法中从7个不同的视角描述系统体系结构: 逻辑视图、开发视图、进程视图、物理视图和场景视图.

逻辑视图: 将系统功能分解, 反映系统组织与协作. 逻辑视图主要对应UML中的类图
开发视图: 描述系统各个模块的组织方式. 开发视图一般由UML中的组件图描述
进程视图: 描述系统的运行特性, 关注性能、稳定性、并发性、集成性. 进程视图一般由UML中的顺序图、通信图、状态机图、协作图描述
物理视图: 描述硬件配置, 关注系统的安装配置通信以及拓扑结构问题. 物理视图一般由UML中的部署图描述
场景视图: 场景视图实际上不包含新内容, 它只是将以上4个视图进行整合, 描述一个特定场景内的构件关系或不同场景间的关系. 场景视图一般由UML中的用例图描述.

用例图

用例即一组动作序列，这些动作序列通常作为服务由特定的参与者触发，将结果反馈给调用者。用例图表示是一个系统中用例与参与者之间的关系的图。

BTRFS

Thu, 01 May 2025 00:00:00 +0000

BTRFS

BTRFS是一个现代的COW(Copy On Write)Linux文件系统，旨在提供现代文件系统提供的高级功能的同时保持高效、高容错和易管理特性。

warning

BTRFS相对于其他成熟稳定的Linux文件系统(e.g. Ext3/Ext4)来说，仍属于一个“十分年轻”的文件系统(尽管这玩意已经发展近15年以上😂)，社区仍在积极开发和验证中。若您正在寻找其他可靠高效的文件系统，您可能对ZFS感兴趣。

写时复制(Copy On Write)

在非写时复制的文件系统中，覆盖一个已存在的数据会对原始数据块进行覆写。而在一个写时复制的文件系统中，文件会使用元数据标记实际物理块，写入已存在数据时会寻找新的可用物理块写入并更改文件元数据指向新物理块，若原始物理块未被任何文件引用则被标记为空闲块以被重新利用。复制这个词可能比较令人迷惑因为整个过程并没有进行文件复制，而仅仅是更新了文件的元数据，但从结果上来看文件的原始物理数据块并没有抹除，相当于对原始数据进行了一次复制然后对复制数据进行了修改😅。

若我们先前存储了文件的原始物理块引用信息可以随时对文件进行恢复，BTRFS正是利用这个特性实现文件快照的。当你对一个文件进行了快照时，原始文件和快照文件都共享同一份物理块引用，当你对快照文件或原始文件进行修改时都会触发上边提到的写时复制机制，若此时需要对原始文件或快照文件进行复原时，只须使用对方的元数据覆盖更新即可。

写时复制的特性很棒，它很灵活而且磁盘空间利用率也非常高，但它也不是十全十美的。针对虚拟机虚拟磁盘这类又大而且读写十分频繁的文件，写时复制的特性会导致这个文件变得十分碎片化，进而影响文件系统的读写性能。值得注意的是，即使是普通文件的读写也存在文件碎片化问题，因为一个文件会是存储在多个物理数据块中的，当文件发生更改时可能仅更新的是文件的部分数据块引用。值得庆幸的是，BTRFS提供了对文件关闭写时复制的方法，但关闭写时复制特性同时也意味着放弃文件快照功能。

info

若对文件进行了快照再关闭文件的写时复制功能时，针对原始文件的修改仍然会触发写时复制特性(因为快照在引用数据)，但对新写入的数据不会触发。

BTRFS子卷(Subvolume)

BTRFS子卷(Subvolume)是一个可挂载的POSIX文件树或POSIX文件命名空间，它属于文件系统层级不属于块设备层级。传统Linux文件系统仅包含一个POSIX文件树，在Linux启动时被挂载到根目录也就是我们熟悉的"/“目录，而BTRFS可以创建多个subvolume子卷，即多个POSIX文件树。当对一个分区进行BTRFS文件系统格式化后，分区默认有一个根或顶层subvolume，ID编号为5，该subvolume不能修改和删除，subvolume内部支持嵌套创建subvolume。以下展示根subvolume下的所有subvolume:


sudo mount /dev/mapper/main /mnt/btrfs
sudo btrfs subvolume list /mnt/btrfs
ID 268 gen 18202 top level 5 path @home
ID 269 gen 18202 top level 5 path @

info

top level N表示该subvolume的上级subvolume的编号为N，编号5代表最顶层subvolume
path XXX表示该subvolume在上级subvolume中的路径，一个subvolume即一个POSIX文件树，subvolume间的文件树是独立的。

按照惯例将根目录和用户目录存储于@和@home两个不同的subvolume以实现隔离快照，将系统安装在BTRFS subvolume上可以实现秒级文件系统级别系统回滚。《秒级文件系统级别系统回滚》这几个字的含金量不必我多说并且支持系统从快照中启动，系统安全问题？不存在的。Linux在启动时会使用类似以下方式挂载subvolume到根目录和用户目录：

Firewalld

Mon, 05 May 2025 00:00:00 +0000

Firewalld

firewalld是一个红帽公司开源的防火墙守护进程，它是内核数据包分类框架nftable的一个前端应用，常用的前端框架例如ufw。

动态防火墙规则管理，防火墙规则的修改无需重启防火墙进程即可生效，且应用服务不会中断。
运行时配置和持久化配置分开配置。运行时配置的修改立即生效，持久化配置的修改重载后生效，运行时配置将在下一次启动时被覆盖。
基于连接(Connection)或接口(Interface)信任等级划分的防火墙区域(Zone)管理。
基于服务(Service)和应用(Application)的防火墙规则配置。
支持IPv4和IPv6防火墙设置。

区域(Zone)

防火墙区域定义了连接(Connection)或接口(Interface)或来源(Source)的信任等级，区域和连接与接口之间是一对多的关系。防火墙针对区域遵循以下原则：

流量的入口仅有一个区域，意味着一个数据包不可能同时来自多个区域。
流量的出口仅有一个区域，意味着一个数据包不可能同时去往多个区域。
防火墙区域定义了来源的信任等级。
区域内部的流量转发默认允许。
区域间的流量转发默认拒绝。

原则4和原则5是原则3的结果。原则4可以通过区域的--remove-forward选项移除，原则5可以通过区域间的防火墙规则配置。

firewalld预定义的几个防火墙区域，在连接或接口未指定区域时，默认为public区域。

drop: 丢弃所有入站流量并且不进行应答，允许出站流量。
block: 拒绝所有入站流量并进行ICMP应答，仅允许系统定义的出站流量。
public: 仅接受系统定义的入站流量，firewalld默认的连接或接口区域。
external: 仅接受系统定义的入站流量，出站流量默认进行NAT地址伪装。
dmz: 仅接受系统定义的入站流量，并限制该区域访问internal区域的行为。
work: 仅接受系统定义的入站流量，代表您信任该区域的流量。
home: 和work一致，仅用作区分。
internal: 和work一致，仅用作区分。
trusted: 接受所有入站流量，代表您完全信任该区域所有流量。


sudo firewall-cmd --info-zone=public

public (default, active)
 target: default
 ingress-priority: 0
 egress-priority: 0
 icmp-block-inversion: no
 interfaces: enp5s0f3u1u4c2
 sources: 
 services: audio-share dhcpv6-client kdeconnect ssh sunshine vnc-server
 ports: 
 protocols: 
 forward: yes
 masquerade: no
 forward-ports: 
 source-ports: 
 icmp-blocks: 
 rich rules:

sudo firewall-cmd --info-zone=dmz

dmz
 target: default
 ingress-priority: 0
 egress-priority: 0
 icmp-block-inversion: no
 interfaces: 
 sources: 
 services: ssh
 ports: 
 protocols: 
 forward: yes
 masquerade: no
 forward-ports: 
 source-ports: 
 icmp-blocks: 
 rich rules:

规则(Rule)

规则分为区域规则(Zone Rule)和防火墙规则(Firewall Rule)。区域规则用于管控区域访问运行防火墙主机的行为(iptable中的Input行为)，防火墙规则用于管控区域间数据转发行为(iptable中的Forward行为)。

网络命名空间

Mon, 12 May 2025 00:00:00 +0000

网络命名空间(Network Namespace)

网络命名空间提供一个网络资源隔离空间，它包含自己的网络设备、IPv4和IPv6协议、ip路由表、ip路由规则以及防火墙规则。除了网络资源的隔离，应用程序视角下/proc/net目录也是针对当前的命名空间而言的。

任何物理网络设备只能处在一个网络命名空间中，当该网络命名空间中最后一个程序运行退出而导致命名空间销毁时，物理设备会退回到初始网络命名空间。


# add network namespace
ip netns add <namespace-name>

# delete network namespace
ip netns delete <namespace-name>

虚拟以太网对(Veth Pair)

虚拟以太网适配器对即一对软件实现的以太网适配器，虚拟以太网对总是成对出现的，用于连接Linux下两个不同的网络命名空间。

可以类比两台物理电脑的两个物理以太网适配器，这两个以太网适配器的职责就是将两台电脑连接起来。

通过以下命令可以创建虚拟以太网适配器对，创建完成后通ip link将可以看到两个以太网适配器，他们的名字后的@xxx即表示对端名字。


# add veth pair
ip link add <veth-name> type veth peer name <peer-veth-name>

# delete veth pair
ip link delete <veth-name> type veth peer name <peer-name>

通过以下命令可以将虚拟以太网适配器移动到指定的网络命名空间：


ip link set <veth-name> netns <namespace-name>

虚拟网桥

Mon, 12 May 2025 00:00:00 +0000

虚拟网桥简介

网桥是一类用于转发两个以上网络数据包的设备。Linux可以通过软件实现虚拟网桥功能，虚拟网桥充当一个虚拟交换机的角色对应用而言是透明的，任何物理接口(e.g. eth0)和虚拟接口(e.g. tap0)可以连接虚拟网桥。

warning

当接口添加到网桥后，原接口将作为二层链路接入网桥并失去路由功能，原接口的网络层功能将由网桥接替。请确认当前是否是通过该接口进行远程主机访问的，接入虚拟网桥后将导致网络连接断开。

虚拟网桥管理

通过iproute2管理


# create bridge device
ip link add name <bridge-name> type bridge

# bring bridge device up
ip link set dev <bridge-name> up

# attach interface
ip link set <dev> master <bridge-name>

# dettach interface
ip link set <dev> nomaster <bridge-name>

# delete bridge device
ip link delete bridge_name type bridge



ls -al /sys/class/net/vmbr0/brif/
total 0
drwxr-xr-x 2 root root 0 Apr 25 14:06 .
drwxr-xr-x 7 root root 0 Apr 12 21:42 ..
lrwxrwxrwx 1 root root 0 Apr 25 14:06 enp3s0 -> ../../../../pci0000:00/0000:00:02.1/0000:03:00.0/net/enp3s0/brport
lrwxrwxrwx 1 root root 0 Apr 25 14:06 tap205i0 -> ../../tap205i0/brport
lrwxrwxrwx 1 root root 0 Apr 25 14:06 veth101i0 -> ../../veth101i0/brport
lrwxrwxrwx 1 root root 0 Apr 25 14:06 veth105i0 -> ../../veth105i0/brport
lrwxrwxrwx 1 root root 0 Apr 25 14:06 veth105i1 -> ../../veth105i1/brport
lrwxrwxrwx 1 root root 0 Apr 25 14:06 veth110i0 -> ../../veth110i0/brport

info

特别提示：

Ansible简介

Wed, 14 May 2025 00:00:00 +0000

Ansible

Ansible是一个简单的IT自动化工具，通过编写"剧本"的方式固定一个部署流程，Ansible会通过SSH的方式登陆目标主机完成剧本指定的部署任务。Ansible内置很多常用模块(例如shell、copy和file)来定制剧本步骤，此外社区也提供了很多常用应用的处理模块(例如postgres、mysql、docker)。

Ansible架构上分为三部分:

控制节点(Control Node): 即安装了Ansible应用程序的主机，可以运行ansible、ansible-playbook命令。
库存(Inventory): 即逻辑组织起来的被控节点列表。
被控节点(Managed Node): 被Ansible控制的远程主机节点。

构建库存(Inventory)

库存即一个维护远程被控节点的列表文件，官方指示的文件结构如下所示，可以在库存文件中指定特定主机或特定主机组的变量。在Playbook中引用该主机时可以直接使用这些变量。


webservers:
 hosts:
 webserver01:
 ansible_host: 192.0.2.140
 http_port: 80
 webserver02:
 ansible_host: 192.0.2.150
 http_port: 443
 # group vars
 vars:
 ansible_user: my_server_user



[webservers]
webserver01 ansible_host=192.0.2.140 http_port=80
webserver02 ansible_host=192.0.2.150 http_port=443

# group vars
[webservers:vars]
ansible_user=my_server_user

默认的库存配置文件路径是/etc/ansible/hosts，当然也可以通过ansible -i <path>指定库存文件路径。

Docker简介

Wed, 14 May 2025 00:00:00 +0000

Docker简介

Dokcer是一个用于应用打包和运输并运行为轻量级容器的工具。它能将应用运行时打包在一起，然后在Linux上直接运行，免去传统裸部署带来的软件依赖管理问题。

Dockerfile

🍉FROM指令

FROM指令指示构建的基础镜像。Docker文档指出，一个有效的dockerfile必须从FROM开始，任何有效的镜像都可作为基础镜像。


FROM [--platform=<platform>] <image>[:<tag>|@<digest>] [AS <name>]

🍉ADD指令

ADD指令添加本地或远程的文件或文件夹到镜像中。ADD指令支持通过HTTP/HTTPS和GIT的方式下载文件并添加到镜像中，压缩包自动解压缩。


ADD <OPTIONS> <src> ... <dest>

# required for paths containing whitespace
ADD <OPTIONS> ["<src>", ... "<dest>"]

Docker网络

Wed, 14 May 2025 00:00:00 +0000

Docker网络

Docker网络一共6种类型，下面列举的常用4种类型：

none: 彻底隔离容器网络。
bridge: 创建网桥网络，并通过虚拟以太网适配器对连接到网桥。
host: 容器共享主机网络命名空间。
macvlan: 分配Mac地址给容器。


# create external control network
docker network create -d [none|bridge|host|macvlan] <network-name>

Bridge网络

容器网络配置

在bridge网络下，docker会创建一个虚拟以太网适配器对，一个连接主机的bridge虚拟网桥，一个移动到容器的网络命名空间。docker会自动根据网络的网段定义给容器一端的虚拟以太网适配器分配ip地址，并自动配置默认网关指向bridge虚拟网桥。

下面展示了一个容器内部的网络配置，可以看到分配了ipv4地址172.16.0.3/16，以及默认网关172.16.0.1，此外eth0@if148表明对端接口序号为148。


ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN qlen 1000
 link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
 inet 127.0.0.1/8 scope host lo
 valid_lft forever preferred_lft forever
 inet6 ::1/128 scope host 
 valid_lft forever preferred_lft forever
147: eth0@if148: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue state UP 
 link/ether 02:42:ac:10:00:03 brd ff:ff:ff:ff:ff:ff
 inet 172.16.0.3/16 brd 172.16.255.255 scope global eth0
 valid_lft forever preferred_lft forever
ip route 
default via 172.16.0.1 dev eth0 
172.16.0.0/16 dev eth0 scope link src 172.16.0.3

通过Hugo搭建静态网站

Tue, 18 Jun 2024 00:00:00 +0000

静态网站简介

notifications

A static website has fixed content It does not require programming languages to build one. It is the easiest form of website to create. Static websites are build of HTML, CSS, and JavaScript.

引用W3Schools对静态网站的定义——静态网站具有固定内容，不需要编程语言来构建，它是最容易创建的一种网站形式，由HTML、CSS和JavaScript构建而成。静态网站不需要设置数据库也不需要编写任何服务器程序，只需编写前端页面，然后部署到类似于Nginx之类的Web服务器分发静态文件即可。常见的静态网站构建框架有以下几种：

不同的博客框架都有各自的优缺点，其中Hugo号称全世界最快的静态网站构建框架，背后使用Go作为处理语言，适合用于生成拥有大量复杂页面的静态网站，本文基于Hugo以及Hinode主题为例，解析如何编写属于自己的静态网站，最后通过Netlify云服务提供商免费将自己的静态网站发布到互联网上。

RubitCat

播放器

文档总览

博客总览

音乐概览

日语精选

英语精选

中文精选

基础概念

数据类型 link

变量与常量 link

表达式

表达式 link

表达式的结果 link

运算符 link

函数

函数 link

变量的作用域 link

声明和定义 link

虚拟内存地址

虚拟地址空间 link

内核地址空间 link

用户地址空间 link

预处理器

预处理器指令 link

include指令 link

define指令 link

ifdef指令 link

数据编码

字符编码与存储编码 link

ANSI(ASCII)编码集 link

UCS字符集 link

转义字符 link

stdlib

1. stdlib.h link

1.1 数据结构 link

1.2 函数 link

stdio

1. stdio.h link

1.1 数据结构 link

1.2 函数 link

string

1. string.h link

1.1 数据结构 link

1.2 函数 link

基础概念

数据类型差异 link

原始类型增强 link

新增类型 link

表达式差异 link

新增特性 link

封装

封装概述 link

C++类 link

类的组成 link

构造函数 link

继承

继承概述 link

C++类继承 link

单继承 link

多继承 link

虚继承 link

多态

多态概述 link

C++多态 link

函数重载 link

运算符重载 link

异常

异常概述 link

C++异常 link

泛型

泛型概述 link

C++泛型 link

函数模板 link

类模板 link

cpp11

1. C++11特性 link

1.1 Lambda表达式 link

1.2 右值引用 link

2. 编译器优化 link

数据类型

变量与常量

表达式

表达式的结果

运算符

函数

变量的作用域

声明和定义

虚拟地址空间

内核地址空间

用户地址空间

预处理器指令

include指令

define指令

ifdef指令

字符编码与存储编码

ANSI(ASCII)编码集

UCS字符集

转义字符

1. stdlib.h

1.1 数据结构

1.2 函数

1. stdio.h

1.1 数据结构

1.2 函数

1. string.h

1.1 数据结构

1.2 函数

数据类型差异

原始类型增强

新增类型

表达式差异

新增特性

封装概述

C++类

类的组成

构造函数

继承概述

C++类继承

单继承

多继承

虚继承

多态概述

C++多态

函数重载

运算符重载

异常概述

C++异常

泛型概述

C++泛型

函数模板

类模板

1. C++11特性

1.1 Lambda表达式

1.2 右值引用

2. 编译器优化

STL简介

容器模板

string

1. istream

1.1 成员变量

1.2 成员函数

2. ostream

2.1 成员变量

2.2 成员函数

2. ifstream

1. event简介

2. event2/event

2.1 数据结构

2.2 函数

3. event2/bufferevent

3.1 数据结构

3.2 函数

1. unistd.h

1.1 数据结构

1.2 函数

2. sys/mmap.h

2.1 数据结构

2.2 函数

3. sys/shm.h