光锥之内

就这样，基于 Firefly 和 Fuwari 开发的 SMATRIX 3.0 诞生了，也就是你现在看到的这个站。

我做了哪些修改#

1. 重做界面 UI#

拿到 Firefly 之后，我做的第一件事就是把 UI 全面重做了一遍，灵感来源于某知名二游的界面设计（懂的都懂）。用到的skill我放在这里了（这个粥味skill是我在小黑盒刷帖子的时候发现的）

Brandon030722

ark-ui-skill

从导航、卡片到文章页的排版，几乎都按照自己的审美重新调整了一遍，让整个站更贴近我理想中的样子。

2. 优化动态页的 Markdown 渲染管线#

动态页之前总给人一种“毛坯房”的感觉，渲染出来的内容比较简陋。这次我重新优化了动态页的 Markdown 渲染管线，从解析、样式到组件化渲染都重新梳理了一遍，让动态页也能有体面的排版。比如说原版Firefly动态页对于Markdown 渲染几乎可以说是没有，但它文章页又做得那么好，于是我就把文章页的渲染管线整个复用到了动态页上。

3. 加入新功能#

Timeline 时间线：记录大事记、版本更新历程再合适不过了；

通过下面的语法来实现

1
::timeline_year{2026}
2

3
::timeline_date{08-09}
4

5
::endtimeline_date
6

7
::endtimeline_year

Timeline时间线

1
::timeline_year{2026}
2
::timeline_date{08-09}
3
`SMATRIX 3.0` 正式发布！基于 `Firefly` 和 `Fuwari` 开发的Astro静态博客。更轻量、更快速、更强大！
4
::endtimeline_date
5
::timeline_date{01-30}
6
持续优化 OvO
7

8
> SMATRIX 2.0.1 （基于Anzhiyu 1.7.1）
9
>
10
> 🐛fix: 恢复部分字体样式显示异常
11
>
12
> ✨feat: 升级Twikoo评论系统后端
13
>
14
> ✨feat: Twikoo评论系统添加自定义表情
15
>
16
> 📦file: 创建 /privacy 完善隐私政策
17
>
18
> 📦file: 创建 /cookies 完善Cookies政策
19

20
::endtimeline_date
21

22
::timeline_date{01-29}
23
新年第一更 (・̀ ω・́)✧
24

25
> SMATRIX 2.0.0 （基于Anzhiyu 1.7.1）
26
>
27
> 🐛fix: 恢复Twikoo预览功能
28
>
29
> ✨feat: 优化 Algolia 搜索
30
>
31
> ✨feat: 替换默认主题为钉钉进步体
32
>
33
> ✨feat: 上线轻量友链朋友圈
34
>
35
> ✨feat: 添加侧边栏日历及倒计时
36
>
37
> ✨feat: 上线基于奶思猫API的博客欢迎系统
38
>
39
> 📦file: 创建 atom.xml 优化RSS订阅体验
40
>
41
> 🎨refactor: 优化侧边栏个人卡片样式
42
>
43
> 🎨refactor: 优化友链显示方式，完善友链申请方式
44
>
45
> 🎨refactor: 优化关于页面显示方式，更新个人信息
46

47
::endtimeline_date
48

49
::endtimeline_year

展开收起

Link 外链卡片：引用外链时不再是一行干巴巴的文字，而是一张带预览的卡片；
```
1
::link{www.baidu.com}
```
Link外链
Music 音乐卡片：可以在文章或动态里直接嵌入音乐卡片，想听就听。
```
1
::music{server="netease",type="playlist",id="7384065438"}
```
Music音乐卡片

未来还打算做哪些修改#

重构远没有结束，接下来还有不少计划：

迁移友链朋友圈：把老朋友们的友链和朋友圈完整迁移过来；（2026-08-10 已完成迁移）

QzKevin

Friend-Circle-Lite

Firefly 一款清新美观的 Astro 博客主题模板

fcircleConfig.ts

1
// 朋友圈页面配置
2
export const fcirclePageConfig: FcirclePageConfig = {
3
  title: "鱼塘",
4
  description: "这里会汇集朋友们的最新动态。",
5
  icon: "material-symbols:fishfood",
6
  apiUrl: "https://fc.smatrix.top/all.json",
7
  frontendUrl: "https://fc.smatrix.top/",
8
  pageSize: 24,
9
  requestTimeout: 8000,
10
};

友链朋友圈

协调部分 UI：有些部分当时做得比较匆忙，风格还不够统一，需要再打磨；
未完待续：剩下的，就交给时间去慢慢填吧。

写在 4.5 周年：一路走来，感谢有你#

最后，想借这个特殊的日子，认真说一声感谢。

4 年多来，这个博客换过不少“家”。

域名从 qzkevin.github.io（GitHub Pages）到 kayin.ml（免费域名），再到如今真正属于我的 smatrix.top；

框架历经 WordPress、Typecho（我还搞过一个把 Typecho 部署到 Vercel 的项目呢）、Hugo、Next.js、Hexo，再到如今的 Astro；

托管平台也从 GitHub Pages、Cloudflare、Netlify、Vercel，一路折腾到了 EdgeOne Pages。

2022

01-17

梦开始的地方：博客基于 WordPress，部署于星辰云虚拟主机上

04-26

部署于星辰云香港云服务器的 Typecho 博客正式上线

08-25

Typecho 博客停止运行，基于 Vercel 部署的 Hexo 博客正式上线

2023

04-18

旧 Hexo 博客因性能问题停止使用，内容迁移至新 Hexo 博客

07-23

域名 SMATRIX.TOP 正式启用

2026

08-09

SMATRIX 3.0 正式发布：基于 Firefly 与 Fuwari 的 Astro 静态博客

回想来，这一路让我学会了很多。曾经玩过虚拟主机、轻量云服务器（断断续续租过好几次），想当年折腾静态博客，很大一部分原因也是为了省点服务器钱。从最初连页面代码都要东拼西凑的新手，到现在能对着代码库指指点点——虽然依然写不出什么厉害的代码，但每一个踩过的坑、每一行魔改过的代码，都构成了现在的我。

感谢鱼鱼、洪哥、LiuShen 这些大佬，是你们的文章和项目一次次给我灵感；感谢每一位来访的朋友，你们的每一次点击、每一条评论，都是我继续折腾下去的动力。

下一个 4.5 年，也请多多指教。 🍀

C++快速入门

Tue, 25 Jul 2023 00:00:00 GMT

NOTE

本文为C++快速入门，旨在记录C++学习中的八个重要部分的笔记进行分享，持续更新中，预计更新完成时间：2023年7月30日

C++快速入门#

初识C++#

编程语言是什么#

我们编写程序，就是希望与计算机进行交流，让计算机帮助我们实现我们期望的效果。从这点出发，其实和人与人之间的沟通交流是⼀样的。两个人如果需要正常的沟通交流，必须要满足的条件是，你说的话对方听得懂，对方说的话你也能听得懂。如果条件不满足，你说中文对方不动，对方说英文你不懂。那么此时就没有办法交流。写程序也是这样，我们需要和计算机沟通交流。但是很遗憾，机器听不懂我们人类的语言，也学不会人类的语言。那么我们去学习机器的语言呢？更加麻烦，计算机只认识0和1，不会太复杂的语言。此时我们怎么办？我们可以借助⼀个“翻译”，把我们的需求翻译成机器语言，说给机器听。但是，这个翻译其实也是⼀个程序，依然没有办法学习人类的语言。幸运的是，这个“翻译员”有自己的独特的语言体系，而这种语言体系比起机器语言来说，要更加容易理解。这就是我们俗称的“编程语言”。编程语言有很多很多，有些语言更加贴合机器的世界，这些语言对我们人类来说，学习的成本就比较高。也有⼀些语言，更加贴合人类的世界，这类的编程语言，更加符合我们⼈类的⽣活习惯和思维逻辑，学习起来难度要小很多，更加容易⼀些。这样的语言，我们称为“高级语言”，而Java就是⼀种高级语言。

基础编辑器部分#

Dev-Cpp（推荐，有一些代码补全，建议新手使用，自行百度或B站“Dev-C++”）
Code::Blocks (与Dev-C++类似，自行百度或B站)
Visual Studio（微软推出的C++集成开发工具，功能全面好用现代化，缺点是体积比较大）
Visual Studio Code（配置麻烦，需要自行配置MinGW,配置教程点击这里查看，代码补全完善好用）

HeloWorld#

“HelloWorld”是每个编程语言的入门必备，了解最基本的框架。

PS: “ ; ”不要漏掉是每一位学习C++的同学的必修课

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
    cout << "HelloWorld!" << endl;
6
    system("pause");  // 有些编译器原生不支持暂停，输入这条语句不让运行的黑框一闪而过
7
    return 0;
8
}

变量和常量的定义#

变量：可以被改变和赋值的量

格式：数据类型变量名称 = 赋值；

PS：最新的C++编译器支持变量不初始化，即可以不进行赋值操作
常量：一经定义不可改变的量

格式： const 数据类型常量名称 = 赋值；

关于数据类型请看下一个部分

1
int a = 10;
2
const int b = 10;

注释#

C++的注释方式有两种：

双斜杠后加注释

//

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
    cout << "HelloWorld!" << endl;
6
    // 这⾥就是单⾏注释
7
    // 下⾯这段话，可以在控制台上输出 Hello World!
8
    return 0;
9
}

斜杆加星号包头尾可进行多行注释

/*
*/

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
    cout << "HelloWorld!" << endl;
6
  /*
7
 这⾥的内容就是多⾏注释的内容
8
  可以同时注释多⾏的内容
9
  */
10
    return 0;
11
}

变量命名#

标识符的命名规则

由字母、数字、下划线组成，不能有其他的组成部分
不能以数字开头，需要以字母或者下划线开头
不能与系统关键字重复
区分大小写

标识符的命名规范

标识符出了在遵循上述的规则之外，还有有⼀定的规范，并不是可以随便写的。标识符最基础的规范就是望文知义，命名要有⼀定的意义，方便我们自己去区分标识符所表达的含义。希望减少拼音的使用，多使用英文单词/复合单词（这样也可以提升下你的英语水平）

关键字是什么？ 其实关键字也是遵循上述前两点规则的字符序列，只不过这样的字符序列已经被系统征用并赋予特殊含义了，我们在定义标识符的时候就不能够再使用了。例如: int、float、const等。

!!! 变量名不要使用C++的保留关键字（不用死记硬背了解一下就行，后面你写得多了，自然就记住了）

541

数据类型#

C++划定在创建一个变量或常量时需要给出对应的数据类型，用于给变量分配内存

image-20230725165912814

整型#

作用：表示整数的数据类型

C++表示整型的有以下几种方式，区别在于所占的内存空间不同

1byte（字节） = 8bit（位），2^16 = 65536，bit是最底层的单位，即0和1

数据类型	占用空间	取值范围
short（短整型）	2byte	-2^15-2^15-1
int（整型）	4byte	-2^31-2^31-1
long（长整型）	4byte（win） 4byte（linux32） 8byte（linux64）	-2^31-2^31-1
long long（长长整型）	8byte	-2^63-2^63-1

sizeof关键字#

作用：利用sizeof关键字可以得到数据类型的内存大小

语法：sizeof(数据类型/变量)

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
    short a = 10;  // 短整型
7
    int b = 10;    // 整型
8
    long c = 10; // 长整型
9
    long long d =10;  // 长长整型
10

11
    cout << sizeof(short) << endl; // 2
12
    cout << sizeof(a) << endl; // 2
13

14
    system("pause");
15
    return 0;
16
}

展开收起

浮点型#

作用：表示小数

类型：单精度float和双精度double

区别：可表示的有效数字范围不同

数据类型	占用空间	有效数字范围
float（单精度）	4byte	7位
double（双精度）	8byte	15-16位

eg.

1
int main(){
2

3
    // 定义单精度float时一定要在数据后面加上f
4
    // 小数的数据类型默认为double
5
    // 加上f告诉计算机数据为单精度浮点型
6

7
    float f1 = 3.14f;
8
    double d1 = 3.14;
9
    cout << "f1 = " << f1 << endl;
10
    cout << "d1 =" << d1 << endl;
11
    return 0;
12

13
}

字符型#

作用：表示单个字符

语法：char ch = ‘a’;

内存占用：1byte

!!! 字符型不等于字符串，定义的只能是单个字符，使用单引号

字符型变量不将其本身存储到内存当中，而是将对应的ASCLL编码存储到内存中去

eg.

1
int main(){
2

3
    // 创建字符变量
4
    char ch = 'a';
5
    cout << ch << endl;
6
    // 字符类型变量内存大小
7
    cout << sizeof(ch) << endl; // 1
8
    // ASCII编码验证（强转int）
9
    cout << (int)ch << endl; // 97
10

11
    return 0;
12
}

转义字符#

作用：用于表示一些不能表示出来的ASCLL字符

1
int main(){
2
    // 转义字符
3

4
    // 换行符 \n
5
    cout << "HelloWorld! \n"; // 控制台输出可以看到没有endl依然换行输出了
6
    // 反斜杠 \\
7
    cout << "\\" << endl;
8
    // 水平制表符 \t
9
    cout << "Hello\tHello" << endl;
10
    return 0;
11

12
}

控制台输出结果

image-20230725173927867

字符串型#

作用：表示一连串的字符

语法：string 变量名 = “字符串值”;

eg.

1
#include<string> // 使用字符串类型的变量需要引用这个头文件，iostream头文件中不包含string数据类型（部分版本编译器）
2

3
// 字符串类型的数据占用的空间大小取决于电脑系统的位数，不同电脑上占用内存大小不同，可以使用sizeof(str)来统计内存大小
4

5
int main(){
6
    string str = "helloworld";
7
    cout << str << endl; // helloworld
8
    return 0;
9
}

布尔类型#

作用：表示真[true（1）]和假[false（0）]

eg.

1
int main(){
2
    bool a = true;
3
    cout << a << endl; // 1
4

5
    bool b = false;
6
    cout << b << endl; // 0
7

8
    // 布尔类型变量占1byte内存大小
9
    cout << sizeof(bool) << endl;  // 1
10

11
    return 0;
12
}

数据的输入输出#

作用：获取键盘输入

语法：cin >> 变量;

eg.

1
int main(){
2

3
    int a = 0;
4
    cout << "a的值为：" << a << endl;   // a的值为：0
5
    cout << "请输入一个整型变量： "<< endl;
6
    cin > >  a;  // 假设键盘输入为 10
7
    cout << "a的值为：" << a << endl; // a的值为：10
8

9
    return 0;
10
}

宏定义#

宏定义在C++中是⼀个比较特殊的命令，它可以在⼀定程度上方便开发⼈员的程序设计过程。但是很多的初学者因为不能很好的去理解宏定义，不明白本质是什么，因此在使⽤宏定义的时候经常会出现问题。

宏定义：就是在⽂件的头部，使⽤#define来定义⼀个标识符⽤来描述⼀个字符串。
语法：#define 标识符字符串

!!! 宏定义一般定义在main函数外，语句后可以没有；，使用宏定义时，任何出现标识符的地方都会被后面的字符串替换

1
#include <iostream>
2
using namespace std;
3

4
#define EXPR (2 + 2)
5

6
int main() {
7
    // 这⾥的EXPR会被替换成(2 + 2)，也就成了 cout << (2 + 2) << endl;
8
    cout << EXPR << endl;
9
    // 这⾥的EXPR会被替换成(2 + 2)，也就成了 cout << (2 + 2) * (2 + 2) << endl;
10
    cout << EXPR * EXPR << endl;
11
    return 0;
12
}

命名空间（namespace）#

在C++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。⼯程越大，名称互相冲突性的可能性越⼤。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发⽣冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

我们之前在代码中已经出现过的std就是一个命名空间，这个命名空间中包含我们常用的cout，cin等

eg. 命名空间的定义及使用

1
#include <iostream>
2
using namespace std; // 没有这段代码，需要std::cout才能使用输出功能
3

4
// 定义⼀个命名空间
5
namespace A {
6
  int num = 10;
7
  // 命名空间可以嵌套
8
  namespace AA {
9
    int num = 30;
10
   }
11
}
12
namespace B {
13
  int num = 20;
14
}
15
// 命名空间是开放的，可以随时把新成员添加到现有的命名空间中
16
namespace A {
17
  int score = 100;
18
}
19
// 在命名空间中，函数的声明和实现可以分离
20
namespace A {
21
  void test();
22
}
23
void A::test() {
24
  cout << "test" << endl;
25
}
26
int main() {
27
  // 输出A命名空间中的num
28
  cout << A::num << endl;
29
  // 输出B命名空间中的num
30
  cout << B::num << endl;
31
  // 输出A::AA命名空间中的num
32
  cout << A::AA::num << endl;
33

34
  return 0;
35
}

展开收起

eg. using语法

1
#include <iostream>
2
// 定义命名空间
3
namespace constant {
4
  const double PI = 3.141592653;
5
  int num1 = 100;
6
  int num2 = 200;
7
}
8
int main() {
9
  // 输出PI
10
  std::cout << constant::PI << std::endl;
11
  // using命名空间中的指定成员
12
  using constant::num1;
13
  std::cout << num1 << std::endl;
14
  std::cout << constant::num2 << std::endl;
15
  // using命名空间
16
  using namespace constant;
17
  using namespace std;
18
  cout << num2 << :endl;
19
  return 0;
20
}

展开收起

!!! 注意事项：不能using两个不同的整个命名空间，然后使用这两个命名空间中相同命名的函数，否则会产生二义性，还是要有命名空间 :: 函数名的方式使用

运算符#

算术运算符#

eg. 假设两个数a为10，b为3，则有：

运算符	描述	示例
+	表示两数相加	a+b= 13
-	表示两数相减	a-b= 7
`*`	表示两数相乘	a*b= 30
/	表示分子除以分母	a/b= 3（3.333）
%	取模运算符，表示整除后取余数	a%b= 1
++a	前置自增运算符，变量先+1，再进行表达式运算	++a= 11
a++	后置自增运算符，变量先进行表达式运算，再+1	a++= 11
—b	前置自减运算符，变量先-1，再进行表达式运算	—b= 2
b—	后置自减运算符，变量先进行表达式运算，再-1	b—= 2

两个整数相除，结果还是整数，即使计算结果不是整数，程序也不会保留小数位，这与数据类型有关
基本常识：0不能作为除数，会报错
小数和小数可以相除，关键是考虑设置好数据类型

重点部分：理解自增自减

运行以下示例程序，寻找规律

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  // 前置自增
6
  int a = 10;
7
  cout << ++a << endl;
