最近在学习OpenGL，对其使用的坐标系有些不了解，后面查资料发现在3D空间中，有左右手坐标系的区别，为了弄清这两种坐标系的区别，于是写下这篇文章方便日后回顾查看。

一、三维坐标系

做3D特效时，就要用到三维坐标系，这是后人在笛卡尔的平面坐标系的基础上发明的。三维坐标系分两种，左手坐标系和右手坐标系，为什么用左手和右手来区分呢？这是因为当确定了x轴，y轴方向之后,z轴的方向的两种，它可以通过左手或右手来确定。下面就是这两个坐标系的规则示意图（图中固定了x轴的正方向向右，y轴的正方向向上）：

相信大多数人对图中的右手坐标系很眼熟，没错，这就是初高中数学教材用到的三维坐标系，只是我们不一定知道它叫右手坐标系。左手坐标系我们之前很少接触，但是在计算机图形学中这种坐标系非常重要，比如iOS的UIView使用的坐标系就是左手坐标系。有人可能会说，不对吧，UIView的坐标系是原点在左上角，y轴正方向向下，图中的不是这样啊，其实没错啦，把图中的左手坐标系沿x轴旋转180度就是原点在左上角的左手坐标系，区别就是旋转的角度不同而已。这是因为左手坐标系或者右手坐标系整体旋转后性质是不变的。

对坐标系使用左手与右手的命名，有一个作用就是用来方便判断旋转的正方向，这就是左手法则和右手法则。例如对左手坐标系，确定一个旋转轴后，左手握住拳头，拇指指向旋转轴的正方向，四指弯曲的方向为旋转的正方向。相应地，右手坐标系就用右手来判定。确定了旋转的正方向后，在公式计算中就很容易知道是该使用正角度还是负角度了。下图就是右手的例子：

其实，完全没必要这么麻烦。先看第一个图的两个坐标系，左边的为左手坐标系，右边的为右手坐标系，两坐标系的x轴和y轴正方向保持一致，z轴正方向相反。分别用左手法则与右手法则去判断它们各自绕z轴旋转的正方向，那么从我们眼睛看屏幕的角度来看，它们绕z轴旋转的正方向都是逆时针，这当然不会是巧合。观察这两个坐标系，就会发现这个逆时针方向与x轴正方向箭头顶点指向y轴正方向箭头顶点的方向一致，这说明绕z轴旋转的正方向与x轴正方向箭头顶端指向y轴正方向箭头顶端的方向有关联吗？我想是的。然后再尝试判断两坐标系绕x轴旋转的正方向，它与y轴正方向顶端指向z轴正方向顶端的方向一致；而绕y轴旋转的正方向，与z轴正方向顶端指向x轴正方向顶端的方向一致。

二、结论

1.结论1

根据上述分析，我们可以得出一个结论：对于任意旋转角度的三维坐标系，绕某一坐标轴旋转的正方向，与另外两个坐标轴的正方向顶端按X—>Y—>Z—>X的顺序进行指向的方向一致。

这就意味着，判断三维坐标系绕某一坐标轴旋转的正方向，不用事先知晓这个坐标系是左手坐标系还是右手坐标系，完全不需要你用手去比划.反过来，既然判断旋转正方向这么容易，我们也可以利用它来快速判断一个坐标系是左手坐标系和右手坐标系：使用上述结论确定坐标系绕某一某旋转的正方向，然后逆用左手法则与右手法则，大拇指指向该轴的正方向，如果左手四指弯曲的方向与旋转的正方向一致，该坐标系就是左手坐标系，反之就是右手坐标系。

不过这还是复杂，还是需要用手比划。有一个更好的方法是：想象y轴是一面墙，你面朝前方斜靠在墙上，可以假设你的头部为y轴正方向顶点，脚为x轴正方向顶点，那么z轴在你的左侧时就是左手坐标系，在右侧时就是右手坐标系。这个时候，人体的生长方向也刚好是绕z轴旋转的正方向。

2.结论2

再扩展一下就是：对于任意旋转角度的三维坐标系，想象你的脚踩在一个坐标轴（如x轴）正方向的顶点，头倚靠在其邻高坐标轴（如y轴）的正方向顶点，面朝背离原点的方向，那么，第三轴正方向顶点在你的左手边时，这个坐标系就是左手坐标系，在右手边时就是右手坐标系，而人体此时的生长方向就是绕第三轴(如z轴)旋转的正方向。（注：这里的邻高坐标轴是我自己定义的一个概念，X轴的邻高坐标轴为Y轴，Y轴的邻高坐标轴为Z轴，Z轴的邻高坐标轴为X轴.）

Mac如何连接寝室里充当远程服务器的Windows端？经过自己将近两天的捣鼓，终于把这个问题解决了。感谢Chat GPT、感谢千问，在搭建连接的过程中给予了我莫大的支持。由于过程颇为繁琐，为了以后遇到类似问题自己能够有所参考，于是趁着期末周仅有的休息时间，写下这篇文章，若有差错的地方，恳请海涵指正。

一、写在前面

1.部署方式

大学的校园网通常是禁止路由器端口转发的，因此要想实现公网电脑远程连接内网服务端电脑就需要使用FRP技术进行内网穿透。基本原理为:

• 云服务器作为中转；
• Windows在内网运行SSH服务；
• Mac通过SSH连接Windows；
• FRP实现内网穿透。

2.相关环境

• 阿里云服务器：1.CPU&内存-2核(vCPU) 2GiB; 2.操作系统: Ubuntu 20.04 64位; 3.公网带宽: 3Mbps
• Windows系统：Win11
• Mac系统：macOS 15.7.3
• FRP版本：frp_0.54.0_linux_amd64(云服务器上)与frp_0.54.0_windows_amd64(Windows机上)

二、搭建步骤

1.云服务器端(FRPS服务端)

在Mac终端或者其他SSH服务端(如Xshell)输入如下代码：

1
2
3
4
5
6
7
8
9
10
11

# 登录云服务器端
ssh root@云服务器公网IP

# 安装基础工具
sudo apt update && sudo apt install -y wget tar

# 下载并解压FRP
wget https://github.com/fatedier/frp/releases/download/v0.54.0/frp_0.54.0_linux_amd64.tar.gz
tar -zxvf frp_0.54.0_linux_amd64.tar.gz
mv frp_0.54.0_linux_amd64 frp
cd frp

默认情况下，FRP保存在/root/目录下。

接着在终端输入指令sudo nano frps.toml创建frps.toml安全配置文件。文件内容如下：

1
2
3
4

# [server]
bindPort = 7000 # 固定端口，无需修改
auth.method = "token"
auth.token = "strong_password" # 设置连接密码

再在终端输入指令sudo nano /etc/systemd/system/frps.service配置开机自启文件，文件内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[Unit]
Description=frp server
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/frp
ExecStart=/root/frp/frps -c /root/frp/frps.toml
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

最后启动FRP服务，终端指令如下：

1
2
3
4
5
6
7

# 启动服务
sudo systemctl daemon-reload
sudo systemctl start frps
sudo systemctl enable frps

# 检查状态
sudo systemctl status frps  # 看到 active (running) 即成功

到此，云服务器上的相关配置文件就配好了。

不过云服务器还有最后一个操作，就是设置安全组允许6000端口、7000端口以及7500端口开放。具体路径为：控制台->云服务器ECS->安全组->管理规则。在入方向增加规则，其中授权策略选择“允许”，优先级选择“1”，协议选择“自定义TCP”，访问来源选择“任何位置”，访问目的设置为“6000”、“7000”以及“7500”。设置完成后可在终端输入命令sudo netstat -tulpn | grep 7000，若有“… Listen …/frps”内容输出，则证明设置成功。

2.Windows配置(FRPC客户端)

下载frp_0.54.0_windows_amd64.zip并解压到指定文件夹，以E:\frp为例。
接着进入E:\frp文件夹中创建frpc.toml，该文件内容如下：

1
2
3
4
5
6
7
8
9
10
11
12

serverAddr = "云服务器公网IP"
serverPort = 7000 # 固定端口，无需修改

auth.method = "token"
auth.token = "strong_password" # 必须同云服务器端的frps.toml文件一致

[[proxies]]
name = "ssh_windows" # 随意取
type = "tcp"
localIP = "127.0.0.1" # 固定ip，无需修改
localPort = 22
remotePort = 6000 # 云服务器映射端口，无需修改

完成上述文件配置后，以管理员身份启动终端输入指令cd E:\frp和.\frpc.exe -c frpc.toml，若出现“login to server success”和“start proxy success”则表示配置成功。

此外可能还需要配置OpenSSH服务的config文件信息，该文件路径为C:\ProgramData\ssh\sshd_config，其中“ProgramData”在Windows中是隐藏文件，需要手动开启。打开sshd_config文件后进行如下修改PasswordAuthentication yes以及PubkeyAuthentication yes，设置完成后再进行SSH连接时就可以支持Windows用户密码验证了。