8
  cout << a << endl;
9

10
  // 后置自增
11
  int b = 10;
12
  cout << b++ << endl;
13
  cout << b << endl;
14

15
  // 前置自减
16
  int c = 5;
17
  cout << --c << endl;
18
  cout << c << endl;
19

20
  // 后置自减
21
  int d = 5;
22
  cout << d-- << endl;
23
  cout << d << endl;
24

25
  return 0;
26
}

展开收起

运行结果：

image-20230726104518086

怎么记忆

免责声明本方法仅用于记忆自增自减，并不代表计算机运行程序的方向性

++在本身+1，—在本身-1
++（—）在前加了再说，变量在前用了再加（减）
基本原理拆解：

1
int main(){
2
    // 前置（++i）
3
    int i =10；
4
    i = i + 1;   // 在原变量上自增
5
    return i;    // 输出修改后的变量
6

7
    // 后置（i++）
8
    int temp = 10; // 记录i的原来的值
9
    i = i +1;  // 进行自增
10
    return temp;   // 输出temp中记录的i的原值（右值）
11
}

关系运算符#

eg. 假设变量A的值为10，变量B的值为20，则

运算符	描述	示例
==	等于（等于要使用两个等号，一个等号是赋值，这点要注意）	(A==B) false
!=	不等于	(A!=B) true
>	大于	(A>B) false
<	小于	(A<B) true
>=	大于等于(同数学上一样，只要大于或等于有一个成立，即为真)	(A>=B) false
<=	小于等于(同数学上一样，只要小或等于有一个成立，即为真)	(A<=B) true

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
    int A = 10;
6
    int B = 20;
7

8
    cout << (A == B) << endl;   // 0（false）
9
    cout << (A != B) << endl;    // 1（true）
10
    cout << (A > B) << endl;     // 0 （false）
11
    cout << (A <= B) << endl;  // 1 （true）
12

13
    return 0;
14
}

逻辑运算符#

再次重复 1代表的是真（true），0代表的是假（false）

eg. 假设变量a的值为1，变量b的值为0，则

运算符	描述	示例
&&	逻辑与，如果两个操作都为true，则条件为true	(a&&b) false
\|\|	逻辑或，其中一个操作为true，则条件为true	(a\|\|b) true
！	逻辑非，用于逆转运算结果，非真即假，非假即真	!(a&&b) true
^	逻辑异或，相同为假，不同为真	(a^b) true / (a^a) false

拓展了解 上面提到的逻辑与和逻辑或，又被称为短路与和短路或，与运算符还有&，或运算符还有|，短路与（左边结果为假，右边不参与运算）和短路或（左边结果为真，右边不参与运算），这样的动态运算使短路与和短路或具有内存优势，因此更多是使用它们

赋值运算符#

运算符	描述	示例
=	简单赋值，将右边的数值赋值给左边的变量	c = a + b，将a + b的值赋给c
+=	加且赋值，将右边的数值加到左边的变量中	c += a，等同于 c = c + a
-=	减且赋值，从左边的变量中减去右边的数值	c -= a，等同于 c = c - a

三目运算符#

三目运算符是一个具有简单逻辑的运算符
语法：condition ？value1 ：value2；
解释：condition处是一个bool类型的变量或者是一个运算结果为bool类型的表达式，如果condition的结果为true时运算结果就为value1，结果为false时运算结果就为value2

eg.

1
#include <iostream>
2
using namespace std;
3

4
int main(){
5
    int num1 = 10;
6
    int num2 = 100;
7

8
    int res = num1 > num2 ? num1 : num 2;
9
    cout << res << endl;  // 100
10

11
    return 0;
12
}

杂项运算符#

运算符	描述	示例
sizeof	统计内存大小运算符	sizeof(int)/sizeof(a)

程序流程结构#

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

顺序结构：程序按照顺序执行，不进行跳转
选择结构：依据条件是否满足，有选择的执行相应功能
循环结构：依据条件是否满足，循环多次执行某段代码

选择结构#

选择结构：又被称为分支结构，通过判断条件是否符合，选择其中的一条分支继续执行

描述图：

if语句#

单行格式if语句(如果if下的语句只有一行，可以不使用{ })
```
1
if(条件){
2
    条件满足时执行的语句
3
}
```

多行格式if语句（if_else语句）

1
if(条件){
2
    条件满足时执行的语句
3
}
4
else{
5
    条件不满足时执行的语句
6
}

多条件if语句（if_else if_else语句）

1
if(条件1){
2
    满足条件1时执行的语句
3
}
4
else if(条件2){
5
    满足条件2时执行的语句
6
}
7
else{
8
    都不满足时执行的语句
9
}

嵌套if语句

1
if(条件1){
2
    if(条件2){
3
        在满足条件1的情况下还满足条件2执行的语句
4
    }
5
}

举例

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  int grade = 600;
6
  if(grade >= 600){
7
    cout << "优秀" << endl;
8
  }
9
  else if(grade >= 500){
10
    cout << "良好" << endl;
11
  }
12
  else{
13
    cout << "继续努力" << endl;
14
  }
15

16

17
  return 0;
18
}

展开收起

三目运算符#

提示本部分内容在上面的运算符部分已经讲过了，就不再做重复

switch语句#

作用：执行多条件分支语句

语法：

1
switch(表达式){
2
    case 结果1 ：{
3
  执行语句1
4
  break;
5
    }
6
    case 结果2 ：{
7
  执行语句2
8
        break; // break用于结束当前分支语句，没有break，switch语句有穿透性会继续执行
9
    }
10
    default : {
11
        都不符合时执行的语句
12
        break;
13
    }
14
}

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
int i = 1;
6
switch(i){
7
   case 1:
8
      cout << "Hello World!" << endl;
9
      break;
10
   case 2:
11
     cout << "Hello World!2" << endl;
12
     break;
13
   case 3:
14
     cout << "Hello World3" << endl;
15
     break;
16
   default:
17
     cout << "Haaaa" << endl;
18
     break;
19
  }
20
  return 0;
21
}

展开收起

运行结果：

Hello World!
Process exited after 0.1242 seconds with return value 0 请按任意键继续…

switch的穿透性穿透性<指的是当switch的变量和某>⼀个case值匹配上之后，将会跳过后续的case或者default的匹配，直接向后穿透。break可以用于避免穿透性

image-20230727113349218

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
    int i = 1;
6
    switch(i){
7
        case 1:
8
            cout << "春暖花开" << endl;
9
        case 2:
10
            cout << "闷热" << endl;
11
        case 3:
12
            cout << "秋高气爽" << endl;
13
        case 4:
14
            cout << "滴水成冰" << endl;
15
        default:
16
            cout << "火星的" << endl;
17
        }
18
    return 0;
19
}

展开收起

运行结果：

春暖花开闷热秋高气爽滴水成冰火星的
Process exited after 0.1461 seconds with return value 0 请按任意键继续…

循环结构#

循环结构：依据条件是否满足，循环多次执行某段代码
描述图：

image-20230727120721620

while循环#

作用：满足循环条件，执行循环语句
语法：while(循环条件){循环语句}
PS<在执行循环语句时>，程序必须提供跳出循环的出口，否则会出现死循环的情况

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  int i = 0 ;
6
  while(i < 10){
7
    cout << "***" << endl;
8
    i++;
9
  }
10
  return 0;
11
}

运行结果：

image-20230727114702118

do-while循环#

与while语句的区别：while语句先判断再执行，因此while语句最少可以1次都不执行，但do-while语句则先执行语句再判断条件，因此do-while语句最少都要执行1次
语法：do{循环语句}while(循环条件)

eg.

1
#include<iostream>
2
using namespace std;
3

4
int mian(){
5
    int i = 0;
6
    do{
7
        cout << "***" << endl;
8
        i++;
9
    }while(i < 10);
10
    return 0;
11
}

for循环语句#

语法：for(起始表达式；条件表达式；循环体){循环语句}
eg.
```
1
for(int i = 0; i < 10; i++){
2
    cout << i << endl;
3
}
```
运行结果：

0
1
2
3
4
5
6
7
8
9
Process exited after 0.08312 seconds with return value 0 请按任意键继续…

嵌套循环#

作用：在循环体里再嵌套一层循环，解决一些实际问题
eg. 只使用cout << "@" << " " ;作为输出语句，输出10列10行的@
```
1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
// 内层执行10次，外层才执行1次
6
  for(int i = 0;i < 10;i++){
7
    for(int j = 0;j < 10;j++){
8
      cout << "@" << "  " ;
9
    }
10
    cout << endl;
11
  }
12

13
  return 0;
14
}
```
运行结果：

@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
@ @ @ @ @ @ @ @ @ @
Process exited after 0.06804 seconds with return value 0 请按任意键继续…
break可以用于结束当前循环

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  for(int i = 0;i < 10;i++){
6
    for(int j = 0;j < 10;j++){
7
      cout << "@" << "  ";
8
      if(j > 4){
9
        break;  //  这个break在内层循环中，就是说大于4的列数不能输出，最终结果只能输出5列
10
      }
11
    }
12
    cout << endl;
13
    if (i > 3){
14
      break;  // 这个break在外层循环中，就是说大于3的行数不能输出，最终结果只能输出4列
15
    }
16
  }
17

18
  return 0;
19
}

展开收起

运行结果：

@ @ @ @ @ @
@ @ @ @ @ @
@ @ @ @ @ @
@ @ @ @ @ @
@ @ @ @ @ @
Process exited after 0.09022 seconds with return value 0 请按任意键继续…

continue可以跳过当前轮数的循环

eg. 通过continue语句输出1-20中的偶数

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  for(int i = 1;i < 21;i++){
6
    if(i % 2 != 0){
7
      continue;  // 这里的continue语句作用是告诉计算机当这个数为单数时请跳到下一次循环，不再执行输出
8
    }
9
    cout << i << "  ";
10
  }
11

12
  return 0;
13
}

运行结果：

2 4 6 8 10 12 14 16 18 20
Process exited after 0.09924 seconds with return value 0 请按任意键继续…

goto语句#

作用：在程序中，可以任意的设置“标签”，使⽤关键字goto可以直接跳转到指定的标签位置继续执⾏程序！
PS：在实际开发中不建议使用goto语句，否则逻辑会很乱，不便于阅读

eg.

1
label1:
2
cout << "1" << endl;
3
goto label3;
4
label2:
5
cout << "2" << endl;
6
label3:
7
cout << "3" << endl;

运行结果：

1
3
Process exited after 0.09924 seconds with return value 0 请按任意键继续…

数组#

概述：所谓数组，就是我们在高一数学第一课中讲到的集合（物以类聚），里面存放了相同类型的数据元素
特点
- 特点1：数组中的每一个元素都是相同的数据类型
- 特点2：数组是连续的内存位置组成的（这个特点的验证我们可以到指针部分详细的说明）
- PS数组在数据类型设置正确的情况下，不仅仅可以存放数字，还可以存放字符，字符串（需要用单引号或双引号包住，数字则不用）等数据

一维数组#

概述：只有一行且有有限的元素的数组

一维数组的定义：

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  // 第一种定义方式
6
  // 数据类型 数组名 [元素个数]
7
  int score[10];
8

9
  // 利用下标法赋值（从0开始）
10
  score[0] = 166;
11
  score[1] = 69;
12
  score[2] = 22;
13

14
  cout << score[0] << endl;   // 166
15
  cout << score[1] << endl;   // 69
16
  cout << score[2] << endl;   // 22
17
  cout << score[4] << endl;   // 0(整型数组默认初始值为0)
18

19
  // 第二种定义方式
20
  // 数据类型 数组名[元素个数] = {元素1,元素2,元素3,...}
21
  int score1[10] = {0,1,2,3,4,5,6,7,8,9} ;
22
  // 遍历输出
23
  for(int i = 0;i < 10;i++){
24
    cout << score1[i] << " ";  // 0 1 2 3 4 5 6 7 8 9
25
  }
26

27
        cout << endl;
28

29
  // 第三种定义方式
30
  // 数据类型 数组名[] = {值1，值2，....}
31
  int score2[] = {1,5,46,5} ;
32
  for(int j = 0;j < 4;j++){
33
    cout << score2[j] << " "; // 1 5 46 5
34
  }
35

36
  return 0;
37
}

展开收起

获取数组占用内存空间大小

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  int arr[10] = {1,2,3,4,5,6,7,8,9,10};
7

8
  cout << "整个数组占用的内存空间为：" << sizeof(arr) << endl;
9
  cout << "每个元素所占内存空间的大小为：" << sizeof(arr[0]) << endl;
10

11
  // 获取一维数组长度（使用这个数组所占内存大小除以单个元素内存大小）
12
  // 已知数组数据类型时sizeof(arr[0])可以被替换为sizeof(int)
13
  cout << "数组的长度为：" << sizeof(arr)/sizeof(arr[0]) << endl;
14

15
  return 0;
16
}

展开收起

运行结果

整个数组占用的内存空间为：40
每个元素所占内存空间的大小为：4
数组的长度为：10
Process exited after 0.08026 seconds with return value 0 请按任意键继续…

获取数组首位内存地址（&为取地址符，后续在指针那块会做详细讲解）
```
1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  int arr[10] = {1,2,3,4,5,6,7,8,9,10};
7

8
  // 获取数组的首地址（逻辑与&，又叫取地址符）
9
  cout << "数组的首地址为：" << &arr << endl;
10
  cout << "数组中第一个元素的地址为：" << &arr[0] << endl;
11
  cout << "数组中第二个元素的地址为：" << &arr[1] << endl;
12

13
  return 0;
14
}
```
运行结果

数组的首地址为：0x70fdf0
数组中第一个元素的地址为：0x70fdf0
数组中第二个元素的地址为：0x70fdf4
Process exited after 0.08472 seconds with return value 0 请按任意键继续…

我们可以看到直接去数组的地址得到的地址和数组第一个元素的地址相同，我们可以推测数组记录的地址就是首位元素的地址，再观察第一第二个元素的地址我们可以看到差值为4，在结合数据类型中整型的内存大小为4，就可以证明数组是有连续的内存位置组成的。

修改数组中的元素

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  int arr[10] = {1,2,3,4,5,6,7,8,9,10};
7

8
  // 修改数组中的元素
9
  cout << "修改前第一个元素：" << arr[0] << endl;  // 1
10
  arr[0] = 100;
11
  cout << "修改后第一个元素：" << arr[0] << endl; // 100
12

13
  return 0;
14
}

!!!数组名是常量是一串固定的内存地址，不能修改

二维数组#

概述：二维数组在一维数组的基础上增加了一个维度，就类似于一个表格

二维数组的定义

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  // 方式1
7
  // 数组类型 数组名[行数][列数] ;
8
  int arr[2][3];
9
  arr[0][0] = 1;
10
  arr[0][1] = 2;
11
  arr[0][2] = 3;
12
  arr[1][0] = 4;
13
  arr[1][1] = 5;
14
  arr[1][2] = 6;
15

16
  // 方式2
17
  // 数据类型 数组名[行数][列数] =  {{值1,值2},{值3,值4}};
18
  int arr1[2][3] = {
19
    {1,2,3},
20
    {4,5,6}
21
  };
22

23
  // 方式3
24
  // 数据类型 数组名[行数][列数] = {值1,值2,...};
25
  int arr2[2][3] = {1,2,3,4,5,6};
26

27
  // 方式4
28
  // 数据类型 数组名[][列数] = {值1,值2,...};
29
  int arr3[][3] = {1,2,3,4,5,6};
30

31
  // 输出结果(可以通过修改数组名查看4种方式的结果)
32
  for(int i = 0;i < 2; i++){
33
    for(int j = 0 ; j < 3 ;j++){
34
      cout << arr[i][j] << "  ";
35
    }
36
    cout << endl;
37
  }
38

39
  return 0;
40
}

展开收起

运行结果

1 2 3
4 5 6
Process exited after 0.0901 seconds with return value 0 请按任意键继续…

二维数组的使用

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  int arr[2][3] = {
7
    {1,2,3},
8
    {4,5,6}
9
  };
10

11
  cout << "二维数组的大小为：" << sizeof(arr) << endl;
12
  cout << "二维数组中一行的大小为：" << sizeof(arr[0]) << endl;
13
  cout << "二维数组中元素的大小为：" << sizeof(arr[0][0]) << endl;
14

15
  // 计算二维数组的行数和列数
16
  cout << "二维数组的行数为：" << sizeof(arr)/sizeof(arr[0]) << endl;
17
  cout << "二维数组的列数为：" << sizeof(arr[0])/sizeof(arr[0][0]) << endl;
18

19
  // 取地址
20
  cout << "二维数组的地址：" << arr << endl;
21
  cout << "二维数组第一行地址：" << arr[0] << endl;
22
  cout << "二维数组第二行地址：" << arr[1] << endl;
23
  cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
24
  cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
25

26
        // 二维数组的元素修改跟一维数组是相同的，不做过多举例
27

28
  return 0;
29
}

展开收起

运行结果

二维数组的大小为：24
二维数组中一行的大小为：12
二维数组中元素的大小为：4
二维数组的行数为：2
二维数组的列数为：3
二维数组的地址：0x70fdf0
二维数组第一行地址：0x70fdf0
二维数组第二行地址：0x70fdfc
二维数组第一个元素地址：0x70fdf0
二维数组第二个元素地址：0x70fdf4
Process exited after 0.07603 seconds with return value 0 请按任意键继续…

我们可以看到二维数组的首地址与一维数组的首地址都是首元素的地址，我们在定义二维数组时每一行中都有三个元素，一个元素占用内存为4，则一列占用内存为12，c在16进制中表示的是13，与首地址的差值正好是12

函数#

作用：将一段代码封装起来，减少重复代码

函数的定义#

返回值类型
函数名
参数列表
函数体语句
Return表达式

语法

1
返回值类型 函数名 （参数列表）{
2

3
  函数体语句
4

5
  Return表达式
6
}

eg. 我们以我们每个程序中都有的主函数为例来看看函数的定义

1
int main(){
2

3
    System("pause");
4

5
    return 0;
6
}

eg. 实现一个加法函数，传入两个整型参数，计算结果并返回

返回值类型 int
函数名 add
参数列表 (int a,int b) (这个部分中的参数叫做形参，没有具体的值，需要传入参数)
函数体语句 int sum = a + b
Return语句 return sum

1
int add(int a,int b){
2
  int sum = a + b;
3
  return sum;
4
}

函数的调用#

语法：函数名 (实际参数);
如：add(a,b);

eg.

1
#include<iostream>
2
using namespace std;
3

4
int add(int a,int b){
5
  int sum = a + b;
6
  return sum;
7
}
8

9

10
int main(){
11

12
     // 调用add函数，把10传到a，20传到b，返回并输出结果
13
  cout << add(10,20) << endl;     // 30
14

15
  int num1 = 10;
16
        int num2 = 20;
17
        int result = add(num1,num2);
18
        cout << result << endl;         // 30
19

20
  return 0;
21
}

展开收起

值传递#

定义：值传递就是函数调用时实参的数值传给形参的过程
值传递时，如果形参发生改变，不会影响实参

eg.

1
#include<iostream>
2
using namespace std;
3

4
// 定义一个返回值为空类型的函数，实现一个交换两个参数的功能
5
void swap(int num1,int num2){
6
  int temp = num1;
7
  num1 = num2;
8
  num2 = temp;
9
}
10

11
int main(){
12

13
  int a = 12;
14
  int b = 33;
15

16
  swap(a,b);
17

18
  cout << a << " " << b << endl;    // 12  33
19
  // 我们可以从结果看出num1和num2这两个形参的位置互换并没有导致a和b这两个实参的改变
20
  // 每个变量都有对应的内存地址，由此可见a,b和num1,num2并不在同一地址，传参的过程只是将实参的值写入形参所在的空间（内存地址）
21
        // 关于内存地址的详细内容见指针部分
22

23
  system("pause");
24
  return 0;
25
}

展开收起

函数的常见形式#

无参无返

1
void test01(){
2
    cout << "无参无返" << endl;
3
}
4

5
//  调用方法
6
test01();

有参无返

1
void test02(int a){
2
    cout << "有参无返" << endl;
3
}
4

5
// 调用方法
6
test02(10);

无参有返

1
int test03(){
2
    return 1000;
3
}
4

5
// 调用方法
6
int a = test03();
7
cout << a << endl; // 1000

有参有返

1
int test04(int a){
2
    cout << "a的值为" << a << endl;
3
    return a;
4
}
5

6
// 调用方法
7
int b = test04(100);
8
cout << b << endl; // 100

完整演示

1
#include<iostream>
2
using namespace std;
3

4
void test01(){
5
    cout << "无参无返" << endl;
6
}
7

8
void test02(int a){
9
    cout << "有参无返" << endl;
10
}
11

12
int test03(){
13
    return 1000;
14
}
15

16
int test04(int a){
17
    cout << "a的值为" << a << endl;
18
    return a;
19
}
20

21
int main(){
22

23
  test01();
24

25
  test02(10);
26

27
  int a = test03();
28
  cout << a << endl; // 1000
29

30

31
  int b = test04(100);
32
  cout << b << endl; // 100
33

34
  return 0;
35
}

展开收起

运行结果

无参无返
有参无返
1000
a的值为100
100
Process exited after 0.08018 seconds with return value 0 请按任意键继续…

函数的声明#

当你把main函数放在前面，其他函数放在后面，但你又在主函数中调用后面的函数的时候，就要在主函数前面进行声明，意思是告诉主函数，有这么个函数在后面可以调用（原因：代码是一行一行从上到下执行的）

作用：告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义，函数的声明可以多次，函数的定义只能一次

eg.

1
#include<iostream>
2
using namespace std;
3

4
// 函数的声明
5
int max(int num1,int num2);
6

7
int main(){
8
  int a = 10;
9
  int b = 20;
10

11
  cout << max(a,b) << endl;
12

13
  return 0;
14
}
15

16
// 函数的定义
17
int max(int num1,int num2){
18
  return num1 > num2 ? num1 : num2;
19
}

展开收起

最新版本的编译器支持不用声明使用主函数后的函数

函数的高阶用法#

函数参数的默认值

在定义参数的时候我们可以给参数一个默认的值，例如：

1
int add(int num1,int num2 = 100){
2
    return num1 + num2;
3
}
4

5
// 调用这个函数的时候可以给num2传入实参也可以不传
6
int main(){
7
    cout << add(100,200) << endl;
8
    cout << add(100) << endl;
9
}

需要注意的是，有默认值的参数，必须是在参数列表的末尾，否则会报错

函数的重载

如果存在多个函数，满足以下两点，则这两个函数构成了重载关系(Overload)

函数名相同
参数不同

参数的不同体现在数量不同，数据类型的不同

注意：重载只与函数的名字、参数有关，与返回值无关

1
#include <iostream>
2
using namespace std;
3

4

5
// 重载载函数的定义
6
void add(int num1, int num2) {
7
  cout << "add(int,int)" << endl;
8
}
9
void add(int num1, double num2) {
10
  cout << "add(int,double)" << endl;
11
}
12
void add(double num1, int num2) {
13
  cout << "add(double,int)" << endl;
14
}
15
void add(double num1, double num2) {
16
  cout << "add(double,double)" << endl;
17
}
18

19

20
int main() {
21

22
  // 区分重载函数靠参数类型，数量（按照返回值区分的函数不能重载）
23
  add(10, 20);   // 调的是add(int, int)的方法
24
  add(10, 11.3); // 调的是add(int, double)的方法
25
  add(11.2, 10); // 调的是add(double, int)的方法
26
  add(11.1, 22.2); // 调的是add(double, double)的方法
27
  return 0;
28
}

展开收起

函数的递归

递归，是一种程序设计的思想。在解决问题的时候，可以将问题拆分成若干个小问题。这些小问题的解决方式，与大的问题解决方式相同。通过解决这些小的问题，逐渐解决这个大的问题。那么什么情况下可以使用递归呢？
- 需要解决的问题可以拆分为若干个小问题，大小问题的解决方法相同
- 有固定规律，自己调用自己
递归涉及到方法的循环调用，因此递归需要设置有效出口条件，避免死递归（无穷递归），导致方法无法结束，方法压栈运行导致栈溢出

C++111
1 #include <iostream> 2 using namespace std; 3 4 //函数的递归：有固定的规律，方法中调用自己 5 //设置有效出口条件，避免死递归（无穷递归），导致方法无法结束，压栈运行而出现栈溢出 6 7 // 定义一个计算阶乘的函数 8 int multiply(int num){ 9 if(num == 1){ 10 return 1; 11 } 12 return num * multiply(num - 1); 13 } 14 15 16 int main(){ 17 18 cout << multiply(5) << endl; 19 20 return 0; 21 }
展开收起
- 函数的递归经典例题：斐波拉契数列
斐波那契数列#
题目描述#
斐波那契数列是指这样的数列：数列的第一个和第二个数都为 1，接下来每个数都等于前面 2 个数之和。
给出一个正整数a，要求斐波那契数列中第a个数是多少。
输入格式#
第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数a(1 <= a <= 30）。
输出格式#
输出有n行，每行输出对应一个输入。输出应是一个正整数，为斐波那契数列中第a个数的大小。
样例 #1#
样例输入 #1#
1 4 2 5 3 2 4 19 5 1
样例输出 #1#
1 5 2 1 3 4181 4 1
我的题解（仅供参考）#
1 #include <iostream> 2 using namespace std; 3 4 int fib(int index){ 5 if(index == 1 || index == 2){ 6 return 1; 7 } 8 return fib(index - 1) + fib (index - 2); 9 } 10 11 int main(){ 12 int m,n; 13 cin >> m; 14 int time01[m]; 15 for(int i = 0;i < m;i++){ 16 cin >> time01[i]; 17 } 18 for(int j = 0;j < m;j++){ 19 n = time01[j]; 20 cout << fib(n) << endl; 21 } 22 return 0; 23 }
展开收起
斐波拉契数列函数的简单实现
```
1
int fib(int num){
2
    if(num == 1 || num == 2){
3
        return 1;
4
    }
5
    return fib(num - 1) + fib(num - 2);
6
}
```
调用其他文件里的函数

我们程序中默认只能调用当前文件中定义的函数，但是一个大型的项目不止由一个文件来组成，很多时候是需要跨文件来调用、访问的。例如，我们将常用的数学计算的功能定义在某一个文件中，那么如何调用这个文件中定义的函数呢

首先我们需要知道，.cpp文件中的内容是无法跨文件直接访问的，如果我们需要让某一个函数跨文件访问，需要为其定义一个.h文件，我们称为“头文件”。在头文件中添加函数的声明部分即可。需要使用的时候，直接使用＃include来包含指定的头文件即可完成。
feibo.cpp
```
1
#include <iostream>
2

3
int feibo(int index){
4
  if(index == 1 || index == 2){
5
    return 1;
6
  }
7
  return feibo(index - 1) + feibo (index - 2);
8
}
```
feibo.h
```
1
// 只做声明不做定义
2

3
int feibo(int index);
```
```
1
// 文件名：main.cpp(可自行选择需要调用函数的文件)
2
#include <iostream>
3
#include "feibo.h"   // 自定义的头文件需要用""来引用，而不是<>
4

5
using namespace std;
6

7
int main(){
8
    // 此时可以直接调用feibo.cpp中定义的函数
9
  cout << feibo(10) << endl;
10
  return 0;
11
}
```

指针#

指针的概念#

作用：可以通过指针来间接访问内存
内存编号从0开始，一般使用16进制数字表示
可以利用变量保存地址
指针占用的内存地址：
```
1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  // 指针也是一种数据类型，看看指针的内存大小
6

7
  cout << "int类型指针占用内存："  << sizeof(int *) << endl;
8
  cout << "float类型指针占用内存："  << sizeof(float *) << endl;
9
  cout << "double类型指针占用内存："  << sizeof(double *) << endl;
10
  cout << "char类型指针占用内存："  << sizeof(char *) << endl;
11

12

13
  return 0;
14
}
```
运行结果

64位
int类型指针占用内存：8
float类型指针占用内存：8
double类型指针占用内存：8
char类型指针占用内存：8
Process exited after 0.07549 seconds with return value 0 请按任意键继续…
32位
int类型指针占用内存：4
float类型指针占用内存：4
double类型指针占用内存：4
char类型指针占用内存：4
Process exited after 0.1363 seconds with return value 0 请按任意键继续…

在32位操作系统下，指针占用4byte内存，在64位操作系统下，指针占用8byte内存

每定义一个变量，程序会向计算机申请一个内存空间，空间的大小取决于数据类型

pic

指针的定义及使用#

指针的定义#

语法：数据类型 *变量名

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  // 定义一个指针
7
  int num1 = 10;
8
  // 指针的定义语法： 数据类型 *变量名
9
  // 指针的数据类型需要和变量的数据类型相同
10
  int *p;
11
  // &取地址符
12
  p = &num1;
13

14
  cout << "num1的地址是：" << &num1 << endl;
15
  cout << "指针p是：" << p << endl;
16

17

18
  return 0;
19
}

展开收起

运行结果

num1的地址是：0x70fe14
指针p是：0x70fe14
Process exited after 0.1053 seconds with return value 0 请按任意键继续…

解引用#

语法：*指针名称
作用：通过指针找到对应的内存地址

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  // 定义一个指针
7
  int num1 = 10;
8
  // 指针的定义语法： 数据类型 *变量名
9
  // 指针的数据类型需要和变量的数据类型相同
10
  int *p;
11
  // &取地址符
12
  p = &num1;
13

14
  // 使用指针
15
  // 可以通过解引用的方式来找到指针指向的内存
16
  // 指针前面加一个*表示解引用
17
  cout << "指针p指向的内存的值为：" << *p << endl;
18
  *p = 100;  // 可以通过修改指针p指向内存的值来修改变量的值
19
  cout << "现在num1的值：" << num1 << endl;
20
  cout << "现在指针p指向的内存的值是：" << *p << endl;
21

22

23

24
  return 0;
25
}

展开收起

运行结果

指针p指向的内存的值为：10
现在num1的值：100
现在指针p指向的内存的值是：100
Process exited after 0.03959 seconds with return value 0 请按任意键继续…

指针在数组中的应用#

利用指针访问数组中的元素

1
using namespace std;
2

3
int main(){
4
  int arr[] = {1,2,3,4,5,6,7,8,9,10};
5
  int *p = arr; // 指向数组的指针
6

7
  cout << "第一个元素是：" << arr[0] << endl;
8
  cout << "指针访问的第一个元素是：" << *p << endl;
9
//  p++;
10
//  cout << *p;
11
// 通过指针p的自增可以遍历数组中的元素
12

13
  for(int i = 0; i < 10; i++){
14
    cout << *p << endl;
15
    p++;
16
  }
17

18
  return 0;
19
}

展开收起

运行结果

第一个元素是：1
指针访问的第一个元素是：1
1
2
3
4
5
6
7
8
9
10
Process exited after 0.07373 seconds with return value 0 请按任意键继续…

指针在函数中的应用#

作用：利用指针函数修改实参的值

1
#include <iostream>
2
using namespace std;
3

4
// 值传递
5
void change(int num){
6
  num = 200;
7
  cout << "&num = " << &num << endl;
8
}
9

10
// 地址传递
11
void change2(int* num){
12
  cout << num << endl;
13
  *num = 200;
14
}
15

16
int main(){
17
  int n = 10;
18
  cout << "&n = " << &n << endl;
19
  change(n);
20
  cout << n << endl;
21

22
  change2(&n);
23
  cout << n << endl;
24

25
  return 0;
26
}

展开收起

运行结果

&n = 0x70fe1c
&num = 0x70fdf0
10
0x70fe1c
200
Process exited after 0.1821 seconds with return value 0 请按任意键继续…

常量引用：在形参前加const可以规避变量因误操作而被修改

空指针和野指针#

空指针：指针指向内存编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存不可访问

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  // 空指针
6
  int *p = NULL;
7
  // 内存地址0-255为系统保留内存，没有权限访问
8
  // 编译运行后无任何输出
9
  cout << *p << endl;
10

11
  return 0;
12
}

野指针：指向非法内存地址的指针

eg.

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5

6
  // 野指针
7
  // 指针变量p指向内存地址为0x1000的空间
8
  int *p = (int *)0x1000;
9
  cout << *p << endl;
10
  // 编译运行后无输出
11

12
  return 0;
13
}

常量指针和指针常量#

const修饰指针的三种情况
1. const修饰指针——常量指针（指针的指向可以修改，但指向的值不可用修改）
2. const修饰常量——指针常量（指针的指向不可用修改，但指向的值可以修改）
3. const既修饰指针，有修饰常量（指针指向不可用修改，指向的值不可以修改）

示例

1
#include<iostream>
2
using namespace std;
3

4
int main(){
5
  int num1 = 10;
6
  int num2 = 20;
7

8
  // 常量指针
9
  const int *p = &num1;
10
  *p = 20; // 运行报错，不能修改指向的值
11
  p = &num2; // 正确，可以修改指针指向
12

13
  // 指针常量
14
  int * const p2 = &num1;
15
  *p2 = 100; // 正确，可以修改指向的值
16
  p2 = &num2; // 运行报错，不可以修改指针指向
17

18

19
  // const修饰指针和常量
20
  const int * const p3 = &num1;
21
  *p3 = 100; // 错误
22
  p3 = &num2; // 错误
23

24

25
  return 0;
26
}

展开收起

引用#

作用：作为一个已定义变量的别名，值和内存地址都与原变量一致
语法：数据类型& 引用名称 = 变量/值

eg.

1
#include <iostream>
2
using namespace std;
3

4
int main(){
5
  int num = 10;
6
  // 定义一个引用
7
  int& a = num;
8

9
  // 比较值
10
  cout << "num = " << num << " " << "a = " << a << endl;
11

12
  // 比较地址
13
  cout << "&num = " << &num << " " << "&a = " << &a << endl;
14

15
  a = 100;
16
  cout << "num = " << num << " " << "a = " << a << endl;
17

18
  return 0;
19
}

展开收起

运行结果

num = 10 a = 10
&num = 0x70fe04 &a = 0x70fe04
num = 100 a = 100
Process exited after 0.08213 seconds with return value 0 请按任意键继续…

引用的实质就是一个指针常量

引用在函数中的应用#

在之前函数的部分中我们说到修改形参不会对实参造成影响，如果我们想通过函数来修改实参要怎么做，引用就可以做到，同样以对换变量的值的函数为例

1
#include <iostream>
2
using namespace std;
3

4
void swap(int num1,int num2){
5
  int tmp = num1;
6
  num1 = num2;
7
  num2 = tmp;
8
}
9

10
void swap2(int& num1,int& num2){
11
  int tmp = num1;
12
  num1 = num2;
13
  num2 = tmp;
14
}
15

16
int main(){
17

18
       // 形参的改变对实参不造成影响
19
  int x = 10, y =20;
20
  swap(x,y);
21
  cout << "(" << x << "," << y << ")" << endl;
22

23
       // 通过引用实现形参控制实参的改变
24
  swap2(x,y);
25
  cout << "(" << x << "," << y << ")" << endl;
26

27

28
  return 0;
29
}

展开收起

运行结果

(10,20)
(20,10)
Process exited after 0.08361 seconds with return value 0 请按任意键继续…

结构体#

结构体的定义#

语法：

1
struct 结构体名称{
2
    // 成员属性
3
    int 成员1;
4
    char 成员2;
5
}

示例程序

1
#include<iostream>
2

3
using namespace std;
4

5
// 公有的，C语言的老古董
6
struct Book{
7
  string name;
8
  string author;   // 如果结构体中成员有初始值，赋值不能使用花括号
9
  string date;
10
}book2,book3; // 全局变量
11

12
// 私有的
13
class Book00{
14
        string name;
15
  string author;
16
  string date;
17
}
18

19

20
int main(){
21

22
  // 局部变量 01
23
  Book book1;
24
  book1.name = "西游记";
25
  book1.author = "吴承恩";
26
  book1.date = "很久以前";
27

28
  // 局部变量02
29
  // 这种方式没有赋值的部分一定是后面的部分
30
  book3 = {"数学","全中国高中生的噩梦","2019吧"};
31

32
  cout << book1.date << endl;
33

34
  return 0;
35
}

展开收起

结构体的使用#

在函数中的使用#

1
#include<iostream>
2

3
struct Book{
4
  string name;
5
  string author;
6
  string date;
7
}；
8

9
Book getBook(){
10
  return{"西游记","吴承恩","很久以前"};
11
}
12

13
int main(){
14
  Book ourBook = getBook();
15

16
  cout << ourBook.name << endl;
17

18
  return 0;
19
}

展开收起

在数组中的使用#

1
#include<iostream>
2

3
using namespace std;
4

5
struct Book{
6
  string name;
7
  string author;
8
  string date;
9
};
10

11
int main(){
12

13
  Book bookArray[2] = {{"西游记","吴承恩","2020"},{"数学","出版社","2019"}};
14

15
  for(int i = 0;i < 2;i++){
16
    cout << bookArray[i].name << endl;
17
    cout << bookArray[i].author << endl;
18
    cout << bookArray[i].date << endl;
19
  }
20

21
  return 0;
22
}