3.Mac端

当云服务端和Windows端配置没有问题后，在Mac终端输入指令ssh Windows用户名@云服务器公网IP即可进行连接。如果想在vs code中进行远程连接，则需要在.ssh\config文件中配置如下信息：

1
2
3
4

Host 终端名称
    HostName 云服务器公网IP
    User Windows用户名
    Port 6000

其中Host名随意。设置好以后即可在vscode中进行远程终端连接，前提是vs code下载了SSH Remote插件。

三、最后的话

在实际配置过程中，不同人会遇到不同的问题，若出现了本文章之外的状况，可以借助AI辅助一下，我相信只要不放弃，总有解决的那一天。

最近又开始使用Git工具部署项目了，太久没用很多基本的语法都忘记了，再加上自己博客也好久没更新文章了。于是乎，接着这个机会就对Git知识进行一次总结吧。

一、前言

1.Git工作流程

Git工作区域可以分为四个：①远程仓库；②本地仓库；③暂存区；④Workspace(即本地项目文件夹)。通过使用Git相关指令可以实现本地项目上传至远程仓库，也可以实现从远程仓库中拉项目到本地文件夹中，具体流程图如下：

2.Git文件状态

Git文件拥有4种状态：
1.Untracked: 这代表此文件在Workspace中但并未加到暂存区中；
2.Unmodified: 这代表该文件已加入到本地仓库且此文件版本与Workspace中文件版本一致。可使用git rm --cached <fileName>命令将其仅从本地仓库中删除，但是不会影响工作区间中的原文件。
3.Modified: 这代表该文件版本已改变但并未放入暂存区中。此时有两种操作：①使用git add <fileName>命令将其放入暂存区；②使用git restore <fileName>命令将本地仓库中前版本同名文件调出进而对Workspace中的同名文件进行覆盖(即丢弃当前修改)。
4.Staged: 这代表此文件已经放入暂存区中。此时仍有两种操作：①使用git commit -m "Tips"将其放入本地仓库中，此时本地仓库文件和工作区文件版本一致，此文件状态将转换为Unmodified；②使用git reset <fileName>命令取消暂存，此时Workspace同名文件状态转化为Modified。

3.忽略文件

Git中忽略文件名为.gitignore，位于Workspace中。其用途简单来说就是避免不必要的文件上传至远程仓库中。.gitignore文件规则如下：

• 忽略文件中的空行或以“#”开始的行会被忽略；
• 可以使用Linux通配符。例如，“*”代表任意多字符、“？”代表一个字符、“[]”代表可选字符范围、“{}”代表可选字符串等；
• 若名称的最前面有“!”，表示例外规则，将不被忽略；
• 若名称的最前面有“/”，表示要忽略的文件或文件夹在此目录下，而其它子目录下的同名文件或文件夹则不会被忽略；
• 若名称的最后有“/”，表示要忽略所有目录下的同名目录，同名文件则不会忽略。