展开收起

运行结果

西游记
吴承恩
2020
数学
出版社
2019
Process exited after 0.07819 seconds with return value 0 请按任意键继续…

和指针的应用#

1
#include<iostream>
2

3
using namespace std;
4

5
struct Book{
6
  string name;
7
  string author;
8
  string date;
9
};
10

11
int main(){
12

13
  Book book1;
14
  book1.name = "西游记";
15

16
  Book* p = &book1;
17

18
  // 结构体的指针需要指向对应的成员
19
  p -> name = "qita";
20

21
  cout << p -> name << endl;
22

23

24

25
  return 0;
26
}

展开收起

结构体的嵌套#

1
#include<iostream>
2

3
using namespace std;
4

5
// 结构体的嵌套
6
struct Data{
7
  int year;
8
  int month;
9
  int day;
10
};
11

12

13
struct Book{
14
  string name;
15
  string author;
16
  Data date;
17
};
18

19
void printBook(Book *book){
20
  book -> name = "我修改了书名";
21
  cout << "书名：" << book -> name << endl;
22
  cout << "出版年份：" << book -> date.year << endl;
23
}
24

25
int main(){
26
  Book book1;
27
  book1.date.year = 1888;
28
  cout << book1.date.year << endl;
29

30
  Book *p = &book1;
31
  printBook(p);
32
  cout << book1.name << endl;
33

34
  return 0;
35
}

展开收起

运行结果

1888
书名：我修改了书名
出版年份：1888
我修改了书名
Process exited after 0.1055 seconds with return value 0 请按任意键继续…

C语言：指针

Fri, 22 Aug 2025 00:00:00 GMT

指针的概念#

系统给虚拟内存的每个存储单元分配了一个编号，从0x00000000 ~ 0xffffffff ，这个编号称之为地址
指针变量：用来存放一个地址的变量
作用：可以通过指针来间接访问内存
每定义一个变量，程序会向计算机申请一个内存空间，空间的大小取决于数据类型

pic

1
#include<stdio.h>
2

3
int main(){
4

5
    printf("int类型指针占用内存：%d\n",sizeof(int *));
6
    printf("float类型指针占用内存：%d\n",sizeof(float *));
7
    printf("double类型指针占用内存：%d\n",sizeof(double *));
8
    printf("char类型指针占用内存：%d\n",sizeof(char *));
9

10
    return 0;
11
}

运行结果

64位
int类型指针占用内存：8 float类型指针占用内存：8 double类型指针占用内存：8 char类型指针占用内存：8
32位
int类型指针占用内存：4 float类型指针占用内存：4 double类型指针占用内存：4 char类型指针占用内存：4

扩展在32位操作系统下，指针占用4byte内存，在64位操作系统下，指针占用8byte内存

指针变量的定义#

语句：数据类型 * 变量名

eg.

1
#include<stdio.h>
2

3
int main(){
4

5
  // 定义一个指针
6
  int num1 = 10;
7
  // 指针的定义语法： 数据类型 *变量名
8
  // 指针的数据类型需要和变量的数据类型相同
9
  int *p;
10
  // &取地址符
11
  p = &num1;
12
    printf("num1的地址是：%p\n",&num1);
13
    printf("指针p是：%p\n",p);
14

15
    return 0;
16
}

展开收起

运行结果(不同设备运行结果不同，但两个地址结果一定相同)

num1的地址是：000000000061FE14 指针p是：000000000061FE14
请按任意键继续…

指针的解引用#

语法：*指针名称

作用：通过指针找到对应的内存地址

1
#include<stdio.h>
2

3
int main(){
4

5
  // 定义一个指针
6
  int num1 = 10;
7
  // 指针的定义语法： 数据类型 *变量名
8
  // 指针的数据类型需要和变量的数据类型相同
9
  int *p;
10
  // &取地址符
11
  p = &num1;
12

13
  // 使用指针
14
  // 可以通过解引用的方式来找到指针指向的内存
15
  // 指针前面加一个*表示解引用
16
  printf("指针p指向的内存的值为：%d\n",*p);
17
  *p = 100;  // 可以通过修改指针p指向内存的值来修改变量的值
18
  printf("现在num1的值：%d\n",num1);
19
  printf("现在指针p指向的内存的值是：%d\n",*p);
20

21
  return 0;
22
}

展开收起

运行结果

指针p指向的内存的值为：10 现在num1的值：100 现在指针p指向的内存的值是：100
请按任意键继续…

指针与数组元素#

我们定义的数组，就是多个相同类型变量的集合，，每个元素都有对应的内存空间，都有对应的地址，因此，指针也可以存放数组元素的地址。

eg.

1
#include<stdio.h>
2

3
int main(){
4
    int a[5];
5
    // 定义指针变量p，保存a[0]的地址
6
    int *p = &a[0];
7
    return 0;
8
}

pic1

应用（数组元素的引用）
1. 数组名[下标]
```
1
int a[5];
2
a[2] = 100;
```
2. 指针加下标
  - c语言规定：数组的名字就是数组的首地址，即第0个元素的地址，就是&a[0] 。
```
1
int a[5];
2
int *p;
3
p = a;
4
p[2] = 100; // 等同于a[2] = 100;
```
  ! ! ! p和a的不同，p是指针变量，而a是个常量。所以可以用等号给p赋值，但不能给a赋值
```
1
p = &a[0]; // 正确
2
a = &a[0]; // 错误
```
3. 通过指针变量运算加取值的方法来引用数组的元素
  - p是数组的第0个元素，相当于a[0],那么p + 2就相当于a[2]
```
1
int a[5];
2
int *p;
3
p = a;
4
*(p + 2) = 100; // 等同于a[2] = 100;
```
4. 通过数组名+取值的方法引用数组的元素
  - 由于C语言中数组的名字也是一个指针，因此我们可以通过如下方式引用数组中的元素
```
1
 int a[5];
2
 *(a+2)=100; // 等同于a[2]=100;
```

指针的运算#

指针加整数,往下指变量（仅指针指向数组时有意义）
```
1
 int a[5];
2
 int *p;
3
 p=a;
4
 p+2; // p是&a[0]，p+2是&a[2]
```

两个相同类型指针比较大小（仅两个相同类型指针变量指向同一数组时有意义）

1
#include<stdio.h>;
2

3
int main(){
4
    int a[10];
5
    int *p,*q;
6
    p = &a[0];
7
    q = &a[6];
8
    printf("%d\n%d\n",p,q);
9
    /* 6421984
10
       6422008
11
       请按任意键继续. . .
12
       两个结果前面的指针小于后面的指针，由于整型为4byte，因此两者间相差24 */
13
    printf("%d\n",q - p); // 6 即两个指针指向的之间有多少个元素
14

15
    return 0;
16
}

展开收起

两个相同类型的指针做减法（仅两个相同类型指针变量指向同一数组时有意义）

1
#include<stdio.h>;
2

3
int main(){
4
    int a[10];
5
    int *p,*q;
6
    p = &a[0];
7
    q = &a[6];
8
    printf("%d\n",q - p); // 6 即两个指针指向的之间有多少个元素
9
    return 0;
10
}

两个相同类型的指针可以相互赋值（void*类型除外）

1
#include<stdio.h>;
2

3
int main(){
4
    int a[10];
5
    int *p,*q;
6
    p = &a[0];
7
    q = &a[6];
8
    // 两个相同类型的指针可以互相复制，例如下面的例子中，q保存了p的地址也指向a
9
    p = a;
10
    q = p;
11
    // 编译运行的结果是p和q指向的同一个地址
12
    printf("%p\n%p\n",p,q);
13
    return 0;
14
}

指针数组#

概念：指针数组是若干个相同类型的指针变量构成的集合（数组）
语法：数据类型 * 数组名 [元素个数];

eg.

1
#include<stdio.h>
2

3
int main(){
4
    char *chr[6] = {"China","America","Russia","French","Btitain","Welcome"};
5
    for(int i = 0;i < 6;i++){
6
        printf("%s\n",chr[i]);
7
    }
8
    return 0;
9
}

运行结果

China
America
Russia
French
Britain
Welcome

Snipaste_2025-08-22_21-15-26

指针的指针#

概念：指针变量的地址

eg.

1
#include<stdio.h>
2

3
int main(){
4

5
    // 指针的指针
6
    int a = 0;
7
    int *p = &a;
8
    int **q = &p; // q保存了p地址
9

10
    return 0;
11
}

理论上，我们可以创建指针的指针的指针乃至更多，无限套娃

指针与字符串#

字符串的概念：字符串就是以’\0’结尾的若干的字符的集合（数组）
字符串的地址：即字符串中第一个字符的地址，例如字符串“helloworld”中字符串的地址即为字符“h”的地址

1
char *s = "helloworld";

数组指针#

概念：指向数组的地址
语法：指向数组的数据类型（*指针变量名）[指向数组的元素个数]

eg.

1
#include<stdio.h>
2

3
int main(){
4

5
    int b[2][3] = {1,2,3,4,5,6};
6
    // 这里二维数组需要两次解引用才能的到b[0][0] 具体原因见下方补充说明
7
    printf("b = %d\n",**b);
8
    printf("b + 1 = %d\n",b[0][0]);
9

10
    int (*t)[3];
11
    printf("b = %p\n",b);
12
    printf("b + 1 = %p\n",b + 1);
13
    t = b;
14
    printf("t = %p\n",t);
15
    printf("t + 1 = %p\n",t + 1);
16

17
    return 0;
18
}

展开收起

运行结果

b = 1 b + 1 = 1 b = 000000000061FDD0 b + 1 = 000000000061FDDC t = 000000000061FDD0 t + 1 = 000000000061FDDC

补充说明
这里二维数组b的数组名实际上指向的是该二维数组中的第一个一维数组的地址，b[2] [3]可以具象化为一个2*3的表格，*b得到的是第0行的地址，**b得到的就是第0行第0列的元素的地址了
Snipaste_2025-08-23_10-09-44

各种数组指针的定义
1. 一维数组指针，加1即为下一个一维数组
  
  如 int (*p)[5]; ，配合每行有5个int型元素的二维数组如 int a[3] [5] 、int b[4] [5]、 int c[5] [5]、int d[6] [5]
2. 二维数组指针，加1即为下一个二维数组
  
  如 int (*p)[4] [5]; 配合三维数组来用。三维数组中由若干个4行5列二维数组构成，如int a[3] [4] [5];、 int b[4] [4] [5];、int c[5] [4] [5];、 int d[6] [4] [5]; 这些三维数组，有个共同的特点，都是有若干个4行5的二维数组构成。
eg.
1 #include<stdio.h> 2 3 4 int main() 5 { 6 int a[3][4][5]; 7 printf("a=%p\n", a); 8 printf("a+1=%p\n", a + 1);// a 和 a+1 地址编号相差 80 个字节 9 // 验证了a+1 跳一个4行5列的一个二维数组 10 11 int(*p)[4][5]; 12 p = a; 13 printf("p=%p\n", p); 14 printf("p+1=%p\n", p + 1);//p 和 p+1 地址编号相差也 80 个字节 15 return 0; 16 }
展开收起

数组名字与指针变量的区别#

相同点：a为数组的名字，是a[0]的地址，p = a则p保存了a[0]的地址，两者都指向a[0]，所以在引用数组时两者等价

1
#include<stdio.h>
2

3
int main()
4
{
5
  int a[3] = {0,1,2};
6
  int* p;
7
  p = a;
8
  printf("a[2] = %d\n", a[2]); // 2
9
  printf("*(a + 2) = % d\n", *(a + 2)); // 2
10
  printf("p[2] = %d\n", p[2]); // 2
11
  printf("*(p + 2) = % d\n", *(p + 2)); // 2
12
  return 0;
13
}

不同点：a作为数组的名字，它是一个常量，值永远是a[0]的地址；而p则为指针变量，可以为其赋值。对a取地址相当于数组指针，而对p取地址则为指针的指针。

指针与函数#

指针传参

1
int num;
2
scanf("%d",&num);

可以将变量的地址传入函数，在被调函数中来修改主调函数中的变量（局部变量）

1
#include<stdio.h>
2

3
void swap(int *p,int *q){
4
    int temp;
5
    temp = *p;
6
    *p = *q;
7
    *q = temp;
8
}
9

10
int main(){
11
    int a = 10,b = 20;
12
    swap(&a,&b);
13
    printf("a = %d,b = %d",a,b); // a = 20,b = 10
14
    return 0;
15
}

展开收起

指针传数组

传一维数组

1
#include<stdio.h>
2

3
void printArray(int *p){
4
    printf("%d\n",p[2]); // 3
5
    printf("%d\n",*(p + 3)); // 4
6
}
7

8
int main(){
9
    int a[5] = {1,2,3,4,5};
10
    printArray(a);
11
    return 0;
12
}

传二维数组

1
#include<stdio.h>
2

3
// int(*p)[3] 将二维数组的三个一维数组依次传入
4
void printArray(int(*p)[3]){
5
  // 通过数组调用
6
    printf("%d\n",p[1][1]); // 5
7
  // 通过指针调用
8
  printf("%d\n",*(*(p + 1) + 2)); // 6
9
}
10

11
int main(){
12
    int a[2][3] = {1,2,3,4,5,6};
13
    printArray(a);
14
    return 0;
15
}

展开收起

传指针数组

1
#include<stdio.h>
2

3
void printChar(char **p){
4
    for(int i = 0;i < 3;i++){
5
        printf("%s\n",p[i]);
6
    }
7
}
8

9
int main(){
10
    char *p[3] = {"Hello","World","Programe"};
11
    printChar(p);
12
    return 0;
13
}

指针作返回值

一个函数可以返回整型数据、字符数据、浮点型的数据，也可以返回一个指针。
这里返回的是fun函数里面局部变量str的地址，函数运行结束，内存就被释放了，返回这个地址，也没有意义了

1
#include<stdio.h>
2

3
char* fun() {
4
  char str[100] = "hello world";
5
  return str;
6
}
7

8

9
int main()
10
{
11
  char* p;
12
  p = fun();
13
  printf("%s\n", p); // 乱码
14
  return 0;
15
}

展开收起

在函数里面给局部变量加static修饰，因为静态数组的内容，在函数结束后，仍然存在

1
#include<stdio.h>
2

3
char* fun() {
4
    static char str[100] = "hello world";
5
    return str;
6
}
7

8

9
int main()
10
{
11
    char* p;
12
    p = fun();
13
    printf("%s\n", p); // hello world
14
    return 0;
15
}

展开收起

函数指针

概念：定义一个指针变量，来存放函数的地址
语法：返回值类型(*函数指针变量名)(形参列表);

1
#include<stdio.h>
2

3
int add(int a,int b){
4
    return a + b;
5
}
6

7
int main(){
8
    int (*p)(int,int);
9
    p = add;
10
    // 通过函数名调用
11
    printf("%d\n",add(1,2));
12
    // 通过函数指针调用
13
    printf("%d\n",(*p)(1,2));
14
    return 0;
15
}

展开收起

函数指针数组

由若干个相同类型的函数指针变量构成的集合，在内存中连续的顺序存储。函数指针数组是个数组，它的每个元素都是一个函数指针变量
语法：类型名(*数组名[元素个数])（形参列表）

1
#include<stdio.h>
2

3
int max(int a,int b){
4
    if(a > b){
5
        return a;
6
    }else{
7
        return b;
8
    }
9
}
10

11
int min(int a,int b){
12
    if(a < b){
13
        return a;
14
    }else{
15
        return b;
16
    }
17
}
18

19
int add(int a,int b){
20
    return a + b;
21
}
22

23
int main(){
24
    int (*p[3])(int,int) = {max,min,add};
25
    printf("%d\n",(*p[2])(4,8)); // 12
26
    return 0;
27
}

展开收起

特殊指针#

空类型指针void *
- void * 并不是指向void类型的变量，而是一种通用指针，任何数据类型的地址都可以为其赋值
```
1
int *p;
2
void *q;
3
q=p // 是可以的，不用强制类型转换
```
空指针NULL
- p哪里都不指向，用于指针的初始化
```
1
int *p = NULL;
```

main 函数传参#

int argc：argc 表示命令行参数个数（argument count），包括程序本身，即 argc 最小为1
char *argv[]：使用argument value来记忆，参数值的意思，argv[] 是一个指向字符串数组的指针，其中每个元素是一个指向传递给程序的参数的指针（argument vector），这些字符串是命令行参数。

1
#include<stdio.h>
2

3
int main(int argc,char *argv[])
4
{
5
  int i;
6
  printf("argc=%d\n", argc);
7
  for ( i = 0; i < argc; i++)
8
  {
9
    printf("argv[%d]=%s\n", i,argv[i]);
10
  }
11
  return 0;
12
}

无参数运行结果

argc=1 argv[0]=test.exe

Terminal window

1
test.exe abc 123

有参数运行结果

argc=3 argv[0]=test.exe argv[1]=abc argv[2]=123

C语言：条件编译

Thu, 21 Aug 2025 00:00:00 GMT

条件编译#

什么是条件编译？#

预处理程序提供了条件编译的功能，可以按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件，这对于程序的移植和调试是很有用的。同时也可以用于头文件的编译控制，防止在复杂包含关系下同一头文件多次包含，以及避免一些不必要的错误发生。

条件编译指令#

指令	作用
#if	编译预处理条件指令，类似if
#ifdef	判断某个宏是否已经被定义
#ifndef	判断某个宏是否未被定义
#elif	若前面条件不满足时，则判断新的条件，类似else if
#else	若前面条件都不满足时，则执行后面的语句，类似else
#endif	#if,#ifdef,#ifndef的结束标志

例子#

1
#include<stdio.h>
2
// 调整EXO_DEX宏定义，编译运行得到不同结果
3
// #define EXO_DEX
4

5
int main(){
6
    #ifdef EXO_DEX
7
        printf("YES \n");
8
    #endif
9
    #ifndef EXO_DEX
10
        printf("NO \n");
11
    #endif
12
    system("Pause");
13
    return 0;
14
}

运行结果#

EXO_DEX已被定义

YES 请按任意键继续…

EXO_DEX未被定义

NO 请按任意键继续…

中医药相关知识点总结

Sun, 05 May 2024 00:00:00 GMT

中医药知识储备#

必备知识点#

四大南药：砂仁、巴戟天、益智、槟榔
十大广药：阳春砂、巴戟天、广陈皮、化橘红、广佛手、沉香、高良姜、广藿香、广地龙、金钱白花蛇
化橘红、广陈皮、阳春砂仁、广藿香、巴戟天、沉香、广佛手、何首乌等八种中草药，入选广东岭南中药材第一批立法保护品种。

补肾暖肾#

巴戟天#

•功能：补肾阳，强筋骨，祛风湿。

•主治：阳痿遗精，宫冷不孕，月经不调，少腹冷痛，风湿痹痛，筋骨痿软。

巴戟天

巴戟天2

益智#

•功能：暖肾，固精缩尿，温脾止泻摄唾。

•主治：肾虚遗尿，小便频数，遗精白浊，脾寒泄泻，腹中冷痛，口多唾涎。

益智1

益智2

温中止呕（散寒）#

土沉香#

•功能：行气止痛，温中止呕，纳气平喘。

•主治：胸腹胀闷疼痛，胃寒呕吐呃逆，肾虚气逆喘急。

土沉香1

土沉香2

高良姜#

功能：温胃止呕，散寒止痛。
主治：脘腹冷痛，胃寒呕吐，嗳气吞酸。

高良姜1

高良姜2

砂仁（阳春砂）#

品质评价：以个大、坚实饱满种仁红棕色、香气浓者为优。
功能：化湿开胃，温脾止泻，理气安胎。
主治：用于湿浊中阻，脘痞不饥，脾胃虚寒，呕吐泄泻，妊娠恶阻，胎动不安。

砂仁2

砂仁1

广藿香#

功能：芳香化浊，和中止呕，发表解暑。
主治：湿浊中阻，脘痞呕吐，暑湿表证，湿温初起，发热倦怠，胸闷不舒，寒湿闭暑，腹痛吐泻，鼻渊头痛。

广藿香1

广藿香2

南肉桂#

【功效】补元阳，暖脾胃，除积冷，通血脉

肉桂

山奈#

【功效】温中散寒

山奈

补肺#

五指毛桃#

【药用功效】健脾补肺、行气利湿、舒筋活络。

五指毛桃

五指毛桃根

牛大力#

【功效】补虚润肺，强筋活络。

牛大力

利湿#

广金钱草#

【功效】利湿退黄，利尿通淋

广金钱草

广金钱草2

消积截疟#

何首乌#

功能：解毒，消痈，截疟，润肠通便。

何首乌

何首乌2

槟榔#

•功能：杀虫，消积，行气，利水，截疟。

•主治：用于绦虫病、蛔虫病、姜片虫病，虫积腹痛，积滞泻痢，里急后重，水肿脚气，疟疾。

槟榔1

槟榔2

通经活络，清热止痉#

广地龙（蚯蚓干）#

•功能：清热止痉，平肝熄风，通经活络，平喘利尿

•主治：热病，发热狂躁，惊痫抽搐，肝阳头痛，中风偏瘫，风湿，痹痛，肺热喘咳，小便不通。

金银白花蛇#

•功能：祛风，通络，止痉

•主治：用于风湿顽痹，麻木拘挛，中风，半身不遂，抽搐痉挛，破伤风，麻风疥癣，瘰疬恶疮。

金钱白花蛇

化痰止咳#

布渣叶（破布叶）#

功效：清暑,消食,化痰

布渣叶1

布渣叶2

化橘红#

•功能：理气宽中，燥湿化痰。

•主治：咳嗽痰多，食积伤酒，呕恶痞闷。

化橘红1

广陈皮#

广陈皮基原：茶枝柑/大红柑/新会柑
主治：理气、健胃、燥湿、祛痰。

陈皮

广佛手#

•功能：疏肝理气，和胃止痛，燥湿化痰。

•主治：肝胃气滞，胸胁胀痛，胃脘痞满，食少呕吐，咳嗽痰多

广佛手1

广佛手2

理气止痛散瘀#

檀香#

【功效】行气温中，开胃止痛

檀香

降香#

【功效】化瘀止血，理气止痛

降香1

降香2

溪黄草#

【功效】清热利湿、退黄祛湿、凉血散瘀

溪黄草1

溪黄草2

两面针（光果花椒）#

功效：活血、散瘀、镇痛、消肿

两面针2

两面针3

单片机开发入门！10多块钱买的ESP8266怎么玩？

Fri, 29 Sep 2023 00:00:00 GMT

下载MicroPython固件#

Micorpython 直白点说：就是一种经过修改之后的Python

想要用Python来操作nodemcu，就要和我们在Windows上编程一样要先配置环境，就需要下载这个固件

从MicroPython官网：https://micropython.org/download/esp8266-1m/

下载Thonny#

要想编写ESP8266的固件，我们就需要一个好用的编译器，我们这里选择的是Thonny

从Thonny官网： https://thonny.org/

串口驱动#

为了能够将程序下载（烧录）到ESP8266中，需要安装串口芯片驱动，ESP8266有两种不同的串口芯片，分别是CH340和CP210X，下面演示用的是后者，大家视自己的情况来选择驱动

烧录MicroPython固件#

ESP8266安装串口驱动和烧录MicroPython固件如图所示

1675057881363

1675057932179

1675058034290

1675058060115

1675058107102

1675058157848

1675058206109

文件懒人包#

为了大家更好地入门ESP8266，上面用到的所有文件我们都打包好到网盘上，大家自行领取

百度网盘
提取码：1xj9

点灯大师#

烧录完成后，可执行下面的代码实现第一个程序,这是一个控制板载LED闪烁的程序

1
from machine import Pin
2
import time
3

4

5
led = Pin(2, Pin.OUT)
6

7
while True:
8
    led.value(0)
9
    print("led 亮")
10
    time.sleep(1)
11

12
    led.value(1)
13
    print("led 灭")
14
    time.sleep(1)

想用VSCode做C++开发？你知道怎么让VSCode编译中文名C++文件吗？

Sat, 26 Aug 2023 00:00:00 GMT

直接就能使用vscode编译并运行带有中文名的C++程序，在tasks.json里面自定义一个任务项就行。

tasks.json

1
{
2
    "version": "2.0.0",
3
    "tasks": [
4
        {
5
            "label": "Run C/C++ Program In Terminal Without Build",
6
            "detail": "在终端运行C/C++程序，不编译",
7
            "type": "shell",
8
            "windows":{
9
                "command": "start cmd /c \"\"${fileDirname}\\${fileBasenameNoExtension}.exe\" && pause\""
10
            },
11
            "linux":{
12
                "command": "\"${fileDirname}/${fileBasenameNoExtension}\" && read -p \"请按任意键继续. . .\""
13
            },
14
            "presentation": {
15
                "focus": true,
16
                "close": true
17
            },
18
            "problemMatcher": []
19
        },
20
       {
21
            "label": "G++ Build And Run In Terminal",
22
            "detail": "使用G++编译并新开终端窗口运行",
23
            "type": "shell",
24
            "dependsOn":[
25
                "G++ Build",
26
                "Run C/C++ Program In Terminal Without Build"
27
            ],
28
            "dependsOrder": "sequence",
29
            "problemMatcher": []
30
        },
31
        {
32
            "type": "shell",
33
            "label": "G++ Build",
34
            "command": [
35
                "g++",
36
                "-Wall",
37
                "-w",
38
                "-g3",
39
                "-I",
40
                ".",
41
                "\"${file}\"",
42
                "-o",
43
                "\"${fileDirname}/${fileBasenameNoExtension}\""
44
            ],
45
            "options": {
46
                "cwd": "${workspaceFolder}"
47
            },
48
            "problemMatcher": [
49
                "$gcc"
50
            ],
51
            "presentation": {
52
                "echo": true,
53
                "reveal": "always",
54
                "focus": true,
55
                "showReuseMessage": true,
56
            }
57
        }
58
    ]
59
}

展开收起

效果演示

默认gdb编译中文文件会报错

image-20230826195508871

设置后如图可以正常编译运行

Ctrl + Shift + P调出命令面板搜索运行任务
如图所示选择编译运行
运行效果如图，实测可以编译运行

image-20230826200200315

image-20230826200113921

image-20230826200126421

你不能运行是因为你不单单是运行程序，而是调试程序，并且你还是使用gdb来进行调试，gdb不支持中文路径名，不是vscode)的问题。

如果你要在VScode中调试带中文名的C++程序，就使用VC的工具链进行编译，然后launch.json里面定义一个使用cppvsdbg的启动项，不过你要使用VC工具链的话，需要下载VS，感兴趣的可以看下我写的文章中关于使用MSVC配置vscode的部分，这里就不介绍了

Vercel私有部署meting-api

Sun, 30 Jul 2023 00:00:00 GMT

前言#

最近 Aplayer 无法使用使用了，然后我就看到了有人出解决办法了，然后我试着做了下，成功了，就写了这个

Vercel 部署#

1）点击下方按钮，进行 Vercel 部署

跳转到Vercel

2）给仓库设置个名字，点击 create

0002522

3）部署成功，显示下面的样子

0002523

自定义域名#

点击 Settings，点击 Domains，设置个域名，点击 Add 然后进入自己的域名控制器中进行解析

0002524

编辑文件#

编辑 [Blogroot]\themes\butterfly\layout\includes\third-party\aplayer.pug 文件

注意：把 https://meting.lmx0.top/ 替换成刚刚你刚刚 vercel 部署的域名

1
link(rel='stylesheet' href=url_for(theme.asset.aplayer_css) media="print" onload="this.media='all'")
2
script(src=url_for(theme.asset.aplayer_js))
3
script(src=url_for(theme.asset.meting_js))
4
script.
5
  var meting_api='https://meting.lmx0.top/api/?server=:server&type=:type&id=:id&auth=:auth&r=:r';

星火认知大模型：目前为止最强的AI大模型？

Wed, 26 Jul 2023 00:00:00 GMT

讯飞开放平台是真的给力，昨天申请的星火认知大模型的体验资格，今天就收到短信通知我已经得到了星火的体验资格，一番体验下来，星火认知大模型会是目前为止最强的AI大模型吗，让我们一起来看一下。

简介#

按照我们博客的惯例，测评的时候，简介肯定不是我们自己来写啦，还是请我们的嘉宾（不…可能是测评对象）自己来一段自我介绍：

随着科技的飞速发展，人工智能已经逐渐渗透到我们生活的方方面面。从智能手机、自动驾驶汽车到智能家居系统，人工智能的应用已经无处不在。在这个过程中，星火认知大模型无疑是一个引人注目的存在。作为一款具有革命性的人工智能技术，它正在改变我们的未来。
星火认知大模型是由我国一家知名科技公司开发的，它基于深度学习技术，通过对大量数据的学习和训练，实现了对自然语言的理解和生成。与传统的人工智能技术相比，星火认知大模型具有更强的语言理解能力和生成能力，使得它在各种应用场景中都能发挥出巨大的潜力。
首先，星火认知大模型在智能问答领域表现突出。通过大量的问答数据训练，它能够快速准确地回答用户提出的问题。无论是关于天气、新闻、科技还是生活百科等方面的问题，星火认知大模型都能够给出满意的答案。这使得它成为了许多人获取信息和知识的重要工具。
此外，星火认知大模型还在智能写作领域取得了显著的成果。它能够根据用户的需求和要求，自动生成高质量的文章、报告和演讲稿等。这对于许多需要大量文字工作的人群来说，无疑是一种极大的便利。同时，星火认知大模型还具备一定的创作能力，可以根据用户的兴趣和喜好，生成独特的文字内容。这使得它在广告文案、小说创作等领域也有着广泛的应用前景。
在教育领域，星火认知大模型同样发挥着重要作用。它可以根据学生的学习进度和需求，为他们提供个性化的学习建议和辅导。这不仅有助于提高学生的学习效果，还能减轻教师的工作负担。此外，星火认知大模型还可以辅助教师进行教学资源的整理和筛选，为他们提供更多优质的教学素材。
当然，星火认知大模型的成功并非一蹴而就。它的背后是无数科研人员和技术专家的辛勤付出和不懈努力。正是他们的智慧和汗水，才使得这项技术得以突破现有的局限，展现出惊人的潜力。在未来的发展过程中，我们有理由相信，星火认知大模型将继续取得更多的突破和成就，为人类社会带来更多的福祉。
然而，我们也要看到，星火认知大模型等人工智能技术的发展并非没有挑战和问题。随着其应用范围的不断扩大，如何确保这些技术的安全性、隐私性和可控性等问题日益凸显。因此，我们需要在推动技术发展的同时，加强对相关法律法规的研究和完善，以确保这些技术能够在健康有序的轨道上发展。
总之，星火认知大模型作为一款具有革命性的人工智能技术，正逐步改变我们的未来。在享受其带来的便利和乐趣的同时，我们也要关注其可能带来的挑战和问题，共同努力创造一个更美好的未来。

拾光说星火的表现非常出色，不仅表明了自己来自一家国内的知名科技公司（那当然是讯飞啦），还分别简述了作为一个AI大模型，在写作，教育等领域可以发挥的作用，还对星火的诞生作出了评价，还是很给力的。我们可以看到的是目前国内AI大模型都是由知名的科技公司开发，讯飞的星火，阿里的通义千问，百度的文心一言，华为的盘古等。我个人对星火认知大模型的期待还是很高的，讯飞在AI领域也是深耕多年，讯飞的语音识别业务在国内也是数一数二的，讯飞听见，E听说（作为一个广东的学生，有幸体验过…）等，这些产品在国内的知名度和影响力是极大的，体验也是没得说，所以我对星火还是抱有很大的信心。

语言处理能力#

中文测试#

按照传统我们先从中文理解能力开始测试，对于国内的大模型来说理解中文还是比较简单的，不过如何使用中文作出更好的回答才是我们想要看到的，测试依然使用的是新高考一卷语文作文，作文题目在这：

好的故事，可以帮我们更好地表达和沟通，可以触动心灵、启迪智慧；好的故事，可以改变一个人的命运，可以展现一个民族的形象……故事是有力量的。以上材料引发了你怎样的联想和思考？请写一篇文章。
要求：选准角度，确定立意，明确文体，自拟标题；不要套作，不得抄袭；不得泄露个人信息；不少于800字。

我们接下来看一下星火的回答

标题：故事的力量
在我们的生活中，故事无处不在。从我们小时候听到的床前故事，到我们长大后阅读的小说，再到我们在电影中看到的情节，故事无时无刻不在影响着我们的生活。故事的力量是无法忽视的，它可以改变一个人的命运，可以展现一个民族的形象，可以帮助我们更好地表达和沟通，可以触动我们的心灵，启迪我们的智慧。
首先，故事的力量在于它可以改变一个人的命运。在历史上，有许多人的命运都被故事改变了。例如，古希腊的奴隶伊索，他因为他的寓言故事而被人们所知，他的命运也因此发生了改变。又如，美国的黑人民权运动领袖马丁·路德·金，他的故事激励了无数的人，推动了美国的民权运动。这些都是故事的力量，它可以改变一个人的命运。
其次，故事的力量在于它可以展现一个民族的形象。每一个民族都有自己的故事，这些故事反映了这个民族的历史、文化、价值观等。通过这些故事，我们可以了解到这个民族的性格和精神。例如，中国的四大名著《红楼梦》、《西游记》、《水浒传》、《三国演义》就展现了中国传统文化的魅力和中国人的性格特点。这些都是故事的力量，它可以展现一个民族的形象。
再次，故事的力量在于它可以帮助我们更好地表达和沟通。在我们的日常生活中，我们经常会用故事来表达我们的想法和感受。例如，当我们想要解释一个复杂的概念时，我们可能会用一个简单的故事来帮助别人理解。当我们想要安慰别人时，我们可能会讲一个温馨的故事来让对方感到温暖。这些都是故事的力量，它可以帮助我们更好地表达和沟通。
最后，故事的力量在于它可以触动我们的心灵，启迪我们的智慧。好的故事往往能够深入人心，触动人的心灵。同时，好的故事也能够启迪我们的智慧，让我们从中得到启示和灵感。例如，古希腊的神话故事就启迪了许多哲学家的思想，成为了西方哲学的重要源泉。这些都是故事的力量，它可以触动我们的心灵，启迪我们的智慧。
总的来说，故事的力量是无法忽视的。它可以改变一个人的命运，可以展现一个民族的形象，可以帮助我们更好地表达和沟通，可以触动我们的心灵，启迪我们的智慧。因此，我们应该更加重视故事的力量，让它在我们的生活中发挥更大的作用。

拾光说我们发现星火的回答明显要优于通义千问，如果还没有看过我们体验通义千问的文章，可以先去看一下，我们可以看到的是，星火和通义千问都用到了四大名著作为例子，我不知道这是一个国产大模型的自我修养，还是它们的思路这么巧就想到一块去了，首先这篇文章的结构很清晰，有分论点，但是第二个分论点还是缺了些什么，主要还是议论讲道理。

英语测试#

这次我们就不让星火翻译单句了，我觉得难度低了一点，普通的翻译软件都可以做到的事情，怎么能够体现星火大模型的能力呢，我们直接上人称九年义务教育英语人的噩梦总有语言不通的李华交了一大堆外国笔友还要折磨你的英语作文。作文题目在这里：

假定你是李华，你的英国笔友Peter对中国文化很感兴趣，来信询问重阳节（the Double Ninth Festival）的相关情况。请你写一封邮件，介绍重阳节。
内容包括：1.重阳节的时间，2.重阳节的活动，3.重阳节的意义

我们先来看看星火大模型的回答结果

Subject: Introduction to the Double Ninth Festival
Dear Peter,
I am thrilled that you are interested in learning about Chinese culture, particularly the Double Ninth Festival. This festival is one of the most significant traditional festivals in China, and I would be happy to share with you some information about it.
Firstly, the Double Ninth Festival falls on the ninth day of the ninth lunar month, which usually lands in October on the Gregorian calendar. It is also known as the Chongyang Festival or the Senior Citizens’ Day. The number “nine” has a special meaning in Chinese culture, representing longevity and good fortune.
Secondly, there are various activities that people engage in during the Double Ninth Festival. One of the most popular ones is climbing mountains, which symbolizes achieving higher levels of success and good health. Additionally, eating chrysanthemum flowers and drinking chrysanthemum tea is believed to bring good luck and ward off evil spirits. Another common activity is wearing cornel branches, which are said to have medicinal properties and can protect against diseases.
Lastly, the Double Ninth Festival holds great significance in Chinese culture. It is a time for people to show respect and care for the elderly, who are highly valued in Chinese society. The festival also emphasizes the importance of maintaining good health and longevity, as well as cherishing life and family.
I hope this brief introduction gives you a better understanding of the Double Ninth Festival. If you have any more questions or would like to know more about Chinese culture, please do not hesitate to ask me.
Best regards, Li Hua