注意: “temp/*.txt”则代表忽略所有”temp/“目录下直属txt文件，但是”temp/sub/“中的txt文件则不会被忽略。

二、使用流程

1.初始化工作间(Workspace)

1
2
3
4
5
6
7
8

# 在当前目录新建一个Git代码库
$ git init

# 新建一个目录，将其初始化为Git代码库
$ git init [project-name]

# 下载一个项目和它的整个代码历史
$ git clone [url]

2.全局配置

首先要进行SSH Key配置。只有在远端仓库添加了本地生成的SSH Key才能实现在本地与远端仓库的文件拉取。

1
2
3
4
5

# 1.生成本地SSH Key
$ ssh-keygen -t rsa -C "邮箱地址"

# 2.查看本地SSH Key， 通常在"C/users/用户名/.ssh/"文件夹中，之后再把此文件内容粘贴到远程仓库中
$ cat ~/.ssh/id_rsa.pub

Git的设置文件为.gitconfig，它可以在用户主目录下(全局配置)，也可以在项目目录下(项目配置)。

1
2
3
4
5
6
7
8
9

# 显示当前的Git配置
$ git config --list

# 编辑Git配置文件
$ git config -e [--global]

# 设置提交代码时的用户信息
$ git config [--global] user.name "用户名"
$ git config [--global] user.email "邮箱地址"

3.项目提交

1
2
3
4
5
6
7
8
9
10
11

# 将项目所有文件(.)添加至暂存区
$ git add .

# 将项目指定文件或文件夹添加至暂存区
$ git add fileName1 fileName2 ...

# 将暂存区文件添加至本地仓库
$ git commit -m "备注内容"

# 将文件推送至远程仓库，常用命令“git push origin main”
$ git push 远程仓库名 分支名

三、其它常用命令

1.分支操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 列出所有分支
$ git branch

# 列出所有远程分支
$ git branch -r

# 新建一个分支但仍然要停留在当前分支
$ git branch 分支名

# 新建一个分支并切换到新分支
$ git checkout -b 分支名

# 合并指定分支到当前分支
$ git merge 指定分支名

# 删除分支
$ git branch -d 分支名

# 删除远程分支
$ git push origin --delete 远程分支名 || git branch -dr 远程仓库/分支名

2.远程同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 显示当前origin所指向的远程仓库
$ git remote -v

# 更改origin所指向的远程仓库
$ git remote set-url origin 新远程仓库地址

# 显示某个远程仓库的信息
$ git remote show 远程仓库

# 上传本地指定分支到远程仓库
$ git push 远程仓库 本地分支名

# 强行推送当前分支到远程仓库
$ git push 远程仓库 --force

3.其它

详情请见网址Git 大全 - Gitee.com

自己在使用CLion集成环境编写C++程序时发现其自动生成了CMakeLists.txt文件，通过查阅相关资料发现其跟CMake有关，于是便写下这篇文章进行相关知识记录方便自己复习。

一、前言

CMake是一个支持跨平台的项目构建工具。另外还有一个更为人熟知的项目构建工具——Makefile(通过make命令进行项目的构建)，然而大多数IDE软件都集成了Make，比如：Visual Code的nmake、Linux下的GNU make以及QT的QMake等。Makefile通常依赖于当前的编译平台，有时程序员编写Makefile工作量会比较大且解决依赖关系时也容易出错。而CMake恰好能解决上述问题，其允许开发者指定整个工程的编译流程，再根据编译平台，自动生成本地化的Makefile和工程文件，最后用户只需要make编译即可。其编译流程如下图：

• 蓝色虚线表示使用Makefile构建项目的过程
• 红色实现表示使用CMake构建项目的过程

二、CMake的使用

CMake支持大写、小写以及混合大小写的命令。如果在编写CMakeLists.txt文件时使用的工具有对应的命令提示，那么大小写随缘即可，无需太过在意。

2.1 注释

• 注释行：CMake中使用#实现行注释，可以放在任何位置
• 注释块：CMake中使用#[[]]实现块注释

1
2
3
4
5
6
7

# 这是一个CMakeLists.txt文件
cmake_minimum_required(VERSION 3.0.0)

#[[这是一个CMakeLists.txt文件
这是一个CMakeLists.txt文件
这是一个CMakeLists.txt文件]]
cmake_minimum_required(VERSION 3.0.0)

2.2 CMakeLists.txt文件编写

假设源文件夹中文件结构如下：

1
2
3
4
5
6
7
8

$ tree
.
├── add.c
├── div.c
├── head.h
├── main.c
├── multi.c
└── sub.c

2.2.1 生成的配置文件不单独放入源文件夹中的子文件中

在上述源文件夹中添加CMakeLists.txt。文件内容如下：

1
2
3

cmake_minimum_required(VERSION 3.0)
project(CALC)
add_executable(app add.c div.c main.c multi.c sub.c)

上述文件中三个命令含义如下：

• cmake_minimum_required: 指定使用的CMake最低版本。(改命令可选，若不加可能会有警告!)
• project: 定义工程的名称并可指定工程的版本、工程描述、web主页地址、支持的语言(默认支持所有的语言)。若不需要则可省略，只需指定出工程名即可。
• add_executable: 定义工程生成的可执行程序名字。(这里的可执行程序名字与项目名字无关)

上述命令官方语法如下:

1
2
3
4
5
6
7
8
9
10
11
12

# PROJECT 指令的语法是：
project(<PROJECT-NAME> [<language-name>...])
project(<PROJECT-NAME>
       [VERSION <major>[.<minor>[.<patch>[.<tweak>]]]]
       [DESCRIPTION <project-description-string>]
       [HOMEPAGE_URL <url-string>]
       [LANGUAGES <language-name>...])
add_executable(可执行程序名 源文件名称)
# 样式1
add_executable(app add.c div.c main.c multi.c sub.c)
# 样式2
add_executable(app add.c;div.c;main.c;multi.c;sub.c)

Ps: 源文件名称可以有多个，若有多个可用空格或;隔开
在控制台执行cmake CMakeLists.txt文件所在路径后，CMakeLists.txt中的命令就会被执行。执行之后，源文件夹中的文件结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

$ tree -L 1
.
├── add.c
├── CMakeCache.txt         # new add file
├── CMakeFiles             # new add dir
├── cmake_install.cmake    # new add file
├── CMakeLists.txt
├── div.c
├── head.h
├── main.c
├── Makefile               # new add file
├── multi.c
└── sub.c

可以看见在对应目录下生成了一个Makefile文件，这时再在控制台中执行make命令就可以对项目进行构建得到所需要的可执行程序了。结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

$ make
Scanning dependencies of target app
[ 16%] Building C object CMakeFiles/app.dir/add.c.o
[ 33%] Building C object CMakeFiles/app.dir/div.c.o
[ 50%] Building C object CMakeFiles/app.dir/main.c.o
[ 66%] Building C object CMakeFiles/app.dir/multi.c.o
[ 83%] Building C object CMakeFiles/app.dir/sub.c.o
[100%] Linking C executable app
[100%] Built target app

# 查看可执行程序是否已经生成
$ tree -L 1
.
├── add.c
├── app# 生成的可执行程序
├── CMakeCache.txt
├── CMakeFiles
├── cmake_install.cmake
├── CMakeLists.txt
├── div.c
├── head.h
├── main.c
├── Makefile
├── multi.c
└── sub.c

最终可执行程序app就被编译出来了，其名字由CMakeLists.txt中指定。

2.2.2 生成的配置文件单独放入源文件夹中的子文件中

在上面的例子中，若CMakeLists.txt文件所在目录执行了cmake命令之后就会生成一些目录和文件(包括makefile)文件。若再基于makefile文件执行make命令，程序在编译过程中还会产生一些中间文件和可执行文件，这样会导致整个项目目录看起来很混乱，不太容易管理和维护，此时我们就可以把生成的这些与项目源码无关的文件统一放到一个对应的目录里边，通常将整个目录命名为build。执行代码以及执行结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$ mkdir build
$ cd build
$ cmake ..
-- The C compiler identification is GNU 5.4.0
-- The CXX compiler identification is GNU 5.4.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/robin/Linux/build

在上面的代码中，首先创建了一个目录build并进入至该目录中，然后再再build目录中执行cmake命令，由于CMakeLists.txt文件中build的上级目录中，因此执行Shell指令为cmake ..。(..代表当前目录的上级目录)
当上述命令执行完毕后，在build目录中会生成一个makefile文件。该目录下的文件结构如下:

1
2
3
4
5
6
7
8
9

$ tree build -L 1
build
├── CMakeCache.txt
├── CMakeFiles
├── cmake_install.cmake
└── Makefile

1 directory, 3 files

这样就可以在build目录中执行make命令编译项目，生成的相关文件自然也就被存储到build目录中了。

2.3 进阶语法

在上面的例子中一共提供了5个源文件，假设这五个源文件需要被反复使用，每次都直接将它们的名字写出来比较麻烦，这时我们需要定义一个变量，该变量可将这些文件名存储起来，在CMake中定义变量需要使用关键字set。

1
2
3

# SET指令语法：
# []中的参数为可选项
SET(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])

• VAR: 变量名
• VALUE: 变量值

1
2
3
4
5
6

# 方式一: 各个源文件之间使用空格间隔
# set(SRC_LIST add.c div.c main.c multi.c sub.c)

# 方式二: 各个源文件之间使用分号;间隔
set(SRC_LIST add.c;div.c;main.c;multi.c;sub.c)
add_executable(app ${SRC_LIST})

2.3.1 指定使用C++标准

在编写C++程序时可能会用到C++11、C++14、C++17、C++20等新特性，那么就需要在编译的时候指定出要使用哪个标准：g++ *.cpp -std=c++11 -o app。此命令通过-std=c++11指定出要使用C++11编译程序，C++标准对应有一宏叫做DCMAKE_CXX_STANDARD。在CMake中想要指定C++有两种方式：

• 方式一：在CMakeLists.txt中通过set命令指定

  1 2 3 4 5 6

  # 增加-std=c++11 set(CMAKE_CXX_STANDARD 11) # 增加-std=c++14 set(CMAKE_CXX_STANDARD 14) # 增加-std=c++17 set(CMAKE_CXX_STANDARD 17)

• 方式二：在执行cmake命令时指定出这个宏的值

  1 2 3 4 5 6

  #增加-std=c++11 cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=11 #增加-std=c++14 cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=14 #增加-std=c++17 cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=17

2.3.2 指定输出的路径

在CMake中指定可执行程序输出的路径，也对应一个宏叫做EXECUTABLE_OUTPUT_PATH，它的值还是通过set命令进行设置。

1
2

set(HOME /home/robin/Linux/Sort)
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin)

• 第一行：定义一个变量用于存储一个绝对路径。
• 第二行：将拼接好的路径值设置给EXECUTABLE_OUTPUT_PATH`宏。（若这个路径的子目录不存在则会自动生成）
  由于可执行程序是基于 cmake 命令生成的 makefile 文件然后再执行 make 命令得到的，所以如果此处指定可执行程序生成路径的时候使用的是相对路径 ./xxx/xxx，那么这个路径中的 ./ 对应的就是 makefile 文件所在的那个目录。

2.3.3 搜索文件

若一个项目里边的源文件很多，在编写CMakeLists.txt文件的时候不可能将项目目录的各个文件一一罗列出来。在CMake中提供了文件搜索命令，可以使用aux_source_directory命令或者file命令。

• 方式一：在CMake中使用aux_source_directory命令可以查找某个路径下的的所有源文件。

  1	aux_source_directory(<dir> <variable>)

• dir: 要搜索的目录
• variable: 将从dir目录下搜索到的源文件列表存储到该变量中

1
2
3
4
5
6
7

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
# 搜索 src 目录下的源文件
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src SRC_LIST)
add_executable(app  ${SRC_LIST})

• 方式二：采用file命令

  1	file(GLOB/GLOB_RECURSE 变量名 要搜索的文件路径和文件类型)

• GLOB: 将指定目录下搜索到满足条件的所有文件名生成一个列表并将其存储到变量中。
• GLOB_RECURSE: 递归搜索指定目录，将搜索到的满足条件的文件名生成一个列表并将其存储到变量中。

1
2
3

file(GLOB MAIN_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
file(GLOB MAIN_HEAD ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)
# file(GLOB MAIN_HEAD "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h")

搜索当前目录的src目录下所有源文件并存储到变量中。

三、最后的话

以上是常用基础的CMake命令，还有很多需要完善的地方，后续会慢慢补充…

为了之后的研究生生活，最近开始学习Python这门语言。刚刚过完了一遍Python基础语法，可是脑子还是感觉空空的。太难的项目暂时又写不出来，于是便尝试编写一个简单的爬虫程序，一是为了巩固Python基础，二是重新拾起爬虫的相关知识。本篇文章基于淘宝电商平台编写爬取电脑商品信息的爬虫程序。

一、写在前面

爬虫(Web Crawler)是一种基于规则对网络中文本、图片等信息进行自动爬取的程序。其主要思想是通过模拟真实用户，向服务器发送请求进而持续对网页数据进行抓取，直到达到某一条件时停止。
本篇教程相关环境如下:

• Python 3.10.11
• requets模块 2.31.0

二、关键步骤

爬虫基本工作流程主要有三个：①明确需求——要采集的网站地址以及目标数据内容；②抓包分析——打开浏览器自带的开发者工具获取包数据网址；③按指定需求对数据进行处理；

1.导入相关模块

1
2
3
4
5
6

import requests
import json
import re
import hashlib
import csv
import time

• requests模块: 用于发送HTTP请求(get/post)
• json模块: 数据一般存储在JSON文件中，而该模块可实现将JSON数据转化为Python中的字典类型，方便数据处理
• re模块: 该模块支持使用正则表达式对文本内容的提取，方便数据处理
• hashlib模块: 存放MD5等数据加密函数，用于淘宝平台中Sign参数的加密逆向分析
• csv模块: 类似Excel表格，用于数据保存
• time模块: Python内置时间模块，用于获取时间戳以及模拟用户浏览操作

2.模拟浏览器

1
2
3
4
5

headers = {
    'cookie': 'cna=zyCGIBdAVWICAXjHIncvopiS; thw=cn; t=b218f49912339b0ceae556e0090e211b; xlly_s=1; _tb_token_=7a5b15963ff84; cookie2=16651aea2c313a912b01cb164e4e08a0; 3PcFlag=1744784663786; _hvn_lgc_=0; cookie3_bak=16651aea2c313a912b01cb164e4e08a0; unb=3971315337; lgc=%5Cu4E00%5Cu8F6E%5Cu5F2F%5Cu6708%5Cu4E00%5Cu7F15%5Cu76F8%5Cu601D; cancelledSubSites=empty; env_bak=FM%2Bgnk3pmwgJGNrZ6%2FSkIJoxCwTm6VI1qZ6TClrxgOc3; cookie17=UNkwcc4KQQFHcg%3D%3D; dnk=hoi3vel; tracknick=%5Cu4E00%5Cu8F6E%5Cu5F2F%5Cu6708%5Cu4E00%5Cu7F15%5Cu76F8%5Cu601D; _l_g_=Ug%3D%3D; sg=%E6%80%9D74; _nk_=%5Cu4E00%5Cu8F6E%5Cu5F2F%5Cu6708%5Cu4E00%5Cu7F15%5Cu76F8%5Cu601D; cookie1=U%2BIlWIeHLSADvBxDCm0kQKQsca6SNqfz%2FIpTHfq3ZQw%3D; sgcookie=E1003OSkTgC9VlYpf2%2FnITYkh7VA%2BCuHtM4rpO%2B0DYpiEHhSZi8%2B46SUAIXRls1C9TuK6mE77ohQhH3D7Vr1b4um%2BPEe%2BqJJGCi4WxE%2BQnQE0fQ%3D; havana_lgc2_0=eyJoaWQiOjM5NzEzMTUzMzcsInNnIjoiYWU2MzZmZDI5YjQ2MDNlNGUxMGU1YTkyYThhNjYyOTEiLCJzaXRlIjowLCJ0b2tlbiI6IjFjUWNFWDNhWm9oMl9BMHFTMzRtNUhnIn0; havana_lgc_exp=1775888706045; cookie3_bak_exp=1745043906045; wk_cookie2=1b3ee28d98c093084dd38ee1285362b2; wk_unb=UNkwcc4KQQFHcg%3D%3D; uc1=cookie16=U%2BGCWk%2F74Mx5tgzv3dWpnhjPaQ%3D%3D&pas=0&cookie14=UoYaj4%2Bx2t0h1w%3D%3D&existShop=false&cookie15=V32FPkk%2Fw0dUvg%3D%3D&cookie21=URm48syIYB3rzvI4Dim4; sn=; uc3=id2=UNkwcc4KQQFHcg%3D%3D&nk2=saDbd13P348Tq%2FXU0Jk%2FOg%3D%3D&vt3=F8dD2EuMY7YkvXA3Qzs%3D&lg2=VT5L2FSpMGV7TQ%3D%3D; csg=b9bc66e6; skt=ce2a91bede66482d; existShop=MTc0NDc4NDcwNg%3D%3D; uc4=nk4=0%40s8Wb7PJZDAD5%2BPfdt88U4O4L5YsttBggT1RI&id4=0%40Ug46vpy6gA%2FUJ82j39S%2FC20NcRKR; _cc_=VFC%2FuZ9ajQ%3D%3D; _samesite_flag_=true; havana_sdkSilent=1744958760754; sdkSilent=1744970016688; mtop_partitioned_detect=1; _m_h5_tk=bd25aec960a5af5dae87a57bd23a76fe_1744909656357; _m_h5_tk_enc=ffb07dba49e6d2242032897636cd438c; tfstk=gGwrwi1R4TBPOMu-Z-Me_JQFb_H-Bv71UJgIxkqnV40oPkmnLr4C24ZhyyyEokF52X_JY3e47p95y_EHLvMh5N61CuESpvbsLYD804nLm2jjZUroe3Dh5N6XGncRPv4CcYla3Imto0mnqXjqnDmiKLcu-qcmjcToKy4nmjmIj30nZvcDiqnnK24nKikmkDMn-jUK-V9qbbjImYz_o14iaVqoudrY30Dewu02Kp24gbuMCqJHK-oucQngid5IS53S12zchLkUmDzq177wUyr3XWc4LUj7SrVU-mFA8BuatuNTtjSlEokrzjo7lhAqUW48LbFyvGEmErFtWbfAkmy7CXutgEbucouo_Wz5kp07_o4q1-TXCAVTuJliIg8JJm4GYJFy-BloDmu10ir891NT8FfC5BdKwSnq5gIJ9BhoDmu10iRp9bHx0VsR2; isg=BEJCPyO0nhwnFY2-jgYMqgg3k0ikE0YtYJe0OYxbdrVg3-JZdKCMPZIZj9ujiL7F',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36'
}

• cookie参数: 存放用户信息，用于检测是否有登录账号信息(登录与否都有相关信息)
• user-agent参数: 用户代理，表示访问设备的基本信息

两个参数获取途径如下：
①打开淘宝平台点击电脑区页面；

②F2或鼠标右键点击检查打开浏览器开发者工具。开发者工具界面如图：

③在开发者工具中选择 网络(network) 并刷新页面。操作如图：

④在开发者工具搜索栏中搜索任意商品名获取商品信息对应的JSON文件，点击搜索内容自动跳转至对应JSON文件，点击标头即可在此页面中依次找到cookie和user-agent参数。操作如图：

3.获取数据包请求地址

1

url = 'https://h5api.m.taobao.com/h5/mtop.relationrecommend.wirelessrecommend.recommend/2.0/?'

Get请求的url地址参数直接在链接中(即?后部分)，通常有两种构造形式：①直接将请求地址存储在一个变量中；②额外构建查询参数请求(链接参数过长时使用)；

1
2
3
4
5
6
7
8
9
10
11
12
13

# 构建查询参数
url_params = {
    'jsv': '2.7.4',
    'appKey': '12574478',
    't': eT,
    'sign': sign,
    'api': 'mtop.relationrecommend.wirelessrecommend.recommend',
    'v': '2.0',
    'type': 'jsonp',
    'dataType': 'jsonp',
    'callback': 'mtopjsonp5',
    'data': ep_data,
}

在上述代码中，t、sign和data是实时参数，因此需要根据时间戳随时变化。

4.查询参数Sign的逆向解密

淘宝平台的sign参数采用了MD5进行加密，此时我们需要对其解密。而解密的关键则是获取淘宝sign加密参数。获取思路则是通过在开发者工具搜索sign:找到相应的main.js文件并在“来源”面板中打开。如下图：

在来源面板中Ctr+F打开搜索按钮，输入sign:进行查询。如下图：

5.查找JSON文件中的目标数据位置

在开发者工具中点击网络(network)模块，并搜索任意商品数据定位至指定JSON数据文件，在预览块中可查看目标数据。如下图:

三、具体实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

import requests
import json
import re
import hashlib
import csv
import time

'''Sign加密逆向分析
    eE(em.token + "&" + eT + "&" + eC + "&" + ep.data)
    eT--时间戳, eC--appKey
'''
def getSign(eT, page, totalResults, sourceS, bc_offset, nt_offset):
    em_token = 'bd25aec960a5af5dae87a57bd23a76fe' # 固定一个
    eC = '12574478' # 固定
    sign_params = {
        "device": "HMA - AL00 ",
        "isBeta": "false",
        "grayHair": "false",
        "from": "nt_history",
        "brand": "HUAWEI",
        "info": "wifi",
        "index": "4",
        "rainbow": "",
        "schemaType": "auction",
        "elderHome": "false",
        "isEnterSrpSearch": "true",
        "newSearch": "false",
        "network": "wifi",
        "subtype": "",
        "hasPreposeFilter": "false",
        "prepositionVersion": "v2",
        "client_os": "Android ",
        "gpsEnabled":"false",
        "searchDoorFrom": "srp",
        "debug_rerankNewOpenCard": "false",
        "homePageVersion": "v7",
        "searchElderHomeOpen": "false",
        "search_action": "initiative",
        "sugg": "_4_1",
        "sversion": "13.6",
        "style": "list",
        "ttid": "600000@taobao_pc_10.7.0",
        "needTabs": "true",
        "areaCode": "CN",
        "vm": "nw",
        "countryNum": "156",
        "m": "pc",
        "page": page, # 翻页变参数
        "n": 48,
        "q": "%E7%94%B5%E8%84%91",
        "qSource": "url",
        "pageSource": "a21bo.jianhua/a.201867-main.d2_first.5af92a89INtItN",
        "tab": "all",
        "pageSize": "48",
        "totalPage": "100",
        "totalResults": totalResults, # 翻页变参数
        "sourceS": sourceS, # 翻页变参数
        "sort": "_coefp",
        "bcoffset": bc_offset, # 翻页变参数
        "ntoffset": nt_offset, # 翻页变参数
        "filterTag": "",
        "service": "",
        "prop": "",
        "loc": "",
        "start_price": None,
        "end_price": None,
        "startPrice": None,
        "endPrice": None,
        "categoryp": "",
        "ha3Kvpairs": None,
        "myCNA": "zyCGIBdAVWICAXjHIncvopiS",
        "screenResolution": "1536x864",
        "userAgent": "Mozilla/5.0(Windows NT 10.0;Win64;x64)AppleWebKit/537.36(KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
        "couponUnikey": ""
    }
    info_data = {
        'appId': '34385',
        'params': json.dumps(sign_params) # 序列化处理
    }
    ep_data = json.dumps(info_data).replace(' ', '')
    aim_str = em_token + '&' + str(eT) + '&' + eC + '&' + ep_data
    md5 = hashlib.md5()
    md5.update(aim_str.encode('utf-8'))
    sign = md5.hexdigest()
    return sign, ep_data

'''获取下一页的参数内容
'''
def getNextParams(json_data):
    totalResults = json_data['data']['mainInfo']['totalResults']
    sourceS = json_data['data']['mainInfo']['sourceS']
    bc_offset = json_data['data']['mainInfo']['bcoffset']
    nt_offset = json_data['data']['mainInfo']['ntoffset']
    return totalResults, sourceS, bc_offset, nt_offset

# 1.模拟浏览器
headers = {
    # cookie-用户信息
    'cookie': 'cna=zyCGIBdAVWICAXjHIncvopiS; thw=cn; t=b218f49912339b0ceae556e0090e211b; xlly_s=1; _tb_token_=7a5b15963ff84; cookie2=16651aea2c313a912b01cb164e4e08a0; 3PcFlag=1744784663786; _hvn_lgc_=0; cookie3_bak=16651aea2c313a912b01cb164e4e08a0; unb=3971315337; lgc=%5Cu4E00%5Cu8F6E%5Cu5F2F%5Cu6708%5Cu4E00%5Cu7F15%5Cu76F8%5Cu601D; cancelledSubSites=empty; env_bak=FM%2Bgnk3pmwgJGNrZ6%2FSkIJoxCwTm6VI1qZ6TClrxgOc3; cookie17=UNkwcc4KQQFHcg%3D%3D; dnk=hoi3vel; tracknick=%5Cu4E00%5Cu8F6E%5Cu5F2F%5Cu6708%5Cu4E00%5Cu7F15%5Cu76F8%5Cu601D; _l_g_=Ug%3D%3D; sg=%E6%80%9D74; _nk_=%5Cu4E00%5Cu8F6E%5Cu5F2F%5Cu6708%5Cu4E00%5Cu7F15%5Cu76F8%5Cu601D; cookie1=U%2BIlWIeHLSADvBxDCm0kQKQsca6SNqfz%2FIpTHfq3ZQw%3D; sgcookie=E1003OSkTgC9VlYpf2%2FnITYkh7VA%2BCuHtM4rpO%2B0DYpiEHhSZi8%2B46SUAIXRls1C9TuK6mE77ohQhH3D7Vr1b4um%2BPEe%2BqJJGCi4WxE%2BQnQE0fQ%3D; havana_lgc2_0=eyJoaWQiOjM5NzEzMTUzMzcsInNnIjoiYWU2MzZmZDI5YjQ2MDNlNGUxMGU1YTkyYThhNjYyOTEiLCJzaXRlIjowLCJ0b2tlbiI6IjFjUWNFWDNhWm9oMl9BMHFTMzRtNUhnIn0; havana_lgc_exp=1775888706045; cookie3_bak_exp=1745043906045; wk_cookie2=1b3ee28d98c093084dd38ee1285362b2; wk_unb=UNkwcc4KQQFHcg%3D%3D; uc1=cookie16=U%2BGCWk%2F74Mx5tgzv3dWpnhjPaQ%3D%3D&pas=0&cookie14=UoYaj4%2Bx2t0h1w%3D%3D&existShop=false&cookie15=V32FPkk%2Fw0dUvg%3D%3D&cookie21=URm48syIYB3rzvI4Dim4; sn=; uc3=id2=UNkwcc4KQQFHcg%3D%3D&nk2=saDbd13P348Tq%2FXU0Jk%2FOg%3D%3D&vt3=F8dD2EuMY7YkvXA3Qzs%3D&lg2=VT5L2FSpMGV7TQ%3D%3D; csg=b9bc66e6; skt=ce2a91bede66482d; existShop=MTc0NDc4NDcwNg%3D%3D; uc4=nk4=0%40s8Wb7PJZDAD5%2BPfdt88U4O4L5YsttBggT1RI&id4=0%40Ug46vpy6gA%2FUJ82j39S%2FC20NcRKR; _cc_=VFC%2FuZ9ajQ%3D%3D; _samesite_flag_=true; havana_sdkSilent=1744958760754; sdkSilent=1744970016688; mtop_partitioned_detect=1; _m_h5_tk=bd25aec960a5af5dae87a57bd23a76fe_1744909656357; _m_h5_tk_enc=ffb07dba49e6d2242032897636cd438c; tfstk=gGwrwi1R4TBPOMu-Z-Me_JQFb_H-Bv71UJgIxkqnV40oPkmnLr4C24ZhyyyEokF52X_JY3e47p95y_EHLvMh5N61CuESpvbsLYD804nLm2jjZUroe3Dh5N6XGncRPv4CcYla3Imto0mnqXjqnDmiKLcu-qcmjcToKy4nmjmIj30nZvcDiqnnK24nKikmkDMn-jUK-V9qbbjImYz_o14iaVqoudrY30Dewu02Kp24gbuMCqJHK-oucQngid5IS53S12zchLkUmDzq177wUyr3XWc4LUj7SrVU-mFA8BuatuNTtjSlEokrzjo7lhAqUW48LbFyvGEmErFtWbfAkmy7CXutgEbucouo_Wz5kp07_o4q1-TXCAVTuJliIg8JJm4GYJFy-BloDmu10ir891NT8FfC5BdKwSnq5gIJ9BhoDmu10iRp9bHx0VsR2; isg=BEJCPyO0nhwnFY2-jgYMqgg3k0ikE0YtYJe0OYxbdrVg3-JZdKCMPZIZj9ujiL7F',
    # user-agent-用户代理
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36'
}

# 2.数据包地址
url = 'https://h5api.m.taobao.com/h5/mtop.relationrecommend.wirelessrecommend.recommend/2.0/?'

# 3.获取时间戳
eT = int(time.time() * 1000) # ms级

# 4.获取加密参数
page = 1
totalResults = 4800
sourceS = '0'
bc_offset = '""'
nt_offset = '""'

# 5.创建文件对象
file = open('C:/Users/Yam/Desktop/Computer.csv', mode='w', encoding='UTF-8-SIG', newline='')
# 字典写入方法
csv_writer = csv.DictWriter(file, fieldnames=['title', 'price', 'real_sale', 'procity', 'store', 'detail'])
# 写入表头
csv_writer.writeheader()

for i in range(25):
    print(f'第{i+1}次爬取...')
    page = i + 1
    sign, ep_data = getSign(eT, page, totalResults, sourceS, bc_offset, nt_offset)
    url_params = {
        'jsv': '2.7.4',
        'appKey': '12574478',
        't': str(eT),
        'sign': sign,
        'api': 'mtop.relationrecommend.wirelessrecommend.recommend',
        'v': '2.0',
        'type': 'jsonp',
        'dataType': 'jsonp',
        'callback': 'mtopjsonp5',
        'data': ep_data,
    }
    # 发送请求
    response = requests.get(url=url, params=url_params, headers=headers)
    goods_info = response.text
    # print(goods_info)
    json_str = re.findall('mtopjsonp\d+\((.*)', goods_info)[0][:-1]
    json_data = json.loads(json_str)
    itemsArray = json_data['data']['itemsArray']
    for item in itemsArray:
        if 'title' not in item.keys():
            continue
        dit = {
            'title': item['title'].replace('<span class=H>', '').replace('</span>', ''),
            'price': item['price'],
            'real_sale': item['realSales'],
            'procity': item['procity'],
            'store': item['shopInfo']['title'],
            'detail': 'https:' + item['auctionURL']
        }
        # 写入数据
        csv_writer.writerow(dit)
    totalResults, sourceS, bc_offset, nt_offset = getNextParams(json_data)
    time.sleep(30) # 睡眠30s
    print(f'第{i+1}次爬取成功!!!')

file.close()

上述代码中可变参数需要根据自身设备进行改变!!!

最近在准备机器学习项目时，关于如何配置Pytorch运行环境问题忙活了好久，网上的教程也不尽人意，因此写下此篇文章方便以后自己回顾，也希望帮助跟我有同样困惑的小伙伴们。

一、写在前面

本篇教程电脑配置如下：

• 操作系统: Windows 11
• 显卡版本(独显): NVIDIA GeForce RTX 2060
• Python: 3.9.12
• Anaconda: Anaconda3 2022.05

若电脑与上配置不同则在后续步骤中软件版本选择需要依据自身电脑做出改变。

二、环境配置

2.1 安装Anaconda

Anaconda最大的优点是可以建立很多个独立Python版本的虚拟库环境，这极大方便了多个项目的环境切换。Anaconda版本选择无关紧要，它只决定默认环境(即base环境)的Python版本，而后续每个虚拟环境的Python版本可以由开发者自行决定。Anaconda官方下载链接

2.2 安装CUDA Toolkit

CUDA(Compute Unified Device Architecture): NAVIDIA开发用于NAVIDIA GPU并行计算的并行计算架构和编程模型。它是一种硬件架构，定义了GPU的并行计算单元、内存架构、线程模型等。
CUDA Toolkit: NAVIDIA提供用于GPU加速计算的开发工具包，用于支持CUDA架构的并行计算。它是一套软件工具，包含了一系列的工具、库和示例代码，用于开发、优化和部署基于CUDA的并行计算应用程序。

• GPU需要与CUDA结合才能完成模型训练、Pytorch安装等任务
• 若没有CUDA, GPU在深度学习中就是个摆设
• GPU(独显)推理速度是CPU(核显)的几十倍

正确安装CUDA Toolkit需要三个条件：①确定显卡算力；②确定CUDA Runtime Version(即CUDA SDK)；③确定CUDA Driver Version；三者对应的关系应为：显卡算力<=CUDA Runtime Version<=CUDA Driver version

1.查看电脑显卡型号
打开任务管理器->点击性能->选择GPU0，在右上角即可显示当前电脑显卡型号。Ps: 若电脑配有显卡则有两个GPU，其中一个是核显即镶嵌在CPU中，厂家为CPU厂家，另一个则为独显，厂家为NVIDIA。具体视图如下：

查看显卡型号

2.确定显卡算力以及确定CUDA Runtime Version
知道显卡类型后，前往网站找到自己显卡版本所支持的算力。此电脑查询结果如下：

获取显卡算力

获取CUDA SDK版本

3.确定CUDA Driver Version
执行win+r输入cmd打开shell命令窗口，输入nvidia-smi命令，将会显示当前电脑所支持的CUDA版本。具体视图如下：

查看CUDA型号

最终我们确定CUDA Toolkit的版本区间应该为11.0-12.1。前往CUDA官网下载指定版本的CUDA Toolkit。安装完成后重启电脑，之后在shell窗口中输入指令nvcc -V检验是否安装成功。

CUDA安装成功截图

2.3 安装Pytorch

前往Pytorch官网下载与CUDA Toolkit版本相对应的Pytorch版本，可采用conda指令或者pip指令安装，推荐采用conda指令安装。注意：OSX栏里的指令安装核显(即CPU)版的Pytorch，而Linux and Windows栏里的指令安装独显(即GPU)版的Pytorch。
安装完成后，打开anaconda中对应虚拟环境的命令行输入指令conda list，若出现pytorch则说明安装成功。如图：

Pytorch安装成功截图

三、最后的话

如果以上环境配置完成，编写如下python脚本：

1
2
3

import torch

print(torch.cuda.is_available())

若运行结果为true，则说明Pytorch可正常使用主机显卡，否则需要检查CUDA Toolkit版本软件以及Pytorch软件版本重新进行适配安装。最后祝愿每一个科研人能够学有所成。

今天刷Leetcode时，一道字符串匹配的题目卡了好久好久，后来才想到这是数据结构中串的朴素匹配算法的应用，因此写下此篇文章方便日后复习。

一、写在前面

数据结构中，朴素匹配算法是一种简单而有效的字符串匹配方法，也被称为暴力搜索方法。它的基本思想是逐个比较主字符串和模式串的每个字符，以此确定是否存在匹配。

二、具体题目

有一个字符串数组words,数组中的每个字符串都可以看作是一个单词。请你按照任意顺序返回words中是其他单词的子字符串的所有单词。（Ps: 如果你可以删除words[j]最左侧或最右侧的若干字符得到words[i]，那么字符串words[i]就是word[j]的子字符串）

示例1:

• 输入：words = [“mass”,”as”,”hero”,”superhero”]
• 输出：[“as”,”hero”]
• 解释：”as” 是 “mass” 的子字符串，”hero” 是 “superhero” 的子字符串。因此[“hero”,”as”]是最终答案。

示例2:

• 输入：words = [“leetcode”,”et”,”code”]
• 输出：[“et”,”code”]
• 解释：”et” 和 “code” 都是 “leetcode” 的子字符串。因此最终答案为[“et”, “code”]

示例3:

• 输入：words = [“blue”,”green”,”bu”]
• 输出：[]

Leetcode原题

三、思路分析

此题关键是编写判断一个字符串(str1)是否是另一个字符串(str2)的子字符串的函数，对此有两种算法可以解决：①简单朴素匹配算法；②KMP算法。由于KMP算法需要构建next数组较为复杂，因此解此题采用简单朴素匹配算法。将str1作为模式串，str2作为主字符串，通过遍历主字符串统计与模式串匹配个数，若匹配个数与模式串长度相等则匹配成功，否则匹配失败。（注：每一次单字符匹配失败都需置匹配统计量为0）
具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

int isSub(char *str1, char *str2) { //判断str1是否为str2的子字符串
if(strlen(str1) > strlen(str2)) return 0;
else {
//int match = 0;
for(int i=0; i<strlen(str2); i++) {
int match = 0;
if(str1[match] == str2[i]) {
for(int j=i; j<strlen(str2); j++) {
if(str1[match]==str2[j]){
match++;
if(match == strlen(str1)) return 1;
}else {
match = 0;
break;
}
}
}
}
}
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

char** stringMatching(char **words, int wordsSize, int* returnSize) {  // 获取words数组中的子字符串
    int len = 0;
    char **ans = NULL;
for(int i=0; i<wordsSize; i++) {
    for(int j=0; j<wordsSize; j++) {
    if(i==j) continue;
    else {
    if(isSub(words[i], words[j])) {
    len++;
    ans = (char**)realloc(ans, sizeof(char*)*len);
    ans[len-1] = (char*)malloc(sizeof(char)*(strlen(words[i])+1));
    strcpy(ans[len-1], words[i]);
    break;
}
}
}
}
*returnSize = len;
return ans;
}

四、题外话

此题解法建立在以下条件下：

• 1 <= words.length <= 100
• 1 <= words[i].length <= 30
• words[i]仅包含小写英文字母。
• 题目数据保证每个words[i]都是独一无二的。

若无此限制，采用简单朴素匹配算法可能会超时。

在编程实现从字符串提取连续的数字时，发现在函数内申请的动态内存无法传递到main函数中使用，基于此写下这篇文章，探究C语言中函数间动态内存的传递方式。

一、写在前面

C语言中，动态申请的内存划分在堆中，其生存周期与程序生存周期一致，系统不会自动回收，需要程序员调用free()函数手动调用。既然如此，如果在函数中申请一个动态内存，那么如何在main函数中调用呢？

二、具体实例

1.错误实例

有如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include<stdio.h>
#include<stdlib.h>

void Func(int a[], int n)
{
    a = (int*)malloc(sizeof(int)*n);
    for(int i=0; i<n; i++) a[i] = i;
}

int main()
{
    int n = 5, *a = NULL;
    Func(a, n);
    if(!a) printf("a is null!\n");
    else
    {
        for(int i=0; i<n; i++) printf("%d ", a[i]);
    }

    return 0;
}

上述代码中，在Func()函数中对a数组进行了动态内存申请，在main()函数中进行调用，程序运行结果为a is null!。造成这种结果是因为此时函数传递方式为值传递，这意味着将指针a传递给函数Func()时，实际上是传递了一个a的副本即当在Func()函数内为a分配内存时，实际上在修改a的副本而不是main()函数中的a。

2.正确实例

在C语言中，函数之间的动态内存传递方式主要有两种：①使用函数传参的方式。此时形参必须为双维指针，否则函数内分配的动态内存无法传入至主函数中。②采用函数返回值的形式，返回值为单维指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 方式一：函数传参
#include<stdio.h>
#include<stdlib.h>

void Func(int **a, int n)
{
    *a = (int*)malloc(sizeof(int)*n);
    for(int i=0; i<n; i++) (*a)[i] = i;
}

int main()
{
    int n = 5, *a = NULL;
    Func(&a, n);
    if(!a) printf("a is null!\n");
    else
    {
        for(int i=0; i<n; i++) printf("%d ", a[i]);
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 方式二: 函数返回值
#include<stdio.h>
#include<stdlib.h>

int* Func(int n)
{
    int *temp = (int*)malloc(sizeof(int)*n);
    for(int i=0; i<n; i++) temp[i] = i;
    return temp;
}

int main()
{
    int n = 5, *a = NULL;
    a = Func(n);
    if(!a) printf("a is null!\n");
    else
    {
        for(int i=0; i<n; i++) printf("%d ", a[i]);
    }

    return 0;
}

三、题外话

在C语言中动态内存的申请可采用malloc()和realloc()函数，前者仅需要传递一个函数参数即需要的内存大小，而后者则需要传递两个函数参数即realloc(ptr, size)，ptr为目的函数指针，成功时返回指向新内存块的指针且原内存将会释放；失败时返回NULL且原指针ptr指向的内存块仍然有效。若ptr为空指针，则该函数效果同malloc()函数。
实际上，realloc()函数用于对已分配内存的扩展，其扩展机制如下：

• 若ptr所指的位置可以继续找到足够的连续内存空间，则该函数会直接在原有内存块的基础上扩展内存。此时返回的地址为ptr原地址；
• 若原位置不能扩展，则该函数会在堆中新寻找一个合适的位置并将原内存块的数据复制到新位置以及释放原有内存块。

自己在刷LeetCode时遇见了最长公共子串这个题目，传统的编程思想使我对此题无从下手，后面查阅资料后了解到动态规划这一思想，因此便写下文章，记录如何使用动态规划解决最长公共子串和最长公共子序列问题。

一、写在前面

当自己在网上搜什么是动态规划时，许许多多晦涩难懂的专业术语映入眼帘，令人望而生畏。然而动态规划遵循着一套固定的流程：递归的暴力解法->带备忘录的递归解法->非递归的动态规划解法。那么什么是动态规划呢？针对一个问题，我们把这个问题拆分成一个个子问题，然后将每个子问题的最优解记录下来(即”备忘录”)，相邻子问题之间层层递进，再根据子问题答案进行反推，最终得出原问题的最优解，这便是动态规划。简单一句话就是，拆分子问题，记住过往，减少重复计算。

二、最长公共子串

1.题目描述

给出两个字符串a和b的最长连续公共子串的长度。例如“abcbcde”和“bbcbce”的最长连续公共子串是“bcbc”，长度为4。

2.思路解析

假设字符串a和b的长度分别是m和n，绘制一张m×n的二维表格table[m][n]。取字符串a和b的字符前缀a’和b’，表格位置i，j上的数字含义是: 字符串a’和b’的且以它们尾巴字符结尾的最长公共子串的长度。

假设已经知道i-1和j-1处的数值，考虑i，j的数值：

• 如果新的a[i]和b[j]相等，则最长公共子串得到扩展，因此数值+1。
• 否则以两个字符为尾巴的最长公共子串不复存在，因此数值清零。
  下图中左右示例对应上述两种情况：
  
  于是得到填表规律：
• 如果当前格子对应的两个字符不同，则写0。
• 否则采用斜上方的格子的数值+1
  
  用代码描述这个填表规则：
• 若a[i]!=b[j]，则填写table[i][j]=0
• 否则，填写table[i][j]=table[i-1][j-1]+1
  表格中的最大值即为最长公共子串的长度，时间复杂度为O(m*n)。

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 返回字符串 a 和 b 的最长公共子串的长度
// 例如 "abcdbcdef" 和 "bbcbbcdee" 的公共字符串是 "bcde" 长度是 4
int LongestCommonSubstring(char *a, int a_length, char *b, int b_length) {
    int table[a_length][b_length];
    int max = 0;

    for (int i = 0; i < a_length; i++) {
        for (int j = 0; j < b_length; j++) {
            if (a[i] == b[j]) {
                if (i >= 1 && j >= 1)
                    table[i][j] = table[i - 1][j - 1] + 1;
                else
                    table[i][j] = 1;
            } else {
                table[i][j] = 0;
            }

            if (table[i][j] > max) {
                max = table[i][j];
            }
        }
    }

    return max;
}

三、最长公共子序列

1.题目描述

给出两个字符串a和b的最长公共子序列的长度。其和公共子串不同的是，公共子序列不要求连续。最长公共子序列是非常经典的动态规划问题，简称LCS问题。例如“abcbcde”和“acabdef”的最长公共子序列是“acbde”，长度为5。LeetCodet题目-最长公共子序列

2.思路解析

如果两个字符串的尾位置分别是i和j，假设它们的最长公共子序列的长度是函数f(i, j):
考虑函数的递推关系：

• 如果两个字符串的尾字符相同，易知f(i, j)=f(i-1, j-1)+1:
• 如果尾字符不同，上述递推关系则不成立:
  原因在于，虽然尾字符不同，但一个字符串的尾字符可能和另一个字符串的前面的某个字符相同，导致最长公共子序列得到扩展。
  注意，上图的关系可以进一步表达为：
  考虑其一般性，取f(i-1, j)和f(i, j-1)的最大值:
  假设字符串a和b的长度分别是m和n，绘制一张m×n的二维表格table[m][n]。取字符串a和b的前缀字符串“a’”和“b’”，表格位置i，j上的数字含义为f(i，j)即字符串a’和b’的最长公共子序列的长度。
  利用已分析的递推关系，表格填写规则如下：
• 如果字符a[i]和b[j]相同，则最长公共子序列得到扩展，数值+1
• 否则，采用左边的和上面的方格中的数值的最大值
  
  按照上述规律，字符串“abcbcde”和“acabdef”的填表过程如下：
  上述规则映射至代码为：
• 若a[i]==b[j]，则填写table[i][j]=table[i-1][j-1]+1
• 否则填写table[i][j]=max(table[i-1][j], table[i][j-1])
  表格中最大值即为最长公共子序列的长度，时间复杂度为O(m*n)。

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#define MAX(a, b) (a) > (b) ? (a) : (b)

// 返回两个字符串 a 和 b 的最长公共子序列的长度
// 例如 "abcbcde" 和 "acabdef" 的最长公共子序列是 "acbde" ，长度为 5
int LongestCommonSubsequence(char *a, int a_length, char *b, int b_length) {
    int table[a_length][b_length];
    int max = 0;

    for (int i = 0; i < a_length; i++) {
        for (int j = 0; j < b_length; j++) {
            if (a[i] == b[j]) {
                if (i >= 1 && j >= 1)
                    table[i][j] = table[i - 1][j - 1] + 1;
                else
                    table[i][j] = 1;
            } else {
                if (i >= 1 && j >= 1)
                    table[i][j] = MAX(table[i - 1][j], table[i][j - 1]);
                else if (i <= 0 && j >= 1)
                    table[i][j] = table[i][j - 1];
                else if (i >= 1 && j <= 0)
                    table[i][j] = table[i - 1][j];
                else
                    table[i][j] = 0;
            }

            if (max < table[i][j]) max = table[i][j];
        }
    }
    return max;
}

其实将Giscus评论系统引入Hexo博客中操作很简单，但是想到自己一开始看着Hexo-Theme-Async文档所介绍的操作依然不知所措的场景，最后还是决定写篇文章讲讲具体的流程。

一、前言

Giscus是由Github Discussions实现的评论系统，它主要有三个优点：①开源；②无跟踪、无广告且永久免费；③无需数据库，所有数据均存储在Github Discussions中。

1.工作原理

Gicsus使用Github Discussions作为数据库存储博客下面的评论。Giscus插件加载时会使用Github Discussions搜索API根据选定的映射方式(如URL、Pathname等)来查找与当前页面关联的discussion。若找不到匹配的discussion，Giscus bot就会在第一次有人留下评论或回应时自动创建一个discussion。访客通过登录Github账号在博客页面进行留言，而作者可以在Github对应仓库上管理评论。

二、具体流程

1.引入Giscus

Hexo主题Hexo-Theme-Async支持Giscuss评论，因此引入步骤很简单，具体流程如下:

• 在Github上选择一个仓库作为存储Discussions的仓库，一般选择博客本身所在的仓库(e.g.Github用户名/Github用户名.github.io)，当然也可以新建一个仓库。
• 安装Giscus
• 开启作为存储Discussions仓库的Discussions功能: 选择GIthub仓库->Settings->Features模块中勾选Discussions

2.配置Giscus

上述操作完成后，进入Giscus官网获取配置信息，填写完仓库和分类后就可在显示配置信息，生成的配置信息样例如下:
分类可以选择Announcements、Q&A等，不一定按照推荐选择分类。

在此配置信息中我们只需关注data-repo、data-repo-id、data-categories、data-category-id这些信息。

3.引入至博客

在_config.async.yml中配置如下:
图中打码部分为专属配置信息，其中theme主题可自己更改，可供选择主题可在Giscus官网查看。

4.效果视图

白天模式下:
黑夜模式下:
评论的管理可在Github中对应仓库的Discussions中实现

自己将本地博客部署到阿里云服务器过程中踩了许许多多的坑，网上的许多教程也不尽人意，因此写下这篇如何将本地博客部署至阿里云服务器的教程博客，希望对有此需求的人有所帮助。

一、写在前面

1.部署方式

博客部署有两种选择：

• 托管至GitHub或者Gitee上: 借用Github或Gitee的这一功能部署网站，操作简单且免费。国内访问速度方面Gitee>Github。
• 部署至私有云服务器上：需要花钱购买服务器、域名，此方式自主性强且相应速度快。
  在此文章中我将叙述如何将本地的Hexo静态博客部署至私有云服务器上。

2.相关环境

• 阿里云服务器: ①CPU&内存-2核(vCPU) 2GiB; ②操作系统: Ubuntu 20.04 64位; ③公网带宽: 3Mbps
• Nodejs版本(云服务器上): v20.13.1
• Git版本(云服务器上): v2.25.1
• Nginx版本(云服务器上): v1.18.0(Ubuntu)

3.前置准备

• 本地成功搭建Hexo博客
• 本地成功安装了Git工具
• 域名与云服务器公有Ip实现映射绑定

二、工作原理

本地撰写的博客会保存在source目录内，当我们输入hexo generate命令时，Hexo将会把我们写的Markdown文件渲染成静态文件(即网页文件)，输入hexo deploy时，Hexo会通过我们的配置好的免密登陆连接至服务器并将生成的静态文件推送至服务器的Git仓库内。当Git仓库内容发生变更时则会触发钩子文件进而将仓库内的内容部署至网站根目录下。
此外我们还需要配置好Nginx服务和域名解析，这样当用户访问我们博客的域名时，域名将会被重定向为云服务的公有Ip地址并通过Nginx服务访问网站根目录里的静态文件。相关流程图如下所示:

三、搭建步骤(针对云服务器)

1.服务端初始配置

• 前往阿里云网站的控制台，记录云服务器的公网Ip: 控制台->云服务器ESC->公网Ip
• 设置阿里云服务器安全组：需要开放80端口(HTTP默认访问端口)、443端口(HTTPS默认访问端口)以及22端口。具体如下图:
• 重置服务器登陆密码，用于远程云登陆服务器：控制台->云服务ESC->服务器实例->全部操作(右上角)->重置实例密码

2.远程登陆服务器

• 打开Xshell并新建会话：①协议：SSH; ②主机: 云服务器公网Ip; ③端口号: 22
• 点击连接：①用户名: root; ②密码: 即上述重置服务器登陆密码时输入的密码
• 登陆成功后终端显示如下图:

3.创建Hexo部署目录

Hexo部署目录实质就是云服务器中存放博客的位置。使用Xshell成功连接远程服务器后输入如下命令:

1

mkdir -p /data/blog # 注意这个路径可按照自定义来

4.安装Nodejs

• 在Xshell终端输入如下命令:

  1 2 3 4

  sudo apt-get install -y curl curl -fsSL https://deb.nodesource.com/setup_20.x -o nodesource_setup.sh sudo -E bash nodesource_setup.sh sudo apt-get install -y nodejs

• 成功安装后依次输入命令: node -v和npm -v，若可显示相应版本号则说明安装成功
  PS:上述命令安装的Nodejs版本为v20.13.1，如需要安装其他版本则可从NodeSource安装

5.安装Git

• 在Xshell终端输入命令: sudo apt-get install git-core

• 成功安装后输入命令: git --version，若可显示其版本号则说明安装成功

6.安装Nginx

• 在Xshell终端输入命令: sudo apt install nginx -y

• 成功安装后输入命令: nginx -v，若可显示版本号则说明安装成功

• 启动Nginx服务：systemctl start nginx.service

• 查看Nginx服务运行状态: systemctl status nginx，若出现active字样则说明Nginx服务启动成功

7.配置Nginx

• 查看nginx.conf文件位置: nginx -t,一般为’/etc/nginx/nginx.conf’

• 修改nginx.conf文件: nano /etc/nginx/nginx.conf，在http模块中添加如下代码：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

  server { listen 80; server_name 域名; return 301 https://$server_name$request_uri; } server { listen 443 ssl; server_name 域名; # 证书文件名称pem文件 ssl_certificate /xxx/xxx/域名.pem; # 证书私钥文件名称key文件 ssl_certificate_key /xxx/xxx/域名.key; # ssl验证配置 缓存有效期 ssl_session_timeout 5m; # 安全链接可选的加密协议 ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3; # 配置加密套件和/加密算法 ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE; # 使用服务器端的首选算法 ssl_prefer_server_ciphers on; # 指定虚拟主机根目录 location / { root /data/blog; # root后路径为Hexo在云服务器的部署目录 index index.html index.htm; } }

  Ps: ssl证书可从域名购买平台上申请，然后下载上传至云服务器自定义位置即可

8.添加git用户

• root用户默认的权限过大，处于安全考虑为云服务器添加名为git的用户，用于将博客自动部署至云服务器上

  1 2	useradd git # 添加名为git的用户 passwd xxx # 修改git用户的密码

• 为git用户授予sudo权限，执行nano /etc/sudoers，在root ALL=(ALL:ALL) ALL语句下添加git ALL=(ALL:ALL) ALL

9.为git用户添加SSH密钥

目前为止，对git仓库进行的所有操作都需要输入密码，我们可以通过为git用户添加SSH密钥的方式来实现免密登录。原理：在本地生成一对密钥文件（分别是公钥和私钥），将公钥文件上传到服务器上；服务器收到连接请求时，会将本地的公钥与服务器的公钥进行比对，用私钥解密服务器发来的一段信息并将其发回，验证通过后准许连接。

• 在本地计算机上打开Git Bush执行命令: ssh-keygen -t rsa，生成密钥对。运行完后可在’C:\Users\用户名.ssh’文件下找到’id_rsa’和’id_rsa.pub’文件，前者为私钥文件，后者为公钥文件

• 在Xshell终端先执行makdir -p /home/git/.ssh，后执行cd /home/git/.ssh以及nano authorized_keys，输入内容为**’id_rsa.pub’**文件内容

• 在Xshell终端中执行如下代码：

  1 2 3

  su root # 从git用户更换至root用户 chmod 600 /home/git/.ssh/authorized_keys chmod 700 /home/git/.ssh

• 将.ssh文件夹及其内的所有文件所有权转交给git用户: chown -R git:git /home/git/.ssh

• 在本地计算机测试是否可以用ssh免密登录服务器，在Git Bash中执行ssh -v git@xxx.xxx.xxx.xxx(Ps:git@后填写服务器的公网Ip) ,若成功则会出现’Welcome to Alibaba Cloud Elastic Compute Service !’提示语。

10.创建Git仓库并配置自动部署

这里的Git仓库（repository）可以理解为一个存放着不同版本代码的代码库，包含了项目所有的源文件和版本控制信息。但我们在这里需要用到的是裸库，即仅包含版本控制信息的仓库。后者不保存文件，常用作服务器仓库，实现数据共享和同步。自动部署的核心在于git-hooks（钩子），可以理解为一种脚本，在特定条件下触发时会调用钩子并执行钩子文件中的内容。

• Xshell切换到root用户，新建目录并在该目录下创建Git仓库

  1 2	cd /home/git git init --bare blog.git # 创建一个名为blog的仓库，--bare参数为创建裸库

• 打开’/home/git/blog.git/hooks’目录下的post-receive钩子文件(若无则新建)，往其添加内容git --work-tree=/data/blog --git-dir=/home/git/blog.git checkout -f。(Ps:work-tree填写Hexo部署目录，git-dir填写Git仓库的目录)

• 为钩子文件及Git仓库目录配置权限。这里需要将我们创建的仓库及部署目录的所有权移交给git用户，因为Linux下创建文件时默认只有拥有者（即创建者）才具有读写权限，而Git进行push操作时登录的用户为git用户。

  1 2 3

  chmod +x /home/git/blog.git/hooks/post-receive #为钩子文件授予可执行权限（+x） chown -R git:git /home/git #将仓库目录的所有权移交给git用户 chown -R git:git /data/blog #将Hexo部署目录的所有权移交给git用户

11.在本地计算机中更改本地博客部署路径

• 打开本地计算机的Hexo文件夹，在_config.yml文件中找到deploy语句并进行如下修改：

  1 2 3 4

  deploy: type: git repository: git@xxx.xxx.xxx.xxx:/home/git/blog.git # git@云服务器公网Ip:云服务器Git仓库地址 branch: master

• 依次执行命令hexo clean、hexo generate、hexo deploy并对云服务器’/data/blog’目录刷新，若有文件出现(该目录原为空目录)则说明博客已成功部署至云服务器上，至此可以在浏览器中输入域名来访问博客站点。(Ps：若域名未与公网Ip绑定<即域名解析>，则无法实现输入域名访问博客站点)

蝉鸣是夏天的前言，也是我回忆的诗篇…