这么看来还是没有什么概念，我们也放上一张通义千问的回答

大伙可以仔细研读一下，感受一下它们的英语写作能力（真的不是我懒得评价…）

生活应用#

我们让星火写了一份夏天痛饮生可乐的广告脚本，我们一起来看看：

很明显，我们可以看到星火的发挥还是很不错的，基本完成了我们的要求，但是他好像不太能理解生可乐，他把这里的生理解为和生水一个意思了，这女孩子我怀疑是（是谁懂的都懂），毕竟每天都喝生可乐，我们由此猜测星火不能联网。

编程能力#

编程能力方面我们就简单的出了一道C++的冒泡排序，相信每一位C++ BUGER都是可以看懂的吧，不要说我考得基本，说不定有的…(是谁我不说)也写不出来呢，星火的回答不知道是bug还是什么，有个引号跑到下面去了，调整一下就可以正常编译运行了，我们简单的看下结果：

1
#include<iostream>
2
using namespace std;
3

4
void bubbleSort(int arr[], int n) {
5
    for (int i = 0; i < n - 1; i++) {
6
        for (int j = 0; j < n - i - 1; j++) {
7
            if (arr[j] > arr[j + 1]) {
8
                swap(arr[j], arr[j + 1]);
9
            }
10
        }
11
    }
12
}
13

14
int main() {
15
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
16
    int n = sizeof(arr) / sizeof(arr[0]);
17
    bubbleSort(arr, n);
18
    cout << "排序后的数组： ";
19
    for (int i = 0; i < n; i++) {
20
        cout << arr[i] << " ";
21
    }
22
    cout << endl;
23
    return 0;
24
}

展开收起

解数学题#

解数学题一直都是AI语言大模型不可跨过的看，前有ChatGPT乱编得一本正经，又有通义千问离谱解题，至于文心一言我只能说没有搞到测试资格测不了，我们看看星火大模型可不可以打破AI语言大模型不会做数学题的固有概念，我们不做大题（最主要是大题符号，图像复杂输不进去），在新高考一卷数学中又挑选了一道中等的多选题，我们一起来看看：

星火认知大模型的回答：

我们再来看一下通义千问的：

怎么说吧就对了一个答案，还是不知道用什么离谱方法做出来的，通义千问把它做成了单选题，我以为是我没告诉他的问题，我就添加了多选题三个字，结果我的发挥出来2个答案，对了1个，按照高考打分制为0分，我只能说真的离谱吧，假如两个模型都不能联网，那么星火就是阅读完了题目，一步步认真做到，而通义千问就是连题都没看懂就开始胡说八道了。

是否联网#

关于我们在第一部分说的关于到底星火认知大模型到底联不联网的问题，这里统一回答：没有，因此到目前为止能够联网的只有微软的New Bing和装了联网插件的ChatGPT外，国内不咋能见到可以联网的AI大模型。

总结#

总的来说，讯飞星火认知大模型可以说是目前国内体验最好的语言类AI大模型，对话体验，语言理解能力都很有讯飞那味，体验都很不戳，以及突破了许多AI语言大模型不能够很好的解决数学题的瓶颈，也是很难得的，说了那么多，我认为目前国内的朋友想要体验AI大模型，我觉得星火绝对是最好的选择，容易申请，体验不错。

通义千问上手体验：阿里达摩院的AI大模型究竟怎么样？

Fri, 23 Jun 2023 00:00:00 GMT

今天正打算写我昨天说的Vercel自建meting-api，然后无意间看到了一篇通义千问的文章，我就想着看看我一个星期前申请的通义千问的测试资格下来没有，打开一看拿到了测试资格，就第一时间写了这篇体验文章，至于刚刚那个，我鸽一下吧，等暑假再更。

自我介绍#

基础的我就不介绍了，让通义千问自我介绍下

Snipaste_2023-06-23_19-21-34

语言处理能力测试#

中文测试#

中文测试我们就选用今年新高考一卷的作文，看看他的写作能力

Snipaste_2023-06-23_19-26-48

文章用到引用论证，是高考议论文常用的手法，通义千问不是干说大道理，而是有理有据，至于例子运用的好不好我就不做评判了，你们可以结合下面的作文解析自己感受一下。

作文解析

2018年习近平总书记在全国宣传思想工作会议上提出：“展形象，就是要推进国际传播能力建设，讲好中国故事、传播好中国声音，向世界展现真实、立体、全面的中国，提高国家文化软实力和中华文化影响力。”

2022年党的二十大报告中指出，“加快构建中国话语和中国叙事体系，讲好中国故事、传播好中国声音，展现可信、可爱、可敬的中国形象。”

命题人的命题灵感来源可见一斑。

材料列举了“好的故事”在不同情境的不同作用，由小及大，“表达沟通—改变个人命运—展现民族形象”。最后总结：“故事是有力量的”，抽丝剥茧，抓住关键词：“故事”是行文的基本范畴；“力量”是描述重点，也是考生布局谋篇的落脚点。考生成长过程中都有听故事的经历，对所闻所见所经历的故事都有真切感受。在文体的选择上，考生可以记叙生活中的故事感悟；可以对某个故事进行分析议论；既可以书写日常生活中个人感触小处入手，也可以探讨如何讲好中国故事等宏观问题。本题可以选择的范围较宽，审题立意、布局谋篇都不难。因为可选素材相对较多，所以写一篇议论文，成篇更容易。

英语测试#

我随机在我的博客里面找了一句话让他翻译为英文

Snipaste_2023-06-23_18-19-21

生产力表现#

为了测试通义千问在编程上的能力，我们选取了Leetcode上的第四道算法题寻找两个正序数组的中位数，我们对比了通义千问的回答和亚马逊的AWS的答案让我很是惊讶

原题在这：

Snipaste_2023-06-23_18-37-20

通义千问#

题目描述

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

nums1 = {2, 4, 6, 8, 10}

nums2 = {1, 3, 5, 7, 9}

则中位数是 5.0

示例 2：

nums1 = {1000, 1001, 1002, 1003, 1004}

nums2 = {2000, 2001, 2002, 2003, 2004}

则中位数是 2001.5

提示：

本题中的答案是中位数，而不是排序后的结果。

题目分析

这道题目是一道经典的正序数组中位数问题，可以使用归并排序的思想进行求解。

我们可以先将两个数组进行归并排序，然后根据排序后的数组的长度，求解中位数。

由于两个数组的长度之和为 m + n，所以中位数的长度为 ceil((m + n) / 2)。

中位数的值可以通过以下步骤求解：

找到两个数组中的第 m 个元素和第 n 个元素。
将这两个元素作为中位数的前两个元素。
将数组中的其他元素按照从小到大的顺序排列，并将第 m 个元素作为中位数的后一个元素，将第 n 个元素作为中位数的前一个元素。

代码实现

以下是使用 Python 实现的代码，其中包括了归并排序的实现：

1
Copy code# 定义排序函数
2
def merge_sort(nums):
3
    m, n = len(nums), len(nums[0])
4
    mid = m + n // 2
5
    left = nums[:mid]
6
    right = nums[mid:]
7
    merge_sort(left)
8
    merge_sort(right)
9
    return merge(left, right)
10

11
# 定义合并函数
12
def merge(left, right):
13
    mid = len(left) + len(right) // 2
14
    i, j = m, n
15
    while i <= mid and j <= mid:
16
        if left[i] <= right[j]:
17
            i += 1
18
        else:
19
            j -= 1
20
    return [left[i:j+1] + right[j+1:m] for i in range(m, n+1)]
21

22
# 定义中位数函数
23
def get_median(nums):
24
    m, n = len(nums), len(nums[0])
25
    left, right = nums[:m], nums[m:]
26
    median = [left[n-1] + right[0] for n in range(m, n+1)]
27
    return median
28

29
# 定义输入函数
30
def input_nums():
31
    nums = [int(num) for num in input().split()]
32
    return nums
33

34
# 调用主函数
35
if __name__ == '__main__':
36
    nums = input_nums()
37
    print('nums1:', nums[:5])
38
    print('nums2:', nums[5:])
39
    print('median1:', get_median(nums[:5]))
40
    print('median2:', get_median(nums[5:]))

展开收起

这段代码中，我们首先实现了两个排序函数，分别用于对两个数组进行排序。然后，我们定义了一个 get_median 函数，用于求解中位数。该函数的实现中，我们首先计算出两个数组的长度之和，然后根据中位数的定义，将排序后的数组分为两部分，取其中间的那一部分作为中位数的前两个元素，将排序后的数组中的第 m 个元素作为中位数的后一个元素，将数组中的其他元素按照从小到大的顺序排列，并将第 m 个元素作为中位数的后一个元素，将第 n 个元素作为中位数的前一个元素。最后，我们将求得的中位数作为结果返回。

在主函数中，我们首先输入两个正序数组，然后分别调用 merge_sort 和 get_median 函数求解中位数，并将求得的中位数输出。

注意，在输出结果时，我们使用了 print 函数中的 range 函数，分别获取了两个数组的长度。

以上是通义千问的回答，通义千问的题目解读就给我干懵了，原题的意思是将的到的两个数组nums1和nums2合并取这个并集中元素的中位数吧，这个好像是高中必修一的元素和集合，再加上初中或高中的求中位数吧。示例一中只求了nums2的中位数就算了，可能是我描述的不够清楚（但我好像是直接把题干复制过去的喔），示例二我就真的搞不懂了，他究竟怎么求出2001.5的，离了个大谱！

亚马逊AWS#

1
# 写一个函数，给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
2
def findMedianSortedArrays(nums1, nums2):
3
    nums = nums1 + nums2
4
    nums.sort()
5
    length = len(nums)
6
    if length % 2 == 0:
7
        return (nums[length // 2] + nums[length // 2 - 1]) / 2
8
    else:
9
        return nums[length // 2]
10

11
# 写一个测试，测试上面的函数
12
def test_findMedianSortedArrays():
13
    nums1 = [1, 3]
14
    nums2 = [2]
15
    assert (findMedianSortedArrays(nums1, nums2) == 2)
16
    nums1 = [1, 2]
17
    nums2 = [3, 4]
18
    assert (findMedianSortedArrays(nums1, nums2) == 2.5)
19
    nums1 = [2,5,8]
20
    nums2 = [1,4,7]
21
    assert (findMedianSortedArrays(nums1,nums2) == 4.5)
22
    nums1 = [1,2,3,5,7,8]
23
    nums2 = [1,6,8]
24
    assert (findMedianSortedArrays(nums1,nums2) == 5)
25

26
# 进行测试
27
if __name__ == '__main__':
28
    test_findMedianSortedArrays()
29
    print('All test passed!')

展开收起

没什么好说的，给你们看一下Leetcode的测试结果，全绿通过，毕竟是专业选手（这位职业选手要不要写篇文章介绍下，可能暑假会考虑一下）

Snipaste_2023-06-23_19-16-02

小功能#

通义千问的百宝箱里面有一些小功能，彩虹屁专家，写情书（不会真的有人用这个玩意写情书吧，不会吧，不会吧），为你写诗，小学生作文（一定不能让小学生知道…），会放飞的菜谱（这个玩意挺有意思，只要你想的出名字的菜，他就可以给你自动生成制作步骤）

Snipaste_2023-06-23_18-14-42

我不明白怎么还有奥田一体集成灶，这个真的不是软广，是他自动生成的，不过生成的还挺正常，不过既然这个功能叫做会放飞的菜谱那我们也放飞我们的想象力，创造了一些离谱的菜，果然也正儿八经的生成出来了。

Snipaste_2023-06-23_18-13-11

Snipaste_2023-06-23_18-14-12

你会发现一个奇怪的事情，就是我们的红烧RTX4090，写着写着就变成了红烧鸡腿了，4090不见踪影，而iPhone 13这边则是一本正经的写下来了，甚至还有小提示。（看来还是RTX4090比较贵一点…）

结尾#

我没有搞到其他大模型的测试资格，所以这篇文章主要是单纯的测试，没有对比，但后续如果我搞到了其它的大模型的测试资格，我也会和通义千问进行对比的。

WWDC2023除了iOS,macOS，iPadOS等小更新，还有什么看头？

Wed, 07 Jun 2023 00:00:00 GMT

昨天晚上熬夜看了WWDC2023，感觉系统更新就像是牙膏都快挤爆了的隔壁某厂，也就这么点小东西，发布的Vision还是感觉很震撼的。很多人都疑惑Vision有啥创新，跟vr一比较也就那么回事。那就让我们一起来看看WWDC2023有什么有意思的东西吧。

iOS 17#

来电秀：个性化的联系海报，用户可以为其他用户的名片选择照片或是Memoji。
iMessage：iMessage共享位置、语音转文字，新增Check In功能保护隐私
FaceTime信箱：允许朋友留下视频信息
NameDrop：用户现在可以将两部iPhone或Apple Watch放在一起，相互分享联系人、音乐、互联网或其他共享活动
Siri唤醒词：苹果将虚拟语音助手Siri的唤醒短语从“嘿Siri”改为“Siri”
StandBy：iOS17还支持全新的Stand By应用，专为MagSafe支架设计，用于在手机横放时显示时钟、日历及其他信息
交互式小组件
离线地图

7001fa723e81a5fe9e5e6e8099c9a75019319172

iPadOS 17#

锁屏：支持锁屏小组件、自定义锁屏（iPhone玩剩下的凑个更新罢了）
交互式小组件
iMessage：iMessage共享位置、语音转文字
FaceTime信箱
健康App（至于有没有必要，仁者见仁智者见智吧）
PDF：自动填充文档，加批注（终于加上了这个功能，做笔记很方便）
备忘录：支持PDF笔记相互跳转链接，支持多人之间进行协作
无边记App的新工具
前台调度：自由的调节窗口大小（我的老iPad就不多说了，用不了）

9bbbc0593410c3ba1b502e1b41c69e1919319172

macOS Sonoma#

桌面小组件（和iPhone上的差不多，也就是图一乐）
选择屏幕共享
Safari可以设置不同的场景
WebAPP可以收进程序坞
游戏模式（真的会有朋友拿mac打游戏吗，是我孤陋寡闻了，我以为mac就只是生产力工具呢）
屏幕保护

042c69959da3551af9796e5c2c69ac8119319172

WatchOS 10#

全新设计：全屏显示应用，左上角和右上角一个是返回、一个是功能按键
表盘：支持上滑呼出小组件，控制中心需要点击电源键进入
远足三维（ultra独享，买不起）
地形图

455824bd9861628d8bbd09abe87af56519319172

Macbook Air 15“#

轻薄：11.5mm的厚度，重1.5kg，我们的air还是那么的air
M2芯片：24核CPU，76核GPU，32核神经网络引擎，M2Ultra可以实现192GB的统一内存
续航：续航长达18小时
售价：RMB10499起

dd8f307f0e2f2d083657d5f6bec3d86919319172

Mac Pro&Mac Studio#

买不起也就图一乐

Mac Studio：带宽更高的HDMI可以支持8K或240Hz刷新率
Mac Pro：M2ULTRA，不说了各方面都很强，实在想了解自己去官网看吧

0ad690db52f1b0c3d84e88cbec45bb1d19319172

Vision Pro#

今年的WWDC的重头戏莫过于苹果的首款头显Vision Pro，让我们来看看有什么看点

搭载M2+R1双芯片：实时处理，影像的超低延迟
豪华的传感器阵容：高清摄像头+LiDAR+深度摄像头
高清显示：Micro-Oled真4K显示
体验方面：
1. Eyesight外屏虚拟形象
2. 空间音频
3. 交互：移除了传统VR上的手柄，改用眼球追踪和手势、语音实现完整的操作交互
4. 多设备协同：看一眼Mac就可以投屏（还得是苹果生态）
5. 虹膜认证解锁
6. 避免你与世界分离，埋没在虚拟世界当中：
  
  （1）无级调节AR与VR的混合比例
  
  （2）发布会上的如果有人在你的眼前走动，将会出现在你的世界中

pic

小结#

今年的WWDC开发者大会确实在传统的操作系统中挤了牙膏，或许可以高情商地说把所有的精力都投入到了Vision Pro的研发上，的确Vision Pro极具创新性，但在很长一段时间里这款产品都不会是人们生活、工作的必需品，当前更多是秀肌肉的产品，我认为iOS17很重要，各位应该也觉得这哪是大版本更新，分明就是个16.7的半代更新，所以还是希望下一年苹果能够在补足操作系统的短板的基础上，继续创新，WWDC2023的总结就到这里，下一年我们再见！

如何在VSCode中配置C/C++开发环境

Sat, 27 May 2023 00:00:00 GMT

1. 下载VScode编辑器#

进入官网：https://code.visualstudio.com/ 下载VSCode编辑器

vscode下载

2.安装VSCode#

这一步应该不用我多说了，没有特殊需求一路下一步即可。

vscode安装

3.下载编译器MinGW#

官网：https://www.mingw-w64.org/
下载地址：https://sourceforge.net/projects/mingw-w64/files/
以上下载地址如果你的网络环境一般可能上不去，我们这里为你放到网盘上了

网盘地址：https://wwnm.lanzoup.com/i2OoO0xgocne 密码

mingw下载

选择下载x86_64-win32.seh，并选择一个目录进行解压（建议是C盘，当然其他盘问题也不大）

4.配置环境变量#

配置环境变量

5.安装插件#

我们需要安装中文包和C++插件，如图

Snipaste_2023-05-27_21-59-14

6.运行代码#

1
#include <stdio.h>
2
#include <stdlib.h>
3
int main()
4
{
5
    printf("Hello World!\n");
6
    system("pause");
7
    return 0;
8
}

Snipaste_2023-05-27_22-20-01

选择两次第一个（第二个忘记截图了qwq）

Snipaste_2023-05-27_22-22-27

控制台正常输出即为配置成功

7.配置文件修改#

该部分解决的是：

1.中文乱码问题

2.启用外部控制台

3.部分出现C++文件无法编译问题

在.vscode文件夹下面launch.json参考以下,"miDebuggerPath"中请填写你的MinGW路径

1
{
2
    "version": "0.2.0",
3
    "configurations": [
4
        {
5
            "name": "gcc.exe - 生成和调试活动文件",
6
            "type": "cppdbg",
7
            "request": "launch",
8
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
9
            "args": [],
10
            "stopAtEntry": false,
11
            "cwd": "${fileDirname}",
12
            "environment": [],
13
            "externalConsole": true,
14
            "MIMode": "gdb",
15
            "miDebuggerPath": "D:\\MinGW\\bin\\gdb.exe",
16
            "setupCommands": [
17
                {
18
                    "description": "为 gdb 启用整齐打印",
19
                    "text": "-enable-pretty-printing",
20
                    "ignoreFailures": true
21
                },
22
                {
23
                    "description": "将反汇编风格设置为 Intel",
24
                    "text": "-gdb-set disassembly-flavor intel",
25
                    "ignoreFailures": true
26
                }
27
            ],
28
            "preLaunchTask": "C/C++: gcc.exe 生成活动文件"
29
        },
30
        {
31
            "name": "g++.exe - 生成和调试活动文件",
32
            "type": "cppdbg",
33
            "request": "launch",
34
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
35
            "args": [],
36
            "stopAtEntry": false,
37
            "cwd": "${fileDirname}",
38
            "environment": [],
39
            "externalConsole": true,
40
            "MIMode": "gdb",
41
            "miDebuggerPath": "D:\\MinGW\\bin\\gdb.exe",
42
            "setupCommands": [
43
                {
44
                    "description": "为 gdb 启用整齐打印",
45
                    "text": "-enable-pretty-printing",
46
                    "ignoreFailures": true
47
                },
48
                {
49
                    "description": "将反汇编风格设置为 Intel",
50
                    "text": "-gdb-set disassembly-flavor intel",
51
                    "ignoreFailures": true
52
                }
53
            ],
54
            "preLaunchTask": "C/C++: g++.exe 生成活动文件"
55
        }
56
    ]
57
}

展开收起

在“tasks.json”中，"command"中也是填写你的MinGW路径

1
{
2
    "tasks": [
3
        {
4
            "type": "cppbuild",
5
            "label": "C/C++: gcc.exe 生成活动文件",
6
            "command": "D:\\MinGW\\bin\\gcc.exe",
7
            "args": [
8
                "-fdiagnostics-color=always",
9
                "-g",
10
                "${file}",
11
                "-o",
12
                "${fileDirname}\\${fileBasenameNoExtension}.exe",
13
                "-fexec-charset=GBK"
14
            ],
15
            "options": {
16
                "cwd": "${fileDirname}"
17
            },
18
            "problemMatcher": [
19
                "$gcc"
20
            ],
21
            "group": "build",
22
            "detail": "调试器生成的任务。"
23
        },
24
        {
25
            "type": "cppbuild",
26
            "label": "C/C++: g++.exe 生成活动文件",
27
            "command": "D:\\MinGW\\bin\\g++.exe",
28
            "args": [
29
                "-fdiagnostics-color=always",
30
                "-g",
31
                "${file}",
32
                "-o",
33
                "${fileDirname}\\${fileBasenameNoExtension}.exe",
34
                "-fexec-charset=GBK"
35
            ],
36
            "options": {
37
                "cwd": "${fileDirname}"
38
            },
39
            "problemMatcher": [
40
                "$gcc"
41
            ],
42
            "group": {
43
                "kind": "build",
44
                "isDefault": true
45
            },
46
            "detail": "调试器生成的任务。"
47
        }
48
    ],
49
    "version": "2.0.0"
50
}

展开收起

1."-fexec-charset=GBK"这个配置项用于解决中文乱码

2. "externalConsole": true这个配置项用于使用外部控制台

3.添加g++.exe相关配置项用于解决部分版本c++文件编译失败问题

（这边建议需要用到该配置项的同学，vscode将c和c++分开两个工作区，c使用gcc.exe，c++使用g++.exe）

8.注意事项#

源代码文件夹含有中文路径，将会无法编译程序。
Windows用户名使用中文，可能无法运行。

Hexo博客安装Algolia全局搜索

Wed, 05 Apr 2023 00:00:00 GMT

小白温馨提示：#

本文中出现的_config.yml指的是博客框架Hexo的默认配置文件,而_config.butterfly.yml指的是博客主题的配置文件，这个是开始之前必须搞清楚的，不然容易发生报错。

1. 创建 Alogolia Index#

登录Algolia官网，没有账号可以用邮箱直接注册一个，或者使用Github登录（各位都是折腾hexo的友人了，不会还没有github吧）

pic1

然后进入 Dashboard，选择新建一个 Index，这里创建了一个名为blog的Index 这个Index会存储你的文章索引，将会用于全局搜索

pic2

2. 配置 API Key#

跟着需要配置API Keys到我们自己的 hexo 博客中来，这样子hexo 博客的数据就可以通过 API 发送给Aloglia 点击右侧进入Setting，再点击进入API Keys

pic3

我们要用到Application ID 、Search-Only API Key、Admin API KEY信息

pic4

3.Hexo Algolia获取站点数据#

你需要安装 hexo-algolia 或 hexo-algoliasearch. 根据它们的说明文档去做相应的配置

下面用 hexo-algoliasearch 进行演示#

1.首先安装 hexohexo-algoliasearch 在博客根目录运行一下命令

1
npm install hexo-algoliasearch --save

如果博客没能自动读取插件，可在_config.yml中添加

1
plugins:
2
  - hexo-algoliasearch

2.接着需要修改 hexo 根目录下的 _config.yml，进行以下配置：

1
algolia:
2
  appId: "Z7A3XW4R2I"
3
  apiKey: "12db1ad54372045549ef465881c17e743"
4
  adminApiKey: "40321c7c207e7f73b63a19aa24c4761b"
5
  chunkSize: 5000
6
  indexName: "blog"
7
  fields:
8
    - content:strip:truncate,0,500
9
    - excerpt:strip
10
    - gallery
11
    - permalink
12
    - photos
13
    - slug
14
    - tags
15
    - title

展开收起

注意缩进！！！ applicationID 就是网页中的 Applicaiton ID apiKey 就是网页中的 Search-Only API Key indexName 就是我们前面创建的Index名称

pic5

代码块里的必填，如果你使用 hexo-algoliasearch，请记得配置 fields 参数的 title, permalink 和 content

最后配置_config.butterfly.yml，添加以下配置

1
# Algolia search
2
algolia_search:
3
  enable: true
4
  hits:
5
    per_page: 6

3.上传索引在博客根目录运行以下命令：

1
hexo algolia

4.最终成果#

运行Hexo三件套，重新部署博客，点击搜索即可使用

pic6

Butterfly主题安装Swiper实现随机打开一篇文章

Thu, 06 Oct 2022 00:00:00 GMT

{% tip cogs %}本文基于店长Akilar和安知鱼的教程{% endtip %}

插件教程#

1.安装插件,在博客根目录`[Blogroot]`下打开终端，运行以下指令安装依赖：#

Terminal window

1
npm install hexo-butterfly-swiper-anzhiyu --save

2.在`_config.butterfly.yml`加入以下配置项#

1
# hexo-butterfly-swiper-anzhiyu
2
# see https://akilar.top/posts/8e1264d1/
3
swiper:
4
  enable: true # 开关
5
  randomenable: true # 人潮汹涌开关
6
  priority: 5 #过滤器优先权
7
  enable_page: / # 应用页面
8
  timemode: date #date/updated
9
  layout: # 挂载容器类型
10
    type: id
11
    name: recent-posts
12
    index: 1
13
  default_descr: 再怎么看我也不知道怎么描述它的啦！
14
  swiper_css: https://cdn.cbd.int/hexo-butterfly-swiper-anzhiyu@1.0.4/lib/swiper.min.css #swiper css依赖
15
  swiper_js: https://npm.elemecdn.com/anzhiyu-blog@1.1.6/js/swiper.min.js #swiper js依赖 #swiper js依赖
16
  custom_css: https://cdn.cbd.int/hexo-butterfly-swiper-anzhiyu@1.0.4/lib/swiperstyle.css # 适配主题样式补丁
17
  custom_js: https://cdn.cbd.int/hexo-butterfly-swiper-anzhiyu@1.0.4/lib/swiper_init.js # swiper初始化方法
18
  gsap_js: https://lf26-cdn-tos.bytecdntp.com/cdn/expire-1-M/gsap/3.9.1/gsap.min.js
19
  people_js: https://npm.elemecdn.com/hexo-butterfly-swiper-anzhiyu@1.0.4/lib/people.min.js

展开收起

3.pjax适配#

在_config.butterfly.yml，用Vscode的小伙伴可以用快捷键{% kbd Crtl %} + {% kbd F %}搜索pjax

把enable里的false改为true

1
# Pjax
2
# It may contain bugs and unstable, give feedback when you find the bugs.
3
# https://github.com/MoOx/pjax
4
pjax:
5
  enable: true
6
  exclude:
7
    # - xxxx
8
    # - xxxx

4.轮播图顺序控制（使用方法）#

新建文章后在配置信息中添加swiper_index: num

1
---
2
title: 文章标题
3
date: 创建日期
4
updated: 更新日期
5
cover: 文章封面
6
description: 文章描述
7
swiper_index: 1 #置顶轮播图顺序，非负整数，数字越大越靠前
8
---

参数释义#

参数	备选值/类型	释义
priority	number	【可选】过滤器优先级，数值越小，执行越早，默认为10，选填
enable	true/false	【必选】控制开关
randomenable	true/false	【必选】人潮汹涌控制开关
enable_page	path/all	【可选】填写想要应用的页面的相对路径（即路由地址）,如根目录就填’/‘,分类页面就填’/categories/‘。若要应用于所有页面，就填’all’，默认为all
exclude	path	【可选】填写想要屏蔽的页面，可以多个。仅当enable_page为’all’时生效。写法见示例。原理是将屏蔽项的内容逐个放到当前路径去匹配，若当前路径包含任一屏蔽项，则不会挂载。
timemode	date/updated	【可选】时间显示，date为显示创建日期，updated为显示更新日期,默认为date
layout.type	id/class	【可选】挂载容器类型，填写id或class，不填则默认为id
layout.name	text	【必选】挂载容器名称
layout.index	0和正整数	【可选】前提是layout.type为class，因为同一页面可能有多个class，此项用来确认究竟排在第几个顺位
error_img	url	封面图片加载失败时的替换图片
insertposition	text	’beforebegin’：元素自身的前面。‘afterbegin’：插入元素内部的第一个子节点之前。‘beforeend’：插入元素内部的最后一个子节点之后。‘afterend’：插入元素自身的后面。
default_descr	text	【可选】默认文章描述
swiper_css	url	【可选】自定义的swiper依赖项css链接
swiper_js	url	【可选】自定义的swiper依赖项加js链接
custom_css	url	【可选】适配主题样式补丁
custom_js	url	【可选】swiper初始化方法
gsap_js	url	【可选】gsap_js依赖
people_js	url	【可选】随机逛逛js
categorygroup_css	url	【可选】分类类别css

温馨提示#

配置swiper插件之前记得配置分类（categories）和标签（tags），不然会出现点击分类和标签图标时无限刷出swiper插件的奇异bug 我把新建这两个页面的指令写在下面

Terminal window

1
hexo new page categories
2
hexo new page tags

这是一封来自程序员的情书??请查收

Wed, 05 Oct 2022 00:00:00 GMT

黑客技术学的再好却无法入侵你的心

服务器入侵的再多对你只有Guest

是我的DDOS造成了你的拒绝服务？还是我的byshell再次被你查杀？

你总有防火墙我始终停不掉

想提权无奈JSP+MYSQL成为我们的障碍

找不到你的注入点扫不到你的空口令所有对我的回应都用3DES加密

你总是自定文件格式我永远找不到你的入口点忽略所有异常却还是跟踪不到你的注册码

虽然我们是不同的对象都有隐私的一面但我相信总有一天我会找到你的接口把我的最真给你看

因为我是你的指针在茫茫内存的堆栈中永远指向你那片天空不孜不倦

我愿做你的内联供你无限次的调用直到海枯石烂

我愿做你的引用和你同进退共生死一起经受考验

只是我不愿苦苦地调试你的心情最终沦为你的友元

如今我们已被MFC封装—事事变迁如今我们已向COM走去—可想当年

没任何奢求只愿做你最后的Administrator

也许，像你说的那样，我们是不同世界的人

本文转至博客字符猫

高中报到

Sun, 11 Sep 2022 00:00:00 GMT

NOTE

本文写于我的上一个博客，现在将原内容转移到此博客，文章写于我高中报到当天

分享一下今天到高中报到的感想#

关于选择学校#

我个人其实成绩不是特别的优秀，在我现在所在的这间高中应该是属于偏上的水平，其实我初中也是在这间学校读的，当时我选了这间学校，同班高分的同学都为我可惜。

但是我昨天为什么说我自己傻呢，是因为有人分数比我低靠我们当地报考政策去了一间好学校，昨天回学校帮忙做筹备，有个我们班经常考第一的同学跟我说“你是不是傻啊，别人谁谁谁靠那啥上了那间学校”我当时我真的有想过我是不是真的傻，错失了这么好的机会，所以我昨天发了一条动态调侃我自己。

其实昨天回校的时候，我妈问我其实老师为什么要叫你们几个毕业了的学生回去帮忙，有没有一种可能你们都是报回去的，当时我就一口咬定刚刚那个同学绝对不是。但让我万万没想到的是今天早上报到的时候，竟然在名单上看到她的名字，我不禁笑了，你说我傻，那你为什么也要留在这里，你觉得不咋滴的学校呢。

其实我在选校的时候考虑到了，他们让我去考的学校我很大可能是压线进的，我自己的心理素质其实时好时坏，我以前也是一直拿第一的（PS：真不是凡尔赛），在近年我也有拿过，但也显得吃力了，心态经常不好，很受打击，就真的我还是觉得能获得良好的自我感觉是继续前进的动力，如果压线进去，追个一两年追不上去，你的心态就彻底崩溃了，更别说努力了，可能你连学习都不愿意了，出于这种考虑我才选择留下来。

看见那个去了很好学校的同学发动态，就单单报个到，还没开学就感受到了内卷的氛围，真的太难了。

图片

关于我的母校或是我未来的学校#

1.打我个措手不及#

2.真可以啊#

3.开玩笑吧#

以上为全部内容，再见朋友们！

开个玩笑，确实挺惊喜的，我正打算好不容易有个没作业的暑假好好玩玩，放松一下心情，没想到啪的一下，很快啊，我又成了学生，收获了作业大礼包，好家伙。我去问了一些好兄弟，他们说他们学校没有作业，我感觉我遭到背刺，慕了慕了！

尾声#

说实话，我跟我的母校这么多年，虽然她总是给我一个又一个惊喜，还有一个又一个背刺，不过我想说：我永远爱你，我的母校，希望在新的时期，与你同在！

为handsome主题添加文章末尾版权信息

Sat, 10 Sep 2022 00:00:00 GMT

为handsome主题添加文章末尾版权信息#

开始之前的免责声明#

本文所需要的源代码是基于wuqintai和MuYu大佬的源码进行修改#

原文地址：#

wuqintai #

MuYu(在我的友链中有沐雨大佬的博客地址大家可以关注他的魔改handsome主题系列作品)#

关于handsome主题#

blog的主题版权问题#

本博客使用正版handsome主题，可在 https://auth.ihewro.com/user/index.html 这里进行查询，本博客也可以作为你了解handsome主题的Demo。

购买#

如果你对handsome主题感兴趣的话，可以在友人C大佬的博客进行购买（友链里找，好吧OωO），请大家支持正版！！！友人C大佬博客直达点我！！！

添加版权声明#

操作方法#

复制代码，打开你的主题文件，以handsome为例，路径为：网站目录/usr/themes/handsome/post.php

1
<div style="padding: 10px;background: rgba(220, 220, 220, 0.22);font-size: 13px;border-left: 3px solid;text-align: left;">
2
     <li class="post-copyright-author"><strong>本文作者：</strong><?php $this->author(); ?></li>
3
     <li class="post-copyright-link"><strong>本文链接：</strong><a href="<?php $this->permalink() ?>" title="<?php $this->title() ?>"><?php $this->permalink() ?></a></li>
4
     <li class="post-copyright-license"><strong>版权声明：</strong>作品采用 <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh" target="_blank" rel="noopener" title="署名-非商业性使用-相同方式共享 "><strong> 知识共享署名 4.0 国际许可协议（CC BY-NC-SA 4.0） </strong></a> 进行许可</li>
5
</div>

添加到post.php文件图中的大概位置

pic.png

如何寻找添加代码的位置#

添加到这里显示的位置就是我的博客现在显示的位置，如需修改可以通过以下两种方法

handsome主题默认的post.php每一个部分都有注释，可按照注释找对应的位置 2.可以在自己的网站调出浏览器开发者应用审查元素，找到元素对应的代码块

注意事项#

建议复制代码时使用一键复制，划动复制注意不要漏掉前后的

1
</div>

可能会导致显示不出来

我提供给大家的代码默认使用的是知识共享署名 4.0 国际许可协议不了解这个协议是什么的，可以自行去某度和某乎了解一下，如果你不需要的可以使用第一部分中MnYu大佬提供的这个

操作方法：将我的代码中的

1
<li class="post-copyright-license"><strong>版权声明：</strong>作品采用 <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh" target="_blank" rel="noopener" title="署名-非商业性使用-相同方式共享 "><strong> 知识共享署名 4.0 国际许可协议（CC BY-NC-SA 4.0） </strong></a> 进行许可</li>

修改为

1
<span>版权说明：若无注明，本文皆<a href="<?php $this->options->rootUrl(); ?>" target="_blank" data-original-title="<?php $this->options->title() ?>"><?php $this->options->title() ?></a>原创，转载请保留文章出处。</span>

小贴士#

使用Typecho写博客的时候千万千万不要直接把HTML或PHP代码尝试在非代码块内写，会有你想不到的事情发生，别问我是怎么知道的，都是血与泪的教训，为了解决这个问题，最终靠恢复MySQL数据库才得以解决（折腾网站一定要记得备份！！！）

尾声#

这篇文章就到这里了，有什么问题的可以在评论区提问，有时间我会进行回复。如果我的作品对你有帮助的话，可以给我点个赞吗，如果可以的话，可以点击“打赏”支持一下作者！

Vercel部署Typecho博客系统

Sat, 10 Sep 2022 00:00:00 GMT

Vercel部署Typecho博客系统#

一键部署#

注册并登录好Vercel账号点击此链接可以直接跳转Vercel新建项目，效果与第一步类似（完成后可跳过第一步）

Deploy to Vercel

第一步（使用一键部署跳过此步骤）#

1.Github创建一个仓库设置为private

2.克隆本仓库代码到你创建的仓库

第二步#

1.获取一个数据库可自己搭建也可以自己找

我这边推荐railway

2.注册一个账号并新建MySQL数据库

3.修改config.inc.php中

1
/** 定义数据库参数 */
2

3
$db = new Typecho_Db('Pdo_Mysql', 'typecho_');
4

5
$db->addServer(array (
6

7
'host' => '请填入数据库地址',
8

9
'user' => '数据库用户名',
10

11
'password' => '数据库密码',
12

13
'charset' => 'utf8',
14

15
'port' => '3306',
16

17
'database' => '数据库名称',
18

19
'engine' => 'MyISAM',
20

21
), Typecho_Db::READ | Typecho_Db::WRITE);
22

23
Typecho_Db::set($db);

展开收起

修改成自己的数据库

第三步#

1.使用Vercel部署github仓库（使用一键部署跳过此步骤）

2.用Vercel提供的域名 + /install.php开始安装（具体安装可自行搜索Typecho安装教程）

Firefly 代码块示例

Sat, 03 Jan 1970 00:00:00 GMT

在这里，我们将探索如何使用 Expressive Code 展示代码块。提供的示例基于官方文档，您可以参考以获取更多详细信息。

表达性代码#

语法高亮#

语法高亮

常规语法高亮#

1
console.log('此代码有语法高亮!')

渲染 ANSI 转义序列#

Terminal window展开收起

1
Standard ANSI colors:
2
- Dimmed:      Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
3
- Foreground:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
4
- Background:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
5
- Reversed:    Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
6

7
8-bit colors (showing colors 160-171 as an example):
8
- Dimmed:      160  161  162  163  164  165  166  167  168  169  170  171 
9
- Foreground:  160  161  162  163  164  165  166  167  168  169  170  171 
10
- Background:  160  161  162  163  164  165  166  167  168  169  170  171 
11
- Reversed:    160  161  162  163  164  165  166  167  168  169  170  171 
12

13
24-bit colors (full RGB):
14
- Dimmed:      ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
15
- Foreground:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
16
- Background:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
17
- Reversed:    ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
18

19
Font styles:
20
- Default
21
- Bold
22
- Dimmed
23
- Italic
24
- Underline
25
- Reversed
26
- Strikethrough

展开收起

编辑器和终端框架#

编辑器和终端框架

代码编辑器框架#

my-test-file.js

1
console.log('标题属性示例')

src/content/index.html

1
<div>文件名注释示例</div>

终端框架#

Terminal window

1
echo "此终端框架没有标题"

PowerShell 终端示例

1
Write-Output "这个有标题!"

覆盖框架类型#

1
echo "看，没有框架!"

PowerShell Profile.ps1

1
# 如果不覆盖，这将是一个终端框架
2
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
3
New-Alias tail Watch-Tail

文本和行标记#

文本和行标记

标记整行和行范围#

1
// 第1行 - 通过行号定位
2
// 第2行
3
// 第3行
4
// 第4行 - 通过行号定位
5
// 第5行
6
// 第6行
7
// 第7行 - 通过范围 "7-8" 定位
8
// 第8行 - 通过范围 "7-8" 定位

选择行标记类型 (mark, ins, del)#

line-markers.js

1
function demo() {
2
  console.log('此行标记为已删除')
3
  // 此行和下一行标记为已插入
4
  console.log('这是第二个插入行')
5

6
  return '此行使用中性默认标记类型'
7
}

为行标记添加标签#

labeled-line-markers.jsx

1
<button
2
  role="button"
3
  {...props}
4
  value={value}
5
  className={buttonClassName}
6
  disabled={disabled}
7
  active={active}
8
>
9
  {children &&
10
    !active &&
11
    (typeof children === 'string' ? <span>{children}</span> : children)}
12
</button>

在单独行上添加长标签#

labeled-line-markers.jsx展开收起

1
<button
2
  role="button"
3
  {...props}
4

5
  value={value}
6
  className={buttonClassName}
7

8
  disabled={disabled}
9
  active={active}
10
>
11

12
  {children &&
13
    !active &&
14
    (typeof children === 'string' ? <span>{children}</span> : children)}
15
</button>

展开收起

使用类似 diff 的语法#

1
此行将标记为已插入
2
此行将标记为已删除
3
这是常规行

1
--- a/README.md
2
+++ b/README.md
3
@@ -1,3 +1,4 @@
4
+this is an actual diff file
5
-all contents will remain unmodified
6
 no whitespace will be removed either

结合语法高亮和类似 diff 的语法#

1
function thisIsJavaScript() {
2
  // 整个块都会以 JavaScript 高亮显示，
3
  // 并且我们仍然可以为其添加 diff 标记！
4
  console.log('要删除的旧代码')
5
  console.log('新的闪亮代码！')
6
}

标记行内的单独文本#

1
function demo() {
2
  // 标记行内的任何给定文本
3
  return '支持给定文本的多个匹配项';
4
}

正则表达式#

1
console.log('单词 yes 和 yep 将被标记。')

转义正斜杠#

Terminal window

1
echo "Test" > /home/test.txt

选择内联标记类型 (mark, ins, del)#

1
function demo() {
2
  console.log('这些是插入和删除的标记类型');
3
  // return 语句使用默认标记类型
4
  return true;
5
}

自动换行#

自动换行

为每个块配置自动换行#

1
// 启用换行的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// wrap=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

配置换行的缩进#

1
// preserveIndent 示例（默认启用）
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// preserveIndent=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

可折叠部分#

可折叠部分


5 collapsed lines
1
// 所有这些样板设置代码将被折叠
2
import { someBoilerplateEngine } from '@example/some-boilerplate'
3
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'
4

5
const engine = someBoilerplateEngine(evenMoreBoilerplate())
6

7
// 这部分代码默认可见
8
engine.doSomething(1, 2, 3, calcFn)
9

10
function calcFn() {
11
  // 您可以有多个折叠部分
3 collapsed lines
12
  const a = 1
13
  const b = 2
14
  const c = a + b
15

16
  // 这将保持可见
17
  console.log(`计算结果: ${a} + ${b} = ${c}`)
18
  return c
19
}
20

4 collapsed lines
21
// 直到块末尾的所有代码将再次被折叠
22
engine.closeConnection()
23
engine.freeMemory()
24
engine.shutdown({ reason: '示例样板代码结束' })

展开收起

行号#

行号

为每个块显示行号#

1
// 此代码块将显示行号
2
console.log('来自第2行的问候!')
3
console.log('我在第3行')

// 此块禁用行号
console.log('你好?')
console.log('抱歉，你知道我在第几行吗?')

更改起始行号#

5
console.log('来自第5行的问候!')
6
console.log('我在第6行')

Tab 代码块#

由 rehype-code-group 提供，语法与 VitePress 代码组一致：用 ::: code-group labels=[...] 包裹多个代码块，即可合并成一组标签页。

Note

labels=[...] 中的标签按顺序对应组内的代码块，用英文逗号分隔；::: 与 code-group 之间的空格不能省略。

基本用法#

1
::: code-group labels=[code.js, code.py, code.html]
2

3
```js
4
export function greet(name) {
5
  return `Hello, ${name}!`;
6
}
7
```
8

9
```py
10
def greet(name):
11
    return f"Hello, {name}!"
12
```
13

14
```html
15
<p>Hello, world!</p>
16
```
17

18
:::

展开收起

渲染效果：

code.jscode.pycode.html

1
export function greet(name) {
2
  return `Hello, ${name}!`;
3
}

1
def greet(name):
2
    return f"Hello, {name}!"

1
<p>Hello, world!</p>

标签中使用 Emoji#

标签支持 emoji 短代码，构建时会自动转换成 emoji：

1
::: code-group labels=[:package: npm, :package: pnpm, :yarn: yarn]

📦 npm📦 pnpm🧶 yarn

Terminal window

1
npm create astro@latest

Terminal window

1
pnpm create astro@latest

Terminal window

1
yarn create astro

与其他代码块特性组合#

组内仍是普通的 Expressive Code 代码块，标题、行号、行标记、折叠、终端框架等特性都可以照常使用。

配置文件终端折叠

astro.config.mjs

1
export default {
2
  theme: "firefly",
3
  codeGroup: true,
4
};

部署

1
pnpm build && pnpm preview


3 collapsed lines
1
// 这三行默认折叠
2
import { a } from "a";
3
import { b } from "b";
4

5
console.log(a, b);

不止是代码块#

标签页内可以放任意内容，例如文字、列表或图片：

说明列表

这是一段普通的段落内容。

列表项一
列表项二

Tip

标签栏在构建期生成，默认展开第一项；支持鼠标点击与键盘 ← / → / Home / End 切换。

Firefly 布局系统详解

Sat, 03 Jan 1970 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

可以通过showBothSidebarsOnPostPage配置是否在文章详情页显示双侧边栏

当position为left或right时开启此项后，文章详情页将显示双侧边栏，主页等其他页面保持单侧边栏

适用在只想用单侧栏，但在文章详情页想用对侧栏的目录等组件的场景

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
  showBothSidebarsOnPostPage: true, // 是否在文章详情页显示双侧边栏
5
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图，可配置在左侧或右侧
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

封面位置#

列表模式的封面图默认在卡片右侧，可以通过 coverPosition 改到左侧。改到左侧后，标题前的主题色竖线会自动隐藏（它是贴着卡片左边缘的设计），腾出的间距留给正文。

网格模式的封面固定在卡片顶部，不受这项配置影响。

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list",    // 列表模式
4
    coverPosition: "right", // 封面图位置："right" 右侧，"left" 左侧
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    grid: {
5
      masonry: true,      // 开启瀑布流
6
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
7
    },
8
  },
9
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly Wiki Link 内部链接示例

Sat, 03 Jan 1970 00:00:00 GMT

Firefly 支持在 Markdown、MDX 文章中使用 Obsidian 风格的 Wiki Link 内部链接。链接目标填写文章的 slug 或文件路径，都不需要包含扩展名，具体匹配规则见下文「链接目标的三种写法」。

文章链接卡片#

[[slug]] 单独成段时，会自动读取目标文章的标题、描述、发布时间、分类、标签和封面，渲染为链接卡片：

1
[[firefly]]
2

3
[[guide/index]]
4

5
[[markdown-extended]]

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

1970-01-02文章示例#Firefly#博客#主题

Firefly 简单使用指南

如何使用 Firefly 博客模板。

1970-01-02博客指南#Firefly#博客#指南

Markdown 扩展功能

了解 Firefly 中的 Markdown 功能

1970-01-01文章示例#Markdown#Firefly#示例

行内链接#

[[slug]] 出现在正文中间时，渲染为普通链接，链接文字自动使用目标文章的标题

1
请参阅 [[firefly]] 了解主题特性。

请参阅 Firefly 一款清新美观的 Astro 博客主题模板了解主题特性。

自定义显示标题#

在 | 后填写链接的显示文字。行内链接会用它替换文章标题；单独成段时依然渲染为卡片，卡片标题使用自定义文字，描述、时间、分类、标签和封面仍然读取目标文章：

1
请参阅 [[firefly|主题介绍]] 了解主题特性。
2

3
[[firefly|Firefly 主题介绍]]

请参阅主题介绍了解主题特性。

Firefly 主题介绍

1970-01-02文章示例#Firefly#博客#主题

一个例外：如果 | 后的文字只是把链接目标又抄了一遍（[[guide/index|index]]），会被当作无效别名忽略，仍然显示文章标题。Obsidian 在插入的链接时会自动补上这样的别名，避免笔记里显示一长串路径，这个例外就是为它准备的。

链接目标的三种写法#

用 Obsidian 管理文章时，把 src/content/posts 目录本身作为 Obsidian 仓库（vault）打开。下文提到的「仓库根目录」都指这个目录，它正好也是 Firefly 解析链接路径的起点。

链接目标按以下顺序匹配：

写法	示例	在 Obsidian 中
frontmatter 的 `slug`	`[[firefly-wiki-link]]`	✗ 不支持
文件路径（相对仓库根目录）	`[[guide/firefly-layout-system]]`	✓ 需改设置（推荐）
裸文件名（仓库内唯一时）	`[[firefly-layout-system]]`	✓ 默认即是

第一种：slug#

slug 写法在 Obsidian 中不支持，slug 是 Firefly 自己的概念，Obsidian 不读取 frontmatter 里的 slug，所以按 slug 写的链接在 Obsidian 里既不会自动补全，也点不动，只有构建出的站点上能正常跳转。如果你主要在 Obsidian 里写作，用下面两种写法。

第二种：文件路径（推荐）#

文件路径写法需要改 Obsidian 设置，在 设置 → 文件与链接 → 链接 → 内部链接类型 中选择基于仓库根目录的绝对路径，Obsidian 插入的链接才会带上目录：

1
[[guide/firefly-layout-system|firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

1970-01-03博客指南#Firefly#布局#指南

因为仓库根目录就是 src/content/posts，Obsidian 写出的这个路径和 Firefly 需要的路径完全一致，不需要任何额外转换。

上面这行末尾的 |firefly-layout-system 是 Obsidian 自动补的别名，Firefly 会忽略它，卡片标题仍然取文章的 title，除非你把它修改和文件名不一致，才会变成你修改后的别名。

内部链接类型下拉框里的基于当前笔记的相对路径只在同目录内可用：它给同目录文章生成的是裸文件名，能正常匹配；但跨目录时会生成 ../ 前缀，Firefly 无法解析，链接会按原文显示。

第三种：裸文件名#

「内部链接类型」的默认值就是尽可能简短的形式：只要文件名在整个仓库里唯一，Obsidian 插入的链接就只有文件名，不带目录。这种写法不需要改任何设置，效果和写完整路径完全一致：

1
[[firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

1970-01-03博客指南#Firefly#布局#指南

文件名重名时这种写法会失效，构建日志里会给出提示，改用完整文件路径即可，所以推荐直接修改 Obsidian 内部链接类型设置为基于仓库根目录的绝对路径，使用第二种文件路径写法，一劳永逸

链接到其他文章的标题#

在文章 slug 后添加 #标题。带标题锚点的链接始终渲染为普通链接：

查看代码块语法高亮

Firefly 布局系统详解#相关链接

1
[[code-examples#语法高亮|查看代码块语法高亮]]
2

3
[[guide/firefly-layout-system#相关链接|firefly-layout-system]]

标题锚点使用与页面标题相同的 slug 规则，因此中文、空格和大小写都会按页面实际生成的 ID 处理。

链接到本页标题#

省略文章 slug，只填写标题即可链接到当前文章：

跳转到本页目标

1
[[#本页目标|跳转到本页目标]]

本页目标#

这是本页 Wiki Link 指向的标题。

不支持附件嵌入#

附件嵌入语法目前不会被转换，会按原文显示：

![[image.png]]

行内代码和代码块中的 [[firefly]] 也不会被转换。

Firefly 文章加密

Fri, 02 Jan 1970 00:00:00 GMT

这是一篇密码保护的示例文章，用于演示文章加密功能。

Firefly 一款清新美观的 Astro 博客主题模板

Fri, 02 Jan 1970 00:00:00 GMT

🌟 项目概述#

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

🖥️在线预览： Firefly - Demo site

🏠我的博客： https://blog.cuteleaf.cn

📝Firefly使用文档： https://docs-firefly.cuteleaf.cn

⭐Firefly开源地址：https://github.com/CuteLeaf/Firefly

⭐Fuwari开源地址：https://github.com/saicaca/fuwari

CuteLeaf

Firefly

Firefly

🚀 技术架构#

静态站点生成: 基于 Astro ，提供极快的加载速度和优秀的 SEO 优化
TypeScript 支持: 完整的类型安全，提升开发体验和代码质量
响应式设计: 使用 Tailwind CSS 构建，完美适配桌面端和移动端
组件化开发: 支持 Astro、Svelte 组件，灵活可扩展

📖 配置说明#

📚 详细配置文档: 查看 Firefly 使用文档获取完整的配置指南

Firefly 简单使用指南

Fri, 02 Jan 1970 00:00:00 GMT

这个博客模板是基于 Astro 构建的。对于本指南中未提及的内容，您可以在 Astro 文档中找到答案。

文章的 Front-matter#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

KaTeX 数学公式示例

Fri, 02 Jan 1970 00:00:00 GMT

本文展示了 Firefly 主题对 KaTeX 数学公式的渲染支持。

行内公式 (Inline)#

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 eiπ+1=0e^{i\pi} + 1 = 0eiπ+1=0 是数学中最优美的公式之一。

质能方程 E=mc2E = mc^2E=mc2 也是家喻户晓。

块级公式 (Block)#

块级公式使用两个 $$ 符号包裹，会居中显示。

∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}∫−∞∞e−x2dx=πx=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}x=2a−b±b2−4ac

复杂示例#

矩阵 (Matrices)#

(abcd)(αβγδ)=(aα+bγaβ+bδcα+dγcβ+dδ)\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \\ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \\ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix}(acbd)(αγβδ)=(aα+bγcα+dγaβ+bδcβ+dδ)

极限与求和 (Limits and Sums)#

∑n=1∞1n2=π26\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}n=1∑∞n21=6π2lim⁡x→0sin⁡xx=1\lim_{x \to 0} \frac{\sin x}{x} = 1x→0limxsinx=1

麦克斯韦方程组 (Maxwell’s Equations)#

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned}∇⋅E∇⋅B∇×E∇×B=ε0ρ=0=−∂t∂B=μ0J+μ0ε0∂t∂E

化学方程式 (Chemical Equations)#

\ceCH4+2O2−>CO2+2H2O\ce{CH4 + 2O2 -> CO2 + 2H2O}\ceCH4+2O2−>CO2+2H2O

符号	代码	渲染结果
Alpha	`\alpha`	α\alphaα
Beta	`\beta`	β\betaβ
Gamma	`\Gamma`	Γ\GammaΓ
Pi	`\pi`	π\piπ
Infinity	`\infty`	∞\infty∞
Right Arrow	`\rightarrow`	→\rightarrow→
Partial	`\partial`	∂\partial∂

MDX 格式文章示例

Fri, 02 Jan 1970 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

使用组件#

这是一个图标组件：

1
import { Icon } from 'astro-icon/components'
2

3
<div class="flex items-center gap-2 my-4">
4
  <Icon name="fa7-solid:rocket" class="text-4xl text-red-500" />
5
  <span>火箭发射！</span>
6
</div>

火箭发射！

使用 JSX#

你也可以直接写 HTML/JSX：

1
<div className="p-4 bg-blue-100 dark:bg-blue-900 rounded-lg my-4">
2
  这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。
3
</div>

这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。

简单的变量导出#

1
export const year = new Date().getFullYear()
2

3
今年是 {year} 年。

今年是 2026 年。

更多信息，请查看 MDX 文档

Markdown 扩展功能

Thu, 01 Jan 1970 00:00:00 GMT

GitHub 仓库卡片#

您可以添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。

CuteLeaf

Firefly