From c0e4fa9359c148fec9b6dd3d9fa341412e6fb4fb Mon Sep 17 00:00:00 2001 From: jinzhongjia Date: Fri, 12 Jan 2024 14:02:29 +0000 Subject: [PATCH] deploy: ea42712c8c0078920b11dd25552135d484822a54 --- 404.html | 8 ++--- about.html | 10 +++--- advanced/assembly.html | 10 +++--- advanced/async.html | 10 +++--- advanced/comptime.html | 10 +++--- advanced/interact-with-c.html | 10 +++--- advanced/memory_manage.html | 14 ++++---- advanced/package_management.html | 10 +++--- advanced/type_cast.html | 10 +++--- appendix/community.html | 10 +++--- appendix/well-known-lib.html | 10 +++--- ... => advanced_memory_manage.md.VVXxDYaI.js} | 4 +-- ...dvanced_memory_manage.md.VVXxDYaI.lean.js} | 2 +- assets/{app.MIdJPtEx.js => app.-PyfpKM3.js} | 2 +- ...basic_advanced_type_struct.md.REVwY0VS.js} | 8 ++--- ..._advanced_type_struct.md.REVwY0VS.lean.js} | 0 ...Y.js => basic_error_handle.md.X3CsP-Vt.js} | 2 +- ...=> basic_error_handle.md.X3CsP-Vt.lean.js} | 0 ....js => basic_optional_type.md.N1LhwqCi.js} | 2 +- ...> basic_optional_type.md.N1LhwqCi.lean.js} | 0 ...c_process_control_decision.md.AilCsfii.js} | 2 +- ...cess_control_decision.md.AilCsfii.lean.js} | 0 ...basic_process_control_loop.md.OpaKXOlk.js} | 12 +++---- ..._process_control_loop.md.OpaKXOlk.lean.js} | 0 ...sic_process_control_switch.md.Z7KwKgFx.js} | 6 ++-- ...rocess_control_switch.md.Z7KwKgFx.lean.js} | 0 ...JyaJgpd3.js => basic_union.md.ugreMmE2.js} | 2 +- ...ean.js => basic_union.md.ugreMmE2.lean.js} | 0 .../chunks/@localSearchIndexroot.92CUtxnc.js | 1 + .../chunks/@localSearchIndexroot.HClziMeA.js | 1 - ...vxVhNN.js => VPLocalSearchBox.NRnZ9XZ2.js} | 2 +- .../{theme.eHXeYJL0.js => theme.fbFORVJM.js} | 4 +-- ...> engineering_build-system.md.0lT4HF-R.js} | 10 +++--- ...ineering_build-system.md.0lT4HF-R.lean.js} | 0 ...onment_install-environment.md.PTNE6kMW.js} | 26 ++++++++------ ...t_install-environment.md.PTNE6kMW.lean.js} | 2 +- assets/index.md.EcLvnWMr.js | 1 + assets/index.md.EcLvnWMr.lean.js | 1 + assets/index.md.Lwj7q2PL.js | 1 - assets/index.md.Lwj7q2PL.lean.js | 1 - basic/advanced_type/array.html | 10 +++--- basic/advanced_type/enum.html | 10 +++--- basic/advanced_type/opaque.html | 10 +++--- basic/advanced_type/pointer.html | 10 +++--- basic/advanced_type/silce.html | 10 +++--- basic/advanced_type/struct.html | 18 +++++----- basic/advanced_type/vector.html | 10 +++--- basic/basic_type/char-and-boolean.html | 10 +++--- basic/basic_type/function.html | 10 +++--- basic/basic_type/number.html | 10 +++--- basic/define-variable.html | 10 +++--- basic/error_handle.html | 14 ++++---- basic/optional_type.html | 14 ++++---- basic/process_control/decision.html | 14 ++++---- basic/process_control/defer.html | 10 +++--- basic/process_control/loop.html | 24 ++++++------- basic/process_control/switch.html | 16 ++++----- basic/process_control/unreachable.html | 10 +++--- basic/union.html | 12 +++---- engineering/build-system.html | 22 ++++++------ engineering/unit-test.html | 10 +++--- environment/editor.html | 10 +++--- environment/install-environment.html | 36 ++++++++++--------- environment/zig-command.html | 10 +++--- epilogue.html | 10 +++--- hashmap.json | 2 +- hello-world.html | 10 +++--- index.html | 12 +++---- more/atomic.html | 10 +++--- more/builtin_func.html | 10 +++--- more/miscellaneous.html | 10 +++--- more/reflection.html | 10 +++--- more/style_guide.html | 10 +++--- more/undefined_behavior.html | 10 +++--- more/wasm.html | 10 +++--- more/zero-type.html | 10 +++--- prologue.html | 10 +++--- sitemap.xml | 2 +- what-is-zig.html | 10 +++--- 79 files changed, 334 insertions(+), 326 deletions(-) rename assets/{advanced_memory_manage.md.2V38NqCn.js => advanced_memory_manage.md.VVXxDYaI.js} (99%) rename assets/{advanced_memory_manage.md.2V38NqCn.lean.js => advanced_memory_manage.md.VVXxDYaI.lean.js} (82%) rename assets/{app.MIdJPtEx.js => app.-PyfpKM3.js} (95%) rename assets/{basic_advanced_type_struct.md.7UsPAPWF.js => basic_advanced_type_struct.md.REVwY0VS.js} (99%) rename assets/{basic_advanced_type_struct.md.7UsPAPWF.lean.js => basic_advanced_type_struct.md.REVwY0VS.lean.js} (100%) rename assets/{basic_error_handle.md.DDwEzY8Y.js => basic_error_handle.md.X3CsP-Vt.js} (99%) rename assets/{basic_error_handle.md.DDwEzY8Y.lean.js => basic_error_handle.md.X3CsP-Vt.lean.js} (100%) rename assets/{basic_optional_type.md.d6QrqvLi.js => basic_optional_type.md.N1LhwqCi.js} (99%) rename assets/{basic_optional_type.md.d6QrqvLi.lean.js => basic_optional_type.md.N1LhwqCi.lean.js} (100%) rename assets/{basic_process_control_decision.md.rdtrtJa0.js => basic_process_control_decision.md.AilCsfii.js} (99%) rename assets/{basic_process_control_decision.md.rdtrtJa0.lean.js => basic_process_control_decision.md.AilCsfii.lean.js} (100%) rename assets/{basic_process_control_loop.md.G0QbfSeI.js => basic_process_control_loop.md.OpaKXOlk.js} (98%) rename assets/{basic_process_control_loop.md.G0QbfSeI.lean.js => basic_process_control_loop.md.OpaKXOlk.lean.js} (100%) rename assets/{basic_process_control_switch.md.c7mMGXuW.js => basic_process_control_switch.md.Z7KwKgFx.js} (98%) rename assets/{basic_process_control_switch.md.c7mMGXuW.lean.js => basic_process_control_switch.md.Z7KwKgFx.lean.js} (100%) rename assets/{basic_union.md.JyaJgpd3.js => basic_union.md.ugreMmE2.js} (99%) rename assets/{basic_union.md.JyaJgpd3.lean.js => basic_union.md.ugreMmE2.lean.js} (100%) create mode 100644 assets/chunks/@localSearchIndexroot.92CUtxnc.js delete mode 100644 assets/chunks/@localSearchIndexroot.HClziMeA.js rename assets/chunks/{VPLocalSearchBox.h_vxVhNN.js => VPLocalSearchBox.NRnZ9XZ2.js} (99%) rename assets/chunks/{theme.eHXeYJL0.js => theme.fbFORVJM.js} (99%) rename assets/{engineering_build-system.md.HJZocaoQ.js => engineering_build-system.md.0lT4HF-R.js} (99%) rename assets/{engineering_build-system.md.HJZocaoQ.lean.js => engineering_build-system.md.0lT4HF-R.lean.js} (100%) rename assets/{environment_install-environment.md.aoj-uaPQ.js => environment_install-environment.md.PTNE6kMW.js} (67%) rename assets/{environment_install-environment.md.aoj-uaPQ.lean.js => environment_install-environment.md.PTNE6kMW.lean.js} (52%) create mode 100644 assets/index.md.EcLvnWMr.js create mode 100644 assets/index.md.EcLvnWMr.lean.js delete mode 100644 assets/index.md.Lwj7q2PL.js delete mode 100644 assets/index.md.Lwj7q2PL.lean.js diff --git a/404.html b/404.html index 8f04a866..ca2841e2 100644 --- a/404.html +++ b/404.html @@ -3,19 +3,19 @@ - 404 | Zig 圣经 + 404 | Zig 语言圣经 - + -
Zig 圣经

Appearance

404

PAGE NOT FOUND

But if you don't change your direction, and if you keep looking, you may end up where you are heading.
Take me home
- +
Zig 语言圣经

Appearance

404

PAGE NOT FOUND

But if you don't change your direction, and if you keep looking, you may end up where you are heading.
Take me home
+ \ No newline at end of file diff --git a/about.html b/about.html index f9cdb21b..1676f067 100644 --- a/about.html +++ b/about.html @@ -3,22 +3,22 @@ - 关于本站 | Zig 圣经 + 关于本站 | Zig 语言圣经 - + - + -
Zig 圣经

Appearance

关于本站 ​

本网站仅仅用于帮助用户快速学习和了解 Zig ， 当前 Zig 版本尚未发布1.0版本，文档可能存在错误之处，敬请谅解！

参与贡献 ​

欢迎各位志同道合的“道友”参与贡献本文档，并一起壮大 zig 中文社区！

贡献方法：

  • fork 本文档仓库
  • 创建一个新的分支，请勿直接使用主分支进行修改
  • 发起 pull request
  • 等待 review
  • 合并到上游仓库，并由 github action 自动构建

🅿️ 提示

本文档所使用的构建工具为 bunjs，在提交时请勿将其他nodejs的包管理工具的额外配置文件添加到仓库中。

- +
Zig 语言圣经

Appearance

关于本站 ​

本网站仅仅用于帮助用户快速学习和了解 Zig ， 当前 Zig 版本尚未发布1.0版本，文档可能存在错误之处，敬请谅解！

参与贡献 ​

欢迎各位志同道合的“道友”参与贡献本文档，并一起壮大 zig 中文社区！

贡献方法：

  • fork 本文档仓库
  • 创建一个新的分支，请勿直接使用主分支进行修改
  • 发起 pull request
  • 等待 review
  • 合并到上游仓库，并由 github action 自动构建

🅿️ 提示

本文档所使用的构建工具为 bunjs，在提交时请勿将其他nodejs的包管理工具的额外配置文件添加到仓库中。

+ \ No newline at end of file diff --git a/advanced/assembly.html b/advanced/assembly.html index a79aa3b6..8822d35a 100644 --- a/advanced/assembly.html +++ b/advanced/assembly.html @@ -3,21 +3,21 @@ - 汇编 | Zig 圣经 + 汇编 | Zig 语言圣经 - + - + -
Zig 圣经

Appearance

汇编 ​

尽管现代高级语言的特性已经非常丰富，但我们仍需要汇编语言的帮助，在某些特殊的场景下，汇编语言可以发挥出比高级语言更好的性能，这是因为汇编语言更加接近硬件，它允许我们对硬件直接进行操作。

一般是在以下场景下，才会涉及到使用汇编语言：

  1. 时效性高的程序，例如工业控制的程序。
  2. 驱动程序，这需要直接操控硬件，由于高级语言的抽象层次过高，导致其不如汇编语言来的方便。
  3. 内核的开发，现代化内核编写时均会使用汇编来完成一些初始化工作，如 bootloader，分段分页，中断处理等。
  4. 程序的优化，高级语言的编译器并不是完美的，它有时会做出反而使程序变慢的“优化”，而汇编语言完全由程序员控制。

在 zig 中使用汇编有两种方式，引入外部的内联汇编，内联汇编大概是使用最多的情况。

🅿️ 提示

对于 x86 和 x86_64 ，当前汇编语法为 AT＆T 语法，而不是更流行的 Intel 语法。这是由于技术限制，汇编解析由LLVM提供，其对 Intel 语法的支持存在 bug 且测试​​结果并不理想。

在未来的某一天 Zig 可能有自己的汇编器。这将使汇编能够更加无缝地集成到语言中，并与流行的 Nasm 语法兼容。

外部汇编 ​

两种方式引入外部汇编，一种是在 build.zig 中使用 addAssemblyFile 添加汇编文件，另一种是通过 zig 本身的全局汇编功能。

这里讲述全局汇编功能：当汇编表达式出现在容器级 comptime 块中时，就是全局汇编。

🅿️ 提示

你可能对于容器这个概念比较疑惑，在 Zig 中，容器是充当保存变量和函数声明的命名空间的任何语法结构。容器也是可以实例化的类型定义。结构体、枚举、联合、不透明，甚至 Zig 源文件本身都是容器，但容器并不能包含语句（语句是描述程序运行操作的一个单位）。

当然，你也可以这样理解：容器是一个只包含变量或常量定义以及函数定义的命名空间。

注意：容器和块（block）不同！

它的实际作用就和使用 addAssemblyFile 的效果类似，在编译期它们会被提取出来作为单独的汇编文件进行编译和链接。

zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
汇编 ​
尽管现代高级语言的特性已经非常丰富，但我们仍需要汇编语言的帮助，在某些特殊的场景下，汇编语言可以发挥出比高级语言更好的性能，这是因为汇编语言更加接近硬件，它允许我们对硬件直接进行操作。
一般是在以下场景下，才会涉及到使用汇编语言：
  1. 时效性高的程序，例如工业控制的程序。
  2. 驱动程序，这需要直接操控硬件，由于高级语言的抽象层次过高，导致其不如汇编语言来的方便。
  3. 内核的开发，现代化内核编写时均会使用汇编来完成一些初始化工作，如 bootloader，分段分页，中断处理等。
  4. 程序的优化，高级语言的编译器并不是完美的，它有时会做出反而使程序变慢的“优化”，而汇编语言完全由程序员控制。
在 zig 中使用汇编有两种方式，引入外部的内联汇编，内联汇编大概是使用最多的情况。
🅿️ 提示
对于 x86 和 x86_64 ，当前汇编语法为 AT＆T 语法，而不是更流行的 Intel 语法。这是由于技术限制，汇编解析由LLVM提供，其对 Intel 语法的支持存在 bug 且测试​​结果并不理想。
在未来的某一天 Zig 可能有自己的汇编器。这将使汇编能够更加无缝地集成到语言中，并与流行的 Nasm 语法兼容。
外部汇编 ​
两种方式引入外部汇编，一种是在 build.zig 中使用 addAssemblyFile 添加汇编文件，另一种是通过 zig 本身的全局汇编功能。
这里讲述全局汇编功能：当汇编表达式出现在容器级 comptime 块中时，就是全局汇编。
🅿️ 提示
你可能对于容器这个概念比较疑惑，在 Zig 中，容器是充当保存变量和函数声明的命名空间的任何语法结构。容器也是可以实例化的类型定义。结构体、枚举、联合、不透明，甚至 Zig 源文件本身都是容器，但容器并不能包含语句（语句是描述程序运行操作的一个单位）。
当然，你也可以这样理解：容器是一个只包含变量或常量定义以及函数定义的命名空间。
注意：容器和块（block）不同！
它的实际作用就和使用 addAssemblyFile 的效果类似，在编译期它们会被提取出来作为单独的汇编文件进行编译和链接。
zig
const std = @import("std");
 
 comptime {
     asm (
@@ -75,7 +75,7 @@
 : OutputOperands
 [ : InputOperands
 [ : Clobbers ] ]
  1. 首先是一个内联汇编的语句，但它和普通的内联语句不同，它可以使用“占位符”，类似%[value]，这就是一个占位符，以 % 开头，如果需要使用寄存器，则需要使用两个 % ，例如使用 CR3 寄存器就是 %%cr3。
  2. 之后是一个输出位置，它表示你需要将值输出到哪里，也可以没有返回值，例如上方的示例中 [ret] "={rax}" (-> usize) 代表我们使用 [ret] 标记了返回值，并且返回值就是 rax 寄存器中的值，其后的 (-> usize) 代表我们整个内联汇编表达式需要返回一个值，当然这里如果是一个变量，就会将rax寄存器的值通过[ret]标记绑定到变量上。（注意，此处的 = 代表只能进行写入操作数，属于是一个约束。）
  3. 这是输入操作数，它和输出位置类似，但它可以存在多个输入，并且它也支持“占位符”和相关的约束。
  4. 这里是改动的寄存器，用于通知编译器，我们在执行此内联汇编会使用（或者称之为破坏更合适）的寄存器，默认包含了输入和输出寄存器。还有一个特殊标记 memory，它会通知编译器内联汇编会写入任意为声明的内存位置。
🅿️ 提示
关于更多的内联汇编约束信息，你可以阅读这里：LLVM documentation，GCC documentation。
WARNING
内联汇编特性在未来可能会发生更改以支持新的特性（如多个返回值），具体见此 issue。
了解更多？可以查看我的这篇文章 Handle Interrupt on x86-64 kernel with zig，这是一篇关于如何在 x86-64 内核上利用 zig 的特性实现中断处理的文章，在这其中我用了内联汇编，算是一个比较巧妙的例子。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/advanced/async.html b/advanced/async.html
index 90178b9a..a9614b3a 100644
--- a/advanced/async.html
+++ b/advanced/async.html
@@ -3,22 +3,22 @@
   
     
     
-    异步 | Zig 圣经
+    异步 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
异步 ​
当前的异步处于冻结状态，在未来可用时将会更新此部分内容！
如果你想了解更多信息，可以查看该 issue！

-    
+    
Zig 语言圣经
Appearance
异步 ​
当前的异步处于冻结状态，在未来可用时将会更新此部分内容！
如果你想了解更多信息，可以查看该 issue！

+    
     
   
 
\ No newline at end of file
diff --git a/advanced/comptime.html b/advanced/comptime.html
index 626119df..2913d2f2 100644
--- a/advanced/comptime.html
+++ b/advanced/comptime.html
@@ -3,21 +3,21 @@
   
     
     
-    编译期 | Zig 圣经
+    编译期 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
编译期 ​
在开始之前，我们需要先梳理一下，什么是编译期？
对于这个概念，你可能会一脸懵逼。所以我们先看一下什么是运行时（runtime）：
“在计算机科学中代表一个计算机程序从开始执行到终止执行的运作、执行的时期。”
对应地，我们可以尝试给编译期做一个定义：“zig 编译期是指在 zig 编译期间执行的动作。”
🅿️ 提示
在 Zig 中，类型是一等公民。它们可以分配给变量，作为参数传递给函数，并从函数返回。但需要注意：它们只能用于编译期已知的语句或函数中！
通常一个编译期已知的语句或函数带有 comptime 关键字！
comptime 这个关键字表示：
  • 在这个调用点，标记的值必须是在编译期已知的，否则 zig 会报告错误！
  • 在函数定义中，该值（包括参数、类型）必须是编译期已知的！
编译期参数实现鸭子类型 ​
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
一个实现 max 功能的函数：
zig
fn max(comptime T: type, a: T, b: T) T {
+    
Zig 语言圣经
Appearance
编译期 ​
在开始之前，我们需要先梳理一下，什么是编译期？
对于这个概念，你可能会一脸懵逼。所以我们先看一下什么是运行时（runtime）：
“在计算机科学中代表一个计算机程序从开始执行到终止执行的运作、执行的时期。”
对应地，我们可以尝试给编译期做一个定义：“zig 编译期是指在 zig 编译期间执行的动作。”
🅿️ 提示
在 Zig 中，类型是一等公民。它们可以分配给变量，作为参数传递给函数，并从函数返回。但需要注意：它们只能用于编译期已知的语句或函数中！
通常一个编译期已知的语句或函数带有 comptime 关键字！
comptime 这个关键字表示：
  • 在这个调用点，标记的值必须是在编译期已知的，否则 zig 会报告错误！
  • 在函数定义中，该值（包括参数、类型）必须是编译期已知的！
编译期参数实现鸭子类型 ​
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
一个实现 max 功能的函数：
zig
fn max(comptime T: type, a: T, b: T) T {
     return if (a > b) a else b;
 }
以上，我们定义了一个函数，它包含一个编译期参数 T，这个 T 的类型是 type，也就是一个类型，同时其他的参数和返回值类型也都是 T，这意味着参数类型与返回值类型是一致的。
很明显，上述的 max 函数仅仅只能比较整数和浮点数，我们可以稍稍改造它一下，使之支持布尔值：
zig
fn max(comptime T: type, a: T, b: T) T {
     if (T == bool) {
@@ -109,7 +109,7 @@
     .items = &buffer,
     .len = 0,
 };
以上代码，我们通过 List 函数初始化变量 list，它是一个结构体的示例，List(i32) 返回的是一个结构体类型。
🅿️ 提示
关于这个结构体的名字，它是由编译器决定的，根据创建匿名结构体时调用的函数名称和参数推断出名称为List(i32)。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/advanced/interact-with-c.html b/advanced/interact-with-c.html
index 9d555f1b..efd43d12 100644
--- a/advanced/interact-with-c.html
+++ b/advanced/interact-with-c.html
@@ -3,21 +3,21 @@
   
     
     
-    与 C 交互 | Zig 圣经
+    与 C 交互 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
与 C 交互 ​
zig 作为一个可以独立于 C 的语言，不依赖 libc，但 zig 仍然具有非常强大的与 c 直接交互的能力，并远超其他语言。
🅿️ 提示
zig 所指的交互并不仅仅是使用 C 的库，zig 还可以作为 C 的编译器，导出 C ABI 兼容的库供其他程序使用。
并且 zig 使用 C 并不是通过 FFI/bindings 实现，而是近乎原生的调用，这归功于 zig 实现了一套 C 的编译器并且支持将 C 代码翻译为 zig 代码！
C ABI 类型 ​
zig 定义了几个对应 C ABI 的基本类型：
  • c_char
  • c_short
  • c_ushort
  • c_int
  • c_uint
  • c_long
  • c_ulong
  • c_longlong
  • c_ulonglong
  • c_longdouble
对应 C void 类型的时候，使用 anyopaque (大小为止的类型)。
C Header 导入 ​
C 语言共享类型通常是通过引入头文件实现，这点在 zig 中可以无缝做到，得益于 zig 的 translate-c 功能。
接下来展示一个例子，简单地引入 c 标准库的 printf 函数：
zig
const c = @cImport({
+    
Zig 语言圣经
Appearance
与 C 交互 ​
zig 作为一个可以独立于 C 的语言，不依赖 libc，但 zig 仍然具有非常强大的与 c 直接交互的能力，并远超其他语言。
🅿️ 提示
zig 所指的交互并不仅仅是使用 C 的库，zig 还可以作为 C 的编译器，导出 C ABI 兼容的库供其他程序使用。
并且 zig 使用 C 并不是通过 FFI/bindings 实现，而是近乎原生的调用，这归功于 zig 实现了一套 C 的编译器并且支持将 C 代码翻译为 zig 代码！
C ABI 类型 ​
zig 定义了几个对应 C ABI 的基本类型：
  • c_char
  • c_short
  • c_ushort
  • c_int
  • c_uint
  • c_long
  • c_ulong
  • c_longlong
  • c_ulonglong
  • c_longdouble
对应 C void 类型的时候，使用 anyopaque (大小为止的类型)。
C Header 导入 ​
C 语言共享类型通常是通过引入头文件实现，这点在 zig 中可以无缝做到，得益于 zig 的 translate-c 功能。
接下来展示一个例子，简单地引入 c 标准库的 printf 函数：
zig
const c = @cImport({
     @cDefine("_NO_CRT_STDIO_INLINE", "1");
     @cInclude("stdio.h");
 });
@@ -62,7 +62,7 @@
     }
     return sum;
 }
额外内容 ​
以下是经过实践和总结出来的额外信息，官方的 ziglang 并未提供！
为什么 zig 可以做到比 c 更好的编译 ​
实际上，zig 本身实现了一个 C 的编译器（目前仅限 linux，其他平台仍使用 llvm），当然不仅仅如此，zig 还提供了一个比较 magic 的东西—— glibc-abi-tool，这是一个收集每个版本的 glibc 的 .abilist 文件的存储库，还包含一个将它们组合成一个数据集的工具。
所以，zig 本身所谓的 “ships with libc” 并不准确，它的确分发 libc，但它只携带每个版本的符号库，仅依赖这个符号库，zig 就可以实现在没有 libc 的情况下仍然正确地进行动态链接！
🅿️ 提示
由于这种特性，这导致 zig 尽管携带了 40 个 libc，却仍然能保持 45MB（linux-x86-64）左右的大小，作为对比 llvm 分发的 clang 完整的工具链的大小多达好几百 M。
关于更多的细节，你可以参考以下链接：
zig 能静态链接 libc 吗？ ​
能，又不能！
zig 支持静态链接 musl（针对linux的另一个 libc，目标为嵌入式系统与移动设备），其他仅支持动态链接。受益于这种特性，我们可以将它作为 C 编译器的替代品使用，它可以提供更加完善的工具链。
举个比较剑走偏锋的例子，go 的 cgo 特性一直为人们所吐槽，一旦使用了它，基本就要和 go 宣称的非常方便的交叉编译说拜拜了，但我们可以使用 zig 来帮助我们实现 cgo 的交叉编译：
sh
CC='zig cc -target x86_64-linux-gnu' CXX='zig cc -target x86_64-linux-gnu' go build
设置 zig 作为 C 编译器来供 go 使用，只要对 zig 和 go 设置正确的target，就可以在本机实现完善的交叉编译。
再进一步，我们还可以构建出 linux 的使用 cgo 的静态链接的二进制可执行文件：
sh
CC='zig cc -target x86_64-linux-musl' CXX='zig cc -target x86_64-linux-musl' CGO_CFLAGS='-D_LARGEFILE64_SOURCE' go build -ldflags='-linkmode=external -extldflags -static'
上方的 CGO_CFLAGS 是为了防止编译失败，ldfalgs 是为了指定静态链接！

-    
+    
     
   
 
\ No newline at end of file
diff --git a/advanced/memory_manage.html b/advanced/memory_manage.html
index 573c92ec..cb3e2105 100644
--- a/advanced/memory_manage.html
+++ b/advanced/memory_manage.html
@@ -3,21 +3,21 @@
   
     
     
-    内存管理 | Zig 圣经
+    内存管理 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
内存管理 ​
zig 在内存管理方面采取了类似 C 的方案，完全由程序员管理内存，这也是为什么 zig 没有运行时开销的原因，同时这也是为什么 zig 可以在如此多环境（包括实时软件、操作系统内核、嵌入式设备和低延迟服务器）中无缝工作的原因。
事实上，在 C 开发中最难以调试的 bug 往往是由于错误的内存管理引起的， zig 在此基础上给我们提供了少量的保护，但仅仅是少量的保护，这就要求程序员在需要明白数据在内存中真实存在的模样（这就涉及到计算机组成原理和操作系统的理论知识了，当然还涉及到一点点的汇编知识）。
事实上，zig 本身的标准库为我们提供了多种内存分配模型：
  1. GeneralPurposeAllocator
  2. FixedBufferAllocator
  3. ArenaAllocator
  4. HeapAllocator
  5. c_allocator
  6. page_allocator
除了这六种内存分配模型外，还提供了内存池的功能 MemoryPool
你可能对上面的多种内存模型感到很迷惑，C 语言中不就是 malloc 吗，怎么到这里这么多的“模型”，这些模型均有着不同的特点，而且它们之间有一部分还可以叠加使用，zig 在这方面提供了更多的选择，而且不仅仅是这些，你还可以自己尝试实现一个内存模型。
🅿️ 提示
除了这些，还有一些你可能用不到的分配模型：
  • std.testing.FailingAllocator
  • std.testing.allocator
  • std.heap.LoggingAllocator
  • std.heap.LogToWriterAllocator
  • std.heap.SbrkAllocator
  • std.heap.ScopedLoggingAllocator
  • std.heap.StackFallbackAllocator
GeneralPurposeAllocator ​
这是一个通用的分配器，当你需要动态内存时，并且还不知道自己应该用什么分配器模型，用这个准没错！
这个分配器的目的不是为了性能，而是为了安全，它支持线程安全，安全检查，检查是否存在泄露等特性，这些特性均可手动配置是否开启。
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
内存管理 ​
zig 在内存管理方面采取了类似 C 的方案，完全由程序员管理内存，这也是为什么 zig 没有运行时开销的原因，同时这也是为什么 zig 可以在如此多环境（包括实时软件、操作系统内核、嵌入式设备和低延迟服务器）中无缝工作的原因。
事实上，在 C 开发中最难以调试的 bug 往往是由于错误的内存管理引起的， zig 在此基础上给我们提供了少量的保护，但仅仅是少量的保护，这就要求程序员在需要明白数据在内存中真实存在的模样（这就涉及到计算机组成原理和操作系统的理论知识了，当然还涉及到一点点的汇编知识）。
事实上，zig 本身的标准库为我们提供了多种内存分配模型：
  1. GeneralPurposeAllocator
  2. FixedBufferAllocator
  3. ArenaAllocator
  4. HeapAllocator
  5. c_allocator
  6. page_allocator
除了这六种内存分配模型外，还提供了内存池的功能 MemoryPool
你可能对上面的多种内存模型感到很迷惑，C 语言中不就是 malloc 吗，怎么到这里这么多的“模型”，这些模型均有着不同的特点，而且它们之间有一部分还可以叠加使用，zig 在这方面提供了更多的选择，而且不仅仅是这些，你还可以自己尝试实现一个内存模型。
🅿️ 提示
除了这些，还有一些你可能用不到的分配模型：
  • std.testing.FailingAllocator
  • std.testing.allocator
  • std.heap.LoggingAllocator
  • std.heap.LogToWriterAllocator
  • std.heap.SbrkAllocator
  • std.heap.ScopedLoggingAllocator
  • std.heap.StackFallbackAllocator
GeneralPurposeAllocator ​
这是一个通用的分配器，当你需要动态内存时，并且还不知道自己应该用什么分配器模型，用这个准没错！
这个分配器的目的不是为了性能，而是为了安全，它支持线程安全，安全检查，检查是否存在泄露等特性，这些特性均可手动配置是否开启。
zig
const std = @import("std");
 
 pub fn main() !void {
     // 使用模型，一定要是变量，不能是常量
@@ -36,7 +36,7 @@
     const bytes = try allocator.alloc(u8, 100);
     // 延后释放内存
     defer allocator.free(bytes);
-}
FixedBufferAllocator ​
这个分配器是固定大小的内存缓冲区，无法扩容，常常在你需要缓冲某些东西时使用，注意默认情况下它不是线程安全的，但是存在着变体 ThreadSafeAllocator，使用 ThreadSafeAllocator 包裹一下它即可。
zig
const std = @import("std");
+}
FixedBufferAllocator ​
这个分配器是固定大小的内存缓冲区，无法扩容，常常在你需要缓冲某些东西时使用，注意默认情况下它不是线程安全的，但是存在着变体 ThreadSafeAllocator，使用 ThreadSafeAllocator 包裹一下它即可。
zig
const std = @import("std");
 
 pub fn main() !void {
     var buffer: [1000]u8 = undefined;
@@ -147,7 +147,7 @@
     _ = p3;
     _ = p4;
 }
除了基本的分配，内存池还支持预分配和指针对齐设置等，源代码可以参考这里memory_pool.zig，它的实现很巧妙，值得一看。
这里有一篇关于最初这个内存池是如何实现的文章：Cool Zig Patterns - Gotta alloc fast
实现内存分配器 ​
待添加，当前你可以通过实现 Allocator 接口来实现自己的分配器。为了做到这一点，必须仔细阅读 std/mem.zig 中的文档注释，然后提供 allocFn 和 resizeFn。
有许多分配器示例可供查看以获取灵感。查看 std/heap.zig 和 std.heap.GeneralPurposeAllocator

-    
+    
     
   
 
\ No newline at end of file
diff --git a/advanced/package_management.html b/advanced/package_management.html
index 144b78c0..bad8b0ce 100644
--- a/advanced/package_management.html
+++ b/advanced/package_management.html
@@ -3,21 +3,21 @@
   
     
     
-    包管理 | Zig 圣经
+    包管理 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
包管理 ​
随着 0.11 的发布，zig 终于迎来了一个正式的官方包管理器，此前已知是通过第三方包管理器下载并处理包。
zig 当前并没有一个中心化存储库，包可以来自任何来源，无论是本地还是网络上。
当前的包管理模式为，先在 build.zig.zon 添加包的元信息，然后在 build.zig 中引入包。
新的文件结构 ​
build.zig.zon 这个文件存储了包的信息，它是 zig 新引入的一种简单数据交换格式，使用了 zig 的匿名结构和数组初始化语法。
zig
.{
+    
Zig 语言圣经
Appearance
包管理 ​
随着 0.11 的发布，zig 终于迎来了一个正式的官方包管理器，此前已知是通过第三方包管理器下载并处理包。
zig 当前并没有一个中心化存储库，包可以来自任何来源，无论是本地还是网络上。
当前的包管理模式为，先在 build.zig.zon 添加包的元信息，然后在 build.zig 中引入包。
新的文件结构 ​
build.zig.zon 这个文件存储了包的信息，它是 zig 新引入的一种简单数据交换格式，使用了 zig 的匿名结构和数组初始化语法。
zig
.{
     .name = "my_package_name",
     .version = "0.1.0",
     .dependencies = .{
@@ -72,7 +72,7 @@
     // 链接依赖提供的库
     exe.linkLibrary(library_name);
 }
如果需要引入一个本地包（且该包自己有 build.zig），那么可以使用 std.Build.anonymousDependency， 它的原型为：
zig
fn anonymousDependency(b: *Build, relative_build_root: []const u8, comptime build_zig: type, args: anytype) *Dependency
参数为包的包构建根目录和通过 @import 导入的包的 build.zig 。
🅿️ 提示
dependency 和 anonymousDependency 都包含一个额外的参数 args，这是传给对应的包构建的参数（类似在命令行构建时使用的 -D 参数，通常是我们使用 b.options 获取，通过 std.Build.option 实现），当前包的参数并不会向包传递，需要手动显式指定转发。
TODO：更多示例说明

-    
+    
     
   
 
\ No newline at end of file
diff --git a/advanced/type_cast.html b/advanced/type_cast.html
index f96dc20a..2725efe6 100644
--- a/advanced/type_cast.html
+++ b/advanced/type_cast.html
@@ -3,21 +3,21 @@
   
     
     
-    类型转换 | Zig 圣经
+    类型转换 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
类型转换 ​
在计算机科学，特别是在程序设计语言中，类型转换（英语：type conversion）指将数据从一种类型转换到另一种类型的过程。
zig 提供了三种类型转换，第一种是已知完全安全且不存在歧义的普通类型转换，第二种是用于避免出现错误的显式强制类型转换，第三种是对等类型解析（Peer Type Resolution）。
普通类型转换 ​
出现时机：当需要一种类型时却提供了另一种类型，如果此时这种转换是安全，且不存在歧义，则会由 zig 自动完成。
仅当完全明确如何从一种类型转换为另一种类型并且保证转换安全时才允许自动转换，但有一个例外，那就是 zig 的 C指针。
大致的规则如下：
限制更严格 ​
例如非 const -> const，增加 volatile 限制，大的内存对齐转为小的内存对齐，错误集合转为超集（子集转为超集），指针转为可选指针，这些转换实际上在运行时没有任何操作，因为值没有任何变化。
整数与浮点数拓宽 ​
整数可以转换为可以表示旧类型全部值的整数类型，这句话看起来可能有点绕，就像 u8 转为 u16 没有任何问题，因为 u16 肯定可以容纳 u8，而 u8 转为 i16 也没有问题，因为 i16 同样也容纳 u8。
浮点数同理，可以转换为可以表示旧类型全部值的浮点类型。
zig
const a: u8 = 250;
+    
Zig 语言圣经
Appearance
类型转换 ​
在计算机科学，特别是在程序设计语言中，类型转换（英语：type conversion）指将数据从一种类型转换到另一种类型的过程。
zig 提供了三种类型转换，第一种是已知完全安全且不存在歧义的普通类型转换，第二种是用于避免出现错误的显式强制类型转换，第三种是对等类型解析（Peer Type Resolution）。
普通类型转换 ​
出现时机：当需要一种类型时却提供了另一种类型，如果此时这种转换是安全，且不存在歧义，则会由 zig 自动完成。
仅当完全明确如何从一种类型转换为另一种类型并且保证转换安全时才允许自动转换，但有一个例外，那就是 zig 的 C指针。
大致的规则如下：
限制更严格 ​
例如非 const -> const，增加 volatile 限制，大的内存对齐转为小的内存对齐，错误集合转为超集（子集转为超集），指针转为可选指针，这些转换实际上在运行时没有任何操作，因为值没有任何变化。
整数与浮点数拓宽 ​
整数可以转换为可以表示旧类型全部值的整数类型，这句话看起来可能有点绕，就像 u8 转为 u16 没有任何问题，因为 u16 肯定可以容纳 u8，而 u8 转为 i16 也没有问题，因为 i16 同样也容纳 u8。
浮点数同理，可以转换为可以表示旧类型全部值的浮点类型。
zig
const a: u8 = 250;
 const b: u16 = a;
 const c: u32 = b;
 const d: u64 = c;
@@ -180,7 +180,7 @@
 const b: ?*usize = @ptrFromInt(0x123456780);
 
 a == b 这个表达式的值为 true

-    
+    
     
   
 
\ No newline at end of file
diff --git a/appendix/community.html b/appendix/community.html
index 54346911..bf04f150 100644
--- a/appendix/community.html
+++ b/appendix/community.html
@@ -3,22 +3,22 @@
   
     
     
-    社区 | Zig 圣经
+    社区 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
-    
+    
+    
     
   
 
\ No newline at end of file
diff --git a/appendix/well-known-lib.html b/appendix/well-known-lib.html
index ec75446d..b0a3e590 100644
--- a/appendix/well-known-lib.html
+++ b/appendix/well-known-lib.html
@@ -3,22 +3,22 @@
   
     
     
-    第三方库 | Zig 圣经
+    第三方库 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
第三方库 ​
这里列出一些仍在积极维护的 Zig 第三方库，你可以进行参考和学习
  • zap： 速度极快的 zig 后端开发库
  • bun: 使用 zig 编写的 js 运行时，原生支持 ts 和包管理
  • mach：zig 的游戏引擎和图形套件
  • capy： 依托于 GTK4 的强大的 GUI 库
  • zld: zig 实现的 LD 的替代品
  • zls: zig的 language server 实现
  • dt: 用于 unix 的 pipe
  • arocc: 使用 zig 编写的 C 编译器
  • bog: 一个轻量强类型嵌入式语言
  • buzz: 一个小型轻量的静态类型脚本语言
  • cyber: 一个快速高效且并发的脚本语言
  • ini: 一个简单的 ini 文件解析库
  • koino: Comrak 的解析器，并且保证与 github 的 markdown 规范兼容
  • LoLa: 适用于游戏的小型脚本语言
  • tigerbeetle: 专为关键任务安全性和性能而设计的分布式财务会计数据库
  • zig-sqlite: 对 sqlite 的 C API包装库
  • duckdb: 对 duckdb 的 API 包裹
  • legend-of-swarkland: 游戏，斯沃克兰的传说
  • pacman: 吃豆人游戏的 zig 版本
  • tetris: 使用 zig 编写的俄罗斯方块
  • river: 使用 zig 编写的窗口管理器
  • minisign: zig 实现的 minisign
  • zig-gamedev: zig 的游戏生态库
  • zig-webui：webui 的包裹，允许 zig 将浏览器作为渲染前端

-    
+    
Zig 语言圣经
Appearance
第三方库 ​
这里列出一些仍在积极维护的 Zig 第三方库，你可以进行参考和学习
  • zap： 速度极快的 zig 后端开发库
  • bun: 使用 zig 编写的 js 运行时，原生支持 ts 和包管理
  • mach：zig 的游戏引擎和图形套件
  • capy： 依托于 GTK4 的强大的 GUI 库
  • zld: zig 实现的 LD 的替代品
  • zls: zig的 language server 实现
  • dt: 用于 unix 的 pipe
  • arocc: 使用 zig 编写的 C 编译器
  • bog: 一个轻量强类型嵌入式语言
  • buzz: 一个小型轻量的静态类型脚本语言
  • cyber: 一个快速高效且并发的脚本语言
  • ini: 一个简单的 ini 文件解析库
  • koino: Comrak 的解析器，并且保证与 github 的 markdown 规范兼容
  • LoLa: 适用于游戏的小型脚本语言
  • tigerbeetle: 专为关键任务安全性和性能而设计的分布式财务会计数据库
  • zig-sqlite: 对 sqlite 的 C API包装库
  • duckdb: 对 duckdb 的 API 包裹
  • legend-of-swarkland: 游戏，斯沃克兰的传说
  • pacman: 吃豆人游戏的 zig 版本
  • tetris: 使用 zig 编写的俄罗斯方块
  • river: 使用 zig 编写的窗口管理器
  • minisign: zig 实现的 minisign
  • zig-gamedev: zig 的游戏生态库
  • zig-webui：webui 的包裹，允许 zig 将浏览器作为渲染前端

+    
     
   
 
\ No newline at end of file
diff --git a/assets/advanced_memory_manage.md.2V38NqCn.js b/assets/advanced_memory_manage.md.VVXxDYaI.js
similarity index 99%
rename from assets/advanced_memory_manage.md.2V38NqCn.js
rename to assets/advanced_memory_manage.md.VVXxDYaI.js
index f50ab8eb..e2254df1 100644
--- a/assets/advanced_memory_manage.md.2V38NqCn.js
+++ b/assets/advanced_memory_manage.md.VVXxDYaI.js
@@ -17,7 +17,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const y=
     const bytes = try allocator.alloc(u8, 100);
     // 延后释放内存
     defer allocator.free(bytes);
-}
FixedBufferAllocator ​
这个分配器是固定大小的内存缓冲区，无法扩容，常常在你需要缓冲某些东西时使用，注意默认情况下它不是线程安全的，但是存在着变体 ThreadSafeAllocator，使用 ThreadSafeAllocator 包裹一下它即可。
zig
const std = @import("std");
+}
FixedBufferAllocator ​
这个分配器是固定大小的内存缓冲区，无法扩容，常常在你需要缓冲某些东西时使用，注意默认情况下它不是线程安全的，但是存在着变体 ThreadSafeAllocator，使用 ThreadSafeAllocator 包裹一下它即可。
zig
const std = @import("std");
 
 pub fn main() !void {
     var buffer: [1000]u8 = undefined;
@@ -127,4 +127,4 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const y=
     _ = p1;
     _ = p3;
     _ = p4;
-}
除了基本的分配，内存池还支持预分配和指针对齐设置等，源代码可以参考这里memory_pool.zig，它的实现很巧妙，值得一看。
这里有一篇关于最初这个内存池是如何实现的文章：Cool Zig Patterns - Gotta alloc fast
实现内存分配器 ​
待添加，当前你可以通过实现 Allocator 接口来实现自己的分配器。为了做到这一点，必须仔细阅读 std/mem.zig 中的文档注释，然后提供 allocFn 和 resizeFn。
有许多分配器示例可供查看以获取灵感。查看 std/heap.zig 和 std.heap.GeneralPurposeAllocator
`,38),k=[l];function t(p,e,E,r,d,g){return a(),i("div",null,k)}const c=s(h,[["render",t]]);export{y as __pageData,c as default};
+}
除了基本的分配，内存池还支持预分配和指针对齐设置等，源代码可以参考这里memory_pool.zig，它的实现很巧妙，值得一看。
这里有一篇关于最初这个内存池是如何实现的文章：Cool Zig Patterns - Gotta alloc fast
实现内存分配器 ​
待添加，当前你可以通过实现 Allocator 接口来实现自己的分配器。为了做到这一点，必须仔细阅读 std/mem.zig 中的文档注释，然后提供 allocFn 和 resizeFn。
有许多分配器示例可供查看以获取灵感。查看 std/heap.zig 和 std.heap.GeneralPurposeAllocator
`,38),k=[l];function t(p,e,E,r,d,g){return a(),i("div",null,k)}const F=s(h,[["render",t]]);export{y as __pageData,F as default};
diff --git a/assets/advanced_memory_manage.md.2V38NqCn.lean.js b/assets/advanced_memory_manage.md.VVXxDYaI.lean.js
similarity index 82%
rename from assets/advanced_memory_manage.md.2V38NqCn.lean.js
rename to assets/advanced_memory_manage.md.VVXxDYaI.lean.js
index 17bef136..0b546f42 100644
--- a/assets/advanced_memory_manage.md.2V38NqCn.lean.js
+++ b/assets/advanced_memory_manage.md.VVXxDYaI.lean.js
@@ -1 +1 @@
-import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const y=JSON.parse('{"title":"内存管理","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"advanced/memory_manage.md","filePath":"advanced/memory_manage.md","lastUpdated":1704979746000}'),h={name:"advanced/memory_manage.md"},l=n("",38),k=[l];function t(p,e,E,r,d,g){return a(),i("div",null,k)}const c=s(h,[["render",t]]);export{y as __pageData,c as default};
+import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const y=JSON.parse('{"title":"内存管理","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"advanced/memory_manage.md","filePath":"advanced/memory_manage.md","lastUpdated":1704979746000}'),h={name:"advanced/memory_manage.md"},l=n("",38),k=[l];function t(p,e,E,r,d,g){return a(),i("div",null,k)}const F=s(h,[["render",t]]);export{y as __pageData,F as default};
diff --git a/assets/app.MIdJPtEx.js b/assets/app.-PyfpKM3.js
similarity index 95%
rename from assets/app.MIdJPtEx.js
rename to assets/app.-PyfpKM3.js
index 46bda2a0..b208e24a 100644
--- a/assets/app.MIdJPtEx.js
+++ b/assets/app.-PyfpKM3.js
@@ -1,4 +1,4 @@
-import{j as o,a4 as p,a5 as u,a6 as c,a7 as l,a8 as f,a9 as d,aa as m,ab as h,ac as A,ad as g,X as v,d as P,u as w,l as y,z as C,ae as R,af as _,ag as b,a3 as E}from"./chunks/framework.iEE2KsGo.js";import{R as D}from"./chunks/theme.eHXeYJL0.js";function i(e){if(e.extends){const a=i(e.extends);return{...a,...e,async enhanceApp(t){a.enhanceApp&&await a.enhanceApp(t),e.enhanceApp&&await e.enhanceApp(t)}}}return e}const s=i(D),T=P({name:"VitePressApp",setup(){const{site:e,lang:a,dir:t}=w();return y(()=>{C(()=>{document.documentElement.lang=a.value,document.documentElement.dir=t.value})}),e.value.router.prefetchLinks&&R(),_(),b(),s.setup&&s.setup(),()=>E(s.Layout)}});async function j(){const e=O(),a=L();a.provide(u,e);const t=c(e.route);return a.provide(l,t),a.component("Content",f),a.component("ClientOnly",d),Object.defineProperties(a.config.globalProperties,{$frontmatter:{get(){return t.frontmatter.value}},$params:{get(){return t.page.value.params}}}),s.enhanceApp&&await s.enhanceApp({app:a,router:e,siteData:m}),{app:a,router:e,data:t}}function L(){return h(T)}function O(){let e=o,a;return A(t=>{let n=g(t),r=null;return n&&(e&&(a=n),(e||a===n)&&(n=n.replace(/\.js$/,".lean.js")),r=v(()=>import(n),__vite__mapDeps([]))),o&&(e=!1),r},s.NotFound)}o&&j().then(({app:e,router:a,data:t})=>{a.go().then(()=>{p(a.route,t.site),e.mount("#app")})});export{j as createApp};
+import{j as o,a4 as p,a5 as u,a6 as c,a7 as l,a8 as f,a9 as d,aa as m,ab as h,ac as A,ad as g,X as v,d as P,u as w,l as y,z as C,ae as R,af as _,ag as b,a3 as E}from"./chunks/framework.iEE2KsGo.js";import{R as D}from"./chunks/theme.fbFORVJM.js";function i(e){if(e.extends){const a=i(e.extends);return{...a,...e,async enhanceApp(t){a.enhanceApp&&await a.enhanceApp(t),e.enhanceApp&&await e.enhanceApp(t)}}}return e}const s=i(D),T=P({name:"VitePressApp",setup(){const{site:e,lang:a,dir:t}=w();return y(()=>{C(()=>{document.documentElement.lang=a.value,document.documentElement.dir=t.value})}),e.value.router.prefetchLinks&&R(),_(),b(),s.setup&&s.setup(),()=>E(s.Layout)}});async function j(){const e=O(),a=L();a.provide(u,e);const t=c(e.route);return a.provide(l,t),a.component("Content",f),a.component("ClientOnly",d),Object.defineProperties(a.config.globalProperties,{$frontmatter:{get(){return t.frontmatter.value}},$params:{get(){return t.page.value.params}}}),s.enhanceApp&&await s.enhanceApp({app:a,router:e,siteData:m}),{app:a,router:e,data:t}}function L(){return h(T)}function O(){let e=o,a;return A(t=>{let n=g(t),r=null;return n&&(e&&(a=n),(e||a===n)&&(n=n.replace(/\.js$/,".lean.js")),r=v(()=>import(n),__vite__mapDeps([]))),o&&(e=!1),r},s.NotFound)}o&&j().then(({app:e,router:a,data:t})=>{a.go().then(()=>{p(a.route,t.site),e.mount("#app")})});export{j as createApp};
 function __vite__mapDeps(indexes) {
   if (!__vite__mapDeps.viteFileDeps) {
     __vite__mapDeps.viteFileDeps = []
diff --git a/assets/basic_advanced_type_struct.md.7UsPAPWF.js b/assets/basic_advanced_type_struct.md.REVwY0VS.js
similarity index 99%
rename from assets/basic_advanced_type_struct.md.7UsPAPWF.js
rename to assets/basic_advanced_type_struct.md.REVwY0VS.js
index a0fd92da..508fc2e3 100644
--- a/assets/basic_advanced_type_struct.md.7UsPAPWF.js
+++ b/assets/basic_advanced_type_struct.md.REVwY0VS.js
@@ -1,4 +1,4 @@
-import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"结构体","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"basic/advanced_type/struct.md","filePath":"basic/advanced_type/struct.md","lastUpdated":1704981177000}'),n={name:"basic/advanced_type/struct.md"},k=h(`
结构体 ​
在 zig 中，类型是一等公民！
结构体本身是一个高级的数据结构，用于将多个数据表示为一个整体。
基本语法 ​
结构体的组成：
  • 首部关键字 struct
  • 和变量定义一样的结构体名字
  • 多个字段
  • 方法
  • 多个声明
以下是一个简短的结构体声明：
zig
const Circle = struct {
+import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"结构体","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"basic/advanced_type/struct.md","filePath":"basic/advanced_type/struct.md","lastUpdated":1704981177000}'),n={name:"basic/advanced_type/struct.md"},k=h(`
结构体 ​
在 zig 中，类型是一等公民！
结构体本身是一个高级的数据结构，用于将多个数据表示为一个整体。
基本语法 ​
结构体的组成：
  • 首部关键字 struct
  • 和变量定义一样的结构体名字
  • 多个字段
  • 方法
  • 多个声明
以下是一个简短的结构体声明：
zig
const Circle = struct {
     radius: u8,
 
     const PI: f16 = 3.14;
@@ -67,7 +67,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
     };
 
     std.debug.print("list len is {}\\n", .{list.length()});
-}
更复杂的例子
下面是一个日常会用到的一个结构体例子，系统账号管理的使用：
zig
const User = struct {
+}
更复杂的例子
下面是一个日常会用到的一个结构体例子，系统账号管理的使用：
zig
const User = struct {
     userName: []u8,
     password: []u8,
     email: []u8,
@@ -192,7 +192,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
 
 const x = Foo{
     .b = 5,
-};
空结构体 ​
你还可以使用空结构体，具体如下：
zig
const Empty = struct {
+};
空结构体 ​
你还可以使用空结构体，具体如下：
zig
const Empty = struct {
     // const PI = 3.14;
 };
zig
const std = @import("std");
 
@@ -291,7 +291,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
     const ptr: *align(4) S = &foo;
     const ptr_to_b: *u32 = &ptr.b;
     try expect(ptr_to_b.* == 2);
-}
命名规则 ​
由于在 zig 中很多结构是匿名的（例如可以把一个源文件看作是一个匿名的结构体），所以 zig 基于一套规则来进行命名：
  • 如果一个结构体位于变量的初始化表达式中，它就以该变量命名（实际上就是声明结构体类型）。
  • 如果一个结构体位于 return 表达式中，那么它以返回的函数命名，并序列化参数。
  • 其他情况下，结构体会获得一个类似 filename.funcname.__struct_ID 的名字。
  • 如果该结构体在另一个结构体中声明，它将以父结构体和前面的规则推断出的名称命名，并用点分隔。
上面几条规则看着很模糊是吧，我们来几个小小的示例来演示一下：
zig
const std = @import("std");
+}
命名规则 ​
由于在 zig 中很多结构是匿名的（例如可以把一个源文件看作是一个匿名的结构体），所以 zig 基于一套规则来进行命名：
  • 如果一个结构体位于变量的初始化表达式中，它就以该变量命名（实际上就是声明结构体类型）。
  • 如果一个结构体位于 return 表达式中，那么它以返回的函数命名，并序列化参数。
  • 其他情况下，结构体会获得一个类似 filename.funcname.__struct_ID 的名字。
  • 如果该结构体在另一个结构体中声明，它将以父结构体和前面的规则推断出的名称命名，并用点分隔。
上面几条规则看着很模糊是吧，我们来几个小小的示例来演示一下：
zig
const std = @import("std");
 
 pub fn main() void {
     const Foo = struct {};
diff --git a/assets/basic_advanced_type_struct.md.7UsPAPWF.lean.js b/assets/basic_advanced_type_struct.md.REVwY0VS.lean.js
similarity index 100%
rename from assets/basic_advanced_type_struct.md.7UsPAPWF.lean.js
rename to assets/basic_advanced_type_struct.md.REVwY0VS.lean.js
diff --git a/assets/basic_error_handle.md.DDwEzY8Y.js b/assets/basic_error_handle.md.X3CsP-Vt.js
similarity index 99%
rename from assets/basic_error_handle.md.DDwEzY8Y.js
rename to assets/basic_error_handle.md.X3CsP-Vt.js
index 37feca34..535311c7 100644
--- a/assets/basic_error_handle.md.DDwEzY8Y.js
+++ b/assets/basic_error_handle.md.X3CsP-Vt.js
@@ -62,7 +62,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
 const number = parseU64(str, 10) catch blk: {
     // do things
     break :blk 13;
-};
try ​
try 用于在出现错误时直接向上层返回错误，没错误就正常执行：
zig
fn doAThing(str: []u8) !void {
+};
try ​
try 用于在出现错误时直接向上层返回错误，没错误就正常执行：
zig
fn doAThing(str: []u8) !void {
     const number = try parseU64(str, 10);
     _ = number; // ...
 }
zig
fn doAThing(str: []u8) !void {
diff --git a/assets/basic_error_handle.md.DDwEzY8Y.lean.js b/assets/basic_error_handle.md.X3CsP-Vt.lean.js
similarity index 100%
rename from assets/basic_error_handle.md.DDwEzY8Y.lean.js
rename to assets/basic_error_handle.md.X3CsP-Vt.lean.js
diff --git a/assets/basic_optional_type.md.d6QrqvLi.js b/assets/basic_optional_type.md.N1LhwqCi.js
similarity index 99%
rename from assets/basic_optional_type.md.d6QrqvLi.js
rename to assets/basic_optional_type.md.N1LhwqCi.js
index 5449afa1..b3db0143 100644
--- a/assets/basic_optional_type.md.d6QrqvLi.js
+++ b/assets/basic_optional_type.md.N1LhwqCi.js
@@ -2,7 +2,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const y=
 const normal_int: i32 = 1234;
 
 // i32的可选类型，现在它的值可以是 i32 或者 null
-const optional_int: ?i32 = 5678;
当然，可选类型在整数上没什么大用，更多是在指针上使用，null（空引用）是许多运行时异常的根源，甚至被指责为计算机科学中最严重的错误。
当然这在 zig 中不存在，通过可选类型我们可以解决这个问题，zig 在解决空指针上采取的方式比较保守，它兼顾了代码的可读性和效率问题。
其中目前最为激进的应该是 Rust ，它真的是非常的激进，这增加了程序员在写代码时的心智负担（因为你经常需要和编译期斗智斗勇，但好处大大是减少了你在运行时 debug 的负担）。相对来说，zig 采取的是一种折中的方案，编译期仍然会给你检测，并且这种检测不是很深奥，而且纠正起来很简单，缺点是并不能保证你的运行时是绝对安全的（可选类型仅仅能保证你不使用空指针，却不能保证你出现悬空指针【迷途指针、野指针】等情况的出现）。
zig 会将 null 特殊看待，并且保证你不会将一个可能为 null 的值赋值给一个不能是 null 的变量。
首先我们和 zig 的目标：C 对比一下，看一下两者在处理 null 上的区别，在接下来的代码中，我们尝试调用 malloc，并且申请一块内存：
c
// 引用的是malloc的原型
+const optional_int: ?i32 = 5678;
当然，可选类型在整数上没什么大用，更多是在指针上使用，null（空引用）是许多运行时异常的根源，甚至被指责为计算机科学中最严重的错误。
当然这在 zig 中不存在，通过可选类型我们可以解决这个问题，zig 在解决空指针上采取的方式比较保守，它兼顾了代码的可读性和效率问题。
其中目前最为激进的应该是 Rust ，它真的是非常的激进，这增加了程序员在写代码时的心智负担（因为你经常需要和编译期斗智斗勇，但好处大大是减少了你在运行时 debug 的负担）。相对来说，zig 采取的是一种折中的方案，编译期仍然会给你检测，并且这种检测不是很深奥，而且纠正起来很简单，缺点是并不能保证你的运行时是绝对安全的（可选类型仅仅能保证你不使用空指针，却不能保证你出现悬空指针【迷途指针、野指针】等情况的出现）。
zig 会将 null 特殊看待，并且保证你不会将一个可能为 null 的值赋值给一个不能是 null 的变量。
首先我们和 zig 的目标：C 对比一下，看一下两者在处理 null 上的区别，在接下来的代码中，我们尝试调用 malloc，并且申请一块内存：
c
// 引用的是malloc的原型
 void *malloc(size_t size);
 
 struct Foo *do_a_thing(void) {
diff --git a/assets/basic_optional_type.md.d6QrqvLi.lean.js b/assets/basic_optional_type.md.N1LhwqCi.lean.js
similarity index 100%
rename from assets/basic_optional_type.md.d6QrqvLi.lean.js
rename to assets/basic_optional_type.md.N1LhwqCi.lean.js
diff --git a/assets/basic_process_control_decision.md.rdtrtJa0.js b/assets/basic_process_control_decision.md.AilCsfii.js
similarity index 99%
rename from assets/basic_process_control_decision.md.rdtrtJa0.js
rename to assets/basic_process_control_decision.md.AilCsfii.js
index 26417169..05288521 100644
--- a/assets/basic_process_control_decision.md.rdtrtJa0.js
+++ b/assets/basic_process_control_decision.md.AilCsfii.js
@@ -9,7 +9,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
     } else {
         print("num is other\\n", .{});
     }
-}
三元表达式 ​
zig 中的三元表达式是通过 if else 来实现的：
zig
const a: u32 = 5;
+}
三元表达式 ​
zig 中的三元表达式是通过 if else 来实现的：
zig
const a: u32 = 5;
 const b: u32 = 4;
 const result = if (a != b) 47 else 3089;
zig
const print = @import("std").debug.print;
 
diff --git a/assets/basic_process_control_decision.md.rdtrtJa0.lean.js b/assets/basic_process_control_decision.md.AilCsfii.lean.js
similarity index 100%
rename from assets/basic_process_control_decision.md.rdtrtJa0.lean.js
rename to assets/basic_process_control_decision.md.AilCsfii.lean.js
diff --git a/assets/basic_process_control_loop.md.G0QbfSeI.js b/assets/basic_process_control_loop.md.OpaKXOlk.js
similarity index 98%
rename from assets/basic_process_control_loop.md.G0QbfSeI.js
rename to assets/basic_process_control_loop.md.OpaKXOlk.js
index 8224f48c..50b18870 100644
--- a/assets/basic_process_control_loop.md.G0QbfSeI.js
+++ b/assets/basic_process_control_loop.md.OpaKXOlk.js
@@ -38,7 +38,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
         count += 1;
         continue :outer;
     }
-}
内联 inline ​
inline 关键字会将 for 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
需要注意，内联 for 循环要求迭代的值和捕获的值均是编译期已知的。
zig
pub fn main() !void {
+}
内联 inline ​
inline 关键字会将 for 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
需要注意，内联 for 循环要求迭代的值和捕获的值均是编译期已知的。
zig
pub fn main() !void {
     const nums = [_]i32{2, 4, 6};
     var sum: usize = 0;
     inline for (nums) |i| {
@@ -75,7 +75,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
 
 fn typeNameLength(comptime T: type) usize {
     return @typeName(T).len;
-}
while ​
while 循环用于重复执行表达式，直到某些条件不再成立.
基本使用：
zig
var i: usize = 0;
+}
while ​
while 循环用于重复执行表达式，直到某些条件不再成立.
基本使用：
zig
var i: usize = 0;
 while (i < 10) {
     if (i == 5) {
         continue;
@@ -93,7 +93,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
         std.debug.print("i is {}\\n", .{i});
         i += 1;
     }
-}
continue 表达式 ​
while 还支持一个被称为 continue 表达式的方法来便于我们控制循环，其内部可以是一个语句或者是一个作用域（{} 包裹）
zig
var i: usize = 0;
+}
continue 表达式 ​
while 还支持一个被称为 continue 表达式的方法来便于我们控制循环，其内部可以是一个语句或者是一个作用域（{} 包裹）
zig
var i: usize = 0;
 while (i < 10) : (i += 1) {}
zig
var i: usize = 1;
 var j: usize = 1;
 while (i * j < 2000) : ({ i *= 2; j *= 3; }) {
@@ -117,7 +117,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
         while (true) {
             break :outer;
         }
-    }
内联 inline ​
inline 关键字会将 while 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
zig
pub fn main() !void {
+    }
内联 inline ​
inline 关键字会将 while 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
zig
pub fn main() !void {
     comptime var i = 0;
     var sum: usize = 0;
     inline while (i < 3) : (i += 1) {
@@ -154,7 +154,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
 
 fn typeNameLength(comptime T: type) usize {
     return @typeName(T).len;
-}
🅿️ 提示
建议以下情况使用内联 while：
  • 需要在编译期执行循环
  • 你确定展开后会代码效率会更高
解构可选类型 ​
像 if 一样，while 也会尝试解构可选类型，并在遇到 null 时终止循环。
zig
while (eventuallyNullSequence()) |value| {
+}
🅿️ 提示
建议以下情况使用内联 while：
  • 需要在编译期执行循环
  • 你确定展开后会代码效率会更高
解构可选类型 ​
像 if 一样，while 也会尝试解构可选类型，并在遇到 null 时终止循环。
zig
while (eventuallyNullSequence()) |value| {
     sum2 += value;
 } else {
     std.debug.print("meet a null\\n", .{});
@@ -178,7 +178,7 @@ import{_ as s,c as i,o as a,U as h}from"./chunks/framework.iEE2KsGo.js";const F=
         std.debug.print("meet a null\\n", .{});
     }
     // 还可以使用else分支，碰到第一个 null 时触发并退出循环
-}
当 |x| 语法出现在 while 表达式上，while 条件必须是可选类型。
解构错误联合类型 ​
和上面类似，同样可以解构错误联合类型，while 分别会捕获错误和有效负载，当错误发生时，转到 else 分支执行，并退出：
zig
while (eventuallyErrorSequence()) |value| {
+}
当 |x| 语法出现在 while 表达式上，while 条件必须是可选类型。
解构错误联合类型 ​
和上面类似，同样可以解构错误联合类型，while 分别会捕获错误和有效负载，当错误发生时，转到 else 分支执行，并退出：
zig
while (eventuallyErrorSequence()) |value| {
     sum1 += value;
 } else |err| {
     std.debug.print("meet a err: {}\\n", .{err});
diff --git a/assets/basic_process_control_loop.md.G0QbfSeI.lean.js b/assets/basic_process_control_loop.md.OpaKXOlk.lean.js
similarity index 100%
rename from assets/basic_process_control_loop.md.G0QbfSeI.lean.js
rename to assets/basic_process_control_loop.md.OpaKXOlk.lean.js
diff --git a/assets/basic_process_control_switch.md.c7mMGXuW.js b/assets/basic_process_control_switch.md.Z7KwKgFx.js
similarity index 98%
rename from assets/basic_process_control_switch.md.c7mMGXuW.js
rename to assets/basic_process_control_switch.md.Z7KwKgFx.js
index 783486ef..bb590653 100644
--- a/assets/basic_process_control_switch.md.c7mMGXuW.js
+++ b/assets/basic_process_control_switch.md.Z7KwKgFx.js
@@ -1,4 +1,4 @@
-import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"Switch","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"basic/process_control/switch.md","filePath":"basic/process_control/switch.md","lastUpdated":1704979746000}'),h={name:"basic/process_control/switch.md"},k=n(`
Switch ​
switch 语句可以进行匹配，并且switch匹配不能出现遗漏匹配的情况。
基本使用 ​
zig
var num: u8 = 5;
+import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"Switch","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"basic/process_control/switch.md","filePath":"basic/process_control/switch.md","lastUpdated":1704979746000}'),h={name:"basic/process_control/switch.md"},k=n(`
Switch ​
switch 语句可以进行匹配，并且switch匹配不能出现遗漏匹配的情况。
基本使用 ​
zig
var num: u8 = 5;
 switch (num) {
     5 => {
         print("this is 5\\n", .{});
@@ -50,7 +50,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
     else => 9,
 };
 
-try expect(b == 1);
作为表达式使用： ​
zig
const os_msg = switch (builtin.target.os.tag) {
+try expect(b == 1);
作为表达式使用： ​
zig
const os_msg = switch (builtin.target.os.tag) {
     .linux => "we found a linux user",
     else => "not a linux user",
 };
zig
const builtin = @import("builtin");
@@ -61,7 +61,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
         else => "not a linux user",
     };
     _ = os_msg;
-}
捕获 Tag Union ​
我们还可以使用 switch 对标记联合类型进行捕获操作，对字段值的修改可以通过在捕获变量名称之前放置 * 并将其转换为指针来完成：
zig
const Item = union(enum) {
+}
捕获 Tag Union ​
我们还可以使用 switch 对标记联合类型进行捕获操作，对字段值的修改可以通过在捕获变量名称之前放置 * 并将其转换为指针来完成：
zig
const Item = union(enum) {
     a: u32,
     c: Point,
     d,
diff --git a/assets/basic_process_control_switch.md.c7mMGXuW.lean.js b/assets/basic_process_control_switch.md.Z7KwKgFx.lean.js
similarity index 100%
rename from assets/basic_process_control_switch.md.c7mMGXuW.lean.js
rename to assets/basic_process_control_switch.md.Z7KwKgFx.lean.js
diff --git a/assets/basic_union.md.JyaJgpd3.js b/assets/basic_union.md.ugreMmE2.js
similarity index 99%
rename from assets/basic_union.md.JyaJgpd3.js
rename to assets/basic_union.md.ugreMmE2.js
index fbe92b7d..970b0380 100644
--- a/assets/basic_union.md.JyaJgpd3.js
+++ b/assets/basic_union.md.ugreMmE2.js
@@ -1,4 +1,4 @@
-import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"联合类型","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"basic/union.md","filePath":"basic/union.md","lastUpdated":1704979746000}'),h={name:"basic/union.md"},k=n(`
联合类型 ​
联合类型(union)，它实际上用户定义的一种特殊的类型，划分出一块内存空间用来存储多种类型，但同一时间只能存储一个类型。
基本使用 ​
联合类型的基本使用：
zig
const Payload = union {
+import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"联合类型","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"basic/union.md","filePath":"basic/union.md","lastUpdated":1704979746000}'),h={name:"basic/union.md"},k=n(`
联合类型 ​
联合类型(union)，它实际上用户定义的一种特殊的类型，划分出一块内存空间用来存储多种类型，但同一时间只能存储一个类型。
基本使用 ​
联合类型的基本使用：
zig
const Payload = union {
     int: i64,
     float: f64,
     boolean: bool,
diff --git a/assets/basic_union.md.JyaJgpd3.lean.js b/assets/basic_union.md.ugreMmE2.lean.js
similarity index 100%
rename from assets/basic_union.md.JyaJgpd3.lean.js
rename to assets/basic_union.md.ugreMmE2.lean.js
diff --git a/assets/chunks/@localSearchIndexroot.92CUtxnc.js b/assets/chunks/@localSearchIndexroot.92CUtxnc.js
new file mode 100644
index 00000000..a37176f5
--- /dev/null
+++ b/assets/chunks/@localSearchIndexroot.92CUtxnc.js
@@ -0,0 +1 @@
+const e='{"documentCount":297,"nextId":297,"documentIds":{"0":"/zig-course/about.html#关于本站","1":"/zig-course/about.html#参与贡献","2":"/zig-course/advanced/assembly.html#汇编","3":"/zig-course/advanced/assembly.html#外部汇编","4":"/zig-course/advanced/assembly.html#内联汇编","5":"/zig-course/advanced/async.html#异步","6":"/zig-course/advanced/comptime.html#编译期","7":"/zig-course/advanced/comptime.html#编译期参数实现鸭子类型","8":"/zig-course/advanced/comptime.html#编译期变量","9":"/zig-course/advanced/comptime.html#编译期表达式","10":"/zig-course/advanced/comptime.html#生成数据结构","11":"/zig-course/advanced/interact-with-c.html#与-c-交互","12":"/zig-course/advanced/interact-with-c.html#c-abi-类型","13":"/zig-course/advanced/interact-with-c.html#c-header-导入","14":"/zig-course/advanced/interact-with-c.html#c-translation-cli","15":"/zig-course/advanced/interact-with-c.html#命令行参数","16":"/zig-course/advanced/interact-with-c.html#cimport-vs-translate-c","17":"/zig-course/advanced/interact-with-c.html#c-翻译缓存","18":"/zig-course/advanced/interact-with-c.html#c-翻译错误","19":"/zig-course/advanced/interact-with-c.html#c-macro","20":"/zig-course/advanced/interact-with-c.html#c-指针","21":"/zig-course/advanced/interact-with-c.html#c-可变参数函数","22":"/zig-course/advanced/interact-with-c.html#额外内容","23":"/zig-course/advanced/interact-with-c.html#为什么-zig-可以做到比-c-更好的编译","24":"/zig-course/advanced/interact-with-c.html#zig-能静态链接-libc-吗","25":"/zig-course/advanced/memory_manage.html#内存管理","26":"/zig-course/advanced/memory_manage.html#generalpurposeallocator","27":"/zig-course/advanced/memory_manage.html#fixedbufferallocator","28":"/zig-course/advanced/memory_manage.html#arenaallocator","29":"/zig-course/advanced/memory_manage.html#heapallocator","30":"/zig-course/advanced/memory_manage.html#c-allocator","31":"/zig-course/advanced/memory_manage.html#page-allocator","32":"/zig-course/advanced/memory_manage.html#memorypool","33":"/zig-course/advanced/memory_manage.html#实现内存分配器","34":"/zig-course/advanced/package_management.html#包管理","35":"/zig-course/advanced/package_management.html#新的文件结构","36":"/zig-course/advanced/package_management.html#编写包","37":"/zig-course/advanced/package_management.html#引入包","38":"/zig-course/appendix/community.html#社区","39":"/zig-course/appendix/well-known-lib.html#第三方库","40":"/zig-course/advanced/type_cast.html#类型转换","41":"/zig-course/advanced/type_cast.html#普通类型转换","42":"/zig-course/advanced/type_cast.html#限制更严格","43":"/zig-course/advanced/type_cast.html#整数与浮点数拓宽","44":"/zig-course/advanced/type_cast.html#立即数整数和浮点数出现歧义","45":"/zig-course/advanced/type_cast.html#切片、数组、指针","46":"/zig-course/advanced/type_cast.html#可选类型","47":"/zig-course/advanced/type_cast.html#错误联合类型","48":"/zig-course/advanced/type_cast.html#编译期数字","49":"/zig-course/advanced/type_cast.html#联合类型和枚举","50":"/zig-course/advanced/type_cast.html#undefined","51":"/zig-course/advanced/type_cast.html#元组和数组","52":"/zig-course/advanced/type_cast.html#显式强制转换","53":"/zig-course/advanced/type_cast.html#对等类型转换","54":"/zig-course/basic/advanced_type/array.html#数组","55":"/zig-course/basic/advanced_type/array.html#创建数组","56":"/zig-course/basic/advanced_type/array.html#多维数组","57":"/zig-course/basic/advanced_type/array.html#哨兵数组","58":"/zig-course/basic/advanced_type/array.html#操作","59":"/zig-course/basic/advanced_type/array.html#乘法","60":"/zig-course/basic/advanced_type/array.html#串联","61":"/zig-course/basic/advanced_type/array.html#字符串","62":"/zig-course/basic/advanced_type/array.html#转义字符","63":"/zig-course/basic/advanced_type/array.html#多行字符串","64":"/zig-course/basic/advanced_type/array.html#奇技淫巧","65":"/zig-course/basic/advanced_type/array.html#使用函数初始化数组","66":"/zig-course/basic/advanced_type/array.html#编译期初始化数组","67":"/zig-course/basic/advanced_type/enum.html#枚举","68":"/zig-course/basic/advanced_type/enum.html#声明枚举","69":"/zig-course/basic/advanced_type/enum.html#枚举方法","70":"/zig-course/basic/advanced_type/enum.html#枚举大小","71":"/zig-course/basic/advanced_type/enum.html#枚举推断","72":"/zig-course/basic/advanced_type/enum.html#非详尽枚举","73":"/zig-course/basic/advanced_type/enum.html#extern","74":"/zig-course/basic/advanced_type/opaque.html#opaque","75":"/zig-course/basic/advanced_type/opaque.html#anyopaque","76":"/zig-course/basic/advanced_type/silce.html#切片","77":"/zig-course/basic/advanced_type/silce.html#切片指针","78":"/zig-course/basic/advanced_type/silce.html#哨兵切片","79":"/zig-course/basic/advanced_type/pointer.html#指针","80":"/zig-course/basic/advanced_type/pointer.html#单项指针","81":"/zig-course/basic/advanced_type/pointer.html#多项指针","82":"/zig-course/basic/advanced_type/pointer.html#哨兵指针","83":"/zig-course/basic/advanced_type/pointer.html#额外特性","84":"/zig-course/basic/advanced_type/pointer.html#volatile","85":"/zig-course/basic/advanced_type/pointer.html#对齐","86":"/zig-course/basic/advanced_type/pointer.html#零指针","87":"/zig-course/basic/advanced_type/pointer.html#编译期","88":"/zig-course/basic/advanced_type/struct.html#结构体","89":"/zig-course/basic/advanced_type/struct.html#基本语法","90":"/zig-course/basic/advanced_type/struct.html#自引用","91":"/zig-course/basic/advanced_type/struct.html#自动推断","92":"/zig-course/basic/advanced_type/struct.html#泛型实现","93":"/zig-course/basic/advanced_type/struct.html#字段默认值","94":"/zig-course/basic/advanced_type/struct.html#空结构体","95":"/zig-course/basic/advanced_type/struct.html#通过字段获取基指针","96":"/zig-course/basic/advanced_type/struct.html#元组","97":"/zig-course/basic/advanced_type/struct.html#高级特性","98":"/zig-course/basic/advanced_type/struct.html#extern","99":"/zig-course/basic/advanced_type/struct.html#packed","100":"/zig-course/basic/advanced_type/struct.html#命名规则","101":"/zig-course/basic/advanced_type/vector.html#向量","102":"/zig-course/basic/advanced_type/vector.html#基本使用","103":"/zig-course/basic/advanced_type/vector.html#splat","104":"/zig-course/basic/advanced_type/vector.html#reduce","105":"/zig-course/basic/advanced_type/vector.html#shuffle","106":"/zig-course/basic/advanced_type/vector.html#select","107":"/zig-course/basic/basic_type/char-and-boolean.html#字符与布尔值","108":"/zig-course/basic/basic_type/char-and-boolean.html#字符","109":"/zig-course/basic/basic_type/char-and-boolean.html#布尔值","110":"/zig-course/basic/basic_type/function.html#函数","111":"/zig-course/basic/basic_type/function.html#基本使用","112":"/zig-course/basic/basic_type/function.html#参数传递","113":"/zig-course/basic/basic_type/function.html#内建函数","114":"/zig-course/basic/basic_type/function.html#高阶使用","115":"/zig-course/basic/basic_type/function.html#anytype","116":"/zig-course/basic/basic_type/function.html#noreturn","117":"/zig-course/basic/basic_type/function.html#extern","118":"/zig-course/basic/basic_type/function.html#setcold","119":"/zig-course/basic/basic_type/function.html#callconv","120":"/zig-course/basic/basic_type/number.html#数值类型","121":"/zig-course/basic/basic_type/number.html#整数","122":"/zig-course/basic/basic_type/number.html#类型","123":"/zig-course/basic/basic_type/number.html#不同进制","124":"/zig-course/basic/basic_type/number.html#除零","125":"/zig-course/basic/basic_type/number.html#溢出","126":"/zig-course/basic/basic_type/number.html#浮点数","127":"/zig-course/basic/basic_type/number.html#运算","128":"/zig-course/basic/error_handle.html#错误处理","129":"/zig-course/basic/error_handle.html#基本使用","130":"/zig-course/basic/error_handle.html#只有一个值的错误集","131":"/zig-course/basic/error_handle.html#全局错误集","132":"/zig-course/basic/error_handle.html#错误联合类型","133":"/zig-course/basic/error_handle.html#catch","134":"/zig-course/basic/error_handle.html#try","135":"/zig-course/basic/error_handle.html#errdefer","136":"/zig-course/basic/error_handle.html#合并和推断错误","137":"/zig-course/basic/error_handle.html#堆栈跟踪","138":"/zig-course/basic/define-variable.html#基本类型","139":"/zig-course/basic/define-variable.html#变量声明","140":"/zig-course/basic/define-variable.html#标识符命名","141":"/zig-course/basic/define-variable.html#常量","142":"/zig-course/basic/define-variable.html#undefined","143":"/zig-course/basic/define-variable.html#块","144":"/zig-course/basic/define-variable.html#注释","145":"/zig-course/basic/optional_type.html#可选类型","146":"/zig-course/basic/optional_type.html#编译期反射访问可选类型","147":"/zig-course/basic/optional_type.html#可选指针","148":"/zig-course/basic/process_control/decision.html#条件","149":"/zig-course/basic/process_control/decision.html#三元表达式","150":"/zig-course/basic/process_control/decision.html#高级用法","151":"/zig-course/basic/process_control/decision.html#解构可选类型","152":"/zig-course/basic/process_control/decision.html#解构错误联合类型","153":"/zig-course/basic/process_control/defer.html#defer","154":"/zig-course/basic/process_control/loop.html#循环","155":"/zig-course/basic/process_control/loop.html#for","156":"/zig-course/basic/process_control/loop.html#迭代数字","157":"/zig-course/basic/process_control/loop.html#迭代索引","158":"/zig-course/basic/process_control/loop.html#多目标迭代","159":"/zig-course/basic/process_control/loop.html#作为表达式使用","160":"/zig-course/basic/process_control/loop.html#标记","161":"/zig-course/basic/process_control/loop.html#内联-inline","162":"/zig-course/basic/process_control/loop.html#while","163":"/zig-course/basic/process_control/loop.html#continue-表达式","164":"/zig-course/basic/process_control/loop.html#作为表达式使用-1","165":"/zig-course/basic/process_control/loop.html#标记-1","166":"/zig-course/basic/process_control/loop.html#内联-inline-1","167":"/zig-course/basic/process_control/loop.html#解构可选类型","168":"/zig-course/basic/process_control/loop.html#解构错误联合类型","169":"/zig-course/basic/process_control/switch.html#switch","170":"/zig-course/basic/process_control/switch.html#基本使用","171":"/zig-course/basic/process_control/switch.html#进阶使用","172":"/zig-course/basic/process_control/switch.html#作为表达式使用","173":"/zig-course/basic/process_control/switch.html#捕获-tag-union","174":"/zig-course/basic/process_control/switch.html#对枚举类型进行自动推断","175":"/zig-course/basic/process_control/switch.html#内联-switch","176":"/zig-course/basic/process_control/unreachable.html#unreachable","177":"/zig-course/basic/union.html#联合类型","178":"/zig-course/basic/union.html#基本使用","179":"/zig-course/basic/union.html#标记联合","180":"/zig-course/basic/union.html#自动推断","181":"/zig-course/basic/union.html#extern-union","182":"/zig-course/basic/union.html#packed-union","183":"/zig-course/engineering/build-system.html#构建系统","184":"/zig-course/engineering/build-system.html#构建模式","185":"/zig-course/engineering/build-system.html#普通构建","186":"/zig-course/engineering/build-system.html#step","187":"/zig-course/engineering/build-system.html#cli-参数","188":"/zig-course/engineering/build-system.html#options-编译期配置","189":"/zig-course/engineering/build-system.html#构建静-动态链接库","190":"/zig-course/engineering/build-system.html#构建-api-文档","191":"/zig-course/engineering/build-system.html#test","192":"/zig-course/engineering/build-system.html#交叉编译","193":"/zig-course/engineering/build-system.html#embedfile","194":"/zig-course/engineering/build-system.html#执行其他命令","195":"/zig-course/engineering/build-system.html#构建纯-c-项目","196":"/zig-course/engineering/build-system.html#构建纯-c-项目-1","197":"/zig-course/engineering/build-system.html#文件生成","198":"/zig-course/engineering/unit-test.html#单元测试","199":"/zig-course/engineering/unit-test.html#基本使用","200":"/zig-course/engineering/unit-test.html#嵌套测试","201":"/zig-course/engineering/unit-test.html#跳过测试","202":"/zig-course/engineering/unit-test.html#检测内存泄漏","203":"/zig-course/engineering/unit-test.html#检查测试模式","204":"/zig-course/environment/editor.html#编辑器选择","205":"/zig-course/environment/editor.html#vs-code","206":"/zig-course/environment/editor.html#vs","207":"/zig-course/environment/editor.html#clion","208":"/zig-course/environment/editor.html#vim-neovim","209":"/zig-course/environment/editor.html#emacs","210":"/zig-course/environment/editor.html#sublime-text","211":"/zig-course/environment/install-environment.html#环境安装","212":"/zig-course/environment/install-environment.html#windows","213":"/zig-course/environment/install-environment.html#scoop","214":"/zig-course/environment/install-environment.html#其他的包管理器","215":"/zig-course/environment/install-environment.html#手动安装","216":"/zig-course/environment/install-environment.html#mac","217":"/zig-course/environment/install-environment.html#linux","218":"/zig-course/environment/install-environment.html#包管理器安装","219":"/zig-course/environment/install-environment.html#手动安装-1","220":"/zig-course/environment/install-environment.html#多版本管理","221":"/zig-course/environment/zig-command.html#zig-命令","222":"/zig-course/environment/zig-command.html#zig-build","223":"/zig-course/environment/zig-command.html#zig-init-exe","224":"/zig-course/environment/zig-command.html#zig-init-lib","225":"/zig-course/environment/zig-command.html#zig-ast-check","226":"/zig-course/environment/zig-command.html#zig-fmt","227":"/zig-course/environment/zig-command.html#zig-test","228":"/zig-course/environment/zig-command.html#zig-fetch","229":"/zig-course/epilogue.html#后记","230":"/zig-course/hello-world.html#hello-world","231":"/zig-course/hello-world.html#简单说明","232":"/zig-course/hello-world.html#换一种方式","233":"/zig-course/hello-world.html#更进一步","234":"/zig-course/hello-world.html#了解更多","235":"/zig-course/more/atomic.html#原子操作","236":"/zig-course/more/atomic.html#内建函数","237":"/zig-course/more/atomic.html#atomicload","238":"/zig-course/more/atomic.html#atomicstore","239":"/zig-course/more/atomic.html#atomicrmw","240":"/zig-course/more/atomic.html#cmpxchgweak","241":"/zig-course/more/atomic.html#cmpxchgstrong","242":"/zig-course/more/atomic.html#fence","243":"/zig-course/more/atomic.html#std-atomic-包","244":"/zig-course/more/atomic.html#原子数据结构","245":"/zig-course/more/atomic.html#spinloophint-自旋锁","246":"/zig-course/more/builtin_func.html#内建函数","247":"/zig-course/more/miscellaneous.html#杂项","248":"/zig-course/more/miscellaneous.html#容器","249":"/zig-course/more/miscellaneous.html#usingnamespace","250":"/zig-course/more/reflection.html#反射","251":"/zig-course/more/reflection.html#观察已有类型","252":"/zig-course/more/reflection.html#typeof","253":"/zig-course/more/reflection.html#typename","254":"/zig-course/more/reflection.html#typeinfo","255":"/zig-course/more/reflection.html#hasdecl","256":"/zig-course/more/reflection.html#hasfield","257":"/zig-course/more/reflection.html#field","258":"/zig-course/more/reflection.html#fieldparentptr","259":"/zig-course/more/reflection.html#call","260":"/zig-course/more/reflection.html#构建新的类型","261":"/zig-course/more/reflection.html#type","262":"/zig-course/more/style_guide.html#风格指南","263":"/zig-course/more/style_guide.html#空白","264":"/zig-course/more/style_guide.html#命名","265":"/zig-course/more/style_guide.html#文档注释指南","266":"/zig-course/more/undefined_behavior.html#未定义操作","267":"/zig-course/more/undefined_behavior.html#不可达代码","268":"/zig-course/more/undefined_behavior.html#索引越界访问","269":"/zig-course/more/undefined_behavior.html#负数转换为无符号整数","270":"/zig-course/more/undefined_behavior.html#数据截断","271":"/zig-course/more/undefined_behavior.html#整数溢出","272":"/zig-course/more/undefined_behavior.html#移位溢出","273":"/zig-course/more/undefined_behavior.html#除零操作","274":"/zig-course/more/undefined_behavior.html#精确除法溢出","275":"/zig-course/more/undefined_behavior.html#尝试解开可选类型-null","276":"/zig-course/more/undefined_behavior.html#尝试解开错误联合类型-error","277":"/zig-course/more/undefined_behavior.html#无效错误码","278":"/zig-course/more/undefined_behavior.html#无效枚举转换","279":"/zig-course/more/undefined_behavior.html#无效错误集合转换","280":"/zig-course/more/undefined_behavior.html#指针对齐错误","281":"/zig-course/more/undefined_behavior.html#联合类型字段访问错误","282":"/zig-course/more/undefined_behavior.html#浮点转换整数发生越界","283":"/zig-course/more/undefined_behavior.html#指针强制转换为-null","284":"/zig-course/more/wasm.html#wasm","285":"/zig-course/more/zero-type.html#零位类型","286":"/zig-course/more/zero-type.html#void","287":"/zig-course/more/zero-type.html#整数","288":"/zig-course/more/zero-type.html#数组和切片","289":"/zig-course/more/zero-type.html#枚举","290":"/zig-course/more/zero-type.html#结构体","291":"/zig-course/more/zero-type.html#联合类型","292":"/zig-course/prologue.html#前言","293":"/zig-course/what-is-zig.html#什么是-zig","294":"/zig-course/what-is-zig.html#为何使用-zig","295":"/zig-course/what-is-zig.html#特点","296":"/zig-course/what-is-zig.html#了解更多"},"fieldIds":{"title":0,"titles":1,"text":2},"fieldLength":{"0":[1,1,8],"1":[1,1,27],"2":[1,1,56],"3":[1,1,80],"4":[1,1,149],"5":[1,1,6],"6":[1,1,39],"7":[1,1,57],"8":[1,1,73],"9":[1,1,86],"10":[1,1,34],"11":[3,1,33],"12":[3,3,23],"13":[3,3,64],"14":[3,3,20],"15":[1,5,37],"16":[5,5,20],"17":[2,3,65],"18":[2,3,37],"19":[2,3,57],"20":[2,3,63],"21":[2,3,51],"22":[1,3,5],"23":[5,4,57],"24":[5,4,61],"25":[1,1,59],"26":[1,1,49],"27":[1,1,50],"28":[1,1,54],"29":[1,1,48],"30":[2,1,48],"31":[2,1,30],"32":[1,1,49],"33":[1,1,19],"34":[1,1,18],"35":[1,1,87],"36":[1,1,64],"37":[1,1,87],"38":[1,1,10],"39":[1,1,87],"40":[1,1,16],"41":[1,1,14],"42":[1,2,13],"43":[1,2,44],"44":[1,2,48],"45":[3,2,63],"46":[1,2,14],"47":[1,2,12],"48":[1,2,13],"49":[1,2,63],"50":[1,2,5],"51":[1,2,16],"52":[1,1,45],"53":[1,1,93],"54":[1,1,13],"55":[1,1,40],"56":[1,2,37],"57":[1,1,48],"58":[1,1,1],"59":[1,2,26],"60":[1,2,36],"61":[1,1,90],"62":[1,2,28],"63":[1,2,35],"64":[1,1,5],"65":[1,2,25],"66":[1,2,42],"67":[1,1,5],"68":[1,1,42],"69":[1,1,21],"70":[1,1,46],"71":[1,1,17],"72":[1,1,33],"73":[1,1,20],"74":[1,1,23],"75":[1,1,18],"76":[1,1,79],"77":[1,1,46],"78":[1,1,51],"79":[1,1,39],"80":[1,1,34],"81":[1,1,67],"82":[1,2,50],"83":[1,1,4],"84":[1,2,46],"85":[1,2,100],"86":[1,2,39],"87":[1,2,23],"88":[1,1,7],"89":[1,1,59],"90":[1,1,118],"91":[1,1,17],"92":[1,1,33],"93":[1,1,14],"94":[1,1,33],"95":[1,1,21],"96":[1,1,46],"97":[1,1,9],"98":[1,2,10],"99":[1,2,118],"100":[1,2,55],"101":[1,1,12],"102":[1,1,101],"103":[2,1,15],"104":[2,1,49],"105":[2,1,90],"106":[2,1,40],"107":[1,1,12],"108":[1,1,60],"109":[1,1,11],"110":[1,1,2],"111":[1,1,78],"112":[1,1,38],"113":[1,1,12],"114":[1,1,1],"115":[1,2,17],"116":[1,2,27],"117":[1,2,28],"118":[2,2,15],"119":[1,2,19],"120":[1,1,6],"121":[1,1,1],"122":[1,2,93],"123":[1,2,12],"124":[1,2,95],"125":[2,2,42],"126":[1,1,78],"127":[1,1,87],"128":[1,1,21],"129":[1,1,62],"130":[1,1,11],"131":[1,1,20],"132":[1,1,67],"133":[1,2,38],"134":[1,2,70],"135":[1,2,72],"136":[1,2,68],"137":[1,1,20],"138":[1,1,2],"139":[1,1,45],"140":[1,2,47],"141":[1,2,27],"142":[1,2,43],"143":[1,1,25],"144":[1,1,63],"145":[1,1,123],"146":[1,1,25],"147":[1,1,6],"148":[1,1,29],"149":[1,1,28],"150":[1,1,3],"151":[1,2,34],"152":[1,2,54],"153":[1,1,31],"154":[1,1,8],"155":[1,1,42],"156":[1,2,9],"157":[1,2,26],"158":[1,2,22],"159":[1,2,24],"160":[1,2,30],"161":[2,2,51],"162":[1,1,31],"163":[2,2,27],"164":[1,2,35],"165":[1,2,29],"166":[2,2,51],"167":[1,2,50],"168":[1,2,53],"169":[1,1,4],"170":[1,1,30],"171":[1,1,48],"172":[2,2,24],"173":[3,2,53],"174":[1,2,19],"175":[2,2,77],"176":[1,1,25],"177":[1,1,6],"178":[1,1,56],"179":[1,1,63],"180":[1,1,15],"181":[2,1,9],"182":[2,1,7],"183":[1,1,14],"184":[1,1,55],"185":[1,1,78],"186":[1,1,111],"187":[2,1,60],"188":[2,1,74],"189":[2,1,77],"190":[3,1,40],"191":[1,1,82],"192":[1,1,51],"193":[1,1,87],"194":[1,1,105],"195":[3,2,155],"196":[3,2,310],"197":[1,2,2],"198":[1,1,11],"199":[1,1,75],"200":[1,1,85],"201":[1,1,20],"202":[1,1,8],"203":[1,1,8],"204":[1,1,4],"205":[2,1,28],"206":[1,1,19],"207":[1,1,36],"208":[2,1,76],"209":[1,1,16],"210":[2,1,12],"211":[1,1,22],"212":[1,1,30],"213":[1,2,34],"214":[1,2,11],"215":[1,2,35],"216":[1,1,11],"217":[1,1,9],"218":[1,2,36],"219":[1,2,8],"220":[1,1,80],"221":[2,1,21],"222":[2,2,6],"223":[3,2,26],"224":[3,2,29],"225":[3,2,3],"226":[2,2,3],"227":[2,2,3],"228":[2,2,34],"229":[1,1,2],"230":[2,1,38],"231":[1,2,79],"232":[2,2,101],"233":[2,2,13],"234":[2,2,10],"235":[1,1,16],"236":[1,1,11],"237":[2,2,13],"238":[2,2,14],"239":[2,2,18],"240":[2,2,20],"241":[2,2,20],"242":[2,2,10],"243":[3,1,1],"244":[1,4,76],"245":[2,4,16],"246":[1,1,2],"247":[1,1,5],"248":[1,1,22],"249":[1,1,54],"250":[1,1,19],"251":[1,1,12],"252":[2,2,58],"253":[2,2,27],"254":[2,2,85],"255":[2,2,34],"256":[2,2,36],"257":[2,2,37],"258":[2,2,30],"259":[2,2,31],"260":[1,1,7],"261":[2,2,60],"262":[1,1,7],"263":[1,1,12],"264":[1,1,103],"265":[1,1,14],"266":[1,1,85],"267":[1,1,5],"268":[1,1,3],"269":[1,1,10],"270":[1,1,22],"271":[1,1,62],"272":[1,1,4],"273":[1,1,7],"274":[1,1,5],"275":[2,1,11],"276":[2,1,8],"277":[1,1,6],"278":[1,1,6],"279":[1,1,5],"280":[1,1,18],"281":[1,1,24],"282":[1,1,14],"283":[2,1,13],"284":[1,1,2],"285":[1,1,13],"286":[1,1,23],"287":[1,1,10],"288":[1,1,13],"289":[1,1,4],"290":[1,1,12],"291":[1,1,6],"292":[1,1,106],"293":[2,1,40],"294":[2,2,20],"295":[1,2,39],"296":[2,2,10]},"averageFieldLength":[1.3198653198653199,1.4511784511784511,37.08080808080806],"storedFields":{"0":{"title":"关于本站","titles":[]},"1":{"title":"参与贡献","titles":["关于本站"]},"2":{"title":"汇编","titles":[]},"3":{"title":"外部汇编","titles":["汇编"]},"4":{"title":"内联汇编","titles":["汇编"]},"5":{"title":"异步","titles":[]},"6":{"title":"编译期","titles":[]},"7":{"title":"编译期参数实现鸭子类型","titles":["编译期"]},"8":{"title":"编译期变量","titles":["编译期"]},"9":{"title":"编译期表达式","titles":["编译期"]},"10":{"title":"生成数据结构","titles":["编译期"]},"11":{"title":"与 C 交互","titles":[]},"12":{"title":"C ABI 类型","titles":["与 C 交互"]},"13":{"title":"C Header 导入","titles":["与 C 交互"]},"14":{"title":"C Translation CLI","titles":["与 C 交互"]},"15":{"title":"命令行参数","titles":["与 C 交互","C Translation CLI"]},"16":{"title":"@cImport vs translate-c","titles":["与 C 交互","C Translation CLI"]},"17":{"title":"C 翻译缓存","titles":["与 C 交互"]},"18":{"title":"C 翻译错误","titles":["与 C 交互"]},"19":{"title":"C Macro","titles":["与 C 交互"]},"20":{"title":"C 指针","titles":["与 C 交互"]},"21":{"title":"C 可变参数函数","titles":["与 C 交互"]},"22":{"title":"额外内容","titles":["与 C 交互"]},"23":{"title":"为什么 zig 可以做到比 c 更好的编译","titles":["与 C 交互","额外内容"]},"24":{"title":"zig 能静态链接 libc 吗？","titles":["与 C 交互","额外内容"]},"25":{"title":"内存管理","titles":[]},"26":{"title":"GeneralPurposeAllocator","titles":["内存管理"]},"27":{"title":"FixedBufferAllocator","titles":["内存管理"]},"28":{"title":"ArenaAllocator","titles":["内存管理"]},"29":{"title":"HeapAllocator","titles":["内存管理"]},"30":{"title":"c_allocator","titles":["内存管理"]},"31":{"title":"page_allocator","titles":["内存管理"]},"32":{"title":"MemoryPool","titles":["内存管理"]},"33":{"title":"实现内存分配器","titles":["内存管理"]},"34":{"title":"包管理","titles":[]},"35":{"title":"新的文件结构","titles":["包管理"]},"36":{"title":"编写包","titles":["包管理"]},"37":{"title":"引入包","titles":["包管理"]},"38":{"title":"社区","titles":[]},"39":{"title":"第三方库","titles":[]},"40":{"title":"类型转换","titles":[]},"41":{"title":"普通类型转换","titles":["类型转换"]},"42":{"title":"限制更严格","titles":["类型转换","普通类型转换"]},"43":{"title":"整数与浮点数拓宽","titles":["类型转换","普通类型转换"]},"44":{"title":"立即数整数和浮点数出现歧义","titles":["类型转换","普通类型转换"]},"45":{"title":"切片、数组、指针","titles":["类型转换","普通类型转换"]},"46":{"title":"可选类型","titles":["类型转换","普通类型转换"]},"47":{"title":"错误联合类型","titles":["类型转换","普通类型转换"]},"48":{"title":"编译期数字","titles":["类型转换","普通类型转换"]},"49":{"title":"联合类型和枚举","titles":["类型转换","普通类型转换"]},"50":{"title":"undefined","titles":["类型转换","普通类型转换"]},"51":{"title":"元组和数组","titles":["类型转换","普通类型转换"]},"52":{"title":"显式强制转换","titles":["类型转换"]},"53":{"title":"对等类型转换","titles":["类型转换"]},"54":{"title":"数组","titles":[]},"55":{"title":"创建数组","titles":["数组"]},"56":{"title":"多维数组","titles":["数组","创建数组"]},"57":{"title":"哨兵数组","titles":["数组"]},"58":{"title":"操作","titles":["数组"]},"59":{"title":"乘法","titles":["数组","操作"]},"60":{"title":"串联","titles":["数组","操作"]},"61":{"title":"字符串","titles":["数组"]},"62":{"title":"转义字符","titles":["数组","字符串"]},"63":{"title":"多行字符串","titles":["数组","字符串"]},"64":{"title":"奇技淫巧","titles":["数组"]},"65":{"title":"使用函数初始化数组","titles":["数组","奇技淫巧"]},"66":{"title":"编译期初始化数组","titles":["数组","奇技淫巧"]},"67":{"title":"枚举","titles":[]},"68":{"title":"声明枚举","titles":["枚举"]},"69":{"title":"枚举方法","titles":["枚举"]},"70":{"title":"枚举大小","titles":["枚举"]},"71":{"title":"枚举推断","titles":["枚举"]},"72":{"title":"非详尽枚举","titles":["枚举"]},"73":{"title":"extern","titles":["枚举"]},"74":{"title":"opaque","titles":[]},"75":{"title":"anyopaque","titles":["opaque"]},"76":{"title":"切片","titles":[]},"77":{"title":"切片指针","titles":["切片"]},"78":{"title":"哨兵切片","titles":["切片"]},"79":{"title":"指针","titles":[]},"80":{"title":"单项指针","titles":["指针"]},"81":{"title":"多项指针","titles":["指针"]},"82":{"title":"哨兵指针","titles":["指针","多项指针"]},"83":{"title":"额外特性","titles":["指针"]},"84":{"title":"volatile","titles":["指针","额外特性"]},"85":{"title":"对齐","titles":["指针","额外特性"]},"86":{"title":"零指针","titles":["指针","额外特性"]},"87":{"title":"编译期","titles":["指针","额外特性"]},"88":{"title":"结构体","titles":[]},"89":{"title":"基本语法","titles":["结构体"]},"90":{"title":"自引用","titles":["结构体"]},"91":{"title":"自动推断","titles":["结构体"]},"92":{"title":"泛型实现","titles":["结构体"]},"93":{"title":"字段默认值","titles":["结构体"]},"94":{"title":"空结构体","titles":["结构体"]},"95":{"title":"通过字段获取基指针","titles":["结构体"]},"96":{"title":"元组","titles":["结构体"]},"97":{"title":"高级特性","titles":["结构体"]},"98":{"title":"extern","titles":["结构体","高级特性"]},"99":{"title":"packed","titles":["结构体","高级特性"]},"100":{"title":"命名规则","titles":["结构体","高级特性"]},"101":{"title":"向量","titles":[]},"102":{"title":"基本使用","titles":["向量"]},"103":{"title":"@splat","titles":["向量"]},"104":{"title":"@reduce","titles":["向量"]},"105":{"title":"@shuffle","titles":["向量"]},"106":{"title":"@select","titles":["向量"]},"107":{"title":"字符与布尔值","titles":[]},"108":{"title":"字符","titles":["字符与布尔值"]},"109":{"title":"布尔值","titles":["字符与布尔值"]},"110":{"title":"函数","titles":[]},"111":{"title":"基本使用","titles":["函数"]},"112":{"title":"参数传递","titles":["函数"]},"113":{"title":"内建函数","titles":["函数"]},"114":{"title":"高阶使用","titles":["函数"]},"115":{"title":"anytype","titles":["函数","高阶使用"]},"116":{"title":"noreturn","titles":["函数","高阶使用"]},"117":{"title":"extern","titles":["函数","高阶使用"]},"118":{"title":"@setCold","titles":["函数","高阶使用"]},"119":{"title":"callconv","titles":["函数","高阶使用"]},"120":{"title":"数值类型","titles":[]},"121":{"title":"整数","titles":["数值类型"]},"122":{"title":"类型","titles":["数值类型","整数"]},"123":{"title":"不同进制","titles":["数值类型","整数"]},"124":{"title":"除零","titles":["数值类型","整数"]},"125":{"title":"溢出:","titles":["数值类型","整数"]},"126":{"title":"浮点数","titles":["数值类型"]},"127":{"title":"运算","titles":["数值类型"]},"128":{"title":"错误处理","titles":[]},"129":{"title":"基本使用","titles":["错误处理"]},"130":{"title":"只有一个值的错误集","titles":["错误处理"]},"131":{"title":"全局错误集","titles":["错误处理"]},"132":{"title":"错误联合类型","titles":["错误处理"]},"133":{"title":"catch","titles":["错误处理","错误联合类型"]},"134":{"title":"try","titles":["错误处理","错误联合类型"]},"135":{"title":"errdefer","titles":["错误处理","错误联合类型"]},"136":{"title":"合并和推断错误","titles":["错误处理","错误联合类型"]},"137":{"title":"堆栈跟踪","titles":["错误处理"]},"138":{"title":"基本类型","titles":[]},"139":{"title":"变量声明","titles":["基本类型"]},"140":{"title":"标识符命名","titles":["基本类型","变量声明"]},"141":{"title":"常量","titles":["基本类型","变量声明"]},"142":{"title":"undefined","titles":["基本类型","变量声明"]},"143":{"title":"块","titles":["基本类型"]},"144":{"title":"注释","titles":["基本类型"]},"145":{"title":"可选类型","titles":[]},"146":{"title":"编译期反射访问可选类型","titles":["可选类型"]},"147":{"title":"可选指针","titles":["可选类型"]},"148":{"title":"条件","titles":[]},"149":{"title":"三元表达式","titles":["条件"]},"150":{"title":"高级用法","titles":["条件"]},"151":{"title":"解构可选类型","titles":["条件","高级用法"]},"152":{"title":"解构错误联合类型","titles":["条件","高级用法"]},"153":{"title":"defer","titles":[]},"154":{"title":"循环","titles":[]},"155":{"title":"for","titles":["循环"]},"156":{"title":"迭代数字","titles":["循环","for"]},"157":{"title":"迭代索引","titles":["循环","for"]},"158":{"title":"多目标迭代","titles":["循环","for"]},"159":{"title":"作为表达式使用","titles":["循环","for"]},"160":{"title":"标记","titles":["循环","for"]},"161":{"title":"内联 inline","titles":["循环","for"]},"162":{"title":"while","titles":["循环"]},"163":{"title":"continue 表达式","titles":["循环","while"]},"164":{"title":"作为表达式使用","titles":["循环","while"]},"165":{"title":"标记","titles":["循环","while"]},"166":{"title":"内联 inline","titles":["循环","while"]},"167":{"title":"解构可选类型","titles":["循环","while"]},"168":{"title":"解构错误联合类型","titles":["循环","while"]},"169":{"title":"Switch","titles":[]},"170":{"title":"基本使用","titles":["Switch"]},"171":{"title":"进阶使用","titles":["Switch"]},"172":{"title":"作为表达式使用：","titles":["Switch","进阶使用"]},"173":{"title":"捕获 Tag Union","titles":["Switch","进阶使用"]},"174":{"title":"对枚举类型进行自动推断","titles":["Switch","进阶使用"]},"175":{"title":"内联 switch","titles":["Switch","进阶使用"]},"176":{"title":"unreachable","titles":[]},"177":{"title":"联合类型","titles":[]},"178":{"title":"基本使用","titles":["联合类型"]},"179":{"title":"标记联合","titles":["联合类型"]},"180":{"title":"自动推断","titles":["联合类型"]},"181":{"title":"extern union","titles":["联合类型"]},"182":{"title":"packed union","titles":["联合类型"]},"183":{"title":"构建系统","titles":[]},"184":{"title":"构建模式","titles":["构建系统"]},"185":{"title":"普通构建","titles":["构建系统"]},"186":{"title":"Step","titles":["构建系统"]},"187":{"title":"CLI 参数","titles":["构建系统"]},"188":{"title":"Options 编译期配置","titles":["构建系统"]},"189":{"title":"构建静/动态链接库","titles":["构建系统"]},"190":{"title":"构建 api 文档","titles":["构建系统"]},"191":{"title":"Test","titles":["构建系统"]},"192":{"title":"交叉编译","titles":["构建系统"]},"193":{"title":"embedFile","titles":["构建系统"]},"194":{"title":"执行其他命令","titles":["构建系统"]},"195":{"title":"构建纯 C 项目","titles":["构建系统","执行其他命令"]},"196":{"title":"构建纯 C++ 项目","titles":["构建系统","执行其他命令"]},"197":{"title":"文件生成","titles":["构建系统","执行其他命令"]},"198":{"title":"单元测试","titles":[]},"199":{"title":"基本使用","titles":["单元测试"]},"200":{"title":"嵌套测试","titles":["单元测试"]},"201":{"title":"跳过测试","titles":["单元测试"]},"202":{"title":"检测内存泄漏","titles":["单元测试"]},"203":{"title":"检查测试模式","titles":["单元测试"]},"204":{"title":"编辑器选择","titles":[]},"205":{"title":"VS Code","titles":["编辑器选择"]},"206":{"title":"VS","titles":["编辑器选择"]},"207":{"title":"CLion","titles":["编辑器选择"]},"208":{"title":"Vim / Neovim","titles":["编辑器选择"]},"209":{"title":"Emacs","titles":["编辑器选择"]},"210":{"title":"Sublime Text","titles":["编辑器选择"]},"211":{"title":"环境安装","titles":[]},"212":{"title":"Windows","titles":["环境安装"]},"213":{"title":"Scoop","titles":["环境安装","Windows"]},"214":{"title":"其他的包管理器","titles":["环境安装","Windows"]},"215":{"title":"手动安装","titles":["环境安装","Windows"]},"216":{"title":"Mac","titles":["环境安装"]},"217":{"title":"Linux","titles":["环境安装"]},"218":{"title":"包管理器安装","titles":["环境安装","Linux"]},"219":{"title":"手动安装","titles":["环境安装","Linux"]},"220":{"title":"多版本管理","titles":["环境安装"]},"221":{"title":"zig 命令","titles":[]},"222":{"title":"zig build","titles":["zig 命令"]},"223":{"title":"zig init-exe","titles":["zig 命令"]},"224":{"title":"zig init-lib","titles":["zig 命令"]},"225":{"title":"zig ast-check","titles":["zig 命令"]},"226":{"title":"zig fmt","titles":["zig 命令"]},"227":{"title":"zig test","titles":["zig 命令"]},"228":{"title":"zig fetch","titles":["zig 命令"]},"229":{"title":"后记","titles":[]},"230":{"title":"Hello World","titles":[]},"231":{"title":"简单说明","titles":["Hello World"]},"232":{"title":"换一种方式？","titles":["Hello World"]},"233":{"title":"更进一步？","titles":["Hello World"]},"234":{"title":"了解更多？","titles":["Hello World"]},"235":{"title":"原子操作","titles":[]},"236":{"title":"内建函数","titles":["原子操作"]},"237":{"title":"@atomicLoad","titles":["原子操作","内建函数"]},"238":{"title":"@atomicStore","titles":["原子操作","内建函数"]},"239":{"title":"@atomicRmw","titles":["原子操作","内建函数"]},"240":{"title":"@cmpxchgWeak","titles":["原子操作","内建函数"]},"241":{"title":"@cmpxchgStrong","titles":["原子操作","内建函数"]},"242":{"title":"@fence","titles":["原子操作","内建函数"]},"243":{"title":"std.atomic 包","titles":["原子操作"]},"244":{"title":"原子数据结构","titles":["原子操作","std.atomic 包"]},"245":{"title":"spinLoopHint 自旋锁","titles":["原子操作","std.atomic 包"]},"246":{"title":"内建函数","titles":[]},"247":{"title":"杂项","titles":[]},"248":{"title":"容器","titles":["杂项"]},"249":{"title":"usingnamespace","titles":["杂项"]},"250":{"title":"反射","titles":[]},"251":{"title":"观察已有类型","titles":["反射"]},"252":{"title":"@TypeOf","titles":["反射","观察已有类型"]},"253":{"title":"@typeName","titles":["反射","观察已有类型"]},"254":{"title":"@typeInfo","titles":["反射","观察已有类型"]},"255":{"title":"@hasDecl","titles":["反射","观察已有类型"]},"256":{"title":"@hasField","titles":["反射","观察已有类型"]},"257":{"title":"@field","titles":["反射","观察已有类型"]},"258":{"title":"@fieldParentPtr","titles":["反射","观察已有类型"]},"259":{"title":"@call","titles":["反射","观察已有类型"]},"260":{"title":"构建新的类型","titles":["反射"]},"261":{"title":"@Type","titles":["反射","构建新的类型"]},"262":{"title":"风格指南","titles":[]},"263":{"title":"空白","titles":["风格指南"]},"264":{"title":"命名","titles":["风格指南"]},"265":{"title":"文档注释指南","titles":["风格指南"]},"266":{"title":"未定义操作","titles":[]},"267":{"title":"不可达代码","titles":["未定义操作"]},"268":{"title":"索引越界访问","titles":["未定义操作"]},"269":{"title":"负数转换为无符号整数","titles":["未定义操作"]},"270":{"title":"数据截断","titles":["未定义操作"]},"271":{"title":"整数溢出","titles":["未定义操作"]},"272":{"title":"移位溢出","titles":["未定义操作"]},"273":{"title":"除零操作","titles":["未定义操作"]},"274":{"title":"精确除法溢出","titles":["未定义操作"]},"275":{"title":"尝试解开可选类型 Null","titles":["未定义操作"]},"276":{"title":"尝试解开错误联合类型 Error","titles":["未定义操作"]},"277":{"title":"无效错误码","titles":["未定义操作"]},"278":{"title":"无效枚举转换","titles":["未定义操作"]},"279":{"title":"无效错误集合转换","titles":["未定义操作"]},"280":{"title":"指针对齐错误","titles":["未定义操作"]},"281":{"title":"联合类型字段访问错误","titles":["未定义操作"]},"282":{"title":"浮点转换整数发生越界","titles":["未定义操作"]},"283":{"title":"指针强制转换为 Null","titles":["未定义操作"]},"284":{"title":"WASM","titles":[]},"285":{"title":"零位类型","titles":[]},"286":{"title":"void","titles":["零位类型"]},"287":{"title":"整数","titles":["零位类型"]},"288":{"title":"数组和切片","titles":["零位类型"]},"289":{"title":"枚举","titles":["零位类型"]},"290":{"title":"结构体","titles":["零位类型"]},"291":{"title":"联合类型","titles":["零位类型"]},"292":{"title":"前言","titles":[]},"293":{"title":"什么是 Zig","titles":[]},"294":{"title":"为何使用 Zig","titles":["什么是 Zig"]},"295":{"title":"特点","titles":["什么是 Zig"]},"296":{"title":"了解更多 ？","titles":["什么是 Zig"]}},"dirtCount":0,"index":[["列出了一些积极维护的",{"2":{"296":1}}],["列举所有可安装的版本",{"2":{"220":1}}],["计算机科学中最严重的错误",{"2":{"295":1}}],["亦或者对速度有很高的要求",{"2":{"294":1}}],["设计",{"2":{"293":1}}],["设置当前目录使用的版本",{"2":{"220":1}}],["设置全局默认版本",{"2":{"220":1}}],["设置中的",{"2":{"212":1}}],["设置可能是",{"2":{"192":1}}],["设置正确的target",{"2":{"24":1}}],["设置",{"2":{"24":1,"187":1}}],["静态类型",{"2":{"293":1}}],["什么是",{"0":{"293":1},"1":{"294":1,"295":1,"296":1}}],["什么是编译期",{"2":{"6":1}}],["帮助新人来更好的理解和学习",{"2":{"292":1}}],["帮助开发人员使用智能编辑器来提高代码质量",{"2":{"207":1}}],["披着高抽象皮的",{"2":{"292":1}}],["庞大很多的社区等等",{"2":{"292":1}}],["成为一个不是c的替代品",{"2":{"292":1}}],["他们在某种程度上都算是失败了",{"2":{"292":1}}],["历史上有不少语言都自诩是",{"2":{"292":1}}],["五花八门",{"2":{"292":1}}],["各式各样的第三方包管理器",{"2":{"292":1}}],["难道不好吗",{"2":{"292":1}}],["至少现在不是",{"2":{"292":1}}],["至少zig",{"2":{"145":1}}],["涉及到它们的值不会出现在构建结果中",{"2":{"285":1}}],["涉及到了位偏移",{"2":{"99":1}}],["零位类型",{"0":{"285":1},"1":{"286":1,"287":1,"288":1,"289":1,"290":1,"291":1}}],["零指针实际上是一个未定义的错误行为",{"2":{"86":1}}],["零指针",{"0":{"86":1}}],["地址很明显是不符合",{"2":{"280":1}}],["地使用",{"2":{"232":1}}],["精确的内存泄漏跟踪",{"2":{"295":1}}],["精确除法使用的是",{"2":{"274":1}}],["精确除法溢出",{"0":{"274":1}}],["精度为纳秒",{"2":{"144":1}}],["移位溢出",{"0":{"272":1}}],["乘",{"2":{"271":1}}],["乘法结果最大或最小为该类型的极限",{"2":{"127":1}}],["乘法环绕",{"2":{"125":1,"271":1}}],["乘法",{"0":{"59":1},"2":{"125":1}}],["减少隐式的执行",{"2":{"292":1}}],["减",{"2":{"271":1}}],["减法结果最小为该类型的极限",{"2":{"127":1}}],["减法环绕",{"2":{"125":1,"271":1}}],["减法",{"2":{"125":1}}],["未定义操作",{"0":{"266":1},"1":{"267":1,"268":1,"269":1,"270":1,"271":1,"272":1,"273":1,"274":1,"275":1,"276":1,"277":1,"278":1,"279":1,"280":1,"281":1,"282":1,"283":1}}],["未列出枚举值可以使用",{"2":{"72":1}}],["断言",{"2":{"265":1}}],["断言它为",{"2":{"254":1}}],["假设",{"2":{"265":1}}],["假设以上这段代码在文件",{"2":{"199":1}}],["鼓励将注释信息复制到多个类似的函数上",{"2":{"265":1}}],["蛇形命名法",{"2":{"264":10}}],["驼峰命名法",{"2":{"264":2}}],["采用四空格缩进",{"2":{"263":1}}],["采取的是一种折中的方案",{"2":{"145":1}}],["英文参考文档",{"2":{"262":1}}],["英语",{"2":{"40":1,"198":1}}],["风格指南",{"0":{"262":1},"1":{"263":1,"264":1,"265":1}}],["调用一个函数",{"2":{"259":1}}],["调用函数时将推断参数类型",{"2":{"115":1}}],["作用于变量时只能访问字段",{"2":{"257":1}}],["作为编译或者依赖管理工具",{"2":{"221":1}}],["作为包导入",{"2":{"188":1}}],["作为表达式来使用",{"2":{"164":1}}],["作为表达式使用",{"0":{"159":1,"164":1,"172":1},"2":{"171":1}}],["作为关键字来声明常量",{"2":{"141":1}}],["作为函数的名字",{"2":{"111":1}}],["作为",{"2":{"24":1,"125":1,"213":1}}],["作为对比",{"2":{"23":1}}],["作为一门",{"2":{"79":1}}],["作为一种折中方案",{"2":{"20":1}}],["作为一个可以独立于",{"2":{"11":1}}],["作为参数传递给函数",{"2":{"6":1}}],["观察已有类型",{"0":{"251":1},"1":{"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1}}],["观察",{"2":{"250":1}}],["观察到",{"2":{"99":1}}],["反射就是程序在运行的时候能够",{"2":{"250":1}}],["反射",{"0":{"250":1},"1":{"251":1,"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"261":1},"2":{"250":1}}],["反斜杠",{"2":{"62":1}}],["暂时还没有决定好分类到何处",{"2":{"247":1}}],["杂项",{"0":{"247":1},"1":{"248":1,"249":1}}],["表示当当违反预定情况时会触发安全检查的未定义行为",{"2":{"265":1}}],["表明调用者处于忙等待自旋循环内",{"2":{"245":1}}],["表达式会完全在编译期执行",{"2":{"252":1}}],["表达式上",{"2":{"167":1,"168":1}}],["表达式的方法来便于我们控制循环",{"2":{"163":1}}],["表达式中",{"2":{"100":1}}],["表达式内应仅包含",{"2":{"13":1}}],["表达式都是无效的",{"2":{"9":1}}],["表达式都在编译时求值",{"2":{"9":1}}],["表达式",{"0":{"163":1},"2":{"7":1,"9":1}}],["防止某些类型的内存重新排序",{"2":{"242":1}}],["强大的编译期运行",{"2":{"295":1}}],["强原子的比较与交换操作",{"2":{"241":1}}],["强制该函数在所有被调用位置内联",{"2":{"119":1}}],["弱原子的比较与交换操作",{"2":{"240":1}}],["见此",{"2":{"239":1}}],["见",{"2":{"236":1}}],["见下方执行其他命令部分",{"2":{"193":1}}],["性能更高了",{"2":{"232":1}}],["句柄",{"2":{"232":1}}],["流句柄",{"2":{"232":1}}],["输出",{"2":{"232":1}}],["输出中文乱码问题",{"2":{"212":1}}],["让我们换一种方式来讲述如何",{"2":{"232":1}}],["让对应的",{"2":{"186":1}}],["别担心",{"2":{"231":1}}],["别忘记三个冒号",{"2":{"4":1}}],["好很多",{"2":{"292":1}}],["好",{"2":{"292":1}}],["好了",{"2":{"231":1}}],["好用",{"2":{"145":1}}],["根文件",{"2":{"231":1}}],["根据其官网所述",{"2":{"293":1}}],["根据名称省略冗余信息",{"2":{"265":1}}],["根据给定的指向结构体字段的指针和名字",{"2":{"258":1}}],["根据文档说明",{"2":{"136":1}}],["根据掩码mask",{"2":{"105":1}}],["根据目标的字节顺序",{"2":{"99":1}}],["根据",{"2":{"53":1,"106":1}}],["根据整数",{"2":{"52":1}}],["根据整数值获取对应的联合标记或者枚举值",{"2":{"52":1}}],["根据整数值获取对应的枚举值",{"2":{"52":1}}],["根据创建匿名结构体时调用的函数名称和参数推断出名称为list",{"2":{"10":1}}],["始终支持导入三个模块",{"2":{"231":1}}],["简单来说",{"2":{"264":1}}],["简单说明",{"0":{"231":1}}],["简单地引入",{"2":{"13":1}}],["适用于单元测试",{"2":{"227":1}}],["适用于游戏的小型脚本语言",{"2":{"39":1}}],["└──",{"2":{"223":2,"224":2}}],["├──",{"2":{"223":1,"224":1}}],["卸载指定版本的",{"2":{"220":1}}],["读者可根据自身需求选择",{"2":{"220":1}}],["之后就可以用",{"2":{"220":1}}],["之后将包含",{"2":{"219":1}}],["之后是一个输出位置",{"2":{"4":1}}],["备注",{"2":{"218":1}}],["手动内存控制",{"2":{"295":1}}],["手动安装",{"0":{"215":1,"219":1}}],["手动编译安装的方法如下",{"2":{"208":1}}],["手动编译依赖的源代码",{"2":{"196":1}}],["仓库分别有着最新的",{"2":{"213":1}}],["仓库和",{"2":{"213":1}}],["工具进行安装",{"2":{"213":1}}],["工欲善其事",{"2":{"204":1}}],["重启计算机",{"2":{"212":1}}],["勾选下方的",{"2":{"212":1}}],["点击下方的",{"2":{"212":1}}],["点击下方的管理语言设置",{"2":{"212":1}}],["管理",{"2":{"212":1,"220":1}}],["打印输出其字段值",{"2":{"254":1}}],["打印该结构体内部字段的信息",{"2":{"254":1}}],["打印",{"2":{"233":1}}],["打印出",{"2":{"232":1}}],["打印字符串是不能这样子做的",{"2":{"231":1}}],["打印结果如下",{"2":{"76":1}}],["打开",{"2":{"212":1}}],["稳定版最终会变得过时",{"2":{"211":1}}],["发生越界访问会发生错误导致程序终止进而触发堆栈跟踪",{"2":{"268":1}}],["发行版",{"2":{"218":1}}],["发布周期与",{"2":{"211":1}}],["发起",{"2":{"1":1}}],["环境变量即可",{"2":{"219":1}}],["环境安装",{"0":{"211":1},"1":{"212":1,"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1}}],["环绕操作符",{"2":{"125":1}}],["危险",{"2":{"210":1}}],["⛔",{"2":{"210":1}}],["经典的编辑器",{"2":{"210":1}}],["安装指定版本的",{"2":{"220":1}}],["安装的方式五花八门",{"2":{"217":1}}],["安装方式如下",{"2":{"213":1}}],["安装即可",{"2":{"210":1}}],["安装",{"2":{"208":1,"213":1,"220":1}}],["安全检查会在debug",{"2":{"266":1}}],["安全检查",{"2":{"26":1}}],["古老的编辑器之一",{"2":{"208":1}}],["插件也是由",{"2":{"210":1}}],["插件的仓库地址为",{"2":{"208":1}}],["插件",{"2":{"207":1,"208":1,"220":1}}],["及",{"2":{"207":1}}],["集成开发环境等等",{"2":{"206":1}}],["确保你的",{"2":{"292":1}}],["确认即可",{"2":{"205":1}}],["确信本次函数执行后肯定不会发生错误",{"2":{"132":1}}],["微软出品",{"2":{"205":1}}],["官网地址",{"2":{"205":1,"206":1}}],["官方维护",{"2":{"210":1}}],["官方维护了",{"2":{"209":1}}],["官方为其开发了插件",{"2":{"205":1}}],["官方文档中关于类型的部分",{"2":{"108":1}}],["官方的",{"2":{"22":1}}],["必先利其器",{"2":{"204":1}}],["必须放在作用域的顶层",{"2":{"144":1}}],["必须仔细阅读",{"2":{"33":1}}],["必须是编译期已知的",{"2":{"6":1}}],["检测和修改它本身状态或行为的一种能力",{"2":{"250":1}}],["检测内存泄漏",{"0":{"202":1}}],["检查测试模式",{"0":{"203":1}}],["检查",{"2":{"145":1}}],["检查是否存在泄露等特性",{"2":{"26":1}}],["名字为空的测试块",{"2":{"201":1}}],["跳过测试的一种方法是使用",{"2":{"201":1}}],["跳过测试",{"0":{"201":1}}],["形式引入测试",{"2":{"200":1}}],["被誉为",{"2":{"208":1}}],["被顶层测试块引用了",{"2":{"200":1}}],["被标记为编译期已知的",{"2":{"8":1}}],["嵌套引用测试在全局测试块中引用另一个容器后",{"2":{"200":1}}],["嵌套测试",{"0":{"200":1}}],["嵌入式设备和低延迟服务器",{"2":{"25":1}}],["软件设计的最小单位",{"2":{"198":1}}],["又称为模块测试来源请求",{"2":{"198":1}}],["又不能",{"2":{"24":1}}],["正确的处理方案是使用",{"2":{"275":1,"276":1}}],["正确的做法是",{"2":{"196":1}}],["正确",{"2":{"232":1}}],["正常使用",{"2":{"231":1}}],["正数是从",{"2":{"105":1}}],["示",{"2":{"195":1}}],["示例",{"2":{"80":1,"81":2,"82":1,"85":1,"86":1,"99":2,"123":1,"179":1,"244":1,"245":1}}],["示例如下",{"2":{"63":1}}],["示例文件",{"2":{"17":1}}],["项目拿去作为工具链使用",{"2":{"295":1}}],["项目",{"0":{"195":1,"196":1}}],["录入根据",{"2":{"194":1}}],["`root",{"2":{"193":1,"194":1}}],["`source",{"2":{"193":1,"194":1}}],["`nightly`",{"2":{"193":1,"194":1}}],["交叉编译",{"0":{"192":1}}],["交互的特性",{"2":{"82":1}}],["交互的函数中",{"2":{"75":1}}],["交互",{"0":{"11":1},"1":{"12":1,"13":1,"14":1,"15":1,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"22":1,"23":1,"24":1}}],["随后将其断言为一个",{"2":{"254":1}}],["随后进行执行并将其绑定到",{"2":{"191":1}}],["随着",{"2":{"34":1}}],["测试块具有隐式的返回值类型",{"2":{"199":1}}],["测试器",{"2":{"199":1}}],["测试名字",{"2":{"199":1}}],["测试",{"2":{"191":1,"221":1}}],["约定库的名字不包含",{"2":{"189":1}}],["链接系统库",{"2":{"196":1}}],["链接系统的gtk4库",{"2":{"195":1}}],["链接c++",{"2":{"196":1}}],["链接标准",{"2":{"195":1}}],["链接到",{"2":{"189":1}}],["链接到系统的",{"2":{"189":1}}],["链接",{"2":{"189":1}}],["链接依赖提供的库",{"2":{"37":1}}],["系统调用的流程",{"2":{"232":1}}],["系统",{"2":{"189":1}}],["系统账号管理的使用",{"2":{"90":1}}],["动态链接库",{"0":{"189":1}}],["塞入二进制程序的构建中",{"2":{"188":1}}],["向处理器发出信号",{"2":{"245":1}}],["向",{"2":{"188":2}}],["向量的类型和长度由编译器推断",{"2":{"103":1}}],["向量的每个元素均是传入的参数",{"2":{"103":1}}],["向量长度",{"2":{"102":1}}],["向量必须拥有编译期已知的长度和类型",{"2":{"102":1,"106":1}}],["向量还支持对具有已知长度的固定长度数组进行赋值",{"2":{"102":1}}],["向量支持与底层基本类型相同的内置运算符",{"2":{"102":1}}],["向量",{"0":{"101":1},"1":{"102":1,"103":1,"104":1,"105":1,"106":1},"2":{"101":1}}],["配置文件",{"2":{"186":1}}],["前言",{"0":{"292":1}}],["前端项目构建等等",{"2":{"194":1}}],["前先构建出数据",{"2":{"186":1}}],["前先构建出",{"2":{"186":1}}],["前面的说法可能比较复杂",{"2":{"57":1}}],["尽量在同一行打开大括号",{"2":{"263":1}}],["尽可能提高安全性但又不至于造成类似",{"2":{"184":1}}],["尽管可以使用其他方式来实现集合功能",{"2":{"286":1}}],["尽管携带了",{"2":{"23":1}}],["尽管现代高级语言的特性已经非常丰富",{"2":{"2":1}}],["效果是在",{"2":{"184":1}}],["较差的运行效率",{"2":{"184":1}}],["禁用安全检查",{"2":{"184":1}}],["禁止变量覆盖外部作用域",{"2":{"140":1}}],["禁止对标量",{"2":{"102":1}}],["启用安全检查",{"2":{"184":3}}],["启动或者禁用某些运行时的安全性功能",{"2":{"16":1}}],["初始化一个联合类型",{"2":{"178":1}}],["初学者可以直接略过以下部分",{"2":{"83":1}}],["划分出一块内存空间用来存储多种类型",{"2":{"177":1}}],["匹配时",{"2":{"174":1}}],["匹配已经穷尽了",{"2":{"173":2}}],["匹配剩余的分支",{"2":{"171":1}}],["捕获",{"0":{"173":1},"2":{"175":1}}],["捕获的是可选类型的指针",{"2":{"152":1}}],["捕获的错误",{"2":{"137":1}}],["范围匹配",{"2":{"171":1}}],["进入",{"2":{"212":1}}],["进阶使用",{"0":{"171":1},"1":{"172":1,"173":1,"174":1,"175":1}}],["进行左移操作时",{"2":{"272":1}}],["进行构建",{"2":{"222":1}}],["进行编译",{"2":{"196":1}}],["进行通信",{"2":{"191":1}}],["进行检测",{"2":{"124":1}}],["进行串联操作",{"2":{"60":1}}],["进行矩阵的叠加",{"2":{"59":1}}],["碰到第一个",{"2":{"167":2}}],["建议以下情况使用内联",{"2":{"166":1}}],["建议对",{"2":{"105":1}}],["直到某些条件不再成立",{"2":{"162":1}}],["直接返回",{"2":{"199":1}}],["直接使用它会导致程序或者编译器停止运行",{"2":{"276":1}}],["直接使用",{"2":{"193":1}}],["直接使用字面量来定义一个元组",{"2":{"96":1}}],["直接看例子",{"2":{"148":1}}],["直接在捕获错误的地方使用",{"2":{"134":1}}],["直接转换成为一个向量",{"2":{"102":1}}],["直接赋值给",{"2":{"45":1}}],["直接一次回收所有分发出去的内存",{"2":{"28":1}}],["直接交互的能力",{"2":{"11":1}}],["迭代索引",{"0":{"157":1}}],["迭代连续的整数很简单",{"2":{"156":1}}],["迭代数字",{"0":{"156":1}}],["迭代数组和切片",{"2":{"155":1}}],["迭代的指针捕获",{"2":{"155":1}}],["迭代的值捕获",{"2":{"155":1}}],["主要用于迭代数组和切片",{"2":{"155":1}}],["答案是",{"2":{"152":1}}],["答案是使用",{"2":{"90":1}}],["解构错误联合类型类似与解构可选类型",{"2":{"152":1}}],["解构错误联合类型",{"0":{"152":1,"168":1}}],["解构可选类型操作很简单",{"2":{"151":1}}],["解构可选类型",{"0":{"151":1,"167":1}}],["解引用方法支持以下几种",{"2":{"81":1}}],["解引用方法是",{"2":{"80":1}}],["三元表达式",{"0":{"149":1}}],["条件必须是错误联合类型",{"2":{"168":1}}],["条件必须是可选类型",{"2":{"167":1}}],["条件",{"0":{"148":1},"1":{"149":1,"150":1,"151":1,"152":1}}],["考虑",{"2":{"147":1}}],["赋值1234",{"2":{"146":1}}],["嗯",{"2":{"145":1}}],["看看是否有解决方案",{"2":{"220":1}}],["看起来可能没什么不同",{"2":{"145":1}}],["看起来要比",{"2":{"145":1}}],["看一下两者在处理",{"2":{"145":1}}],["野指针",{"2":{"145":1}}],["迷途指针",{"2":{"145":1}}],["却不能保证你出现悬空指针",{"2":{"145":1}}],["却仍然能保持",{"2":{"23":1}}],["缺省时为",{"2":{"184":1}}],["缺省则使用本机作为构建目标",{"2":{"15":1}}],["缺点是并不能保证你的运行时是绝对安全的",{"2":{"145":1}}],["空白",{"0":{"263":1}}],["空引用",{"2":{"145":1}}],["空结构体",{"0":{"94":1}}],["顶层文档注释",{"2":{"144":3}}],["纪元",{"2":{"144":1}}],["纳秒数",{"2":{"144":1}}],["像odin",{"2":{"292":1}}],["像meson",{"2":{"292":1}}],["像",{"2":{"167":1}}],["像基础的",{"2":{"148":1}}],["像这里就是多行文档注释",{"2":{"144":1}}],["像复合类型",{"2":{"112":1}}],["存在第三方插件",{"2":{"206":1}}],["存在着",{"2":{"112":1}}],["存储时间戳的结构体",{"2":{"144":1}}],["说实话",{"2":{"144":1}}],["说明符更改函数的调用约定",{"2":{"117":1}}],["说明",{"2":{"108":1}}],["了",{"2":{"144":1}}],["了解更多",{"0":{"234":1,"296":1},"2":{"4":1}}],["起到的注释效果相同",{"2":{"144":1}}],["注释",{"0":{"144":1}}],["注意它也是只读的",{"2":{"155":1}}],["注意它是只读的",{"2":{"155":1}}],["注意函数的返回值",{"2":{"132":1}}],["注意浮点数陷阱",{"2":{"126":1}}],["注意我们这里指的是数据类型的范围变小了",{"2":{"270":1}}],["注意我们这里使用的是浮点类型",{"2":{"102":1}}],["注意我们使用的是递归方法来实现斐波那契数列求值",{"2":{"9":1}}],["注意这里",{"2":{"49":1}}],["注意默认情况下它不是线程安全的",{"2":{"27":1}}],["注意",{"2":{"3":1,"4":1,"7":1,"9":1,"13":1,"14":1,"15":1,"32":1,"36":1,"57":1,"73":1,"76":1,"104":1,"129":1,"136":1,"141":1,"186":2,"193":1,"194":1,"195":1,"196":2,"200":1,"248":1,"249":1,"257":1,"281":1}}],["块即可",{"2":{"199":1}}],["块也可以是一个表达式",{"2":{"143":1}}],["块",{"0":{"143":1},"2":{"143":1}}],["块中的多个",{"2":{"53":1}}],["块中时",{"2":{"3":1}}],["慎重使用",{"2":{"142":1}}],["已知的",{"2":{"141":1}}],["已经是",{"2":{"292":1}}],["已经将",{"2":{"223":1,"224":1,"230":1}}],["已经将上行代码中的",{"2":{"193":1,"194":1}}],["已经将上方代码中的",{"2":{"36":1}}],["已经修改为默认使用",{"2":{"129":1}}],["格式化字符串使用的是",{"2":{"231":1}}],["格式是",{"2":{"139":1}}],["格式为",{"2":{"35":1}}],["都受命名约定的约束",{"2":{"264":1}}],["都很实用",{"2":{"137":1}}],["都包含一个额外的参数",{"2":{"37":1}}],["堆栈跟踪",{"0":{"137":1}}],["堆栈的嵌套层数最大是",{"2":{"9":1}}],["推荐将",{"2":{"213":1}}],["推荐使用",{"2":{"213":1}}],["推荐关闭",{"2":{"208":1}}],["推荐安装插件",{"2":{"208":1}}],["推导出的错误集是最小错误集",{"2":{"136":1}}],["推导错误和递归并不兼容",{"2":{"136":1}}],["推断错误集",{"2":{"136":1}}],["另一个就是使用固定的版本来编译这个项目",{"2":{"220":1}}],["另一个程序生成的数据",{"2":{"186":1}}],["另一种是通过",{"2":{"3":1}}],["另外",{"2":{"136":1,"191":1,"288":1}}],["明确声明的错误集",{"2":{"136":1}}],["由",{"2":{"293":1}}],["由内核执行完成进程需要的系统调用函数后再将控制权返回给进程",{"2":{"232":1}}],["由官方维护",{"2":{"208":1}}],["由编译器推导而出的错误集",{"2":{"136":1}}],["由于发行版的不同",{"2":{"217":1}}],["由于依赖了",{"2":{"196":1}}],["由于计算机是二进制的特性",{"2":{"126":1}}],["由于在",{"2":{"100":1}}],["由于没有字段名",{"2":{"96":1}}],["由于",{"2":{"75":1,"108":1,"196":1,"212":1,"220":1,"250":1}}],["由于涉及到系统调用",{"2":{"31":1}}],["由于这种特性",{"2":{"23":1}}],["由于高级语言的抽象层次过高",{"2":{"2":1}}],["合并为一个命令",{"2":{"223":1,"224":1,"230":1}}],["合并和推断错误",{"0":{"136":1}}],["合并到上游仓库",{"2":{"1":1}}],["释放代码始终紧跟在分配代码之后",{"2":{"135":1}}],["释放内存",{"2":{"27":2}}],["您可以获得强大的错误处理能力",{"2":{"135":1}}],["申请一块内存",{"2":{"135":1}}],["申请内存",{"2":{"26":1,"27":2}}],["给",{"2":{"133":1}}],["想要无条件的解构它",{"2":{"132":1}}],["均可直接安装",{"2":{"220":1}}],["均可以",{"2":{"193":1}}],["均支持",{"2":{"207":1}}],["均为第三方作者维护",{"2":{"207":1}}],["均被使用",{"2":{"139":1}}],["均会被转换为",{"2":{"132":1}}],["均是我们构建的一部分",{"2":{"185":1}}],["均是可以操作的",{"2":{"76":1}}],["均是在内存中连续分配且固定数量的相同类型元素",{"2":{"54":1}}],["警告",{"2":{"131":1,"142":1,"292":2}}],["⚠️",{"2":{"131":1,"142":1,"292":2}}],["全局错误集",{"0":{"131":1}}],["全局变量",{"2":{"18":1}}],["程序默认是从此处开始执行",{"2":{"231":1}}],["程序单元是应用的最小可测试部件",{"2":{"198":1}}],["程序a",{"2":{"186":1}}],["程序会在某些时候因为某些我们知道或者不知道的原因出错",{"2":{"128":1}}],["程序的优化",{"2":{"2":1}}],["我要说的是你说的基本是对的",{"2":{"292":1}}],["我要告诉你",{"2":{"232":1}}],["我认为",{"2":{"292":1}}],["我认为这个设计并不太好",{"2":{"144":1}}],["我才推荐你来学习它",{"2":{"292":1}}],["我相信你一定是从",{"2":{"230":1}}],["我还未在社区发现高质量的相关包",{"2":{"127":1}}],["我们显示强制截断位",{"2":{"270":1}}],["我们观察并获得的类型信息是",{"2":{"254":1}}],["我们知道系统调用会造成内核上下文切换的开销",{"2":{"232":1}}],["我们只需要正常打印即可",{"2":{"232":1}}],["我们假定",{"2":{"232":1}}],["我们传入的第二个参数是一个元组",{"2":{"231":1}}],["我们先通过",{"2":{"231":1}}],["我们将会单独讲述",{"2":{"223":1}}],["我们已经安装了",{"2":{"221":1}}],["我们就不需要使用else了",{"2":{"173":2}}],["我们就不说了",{"2":{"148":1}}],["我们称之为对",{"2":{"155":2}}],["我们在此处打印必须要要使用",{"2":{"254":1}}],["我们在这里并没有使用",{"2":{"195":1,"196":1}}],["我们在内部尝试解引用后再一次捕获指针来进行操作",{"2":{"152":1}}],["我们在执行此内联汇编会使用",{"2":{"4":1}}],["我们结构后获得",{"2":{"151":1}}],["我们也可以通过编译期函数来实现反射进而访问可选类型",{"2":{"146":1}}],["我们也可以用",{"2":{"82":1}}],["我们尝试调用",{"2":{"145":1}}],["我们绝对不能在赋值前使用它",{"2":{"142":1}}],["我们很容易能够知道发生了什么",{"2":{"137":1}}],["我们很容易就可以创建一个多维数组出来",{"2":{"56":1}}],["我们并未显示声明返回的错误",{"2":{"136":1}}],["我们这时再使用以上的定义方法未免过于啰嗦",{"2":{"130":1}}],["我们来看看维基百科怎么说的",{"2":{"293":1}}],["我们来看一个比较简单的函数",{"2":{"132":1}}],["我们来通过一个简单的程序",{"2":{"230":1}}],["我们来两个例子来说明就可以",{"2":{"136":1}}],["我们来用一个简单的函数作为说明",{"2":{"111":1}}],["我们来几个小小的示例来演示一下",{"2":{"100":1}}],["我们定义了一个元组类型",{"2":{"96":1}}],["我们定义了一个函数",{"2":{"7":1}}],["我们接下来演示一个示例",{"2":{"82":1}}],["我们不在这里使用",{"2":{"73":1}}],["我们还可以使用环绕",{"2":{"271":1}}],["我们还可以使用",{"2":{"173":1}}],["我们还可以使用捕获语法来捕获错误",{"2":{"135":1}}],["我们还可以覆盖枚举的标记值",{"2":{"68":1}}],["我们还可以构建出",{"2":{"24":1}}],["我们放在这里讲解字符串",{"2":{"61":1}}],["我们使用",{"2":{"139":1,"188":1}}],["我们使用语法",{"2":{"57":1,"82":1}}],["我们使用了内存分配的功能",{"2":{"90":1}}],["我们使用了内建函数",{"2":{"70":1}}],["我们使用了编译期的功能",{"2":{"66":1}}],["我们使用了",{"2":{"56":1,"254":1}}],["我们需要了解一下前置知识",{"2":{"236":1}}],["我们需要显示声明要格式化的参量类型",{"2":{"231":1}}],["我们需要引入",{"2":{"13":1}}],["我们需要先梳理一下",{"2":{"6":1}}],["我们通过使用",{"2":{"145":1,"187":1}}],["我们通过",{"2":{"10":1,"199":1}}],["我们通过全局汇编定义了一个汇编函数",{"2":{"3":1}}],["我们用它来进行数据的初始化",{"2":{"9":1}}],["我们可以在内部继续使用",{"2":{"152":1}}],["我们可以这样做",{"2":{"152":1}}],["我们可以这样处理",{"2":{"145":1}}],["我们可以以此代表1970年前",{"2":{"144":1}}],["我们可以定义多个重复的错误",{"2":{"129":1}}],["我们可以仍然可以通过结构体字段的指针来获取到基指针",{"2":{"95":1}}],["我们可以很容易的实现泛型",{"2":{"92":1}}],["我们可以使用",{"2":{"85":1,"142":1,"202":1}}],["我们可以通过",{"2":{"186":1,"203":1}}],["我们可以通过指针来操作其指向内存区域",{"2":{"79":1}}],["我们可以通过使用",{"2":{"68":1}}],["我们可以实现某些其他语言所不具备的方式来操作数组",{"2":{"64":1}}],["我们可以直接将它转化为数组",{"2":{"51":1}}],["我们可以将它作为",{"2":{"24":1}}],["我们可以正常把它当作常量来使用",{"2":{"7":1}}],["我们可以看到",{"2":{"7":1}}],["我们可以稍稍改造它一下",{"2":{"7":1}}],["我们可以尝试给编译期做一个定义",{"2":{"6":1}}],["法",{"2":{"127":1}}],["结果为",{"2":{"252":1}}],["结果为该类型的极限",{"2":{"127":1}}],["结构",{"2":{"254":1}}],["结构大体是这样的",{"2":{"4":1}}],["结构体代表",{"2":{"144":1}}],["结构体会获得一个类似",{"2":{"100":1}}],["结构体进行转换操作",{"2":{"99":1}}],["结构体字段的顺序是由编译器决定的",{"2":{"95":1}}],["结构体允许使用默认值",{"2":{"93":1}}],["结构体的",{"2":{"254":1}}],["结构体的方法除了使用",{"2":{"89":1}}],["结构体的组成",{"2":{"89":1}}],["结构体本身是一个高级的数据结构",{"2":{"88":1}}],["结构体和联合类型会被翻译为",{"2":{"18":1}}],["结构体",{"0":{"88":1,"290":1},"1":{"89":1,"90":1,"91":1,"92":1,"93":1,"94":1,"95":1,"96":1,"97":1,"98":1,"99":1,"100":1},"2":{"3":1,"96":1,"112":1,"248":1,"254":1,"290":1}}],["饱和左移",{"2":{"127":1}}],["饱和乘法",{"2":{"127":1}}],["饱和减法",{"2":{"127":1}}],["饱和加法",{"2":{"127":1}}],["聊点",{"2":{"127":1}}],["按位非",{"2":{"127":1}}],["按位异或",{"2":{"127":1}}],["按位或",{"2":{"127":1}}],["按位与",{"2":{"127":1}}],["按值传递结构和联合类型",{"2":{"112":1}}],["嘛",{"2":{"126":1}}],["受制于浮点精度",{"2":{"126":1}}],["受益于",{"2":{"64":1}}],["受益于这种特性",{"2":{"24":1}}],["负数转换为无符号整数",{"0":{"269":1}}],["负数是从",{"2":{"105":1}}],["负无穷大这些语法",{"2":{"126":1}}],["详见",{"2":{"126":1,"295":1}}],["切换到",{"2":{"126":1}}],["切片长度为",{"2":{"81":1}}],["切片第一个元素为",{"2":{"81":1}}],["切片语法",{"2":{"81":1}}],["切片本身还有边界检查",{"2":{"77":1}}],["切片本身除了具有",{"2":{"77":1}}],["切片指针",{"0":{"77":1}}],["切片的本质",{"2":{"76":1}}],["切片的使用方式就是类似数组",{"2":{"76":1}}],["切片和数组看起来上很像",{"2":{"76":1}}],["切片",{"0":{"45":1,"76":1},"1":{"77":1,"78":1},"2":{"76":1,"81":1,"155":4,"157":1,"288":2}}],["模块获取到了标准输出和错误输出的",{"2":{"232":1}}],["模式构建",{"2":{"184":1}}],["模式下开启",{"2":{"266":1}}],["模式下快速暴露某些错误",{"2":{"184":1}}],["模式下",{"2":{"142":1,"176":2}}],["模式下会产生未定义的行为",{"2":{"134":1}}],["模式下会产生恐慌",{"2":{"134":1}}],["模式",{"2":{"126":2}}],["模型",{"2":{"25":1}}],["任意整数类型",{"2":{"126":1}}],["任意浮点类型",{"2":{"126":1}}],["任何的非",{"2":{"61":1}}],["任何被执行",{"2":{"36":1}}],["任何函数之外",{"2":{"9":1}}],["任何发生运行时对变量的操作将会在编译时报错",{"2":{"8":1}}],["处理溢出",{"2":{"134":1}}],["处理溢出有两种方式",{"2":{"125":1}}],["处理方式有三种",{"2":{"18":1}}],["取否环绕",{"2":{"271":1}}],["取反环绕",{"2":{"125":1}}],["取反",{"2":{"125":1,"271":1}}],["取地址",{"2":{"77":1,"79":1}}],["加强安全性的一种方式",{"2":{"184":1}}],["加减乘除",{"2":{"127":1}}],["加减操作",{"2":{"79":1}}],["加法环绕",{"2":{"125":1,"271":1}}],["加法",{"2":{"125":1}}],["溢出",{"0":{"125":1}}],["$home",{"2":{"220":1}}],["$",{"2":{"124":1,"220":1}}],["^=",{"2":{"127":1}}],["^",{"2":{"124":4,"127":2,"266":5}}],["求余",{"2":{"124":1}}],["小驼峰命名法",{"2":{"231":1}}],["小于等于",{"2":{"127":1}}],["小于",{"2":{"127":1}}],["小细节",{"2":{"124":1,"144":2,"208":1}}],["小技巧",{"2":{"35":1}}],["二进制的目录加入到",{"2":{"219":1}}],["二进制可执行程序的构建结果会输出在",{"2":{"189":1}}],["二进制体积小",{"2":{"184":1}}],["二进制体积大",{"2":{"184":3}}],["二进制",{"2":{"123":1}}],["八进制",{"2":{"123":1}}],["十进制",{"2":{"123":1}}],["十六进制",{"2":{"62":1,"123":1}}],["十六进制八位字节值",{"2":{"62":1}}],["描述",{"2":{"122":1}}],["告诉优化器当前函数很少被调用",{"2":{"118":1}}],["高明的可选类型",{"2":{"295":1}}],["高阶使用",{"0":{"114":1},"1":{"115":1,"116":1,"117":1,"118":1,"119":1}}],["高级用法",{"0":{"150":1},"1":{"151":1,"152":1}}],["高级特性",{"0":{"97":1},"1":{"98":1,"99":1,"100":1}}],["高级语言的编译器并不是完美的",{"2":{"2":1}}],["介于内建函数的数目过多",{"2":{"113":1}}],["传递的",{"2":{"195":1,"196":1}}],["传递给包",{"2":{"194":1}}],["传递给构建",{"2":{"192":1}}],["传递参数",{"2":{"193":1,"194":1}}],["传递完全使用值传递",{"2":{"112":1}}],["传入到fiexed",{"2":{"27":2}}],["引用的是malloc的原型",{"2":{"145":1}}],["引用传递",{"2":{"112":2}}],["引入了",{"2":{"231":1}}],["引入模块",{"2":{"37":1}}],["引入包",{"0":{"37":1}}],["引入一种新类型",{"2":{"20":1}}],["引入的代码时打印缓存文件的存储位置",{"2":{"17":1}}],["引入外部的内联汇编",{"2":{"2":1}}],["值传递",{"2":{"112":2}}],["值得一提的是",{"2":{"144":1}}],["值得一看",{"2":{"32":1}}],["值得注意的是",{"2":{"89":1,"126":1,"186":1,"210":1,"254":1}}],["泛型",{"2":{"111":1}}],["泛型实现",{"0":{"92":1}}],["虽然是",{"2":{"108":1}}],["应该使用",{"2":{"264":1}}],["应该会注意到",{"2":{"108":1}}],["应使用",{"2":{"264":2}}],["应尽量避免使用",{"2":{"131":1}}],["应当避免使用此类型",{"2":{"20":1}}],["应当只存在一个",{"2":{"13":1}}],["绝非我们平常所指的单个文字",{"2":{"107":1}}],["码表中的内容",{"2":{"108":1}}],["码表的值来替换字符",{"2":{"108":1}}],["码表的值",{"2":{"107":1}}],["码点",{"2":{"62":1}}],["码点中使用",{"2":{"61":1}}],["码点字面量类型是",{"2":{"61":1}}],["往往都是",{"2":{"107":1}}],["往往是由于错误的内存管理引起的",{"2":{"25":1}}],["挑选出来的元素",{"2":{"105":1}}],["变小",{"2":{"105":1}}],["变大",{"2":{"105":1}}],["变量名是time",{"2":{"188":1}}],["变量等这些提供注释",{"2":{"144":1}}],["变量是在内存中存储值的单元",{"2":{"139":1}}],["变量声明和",{"2":{"293":1}}],["变量声明",{"0":{"139":1},"1":{"140":1,"141":1,"142":1}}],["变量的声明和定义是编程语言中最基础且最常见的操作之一",{"2":{"138":1}}],["变量的长度",{"2":{"105":1}}],["变量",{"2":{"9":1,"76":1,"139":1,"142":1}}],["变量可以也标记上",{"2":{"8":1}}],["从本质上看",{"2":{"294":1}}],["从现代语言中采用的功能包括添加编译时泛型类型",{"2":{"293":1}}],["从而提高开发人员的工作效率",{"2":{"207":1}}],["从",{"2":{"105":2,"106":1,"137":1}}],["选出指定索引的值",{"2":{"105":2}}],["或许",{"2":{"294":1}}],["或许可能有人会跟我说",{"2":{"292":1}}],["或许有人使用",{"2":{"292":1}}],["或许将来可能是",{"2":{"292":1}}],["或方法",{"2":{"261":1}}],["或不被调用",{"2":{"118":1}}],["或",{"2":{"105":3,"106":1}}],["或者其他工具提供更好的帮助说明",{"2":{"265":1}}],["或者其他线程等等",{"2":{"4":1}}],["或者手动编译",{"2":{"208":1}}],["或者使用",{"2":{"196":1}}],["或者是让",{"2":{"178":1}}],["或者是一个",{"2":{"132":1,"133":1}}],["或者具有",{"2":{"170":1}}],["或者向量",{"2":{"105":1}}],["或者普通结构体",{"2":{"98":1}}],["或者对某一种特定对象的计数",{"2":{"67":1}}],["或者游戏事件循环之类的",{"2":{"28":1}}],["或者",{"2":{"16":1,"122":1,"140":1,"145":1,"178":1}}],["或者我们可以手动执行构建",{"2":{"13":1}}],["或者称之为破坏更合适",{"2":{"4":1}}],["组成一个新的向量",{"2":{"105":1}}],["生成某些特定的文件",{"2":{"194":1}}],["生成一个向量",{"2":{"103":1}}],["生成数据结构",{"0":{"10":1}}],["过长的向量长度",{"2":{"102":1}}],["比",{"2":{"292":1}}],["比目标机器的",{"2":{"102":1}}],["比较远算符",{"2":{"102":1}}],["~x",{"2":{"127":1}}],["~",{"2":{"102":1,"105":2,"127":1,"208":1}}],["算术运算符",{"2":{"102":1}}],["算是一个比较巧妙的例子",{"2":{"4":1}}],["浮点转换整数发生越界",{"0":{"282":1}}],["浮点运算时遵循",{"2":{"126":1}}],["浮点字面量则是具有",{"2":{"126":1}}],["浮点数在某些操作上是反直觉的",{"2":{"126":1}}],["浮点数有",{"2":{"126":1}}],["浮点数就是表示带有小数点的数字",{"2":{"126":1}}],["浮点数",{"0":{"126":1}}],["浮点数同理",{"2":{"43":1}}],["浮点",{"2":{"101":1}}],["整型",{"2":{"101":1,"112":1}}],["整数溢出",{"0":{"271":1}}],["整数就是",{"2":{"231":1}}],["整数类型允许的最大位宽为65535",{"2":{"122":1}}],["整数字面量的类型",{"2":{"122":1}}],["整数",{"0":{"121":1,"287":1},"1":{"122":1,"123":1,"124":1,"125":1},"2":{"52":1,"287":1}}],["整数可以转换为可以表示旧类型全部值的整数类型",{"2":{"43":1}}],["整数与浮点数拓宽",{"0":{"43":1}}],["布尔这种",{"2":{"112":1}}],["布尔值有两个",{"2":{"109":1}}],["布尔值",{"0":{"109":1}}],["布尔值往往通过二进制的",{"2":{"107":1}}],["布尔",{"2":{"101":1}}],["基于一套规则来进行命名",{"2":{"100":1}}],["基本都是遵循的c",{"2":{"292":1}}],["基本类型",{"0":{"138":1},"1":{"139":1,"140":1,"141":1,"142":1,"143":1,"144":1}}],["基本",{"2":{"108":1}}],["基本使用",{"0":{"102":1,"111":1,"129":1,"170":1,"178":1,"199":1},"2":{"162":1}}],["基本语法",{"0":{"89":1}}],["基本就要和",{"2":{"24":1}}],["待需要时再来学习即可",{"2":{"97":1}}],["待添加详细注释",{"2":{"195":1}}],["待添加",{"2":{"33":1}}],["匿名模块还支持直接使用其他程序输出",{"2":{"193":1}}],["匿名",{"2":{"96":1}}],["返回错误时",{"2":{"199":1}}],["返回错误时我们想将它向上传递",{"2":{"132":1}}],["返回错误时我们准备一个默认值",{"2":{"132":1}}],["返回值时触发",{"2":{"164":1}}],["返回一个",{"2":{"144":1}}],["返回一个错误",{"2":{"137":1}}],["返回的是一个",{"2":{"179":1}}],["返回的是一个结构体类型",{"2":{"10":1}}],["返回的错误类型将会由",{"2":{"136":1}}],["返回所有元素是",{"2":{"105":1}}],["返回向量",{"2":{"105":1}}],["返回对应的结构体基指针",{"2":{"95":1}}],["后面再来学习",{"2":{"231":1}}],["后面加数字即可",{"2":{"122":1}}],["后记",{"0":{"229":1}}],["后跟任意字母数字或下划线",{"2":{"140":1}}],["后续会讲解",{"2":{"127":1}}],["后续我们会专门讲解泛型这一个利器",{"2":{"92":1}}],["后还是",{"2":{"127":1}}],["后端开发库",{"2":{"39":1}}],["q",{"2":{"196":1}}],["quarter4",{"2":{"99":2}}],["quarter3",{"2":{"99":2}}],["quot",{"2":{"4":2,"62":1,"96":4,"125":2,"140":2,"195":2,"196":2,"203":2,"271":14}}],["qq",{"2":{"90":1}}],["命令初始化一个项目",{"2":{"230":1}}],["命令创建出来的",{"2":{"224":1}}],["命令",{"0":{"221":1},"1":{"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1},"2":{"218":1,"221":1}}],["命令来执行测试",{"2":{"191":1}}],["命令行参数",{"0":{"15":1},"2":{"201":2}}],["命名法",{"2":{"264":10}}],["命名",{"0":{"264":1}}],["命名须以",{"2":{"140":1}}],["命名规则",{"0":{"100":1}}],["命名空间来实现内存排序",{"2":{"235":1}}],["命名空间",{"2":{"90":1,"264":1}}],["专属语法",{"2":{"292":1}}],["专有名词或任何其他在书面英语中具有大写规则的单词与任何其他单词一样",{"2":{"264":1}}],["专门处理上面这种语法",{"2":{"200":1}}],["专门为匿名结构体和文件类的类型声明",{"2":{"90":1}}],["专为关键任务安全性和性能而设计的分布式财务会计数据库",{"2":{"39":1}}],["平常使用过程中会面临另外的一个情况",{"2":{"90":1}}],["首字母缩写词",{"2":{"264":1}}],["首字母缩略词",{"2":{"264":1}}],["首先",{"2":{"232":1}}],["首先确保你的路径是正确的",{"2":{"215":1}}],["首先我们和",{"2":{"145":1}}],["首先是一个内联汇编的语句",{"2":{"4":1}}],["首部关键字",{"2":{"89":1}}],["修改方法为",{"2":{"212":1}}],["修改为更加精确的类型",{"2":{"16":1}}],["修饰的",{"2":{"200":1}}],["修饰",{"2":{"112":1}}],["修饰符后",{"2":{"86":1}}],["尝试解开错误联合类型",{"0":{"276":1}}],["尝试解开可选类型",{"0":{"275":1}}],["尝试刷新buffer",{"2":{"232":1}}],["尝试运行命令并捕获标准输出",{"2":{"194":1}}],["尝试添加一个静态库",{"2":{"189":1}}],["尝试在设置内存对齐后再进行类型比较",{"2":{"85":1}}],["尝试比较类型",{"2":{"85":1}}],["架构的指针对齐大小",{"2":{"85":1}}],["架构",{"2":{"85":1,"189":1}}],["找出任何类型的内存对齐大小",{"2":{"85":1}}],["数据截断",{"0":{"270":1}}],["数据c",{"2":{"186":1}}],["数值类型是语言运行时的基本类型",{"2":{"120":1}}],["数值类型",{"0":{"120":1},"1":{"121":1,"122":1,"123":1,"124":1,"125":1,"126":1,"127":1}}],["数个字节",{"2":{"85":1}}],["数组和切片",{"0":{"288":1}}],["数组和切片的指针都存储了长度",{"2":{"81":1}}],["数组或者切片",{"2":{"158":1}}],["数组或切片",{"2":{"78":1}}],["数组等",{"2":{"112":1}}],["数组第一个元素为",{"2":{"81":1}}],["数组指针进行切片操作",{"2":{"76":1}}],["数组指针赋值给多项指针",{"2":{"45":1}}],["数组之间可以使用",{"2":{"60":1}}],["数组才会有索引为数组长度的元素",{"2":{"57":1}}],["数组最后一个元素值",{"2":{"57":1}}],["数组长度为",{"2":{"57":1,"81":1}}],["数组元素是连续放置的",{"2":{"55":1}}],["数组的分配和",{"2":{"54":1}}],["数组是日常敲代码使用相当频繁的类型之一",{"2":{"54":1}}],["数组",{"0":{"45":1,"54":1},"1":{"55":1,"56":1,"57":1,"58":1,"59":1,"60":1,"61":1,"62":1,"63":1,"64":1,"65":1,"66":1},"2":{"81":1,"127":4,"155":2,"288":1}}],["每个级别都包含上一个级别的所有保证",{"2":{"236":1}}],["每个文件可以使用",{"2":{"191":1}}],["每种类型都有一个对齐方式",{"2":{"85":1}}],["每次执行分配时",{"2":{"31":1}}],["保证内存布局和声明顺序相同并且尽量紧凑",{"2":{"182":1}}],["保证内存布局与目标",{"2":{"181":1}}],["保证我们这里的",{"2":{"145":1}}],["保证错误一定是目标错误集的值",{"2":{"131":1}}],["保证使用",{"2":{"84":1}}],["保证切片不会被优化为数组指针",{"2":{"77":1}}],["副作用",{"2":{"84":2}}],["等到要打印的内容都到一定程度后再一次性全部",{"2":{"232":1}}],["等到你需要时再来查看",{"2":{"85":1}}],["等到你需要时再来学习即可",{"2":{"83":1}}],["等",{"2":{"192":1}}],["等情况的出现",{"2":{"145":1}}],["等你需要时再来查看",{"2":{"84":1}}],["等待",{"2":{"1":1}}],["额外特性",{"0":{"83":1},"1":{"84":1,"85":1,"86":1,"87":1}}],["额外内容",{"0":{"22":1},"1":{"23":1,"24":1}}],["尤其是在切片中",{"2":{"79":1}}],["符号来获取某个变量所对应的内存地址",{"2":{"79":1}}],["显然这种方式更靠谱一些",{"2":{"220":1}}],["显示声明运行依赖于构建",{"2":{"186":1}}],["显示声明切片类型",{"2":{"78":1}}],["显式强制转换为错误的子集",{"2":{"52":1}}],["显式强制转换对齐",{"2":{"52":1}}],["显式强制转换是通过内建函数完成的",{"2":{"52":1}}],["显式强制转换",{"0":{"52":1}}],["显式声明包含的源文件",{"2":{"35":1}}],["索引越界访问",{"0":{"268":1}}],["索引语法",{"2":{"81":1}}],["索引",{"2":{"78":1}}],["索引它们会返回独立的字节",{"2":{"61":1}}],["边界使用变量",{"2":{"77":1}}],["属性",{"2":{"77":1}}],["属性外",{"2":{"77":1}}],["属于是一个约束",{"2":{"4":1}}],["右边界值为",{"2":{"76":1}}],["右侧是倍数",{"2":{"59":1}}],["规则",{"2":{"76":1}}],["规范兼容",{"2":{"39":1}}],["左侧",{"2":{"132":1}}],["左移右移",{"2":{"127":1}}],["左边界值为0",{"2":{"76":1}}],["左闭右开",{"2":{"76":1}}],["左右的大小",{"2":{"23":1}}],["遵循",{"2":{"76":1,"112":1}}],["常规的运算可能导致溢出",{"2":{"271":1}}],["常规的运算有等于",{"2":{"127":1}}],["常用命令",{"2":{"220":1}}],["常用于函数无返回值",{"2":{"286":1}}],["常用于单元测试和调试",{"2":{"126":1}}],["常用于流程控制",{"2":{"109":1}}],["常用于与",{"2":{"75":1}}],["常见的系统管理器",{"2":{"220":1}}],["常见的加减乘除我们就不聊了",{"2":{"127":1}}],["常量",{"0":{"141":1},"2":{"139":1,"141":1,"261":1,"263":1}}],["常量声明和方法的定义",{"2":{"75":1}}],["常常在你需要缓冲某些东西时使用",{"2":{"27":1}}],["拥有不同的变量",{"2":{"75":1}}],["兼容",{"2":{"73":1,"181":1}}],["兼容的库供其他程序使用",{"2":{"11":1}}],["非常强大的构建系统",{"2":{"295":1}}],["非常好",{"2":{"292":1}}],["非常的全面",{"2":{"221":1}}],["非公共成员需要我们手动以",{"2":{"200":1}}],["非必要不使用",{"2":{"160":1,"165":1}}],["非",{"2":{"99":1}}],["非详尽枚举",{"0":{"72":1}}],["非utf",{"2":{"61":1}}],["要么全部不完成",{"2":{"235":1}}],["要以编程方式跳过测试",{"2":{"201":1}}],["要更加灵活",{"2":{"76":1}}],["要注意的是",{"2":{"70":1}}],["要在编译使用",{"2":{"17":1}}],["没错误就正常执行",{"2":{"134":1}}],["没错",{"2":{"69":1}}],["没有对应的声明",{"2":{"255":1}}],["没有任何问题",{"2":{"43":1}}],["没有运行时开销的原因",{"2":{"25":1}}],["没有具体的定义",{"2":{"18":1}}],["覆盖部分值",{"2":{"68":1}}],["现在跨语言调用",{"2":{"292":1}}],["现在已经不再是一门语言",{"2":{"292":1}}],["现在我要告诉你",{"2":{"231":1}}],["现在我们可以在",{"2":{"68":1}}],["现在",{"2":{"221":1}}],["现在它的值可以是",{"2":{"145":1}}],["现代操作系统页大小最小为4k",{"2":{"31":1}}],["现代化内核编写时均会使用汇编来完成一些初始化工作",{"2":{"2":1}}],["声明可以使用",{"2":{"287":1}}],["声明混入到当前的容器中",{"2":{"249":1}}],["声明变量",{"2":{"139":1}}],["声明枚举",{"0":{"68":1}}],["声明函数调用约定为",{"2":{"21":1}}],["举常常用来列出一个有限集合的任何成员",{"2":{"67":1}}],["举个比较剑走偏锋的例子",{"2":{"24":1}}],["讲解",{"2":{"66":1}}],["自旋锁",{"0":{"245":1}}],["自纪元开始后的秒数",{"2":{"144":1}}],["自引用",{"0":{"90":1}}],["自身的语言特性",{"2":{"64":1}}],["自动代码重构并且深度整合",{"2":{"207":1}}],["自动推断",{"0":{"91":1,"180":1},"2":{"180":1}}],["自动转换到",{"2":{"48":1}}],["自动转换",{"2":{"45":1,"51":1}}],["自动完成",{"2":{"41":1}}],["自动构建",{"2":{"1":1}}],["奇技淫巧",{"0":{"64":1},"1":{"65":1,"66":1}}],["行尾不会包含在字符串中",{"2":{"63":1}}],["多版本管理",{"0":{"220":1}}],["多匹配项",{"2":{"171":1}}],["多目标迭代",{"0":{"158":1}}],["多个",{"2":{"196":1}}],["多个匹配",{"2":{"173":2}}],["多个重复的错误",{"2":{"129":1}}],["多个声明",{"2":{"89":1}}],["多个字段",{"2":{"89":1}}],["多项指针的类型为",{"2":{"81":1}}],["多项指针指向位置数量的多个元素",{"2":{"81":1}}],["多项指针",{"0":{"81":1},"1":{"82":1}}],["多行字符串没有转义",{"2":{"63":1}}],["多行字符串",{"0":{"63":1}}],["多维数组",{"0":{"56":1},"2":{"56":1}}],["位同理",{"2":{"122":1}}],["位操作符",{"2":{"102":1}}],["位或者多位",{"2":{"62":1}}],["位",{"2":{"62":1,"108":1,"122":2}}],["双引号",{"2":{"62":1}}],["制表符",{"2":{"62":1}}],["回车",{"2":{"62":1}}],["回收p2",{"2":{"32":1}}],["换另一个文件就不行了",{"2":{"255":1}}],["换一种方式",{"0":{"232":1}}],["换行符号",{"2":{"63":1}}],["换行",{"2":{"62":1}}],["换种说法",{"2":{"57":1}}],["含义",{"2":{"62":1}}],["⚡",{"2":{"61":1}}],["💯",{"2":{"61":3}}],["串联",{"0":{"60":1},"2":{"127":1}}],["98222",{"2":{"123":1}}],["9",{"2":{"59":2,"132":1,"152":2,"160":1,"161":2,"166":2,"171":1,"196":2}}],["99",{"2":{"8":4}}],["运算可能出现溢出",{"2":{"271":1}}],["运算的优先级",{"2":{"127":1}}],["运算",{"0":{"127":1}}],["运算符就表示我们选择捕获这个值对应的指针",{"2":{"151":1}}],["运算符将两个错误合并到一起",{"2":{"136":1}}],["运算符右侧必须是一个与其左侧函数返回的错误联合类型展开后的类型一致",{"2":{"133":1}}],["运算符",{"2":{"96":1,"105":1}}],["运算符左侧是数组",{"2":{"59":1}}],["运行",{"2":{"221":1}}],["运行的",{"2":{"195":1,"196":1}}],["运行而不是构建缓存中运行",{"2":{"186":1}}],["运行程序的目标计算机",{"2":{"122":1}}],["运行时参数传递",{"2":{"195":1,"196":1}}],["运行时如果出错会给出完整的堆栈跟踪",{"2":{"124":1}}],["运行时可知",{"2":{"76":1}}],["运行时",{"2":{"39":1,"124":1}}],["哨兵",{"2":{"82":1}}],["哨兵指针就和哨兵数组类似",{"2":{"82":1}}],["哨兵指针",{"0":{"82":1}}],["哨兵终止的切片允许元素访问",{"2":{"78":1}}],["哨兵切片认定哨兵位置处的元素是哨兵值",{"2":{"78":1}}],["哨兵切片也可以使用切片语法",{"2":{"78":1}}],["哨兵切片",{"0":{"78":1}}],["哨兵值为",{"2":{"57":1}}],["哨兵数组",{"0":{"57":1}}],["长度无关",{"2":{"288":1}}],["长度",{"2":{"60":1,"76":1,"81":1,"127":2}}],["长度为",{"2":{"57":1}}],["长度固定",{"2":{"54":1}}],["原因在于",{"2":{"252":1}}],["原型为",{"2":{"252":1}}],["原子级别讲解等",{"2":{"245":1}}],["原子性分为六个级别",{"2":{"236":1}}],["原子数据结构",{"0":{"244":1},"2":{"235":1}}],["原子操作的顺序级别",{"2":{"236":1}}],["原子操作是指一个或一系列的操作",{"2":{"235":1}}],["原子操作是在多线程环境中非常重要的一个概念",{"2":{"235":1}}],["原子操作",{"0":{"235":1},"1":{"236":1,"237":1,"238":1,"239":1,"240":1,"241":1,"242":1,"243":1,"244":1,"245":1}}],["原本",{"2":{"207":1}}],["原始类型",{"2":{"112":1}}],["原则上不允许忽略函数的返回值",{"2":{"111":1}}],["原文档应该是",{"2":{"57":1}}],["原生支持",{"2":{"39":1}}],["很适合你",{"2":{"294":1}}],["很像",{"2":{"294":1}}],["很好",{"2":{"292":1}}],["很好的运行效率",{"2":{"184":1}}],["很显然",{"2":{"273":1}}],["很简单",{"2":{"230":1}}],["很抱歉",{"2":{"57":1}}],["很明显就应该是",{"2":{"126":1}}],["很明显",{"2":{"7":1}}],["循环结束并且没有经过",{"2":{"164":1}}],["循环结束前执行",{"2":{"135":1}}],["循环用于重复执行表达式",{"2":{"162":1}}],["循环要求迭代的值和捕获的值均是编译期已知的",{"2":{"161":1}}],["循环展开",{"2":{"161":1,"166":1}}],["循环是另一种循环处理方式",{"2":{"155":1}}],["循环分为两种",{"2":{"154":1}}],["循环的作用域中",{"2":{"135":1}}],["循环",{"0":{"154":1},"1":{"155":1,"156":1,"157":1,"158":1,"159":1,"160":1,"161":1,"162":1,"163":1,"164":1,"165":1,"166":1,"167":1,"168":1},"2":{"56":1,"66":1}}],["循环将会被自动内联",{"2":{"8":1}}],["|field|",{"2":{"254":1}}],["|foo|",{"2":{"145":1}}],["|decl|",{"2":{"200":1}}],["|args|",{"2":{"186":1,"193":1,"194":1,"195":1,"196":1}}],["|arr",{"2":{"56":1}}],["|num",{"2":{"175":1}}],["|number|",{"2":{"134":2}}],["|slice|",{"2":{"175":1}}],["|x|",{"2":{"167":1,"168":1}}],["|idx|",{"2":{"175":1}}],["|item|",{"2":{"173":2}}],["|i",{"2":{"158":1}}],["|i|",{"2":{"156":1,"161":2}}],["|optional",{"2":{"152":1}}],["|real",{"2":{"151":1}}],["|leftover",{"2":{"134":1}}],["|err|",{"2":{"134":2,"135":1,"152":3,"168":2}}],["|ele",{"2":{"76":1}}],["|c|",{"2":{"132":1}}],["|=",{"2":{"127":4}}],["||",{"2":{"127":1,"136":1}}],["|",{"2":{"66":1,"102":1,"127":8,"134":2,"151":1,"152":9,"155":1,"160":8,"173":2,"179":1,"186":5,"196":2,"245":2}}],["|value",{"2":{"157":1}}],["|value|",{"2":{"152":1,"155":1,"159":1,"167":2,"168":2,"179":1}}],["|val",{"2":{"56":1}}],["矩阵乘",{"2":{"127":1}}],["矩阵",{"2":{"56":1,"127":1}}],["创建出来的",{"2":{"224":1}}],["创建了一个",{"2":{"188":1}}],["创建一个运行",{"2":{"195":1,"196":1}}],["创建一个",{"2":{"185":1,"188":1}}],["创建一个节点均为",{"2":{"185":1}}],["创建一个新的分支",{"2":{"1":1}}],["创建数组",{"0":{"55":1},"1":{"56":1}}],["元组还有一个和数组一样的字段",{"2":{"96":1}}],["元组实际上就是不指定字段的",{"2":{"96":1}}],["元组",{"0":{"96":1}}],["元组和数组",{"0":{"51":1}}],["元素类型",{"2":{"60":1}}],["元素",{"2":{"56":1}}],["元素必须有相同的类型",{"2":{"54":1}}],["因此我更愿意称之为",{"2":{"292":1}}],["因此我们可以通过操控指针来修改其值",{"2":{"151":1}}],["因此它的反射是在编译期实现的",{"2":{"250":1}}],["因此它们除了指针默认的语法外",{"2":{"81":1}}],["因此在使用社区已有类库时",{"2":{"220":1}}],["因此",{"2":{"211":1}}],["因此不能保证代码可以观察到它",{"2":{"142":1}}],["因此该错误集是可以被编译器自动推导的",{"2":{"132":1}}],["因此如果想把非",{"2":{"61":1}}],["因此数组有以下三点特性",{"2":{"54":1}}],["因为相当于不存在",{"2":{"286":1}}],["因为如果有可执行二进制程序构建使用了",{"2":{"189":1}}],["因为你经常需要和编译期斗智斗勇",{"2":{"145":1}}],["因为错误类型在",{"2":{"128":1}}],["因为内核本身应当是一个不会退出的程序",{"2":{"116":1}}],["因为它和",{"2":{"160":1,"165":1}}],["因为它会阻止编译器在编译期就检测出可能存在的错误",{"2":{"131":1}}],["因为它相对数组来说",{"2":{"76":1}}],["因为它有对应的类型",{"2":{"49":1}}],["因为它也是唯一值",{"2":{"49":1}}],["因为值没有任何变化",{"2":{"42":1}}],["因为",{"2":{"20":1,"43":2,"108":1,"252":1,"270":1}}],["因为编译期会在编译期隐式内联",{"2":{"7":1}}],["到现在已经处于一种较为割裂的存在",{"2":{"292":1}}],["到枚举大小等价整数类型的安全语义",{"2":{"72":1}}],["到",{"2":{"53":4}}],["执行实现泛型和反射",{"2":{"295":1}}],["执行系统调用",{"2":{"232":1}}],["执行以下命令",{"2":{"215":1}}],["执行时会仅执行文件内的顶级测试块",{"2":{"200":1}}],["执行其他命令",{"0":{"194":1},"1":{"195":1,"196":1,"197":1}}],["执行单元测试",{"2":{"191":1}}],["执行",{"2":{"160":1,"165":1}}],["执行相加的操作",{"2":{"102":1}}],["执行检查内存是否相等",{"2":{"53":1}}],["执行的时期",{"2":{"6":1}}],["截断位",{"2":{"52":1}}],["有异曲同工之妙",{"2":{"295":1}}],["有几点是非常值得单独拿出来说明一下的",{"2":{"295":1}}],["有一些类型是特殊的零位类型",{"2":{"285":1}}],["有可能出现新版本",{"2":{"220":1}}],["有两种方案可以选择",{"2":{"208":1}}],["有意思的是",{"2":{"184":1}}],["有时我们需要针对不同的错误做更为细致的处理",{"2":{"134":1}}],["有的错误我们可以预知并处理",{"2":{"128":1}}],["有关浮点运算的模式",{"2":{"126":1}}],["有以下默认操作可以导致溢出",{"2":{"125":1}}],["有符号指针大小的整数",{"2":{"122":1}}],["有符号128位整数",{"2":{"122":1}}],["有符号16位整数",{"2":{"122":1}}],["有符号64位整数",{"2":{"122":1}}],["有符号32位整数",{"2":{"122":1}}],["有符号8位整数",{"2":{"122":1}}],["有且只有一个选择",{"2":{"111":1}}],["有些错误我们无法预知",{"2":{"128":1}}],["有些转换在运行时无操作",{"2":{"52":1}}],["有些转换是安全的",{"2":{"52":1}}],["有些是执行语言级断言",{"2":{"52":1}}],["有许多分配器示例可供查看以获取灵感",{"2":{"33":1}}],["字母",{"2":{"140":1}}],["字节对齐",{"2":{"280":1}}],["字节写入未定义的内存",{"2":{"142":1}}],["字节放入字符串中",{"2":{"61":1}}],["字节均会被作为",{"2":{"61":1}}],["字符",{"0":{"108":1},"2":{"107":1}}],["字符与布尔值",{"0":{"107":1},"1":{"108":1,"109":1}}],["字符看待",{"2":{"61":1}}],["字符串可以使用",{"2":{"61":1}}],["字符串是没有独立的类型的",{"2":{"61":1}}],["字符串",{"0":{"61":1},"1":{"62":1,"63":1},"2":{"199":1}}],["字面量",{"2":{"123":1}}],["字面量推导是错误的",{"2":{"49":1}}],["字面量供",{"2":{"49":2}}],["字段的",{"2":{"264":1}}],["字段类型",{"2":{"254":1}}],["字段会被尽量压缩为占用尽可能小的",{"2":{"99":1}}],["字段严格按照声明的顺序排列",{"2":{"99":1}}],["字段默认值",{"0":{"93":1}}],["字段更换为",{"2":{"36":1,"193":1,"194":1}}],["字段",{"2":{"35":1,"195":1,"196":1}}],["字段是当前",{"2":{"35":1}}],["先使用",{"2":{"230":1}}],["先列出通过包管理器安装",{"2":{"217":1}}],["先通过",{"2":{"191":1}}],["先来看一下在",{"2":{"144":1}}],["先转为长度为",{"2":{"45":1}}],["先在",{"2":{"34":1}}],["单独的一门语言",{"2":{"292":1}}],["单独创建一个source目录",{"2":{"208":1}}],["单元测试的是实现非常简单",{"2":{"199":1}}],["单元测试",{"0":{"198":1},"1":{"199":1,"200":1,"201":1,"202":1,"203":1},"2":{"198":1}}],["单语句多语句",{"2":{"163":1}}],["单个数字",{"2":{"102":1}}],["单个字节的分配可能会剩下数千的字节无法使用",{"2":{"31":1}}],["单项指针的类型为",{"2":{"80":1}}],["单项指针指向单个元素",{"2":{"80":1}}],["单项指针",{"0":{"80":1}}],["单项指针可以赋值给长度只有",{"2":{"45":1}}],["单引号",{"2":{"62":1}}],["you",{"2":{"220":1}}],["your",{"2":{"215":4}}],["y++",{"2":{"196":2}}],["y3",{"2":{"196":1}}],["y0",{"2":{"196":1}}],["y",{"2":{"45":2,"46":1,"47":1,"48":1,"91":2,"95":4,"127":1,"143":3,"173":3,"176":2,"196":23,"253":3,"257":6,"258":1}}],["y2",{"2":{"45":1,"196":1}}],["y1",{"2":{"45":1,"46":1,"196":1}}],["892159",{"2":{"266":1}}],["8编码",{"2":{"212":1}}],["8",{"2":{"44":1,"60":2,"61":6,"62":1,"68":1,"90":1,"102":1,"106":1,"108":1,"173":2,"196":5,"212":2,"261":1,"264":1}}],["86899cd499e4c3f94aa141e400ac265f",{"2":{"17":1}}],["最优和可重用的软件",{"2":{"293":1}}],["最常用的一个",{"2":{"192":1}}],["最好将指针分配给",{"2":{"79":1}}],["最终得到一个标量",{"2":{"104":1}}],["最终",{"2":{"44":2}}],["最后将整个",{"2":{"188":1}}],["最后释放内存",{"2":{"28":1}}],["最后一定要加",{"2":{"15":1}}],["得到指针类型为",{"2":{"77":1}}],["得到的是单项指针",{"2":{"77":1}}],["得到结果再转换为",{"2":{"44":2}}],["得益于",{"2":{"13":1,"192":1}}],["转到",{"2":{"168":1}}],["转换到所有错误集",{"2":{"131":1}}],["转换到超集",{"2":{"129":1}}],["转换为",{"2":{"44":2,"52":2}}],["转义字符",{"0":{"62":1},"2":{"62":1}}],["转为",{"2":{"43":2}}],["立即数整数和浮点数出现歧义",{"0":{"44":1}}],["just",{"2":{"244":1}}],["jinzhongjia",{"2":{"208":1}}],["j++",{"2":{"196":1}}],["j|",{"2":{"158":1}}],["j",{"2":{"43":2,"163":4,"196":5}}],["json",{"2":{"194":1}}],["js",{"2":{"39":1}}],["肯定可以容纳",{"2":{"43":1}}],["子集转为超集",{"2":{"42":1}}],["限制",{"2":{"42":1}}],["限制更严格",{"0":{"42":1}}],["增加新的示例",{"2":{"254":1}}],["增加更多的讲解",{"2":{"245":1}}],["增加代码出错",{"2":{"131":1}}],["增加",{"2":{"42":1}}],["大多数编译时无法检测到的未定义行为均会在运行时被检测到",{"2":{"266":1}}],["大致的图如下",{"2":{"186":1}}],["大致的规则如下",{"2":{"41":1}}],["大于等于",{"2":{"127":1}}],["大于",{"2":{"127":1}}],["大端和小端",{"2":{"99":1}}],["大小长的向量将编译为多个",{"2":{"102":1}}],["大小短的向量的操作通常会编译为单个",{"2":{"102":1}}],["大小和对齐方式的新类型",{"2":{"74":1}}],["大小为止的类型",{"2":{"12":1}}],["大的内存对齐转为小的内存对齐",{"2":{"42":1}}],["出现时机",{"2":{"41":1}}],["普通用户选择",{"2":{"215":1}}],["普通构建",{"0":{"185":1}}],["普通结构体不同",{"2":{"99":1}}],["普通类型转换",{"0":{"41":1},"1":{"42":1,"43":1,"44":1,"45":1,"46":1,"47":1,"48":1,"49":1,"50":1,"51":1}}],["普通指针",{"2":{"20":1}}],["第二个是参量表",{"2":{"231":1}}],["第二个是安装目录",{"2":{"185":1}}],["第二种是用于避免出现错误的显式强制类型转换",{"2":{"40":1}}],["第一个参数是要格式化的字符串",{"2":{"231":1}}],["第一个是缓存目录",{"2":{"185":1}}],["第一个元素",{"2":{"81":1}}],["第一种是已知完全安全且不存在歧义的普通类型转换",{"2":{"40":1}}],["第3个元素为",{"2":{"76":1}}],["第2个元素为",{"2":{"76":1}}],["第",{"2":{"76":1}}],["第三种是对等类型解析",{"2":{"40":1}}],["第三方库",{"0":{"39":1},"2":{"39":1}}],["特点",{"0":{"295":1}}],["特殊看待",{"2":{"145":1}}],["特别是在程序设计语言中",{"2":{"40":1}}],["特性的分配器模型",{"2":{"29":1}}],["特性一直为人们所吐槽",{"2":{"24":1}}],["允许函数处理各种数据",{"2":{"293":1}}],["允许预测",{"2":{"191":1}}],["允许构建器读取来自命令行参数的构建优化模式",{"2":{"185":1}}],["允许构建器读取来自命令行参数的构建目标三元组",{"2":{"185":1}}],["允许编译器在编译时显示生成所有分支",{"2":{"175":1}}],["允许我们通过非常规的方式来声明一个类型",{"2":{"260":1}}],["允许我们通过一个整数来反推一个枚举",{"2":{"72":1}}],["允许我们观察已有的类型",{"2":{"250":1}}],["允许我们将一些信息传递到项目中",{"2":{"188":1}}],["允许我们获取字段指针",{"2":{"99":1}}],["允许我们不列出所有的枚举值",{"2":{"72":1}}],["允许自动转换为错误联合类型",{"2":{"47":1}}],["允许自动转换为可选类型",{"2":{"46":1}}],["允许直接将数组的指针赋值给切片",{"2":{"45":1}}],["允许",{"2":{"39":1}}],["允许地址为",{"2":{"20":1}}],["吃豆人游戏的",{"2":{"39":1}}],["斯沃克兰的传说",{"2":{"39":1}}],["游戏",{"2":{"39":1}}],["游泳起来像鸭子",{"2":{"7":1}}],["kelley",{"2":{"293":1}}],["kernel32",{"2":{"116":1}}],["kernel",{"2":{"4":1}}],["k",{"2":{"43":2}}],["koino",{"2":{"39":1}}],["依赖上方构建的",{"2":{"191":1}}],["依赖step",{"2":{"190":1}}],["依赖它即可",{"2":{"186":1}}],["依赖于前面的运行",{"2":{"195":1,"196":1}}],["依赖于构建",{"2":{"195":1,"196":1}}],["依赖于",{"2":{"186":1,"193":1,"194":1}}],["依赖一个库",{"2":{"186":1}}],["依赖项",{"2":{"35":1}}],["依次线性排列",{"2":{"54":1}}],["依托于",{"2":{"39":1,"92":1}}],["速度极快的",{"2":{"39":1}}],["相对于build",{"2":{"195":1,"196":1}}],["相对来说",{"2":{"145":1}}],["相同",{"2":{"60":1,"193":1}}],["相等",{"2":{"43":2,"45":1}}],["相关的社区",{"2":{"38":1}}],["相当于是",{"2":{"75":1}}],["相当于",{"2":{"15":2}}],["社区",{"0":{"38":1}}],["需要使用",{"2":{"249":1}}],["需要手动编译gtkmm",{"2":{"196":1}}],["需要手动显式指定转发",{"2":{"37":1}}],["需要在编译期执行循环",{"2":{"166":1}}],["需要在编译期已知矩阵",{"2":{"127":1}}],["需要注意的是",{"2":{"178":1,"254":1,"261":1}}],["需要注意的是如果他们在",{"2":{"135":1}}],["需要注意",{"2":{"161":1}}],["需要两个矩阵",{"2":{"127":1}}],["需要保证",{"2":{"15":1}}],["且返回类型",{"2":{"264":2}}],["且返回非类型",{"2":{"264":3}}],["且该类型是零位类型",{"2":{"291":1}}],["且该类型必须具有明确的大小",{"2":{"81":1}}],["且该包自己有",{"2":{"37":1}}],["且不存在歧义",{"2":{"41":1}}],["且测试​​结果并不理想",{"2":{"2":1}}],["方法",{"2":{"89":1}}],["方法来访问包的链接库和暴露的",{"2":{"37":1}}],["方式",{"2":{"20":1}}],["即当可以立即从命名推断出其用途时",{"2":{"265":1}}],["即使是只有",{"2":{"264":1}}],["即使使用",{"2":{"201":1}}],["即定义的变量",{"2":{"261":1}}],["即便此时还没有新的稳定版",{"2":{"211":1}}],["即便对应的部分不存在也需要有冒号",{"2":{"4":1}}],["即被",{"2":{"200":1}}],["即默认的",{"2":{"186":1}}],["即实际的运行",{"2":{"186":1,"193":1,"194":1}}],["即尽可能使用常量",{"2":{"139":1}}],["即超集不是子集",{"2":{"131":1}}],["即",{"2":{"105":1,"152":1,"267":1}}],["即可",{"2":{"82":1,"111":1,"192":1,"215":1}}],["即引入该包的项目均可看到该包的构建结果",{"2":{"36":1}}],["同样可以解构错误联合类型",{"2":{"168":1}}],["同样不推荐使用",{"2":{"160":1,"165":1}}],["同样支持捕获指针来操作值",{"2":{"152":1}}],["同样也容纳",{"2":{"43":1}}],["同之前",{"2":{"127":1}}],["同上",{"2":{"127":1}}],["同理",{"2":{"36":1}}],["同时不像其他语言那样对运行时安全性的要求",{"2":{"293":1}}],["同时还提供现代功能",{"2":{"293":1}}],["同时还利用了",{"2":{"66":1}}],["同时它也是",{"2":{"175":1}}],["同时",{"2":{"68":1,"76":1,"77":1,"122":1,"129":1,"139":1,"292":1}}],["同时这也是为什么",{"2":{"25":1}}],["同时其他的参数和返回值类型也都是",{"2":{"7":1}}],["编程更简单",{"2":{"293":1}}],["编辑器之神",{"2":{"208":1}}],["编辑器选择",{"0":{"204":1},"1":{"205":1,"206":1,"207":1,"208":1,"209":1,"210":1}}],["编码的",{"2":{"61":1}}],["编码",{"2":{"61":1,"62":1}}],["编写的窗口管理器",{"2":{"39":1}}],["编写的俄罗斯方块",{"2":{"39":1}}],["编写的",{"2":{"39":2}}],["编写包",{"0":{"36":1}}],["编译的系统编程语言",{"2":{"293":1}}],["编译时的",{"2":{"231":1}}],["编译时检测出错误则直接停止编译",{"2":{"124":1}}],["编译系统",{"2":{"207":1}}],["编译器假设永远不会执行到",{"2":{"176":1}}],["编译器这里不能是一个",{"2":{"145":1}}],["编译器自行推导而出",{"2":{"136":1}}],["编译器自动进行推断",{"2":{"71":1}}],["编译器会返回错误或者值",{"2":{"232":1}}],["编译器会添加一些随机因素进入到程序中",{"2":{"184":1}}],["编译器会帮我们完成其余的工作",{"2":{"174":1}}],["编译器会做一个额外的工作",{"2":{"129":1}}],["编译器会直接将切片优化为数组指针",{"2":{"76":1}}],["编译器对于除零的处理是分别在编译期和运行时",{"2":{"124":1}}],["编译器将自动忽略该返回值",{"2":{"111":1}}],["编译器将会报告错误",{"2":{"9":1}}],["编译器推断出类型即可",{"2":{"91":1}}],["编译器进行严格的计算",{"2":{"70":1}}],["编译器还不会对字节进行修改",{"2":{"61":1}}],["编译器来推导",{"2":{"49":1}}],["编译器来自动推导",{"2":{"49":1}}],["编译器来供",{"2":{"24":1}}],["编译器",{"2":{"39":1}}],["编译器的替代品使用",{"2":{"24":1}}],["编译后的结果是这个样子",{"2":{"7":1}}],["编译期的特性",{"2":{"261":1}}],["编译期的整数",{"2":{"122":1}}],["编译期配置",{"0":{"188":1}}],["编译期进行推倒",{"2":{"178":1}}],["编译期反射访问可选类型",{"0":{"146":1}}],["编译期仍然会给你检测",{"2":{"145":1}}],["编译期初始化数组",{"0":{"66":1}}],["编译期已知的数字",{"2":{"48":1}}],["编译期数字",{"0":{"48":1}}],["编译期表达式",{"0":{"9":1},"2":{"171":1}}],["编译期变量",{"0":{"8":1}}],["编译期参数实现鸭子类型",{"0":{"7":1}}],["编译期间执行的动作",{"2":{"6":1}}],["编译期是指在",{"2":{"6":1}}],["编译期",{"0":{"6":1,"87":1},"1":{"7":1,"8":1,"9":1,"10":1},"2":{"60":1,"124":1,"141":1,"295":1}}],["版本是最新的",{"2":{"292":1}}],["版本加入",{"2":{"228":1}}],["版本的",{"2":{"223":1,"224":1,"230":1}}],["版本控制系统",{"2":{"205":1}}],["版本不允许使用不会被修改的变量",{"2":{"139":1}}],["版本",{"2":{"39":1,"207":1,"208":1,"211":2,"213":1,"215":1,"219":1,"220":1,"292":1}}],["版本支持两种打包格式的源文件",{"2":{"35":1}}],["版本新引入的",{"2":{"35":1}}],["版本尚未发布1",{"2":{"0":1}}],["新的优化和各种安全机制",{"2":{"293":1}}],["新的文件结构",{"0":{"35":1}}],["新引入的一种简单数据交换格式",{"2":{"35":1}}],["新类型",{"2":{"20":1}}],["然后再通过",{"2":{"254":1}}],["然后在",{"2":{"34":1}}],["然后提供",{"2":{"33":1}}],["添加参数",{"2":{"194":1}}],["添加",{"2":{"188":1,"190":1,"195":1,"196":1}}],["添加一个匿名的依赖",{"2":{"193":1,"194":1}}],["添加一个匿名模块即可",{"2":{"193":1}}],["添加一个依赖项",{"2":{"185":1}}],["添加一个二进制可执行程序构建",{"2":{"185":1,"186":1,"187":1,"188":1,"189":1,"191":1,"193":1,"194":1,"195":1,"196":1}}],["添加到顶级",{"2":{"185":1,"186":1,"187":1,"188":1,"189":1,"191":1,"193":1,"194":1,"195":1,"196":1}}],["添加更多关于该类型使用的示例和说明",{"2":{"75":1}}],["添加包的元信息",{"2":{"34":1}}],["添加汇编文件",{"2":{"3":1}}],["zvm",{"2":{"220":2}}],["zip",{"2":{"189":2}}],["zig`",{"2":{"238":1}}],["zigzig",{"2":{"228":1}}],["zigup",{"2":{"220":1}}],["zigtools",{"2":{"208":1}}],["zigtest",{"2":{"44":1,"245":1,"266":1}}],["zigbrains",{"2":{"207":1}}],["zigbuild",{"2":{"188":1,"194":1}}],["zigvs",{"2":{"206":1}}],["zigvar",{"2":{"45":3,"143":1,"151":1,"152":2,"155":1,"159":1,"160":2,"162":1,"163":2,"165":1,"170":1,"192":1,"286":1}}],["zigmain",{"2":{"196":1}}],["zigsrc",{"2":{"195":1}}],["zighello",{"2":{"193":1}}],["zigwhile",{"2":{"167":1,"168":1}}],["zigfor",{"2":{"156":1}}],["zigfn",{"2":{"7":3,"10":1,"36":1,"37":2,"53":4,"92":1,"111":1,"115":1,"118":1,"134":4,"135":2,"164":1,"175":1,"186":1}}],["zigif",{"2":{"152":1}}],["zigcomptime",{"2":{"124":1}}],["zigconst",{"2":{"3":1,"8":1,"9":2,"13":1,"21":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"43":1,"45":1,"46":1,"47":1,"48":1,"49":1,"51":1,"53":3,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"68":2,"69":1,"70":1,"71":1,"72":1,"73":1,"74":1,"76":1,"77":1,"78":1,"80":1,"81":2,"82":1,"85":2,"86":1,"87":1,"89":2,"90":4,"91":1,"93":1,"94":2,"95":1,"99":3,"100":1,"102":1,"103":1,"104":1,"105":1,"106":1,"108":2,"124":1,"126":2,"129":1,"130":2,"132":1,"134":1,"139":1,"140":1,"141":1,"142":1,"145":1,"146":1,"148":1,"149":2,"151":1,"152":2,"153":1,"155":1,"157":1,"158":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"171":1,"172":2,"173":2,"174":1,"175":1,"176":1,"178":3,"179":3,"180":1,"185":1,"186":1,"187":1,"188":2,"189":2,"190":1,"191":1,"193":2,"194":2,"195":1,"196":1,"199":1,"200":1,"230":1,"232":2,"244":1,"249":1,"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"261":1,"270":1,"271":1,"280":1,"281":1,"282":1}}],["zigexport",{"2":{"117":1}}],["zigextern",{"2":{"116":1,"117":1,"145":1}}],["zig的标准库",{"2":{"61":1}}],["zig的",{"2":{"39":1}}],["ziggit",{"2":{"38":1}}],["ziglang",{"2":{"22":1,"184":1}}],["zigptr",{"2":{"20":2}}],["zigpub",{"2":{"4":1,"19":1,"111":1,"161":1,"166":1,"185":1,"200":1,"249":1}}],["zigasm",{"2":{"4":1}}],["zig",{"0":{"23":1,"24":1,"221":1,"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"293":1,"294":1},"1":{"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"294":1,"295":1,"296":1},"2":{"0":2,"1":1,"2":2,"3":4,"4":2,"6":4,"7":1,"8":3,"10":1,"11":7,"12":1,"13":5,"14":4,"15":1,"17":10,"18":4,"19":3,"20":4,"21":2,"23":5,"24":8,"25":6,"30":1,"32":2,"33":2,"34":4,"35":8,"36":4,"37":4,"38":4,"39":15,"40":1,"41":2,"44":3,"49":2,"53":2,"54":1,"55":3,"61":3,"64":1,"68":2,"70":1,"71":1,"72":1,"73":1,"79":3,"82":2,"84":1,"85":1,"88":1,"90":3,"91":2,"92":1,"96":3,"97":1,"99":2,"100":2,"102":3,"105":1,"106":1,"108":2,"109":1,"111":4,"112":2,"119":1,"122":3,"124":15,"125":1,"126":2,"127":2,"128":2,"129":1,"130":1,"133":2,"136":2,"137":1,"139":3,"140":1,"141":1,"142":1,"143":1,"144":6,"145":9,"148":1,"149":1,"154":1,"164":1,"175":1,"178":3,"179":1,"180":1,"183":3,"184":4,"185":9,"186":5,"187":3,"188":5,"189":6,"190":1,"191":6,"192":5,"193":7,"194":8,"195":4,"196":5,"199":7,"200":2,"201":1,"205":2,"207":4,"208":8,"209":2,"210":2,"211":2,"212":1,"213":4,"214":3,"215":4,"216":3,"217":2,"218":9,"219":2,"220":16,"221":3,"222":1,"223":10,"224":13,"228":3,"230":7,"231":8,"232":4,"234":1,"235":1,"237":1,"239":1,"240":1,"241":1,"242":1,"247":1,"248":2,"249":1,"250":1,"251":1,"252":1,"253":1,"254":2,"260":1,"261":2,"264":3,"266":23,"271":1,"285":1,"292":14,"293":3,"294":2,"295":1,"296":4}}],["zz",{"2":{"53":3,"171":3}}],["z",{"2":{"45":2,"105":1,"132":2,"189":1,"257":4}}],["z2",{"2":{"45":1}}],["z1",{"2":{"45":1}}],["zero",{"2":{"44":1,"68":1,"86":2,"124":10,"285":1,"290":1}}],["zls",{"2":{"39":1,"208":7,"209":1}}],["zld",{"2":{"39":1}}],["zap",{"2":{"39":1}}],["zon",{"2":{"34":1,"35":2,"37":1,"228":1}}],["终于迎来了一个正式的官方包管理器",{"2":{"34":1}}],["接着上面的函数写",{"2":{"133":2}}],["接口来实现自己的分配器",{"2":{"33":1}}],["接下来加深一点难度",{"2":{"232":1}}],["接下来",{"2":{"232":1}}],["接下来就了解一下基本的",{"2":{"221":1}}],["接下来我们演示以下切片的使用方式",{"2":{"76":1}}],["接下来我们介绍具体的内部结构",{"2":{"4":1}}],["接下来展示一个例子",{"2":{"13":1}}],["接下来讲解一下它们的组成和使用",{"2":{"4":1}}],["源码位于",{"2":{"199":1}}],["源码的命名方式",{"2":{"111":1}}],["源代码路径",{"2":{"195":1,"196":1}}],["源代码文件可以使用",{"2":{"196":1}}],["源代码文件",{"2":{"195":2,"196":2}}],["源代码",{"2":{"194":1,"195":1}}],["源代码可以参考这里memory",{"2":{"32":1}}],["源文件带后缀",{"2":{"231":1}}],["源文件",{"2":{"231":1}}],["源文件准备的",{"2":{"195":1,"196":1}}],["源文件地址",{"2":{"189":1}}],["源文件内容的",{"2":{"35":1}}],["源文件本身都是容器",{"2":{"3":1,"248":1}}],["再进行学习",{"2":{"292":1}}],["再进一步",{"2":{"24":1}}],["再来一个简单的例子告诉你",{"2":{"232":1}}],["再将以下内容覆写到",{"2":{"230":1}}],["再说明如何手动安装",{"2":{"217":1}}],["再使用",{"2":{"195":1}}],["再解构可选类型",{"2":{"152":1}}],["再转换为多项指针",{"2":{"45":1}}],["再相除",{"2":{"44":2}}],["再申请一快内存",{"2":{"32":1}}],["连续申请三块内存",{"2":{"32":1}}],["既然我们经常要分配内存",{"2":{"32":1}}],["消除频繁调用内存分配和释放函数所带来的开销问题",{"2":{"32":1}}],["库或者实现",{"2":{"296":1}}],["库集成",{"2":{"295":1}}],["库导入",{"2":{"293":1}}],["库的名字",{"2":{"189":1}}],["库的内存分配",{"2":{"30":1}}],["库b",{"2":{"186":1}}],["库获取对应的",{"2":{"179":1}}],["库",{"2":{"39":1,"190":1,"195":2,"196":1}}],["库时引入头文件",{"2":{"16":1}}],["才会执行",{"2":{"135":1}}],["才会涉及到使用汇编语言",{"2":{"2":1}}],["才有效",{"2":{"29":1}}],["善后工作",{"2":{"29":1}}],["操作来处理计算",{"2":{"271":1}}],["操作作为依赖添加到",{"2":{"190":1}}],["操作如下",{"2":{"190":1}}],["操作的检测和堆栈跟踪",{"2":{"125":1}}],["操作的构建结果均会被暴露出去",{"2":{"36":1}}],["操作",{"0":{"58":1},"1":{"59":1,"60":1},"2":{"28":1,"160":1,"165":1}}],["操作系统内核",{"2":{"25":1}}],["获取错误时",{"2":{"277":1}}],["获取类型信息",{"2":{"254":1}}],["获取writer句柄",{"2":{"232":1}}],["获取buffer",{"2":{"232":1}}],["获取有关推断类型的信息",{"2":{"115":1}}],["获取了",{"2":{"85":1}}],["获取内存对齐信息",{"2":{"85":1}}],["获取内存allocator",{"2":{"27":2}}],["获取指针指向的地址",{"2":{"52":1}}],["获取浮点数的整数部分",{"2":{"52":1}}],["获取对应错误的整数值",{"2":{"52":1}}],["获取",{"2":{"37":1}}],["获取包提供的模块",{"2":{"37":1}}],["获取包构建的library",{"2":{"37":1}}],["获取包",{"2":{"37":1}}],["获取分配器模型",{"2":{"29":1}}],["获取分配器",{"2":{"28":1,"29":1}}],["获取线程安全的内存allocator",{"2":{"27":1}}],["延后释放内存",{"2":{"26":1}}],["拿到一个allocator",{"2":{"26":1,"28":1}}],["用比喻来说",{"2":{"250":1}}],["用户可以更改主题和键盘快捷方式实现个性化设置",{"2":{"205":1}}],["用来获取它们的长度",{"2":{"81":1}}],["用起来和",{"2":{"30":1}}],["用这个准没错",{"2":{"26":1}}],["用于维护健壮",{"2":{"293":1}}],["用于获取变量",{"2":{"257":1}}],["用于返回一个容器中是否包含指定名字的声明",{"2":{"255":1}}],["用于转发声明",{"2":{"249":1}}],["用于创建一个内存屏障",{"2":{"242":1}}],["用于原子化的修改值并返回修改前的值",{"2":{"239":1}}],["用于对某个类型指针进行原子化的赋值",{"2":{"238":1}}],["用于某个类型指针进行原子化的读取值",{"2":{"237":1}}],["用于错误输出",{"2":{"232":1}}],["用于正常的输出",{"2":{"232":1}}],["用于将包添加到全局缓存并打印包的hash",{"2":{"228":1}}],["用于将多个数据表示为一个整体",{"2":{"88":1}}],["用于格式化代码源文件",{"2":{"226":1}}],["用于当",{"2":{"199":1}}],["用于便捷地添加多个源文件",{"2":{"195":1,"196":1}}],["用于执行测试",{"2":{"191":1}}],["用于执行general",{"2":{"26":1,"28":1}}],["用于给函数",{"2":{"144":1}}],["用于限制变量声明的范围",{"2":{"143":1}}],["用于来离开作用域前清理掉tmp",{"2":{"135":1}}],["用于在出现错误时直接向上层返回错误",{"2":{"134":1}}],["用于发生错误时提供一个默认值",{"2":{"133":1}}],["用于表示一个圆",{"2":{"89":1}}],["用于比较字节",{"2":{"61":1}}],["用于",{"2":{"39":1}}],["用于控制预处理器指令并引入头文件",{"2":{"13":1}}],["用于通知编译器",{"2":{"4":1}}],["怎么到这里这么多的",{"2":{"25":1}}],["除数为零是也是非法的",{"2":{"273":1}}],["除此以外",{"2":{"271":1}}],["除法",{"2":{"124":1,"125":4}}],["除",{"2":{"124":1,"271":1}}],["除零是非法操作",{"2":{"273":1}}],["除零操作",{"0":{"273":1}}],["除零",{"0":{"124":1},"2":{"124":1,"125":1}}],["除非",{"2":{"270":1}}],["除非是一个",{"2":{"264":1}}],["除非需要换行",{"2":{"263":1}}],["除非你的程序逻辑有问题",{"2":{"184":1}}],["除非你有把握每次都能正确的处理它们",{"2":{"76":1}}],["除非函数本身在编译时被调用",{"2":{"9":1}}],["除了获取类型信息外",{"2":{"260":1}}],["除了基本的分配",{"2":{"32":1}}],["除了这些",{"2":{"25":1}}],["除了这六种内存分配模型外",{"2":{"25":1}}],["开发时过重的心智负担",{"2":{"184":1}}],["开发中最难以调试的",{"2":{"25":1}}],["开始学习其他语言的",{"2":{"230":1}}],["开始",{"2":{"55":1,"105":3}}],["开头将会是",{"2":{"199":1}}],["开头",{"2":{"4":1,"140":1,"231":1}}],["完善的堆栈跟踪",{"2":{"295":1}}],["完全是编译期计算的",{"2":{"255":1,"256":1}}],["完全由程序员管理内存",{"2":{"25":1}}],["完整堆栈跟踪生效的三个方式",{"2":{"137":1}}],["完整的工具链的大小多达好几百",{"2":{"23":1}}],["完整的构架目标三元组可以在这里",{"2":{"15":1}}],["宣称的非常方便的交叉编译说拜拜了",{"2":{"24":1}}],["能",{"2":{"24":1}}],["能静态链接",{"0":{"24":1}}],["吗",{"0":{"24":1},"2":{"25":1}}],["分隔",{"2":{"253":1}}],["分割的多匹配",{"2":{"171":1}}],["分别代表标准库",{"2":{"231":1}}],["分别会捕获错误和有效负载",{"2":{"168":1}}],["分别可以执行单个语句和一个块",{"2":{"153":1}}],["分别是普通注释",{"2":{"144":1}}],["分别是",{"2":{"109":1,"111":1,"129":1,"207":1}}],["分支",{"2":{"170":1,"175":1}}],["分支执行",{"2":{"168":1}}],["分支捕获的是错误",{"2":{"152":1}}],["分支并非必要",{"2":{"151":1}}],["分配内存",{"2":{"29":1}}],["分发的",{"2":{"23":1}}],["分段分页",{"2":{"2":1}}],["4558e134302b78f1a543202d094b3e06",{"2":{"266":1}}],["45mb",{"2":{"23":1}}],["41",{"2":{"199":4}}],["415808",{"2":{"196":1}}],["411985",{"2":{"196":1}}],["432192",{"2":{"196":1}}],["431376",{"2":{"196":1}}],["431424",{"2":{"196":1}}],["43",{"2":{"179":1}}],["47",{"2":{"149":2}}],["4294967296",{"2":{"282":1}}],["428369",{"2":{"196":1}}],["427089",{"2":{"196":1}}],["42",{"2":{"115":1,"179":3,"180":1,"199":2,"264":1,"281":1}}],["4x4",{"2":{"56":2}}],["4",{"2":{"44":1,"45":1,"49":2,"56":2,"57":3,"60":2,"68":1,"70":1,"76":2,"77":1,"81":3,"85":9,"90":1,"99":2,"102":8,"103":1,"104":1,"105":2,"106":7,"124":1,"149":2,"155":3,"157":2,"158":1,"159":1,"161":4,"196":3,"257":2,"280":2}}],["40",{"2":{"23":1,"196":1}}],["个字母的首字母缩略词也受这些约定的约束",{"2":{"264":1}}],["个月",{"2":{"211":1}}],["个元素为",{"2":{"76":1}}],["个",{"2":{"23":1}}],["目录名称也应使用",{"2":{"264":1}}],["目前情况来看",{"2":{"292":1}}],["目前的语法均是围绕着语义明确化",{"2":{"292":1}}],["目前插件市场活跃的两个",{"2":{"207":1}}],["目前最轻量且生态丰富的编辑器",{"2":{"205":1}}],["目前有以下几种编辑器推荐",{"2":{"204":1}}],["目前",{"2":{"128":1,"235":1,"292":1}}],["目前为止",{"2":{"35":1,"220":1}}],["目前仅限",{"2":{"23":1}}],["目标机器",{"2":{"108":1}}],["目标为嵌入式系统与移动设备",{"2":{"24":1}}],["目标上",{"2":{"20":1}}],["目标和",{"2":{"17":1}}],["更何况",{"2":{"292":1}}],["更为完善的生态",{"2":{"292":1}}],["更高效的错误跟踪",{"2":{"292":1}}],["更进一步",{"0":{"233":1}}],["更改系统区域设置",{"2":{"212":1}}],["更改类型但保持位不变",{"2":{"52":1}}],["更加进阶的错误处理方案",{"2":{"134":1}}],["更复杂的例子",{"2":{"90":1}}],["更多能拿得出手的代表项目",{"2":{"292":1}}],["更多的类型我们在后面会详细说明",{"2":{"231":1}}],["更多的内建函数文档请看",{"2":{"113":1}}],["更多是在指针上使用",{"2":{"145":1}}],["更多是为了代替需要使用宏",{"2":{"8":1}}],["更多示例说明",{"2":{"37":1}}],["更好的编译",{"0":{"23":1}}],["为何使用",{"0":{"294":1}}],["为空或者字段均为零位类型时",{"2":{"290":1}}],["为稳定版本",{"2":{"208":1}}],["为基础设计的",{"2":{"207":1}}],["为前缀",{"2":{"113":1}}],["为我们提供了并行操纵一组同类型",{"2":{"101":1}}],["为",{"2":{"44":2,"86":1,"105":1,"106":1,"186":1,"193":1,"194":1}}],["为了处理这些情况",{"2":{"271":1}}],["为了实现性能和必要保证之间的平衡",{"2":{"236":1}}],["为了仅检测错误",{"2":{"152":1}}],["为了获得最佳的性能",{"2":{"95":1}}],["为了方便处理",{"2":{"61":1}}],["为了做到这一点",{"2":{"33":1}}],["为了构建这个",{"2":{"13":1}}],["为什么要再学习一门如此",{"2":{"292":1}}],["为什么是作用域顶层呢",{"2":{"144":1}}],["为什么呢",{"2":{"61":1}}],["为什么不回收内存来给新的申请使用而不是释放内存呢",{"2":{"32":1}}],["为什么",{"0":{"23":1}}],["报错并通知出现了未定义行为",{"2":{"20":1}}],["此外",{"2":{"293":1}}],["此风格指南来自官方的",{"2":{"262":1}}],["此声明可以被检测到是因为类型和代码处于同一个文件中",{"2":{"255":1}}],["此方法允许添加多个参数",{"2":{"194":1}}],["此操作允许用户通过构建系统的命令传递参数",{"2":{"186":1}}],["此步骤不是必要的",{"2":{"186":1}}],["此行为只是一种实现功能",{"2":{"142":1}}],["此函数会返回一个当前包裹它的容器的类型",{"2":{"90":1}}],["此处",{"2":{"261":1}}],["此处并不是拼写错误",{"2":{"215":1}}],["此处将编译后的zls直接覆盖mason的zls",{"2":{"208":1}}],["此处测试由于未被引用",{"2":{"200":1}}],["此处开始构建单元测试",{"2":{"191":1}}],["此处是普通注释",{"2":{"144":1}}],["此处也是一个文档注释",{"2":{"144":1}}],["此处假定这个错误不会发生",{"2":{"134":1}}],["此处仅仅是简单提及一下该特性",{"2":{"92":1}}],["此处可以看",{"2":{"90":1}}],["此处歧义为两种情况",{"2":{"44":1}}],["此处的意思是如果有返回值",{"2":{"232":1}}],["此处的",{"2":{"4":1}}],["此前已知是通过第三方包管理器下载并处理包",{"2":{"34":1}}],["此时结构体也是零位类型",{"2":{"290":1}}],["此时与数组",{"2":{"288":1}}],["此时程序或者编译器会停止并发出警告",{"2":{"272":1}}],["此时它被视为一个命名空间",{"2":{"264":1}}],["此时它是一个多项指针",{"2":{"20":1}}],["此时它是单项指针",{"2":{"20":1}}],["此时我们就分别得到了使用缓冲区的",{"2":{"232":1}}],["此时我们可以再指定构建库",{"2":{"186":1}}],["此时控制权会切换回内核",{"2":{"232":1}}],["此时需要搭配",{"2":{"164":1}}],["此时变量的值将会是无意义的值",{"2":{"142":1}}],["此时p2和p4指向同一块内存",{"2":{"32":1}}],["此时会触发安全检查的保护机制",{"2":{"20":1}}],["支持有关",{"2":{"293":1}}],["支持stdin和指定路径",{"2":{"226":1}}],["支持指定文件和标准输入",{"2":{"225":1}}],["支持交叉编译到任何",{"2":{"192":1}}],["支持我们从命令行构建时指定构建模式",{"2":{"189":1}}],["支持我们从命令行构建时指定构建目标",{"2":{"189":1}}],["支持编译期运算",{"2":{"171":1}}],["支持任何已知的最大",{"2":{"102":1}}],["支持任意位宽的整数",{"2":{"99":1,"122":1}}],["支持在一个",{"2":{"36":1}}],["支持通过",{"2":{"35":1}}],["支持静态链接",{"2":{"24":1}}],["支持外部",{"2":{"21":1}}],["支持和整数进行比较",{"2":{"20":1}}],["支持与整数进行强制转换",{"2":{"20":1}}],["支持",{"2":{"20":1}}],["支持仅使用",{"2":{"10":1}}],["具有",{"2":{"126":1}}],["具有较大对齐大小的指针可以隐式转换为具有较小对齐大小的指针",{"2":{"85":1}}],["具有以下特点",{"2":{"20":1}}],["具体原因见此",{"2":{"261":1}}],["具体细节可以查看内存屏障的相关信息",{"2":{"242":1}}],["具体",{"2":{"239":1}}],["具体安装方法见",{"2":{"195":1}}],["具体见",{"2":{"182":1}}],["具体见这里",{"2":{"153":1}}],["具体见此",{"2":{"4":1}}],["具体的堆栈跟踪实现细节可以看这里",{"2":{"137":1}}],["具体的信息可见这里",{"2":{"137":1}}],["具体可以参考该",{"2":{"196":1}}],["具体可以参照以下例子",{"2":{"108":1}}],["具体可以见",{"2":{"181":1}}],["具体可以看下面的示例",{"2":{"57":1}}],["具体如下",{"2":{"94":1}}],["具体问题可以见这个",{"2":{"9":1}}],["头文件后",{"2":{"20":1}}],["错误堆栈跟踪显示代码中将错误返回到调用函数的所有点",{"2":{"137":1}}],["错误集在这里被保留在",{"2":{"132":1}}],["错误集合转为超集",{"2":{"42":1}}],["错误处理",{"0":{"128":1},"1":{"129":1,"130":1,"131":1,"132":1,"133":1,"134":1,"135":1,"136":1,"137":1}}],["错误联合类型如果是",{"2":{"276":1}}],["错误联合类型的载荷",{"2":{"47":1}}],["错误联合类型",{"0":{"47":1,"132":1},"1":{"133":1,"134":1,"135":1,"136":1}}],["错误联合可选类型也可以",{"2":{"46":1}}],["错误联合可选类型也有效",{"2":{"45":1}}],["错误",{"2":{"19":1}}],["故会引起程序或者编译器报错",{"2":{"273":1}}],["故会直接出现报错",{"2":{"269":1}}],["故值也是编译期已知的",{"2":{"255":1,"256":1}}],["故函数",{"2":{"252":1}}],["故只能在",{"2":{"196":1}}],["故只有在使用它们时才会报告编译错误",{"2":{"18":1}}],["故可能一个函数被推导出",{"2":{"136":1}}],["故可以直接转换",{"2":{"49":1}}],["故不进行系统讲解",{"2":{"113":1}}],["故你可以暂时略过这里",{"2":{"82":1}}],["故称为",{"2":{"82":1}}],["故是不同的类型",{"2":{"75":1}}],["故我们这里选择构建一个",{"2":{"196":1}}],["故我们可以在下面使用inline",{"2":{"175":1}}],["故我们可以使用下标来访问数组的元素",{"2":{"55":1}}],["故我们无需专门为编译期表达式编写函数",{"2":{"9":1}}],["故仅可在",{"2":{"29":1}}],["故",{"2":{"20":1}}],["那肯定要有指针的",{"2":{"79":1}}],["那就会发生",{"2":{"134":1}}],["那就代表你目前无需了解以下部分",{"2":{"97":1}}],["那就是确定错误的数量",{"2":{"129":1}}],["那就是",{"2":{"41":1,"111":1}}],["那就可以正常使用",{"2":{"18":1}}],["那么会触发非法行为",{"2":{"281":1}}],["那么会触发完整的堆栈跟踪",{"2":{"267":1}}],["那么会导致程序或者编译器报告错误",{"2":{"278":1,"279":1}}],["那么会导致程序或编译器报错",{"2":{"277":1}}],["那么会导致出现错误",{"2":{"275":1}}],["那么会自动进行转换",{"2":{"48":1}}],["那么使用",{"2":{"264":1}}],["那么赋值为参数的新值",{"2":{"240":1,"241":1}}],["那么此时的解决方式就如下",{"2":{"232":1}}],["那么建议将",{"2":{"212":1}}],["那么emacs就是神的编辑器",{"2":{"209":1}}],["那么我们可以在构建",{"2":{"186":1}}],["那么请使用",{"2":{"140":1}}],["那么它会自动被构建",{"2":{"189":1}}],["那么它将不会执行默认的初始化操作",{"2":{"142":1}}],["那么它们会在",{"2":{"135":1}}],["那么它以返回的函数命名",{"2":{"100":1}}],["那么",{"2":{"135":1,"152":1,"266":1}}],["那么如何假定函数不会返回错误呢",{"2":{"134":1}}],["那么你需要自己实现相关的结构体了",{"2":{"127":1}}],["那么以下",{"2":{"108":1}}],["那么指针也可以在编译期发挥作用",{"2":{"87":1}}],["那么本节内容你可以跳过了",{"2":{"85":1}}],["那么这里你可以略过",{"2":{"84":1}}],["那么这只鸟就可以被称为鸭子",{"2":{"7":1}}],["那么可以使用该命令",{"2":{"224":1}}],["那么可以使用",{"2":{"37":1}}],["那么推荐你使用这个",{"2":{"28":1}}],["仅具有一种可能类型",{"2":{"291":1}}],["仅作为一份参考",{"2":{"262":1}}],["仅需要安装",{"2":{"205":1}}],["仅在函数作用域返回错误时",{"2":{"135":1}}],["仅在对应章节说明涉及到的内建函数",{"2":{"113":1}}],["仅有一位",{"2":{"99":1}}],["仅仅一个示例不足以说明",{"2":{"254":1}}],["仅仅执行了类型计算",{"2":{"252":1}}],["仅仅是",{"2":{"207":1}}],["仅仅是宏",{"2":{"19":1}}],["仅仅讲述的少量内容",{"2":{"84":1}}],["仅当完全明确如何从一种类型转换为另一种类型并且保证转换安全时才允许自动转换",{"2":{"41":1}}],["仅依赖这个符号库",{"2":{"23":1}}],["仅存在函数的声明",{"2":{"18":1}}],["仅添加参数",{"2":{"15":1}}],["宏",{"2":{"18":2}}],["拼接",{"2":{"18":1}}],["会要求你显示传递和管理你的内存",{"2":{"295":1}}],["会导致编译器错误",{"2":{"280":1}}],["会编译失败并触发堆栈跟踪",{"2":{"266":1}}],["会发出编译错误并停止继续编译",{"2":{"266":1}}],["会触发编译器错误",{"2":{"252":1}}],["会触发未定义行为",{"2":{"20":1}}],["会自动为我们根据后面的参量表推导出对应的类型",{"2":{"231":1}}],["会自动使用包的",{"2":{"228":1}}],["会自动搜索当前目录及父目录的",{"2":{"222":1}}],["会自动下载最新的zls并配置好",{"2":{"208":1}}],["会写到",{"2":{"220":2}}],["会假定其参数为",{"2":{"199":1}}],["会在编译时转为一个规范的",{"2":{"188":1}}],["会在经过预处理器加工后的代码上进行翻译",{"2":{"19":1}}],["会给顶层的",{"2":{"185":1}}],["会通过该文件对整个项目进行构建操作",{"2":{"185":1}}],["会调用",{"2":{"176":1}}],["会先尝试解构错误联合类型",{"2":{"152":1}}],["会被自动添加进环境变量",{"2":{"213":1}}],["会被自动转换",{"2":{"45":1}}],["会被视作地址",{"2":{"147":1}}],["会将错误堆栈跟踪输出到标准错误输出",{"2":{"199":1}}],["会将",{"2":{"145":1}}],["会将字符串假定为",{"2":{"61":1}}],["会从块中返回一个值出来",{"2":{"143":1}}],["会执行",{"2":{"135":1}}],["会尝试计算联合类型表达式",{"2":{"134":1}}],["会尝试自动计算数组的长度",{"2":{"55":1}}],["会只使用它们的位宽",{"2":{"99":1}}],["会为每个值分配一个整数的字段名",{"2":{"96":1}}],["会尽量转换为所有对等类型可以转换成的类型",{"2":{"53":1}}],["会尽量将类似函数的宏定义转为对应的",{"2":{"19":1}}],["会优先使用",{"2":{"30":1}}],["会使用",{"2":{"18":1}}],["会暂时简单处理一下它们以继续翻译任务",{"2":{"18":1}}],["会无法翻译",{"2":{"18":1}}],["会报告错误",{"2":{"6":1}}],["针对多个",{"2":{"195":1,"196":1}}],["针对不同的错误采取不同的处理方式",{"2":{"132":1}}],["针对不同的参数",{"2":{"8":1}}],["针对原始类型的这种策略开销非常小",{"2":{"112":1}}],["针对linux的另一个",{"2":{"24":1}}],["针对顶级声明使用惰性分析",{"2":{"18":1}}],["针对某些",{"2":{"18":1}}],["构建新类型的能力主要依赖于",{"2":{"260":1}}],["构建新的类型",{"0":{"260":1},"1":{"261":1}}],["构建项目",{"2":{"222":1}}],["构建过于复杂",{"2":{"196":1}}],["构建优化模式",{"2":{"195":1,"196":1}}],["构建纯",{"0":{"195":1,"196":1}}],["构建其他的编程语言",{"2":{"194":1}}],["构建一个运行命令",{"2":{"194":1}}],["构建一个",{"2":{"191":1}}],["构建一个单元测试的",{"2":{"191":2}}],["构建器和测试器会通过",{"2":{"191":1}}],["构建文档",{"2":{"190":1}}],["构建目标相关信息",{"2":{"231":1}}],["构建目标",{"2":{"189":1,"195":1,"196":1}}],["构建静",{"0":{"189":1}}],["构建下可能会有所不同",{"2":{"184":1}}],["构建速度慢",{"2":{"184":3}}],["构建速度很快",{"2":{"184":1}}],["构建模式下",{"2":{"184":1}}],["构建模式",{"0":{"184":1},"2":{"189":1}}],["构建模式外",{"2":{"124":1}}],["构建系统",{"0":{"183":1},"1":{"184":1,"185":1,"186":1,"187":1,"188":1,"189":1,"190":1,"191":1,"192":1,"193":1,"194":1,"195":1,"196":1,"197":1}}],["构建",{"0":{"190":1},"2":{"17":1,"185":1,"189":1,"221":1}}],["包",{"0":{"243":1},"1":{"244":1,"245":1},"2":{"232":1}}],["包和",{"2":{"232":1}}],["包中定义的",{"2":{"231":1}}],["包传递给程序",{"2":{"188":1}}],["包的版本",{"2":{"35":1}}],["包可以来自任何来源",{"2":{"34":1}}],["包管理器安装",{"0":{"218":1}}],["包管理",{"0":{"34":1},"1":{"35":1,"36":1,"37":1}}],["包裹某种类型获取到一个原子数据结构",{"2":{"244":1}}],["包裹",{"2":{"27":1,"39":1,"163":1}}],["包裹一下它即可",{"2":{"27":1}}],["包括编译出来的各种库供其他语言使用",{"2":{"292":1}}],["包括了",{"2":{"124":1}}],["包括错误集",{"2":{"47":1}}],["包括",{"2":{"46":1,"102":1}}],["包括实时软件",{"2":{"25":1}}],["包括参数",{"2":{"6":1}}],["包含计算的结果和是否发生溢出的判断位",{"2":{"271":1}}],["包含的元素数量超过",{"2":{"263":1}}],["包含了许多智能功能来提高开发人员的生产力",{"2":{"207":1}}],["包含了一个",{"2":{"76":1,"81":1}}],["包含一个对外暴露的",{"2":{"185":1}}],["包含两个方法",{"2":{"89":1}}],["包含两种指针",{"2":{"79":1}}],["包含字段",{"2":{"89":1}}],["包含所有则指定为空",{"2":{"35":1}}],["包含",{"2":{"18":1,"232":1}}],["包含翻译后的代码",{"2":{"17":1}}],["包含要翻译的文件",{"2":{"17":1}}],["请将每个元素放在单独的行上",{"2":{"263":1}}],["请使测试返回错误",{"2":{"201":1}}],["请使用内部约定",{"2":{"264":1}}],["请使用标准库",{"2":{"126":1}}],["请使用可选类型",{"2":{"86":1}}],["请使用",{"2":{"17":1,"36":1,"85":1,"111":1}}],["请见谅",{"2":{"99":1}}],["请只在目标",{"2":{"86":1}}],["请不要操作它们",{"2":{"76":1}}],["请转换为普通指针后再进行操作",{"2":{"20":1}}],["请注意",{"2":{"19":1,"102":1,"201":1}}],["请勿直接使用主分支进行修改",{"2":{"1":1}}],["缓存系统集成",{"2":{"17":1}}],["无隐式执行",{"2":{"295":1}}],["无效错误集合转换",{"0":{"279":1}}],["无效错误码",{"0":{"277":1}}],["无效枚举转换",{"0":{"278":1}}],["无需",{"2":{"295":1}}],["无需注释其用途",{"2":{"265":1}}],["无需引入额外的语法",{"2":{"10":1}}],["无副作用是指",{"2":{"252":1}}],["无复现构建",{"2":{"184":1}}],["无穷大",{"2":{"126":1}}],["无",{"2":{"122":1}}],["无符号指针大小的整数",{"2":{"122":1}}],["无符号128位整数",{"2":{"122":1}}],["无符号16位整数",{"2":{"122":1}}],["无符号64位整数",{"2":{"122":1}}],["无符号32位整数",{"2":{"122":1}}],["无符号8位整数",{"2":{"122":1}}],["无论是数组还是切片",{"2":{"268":1}}],["无论是本地还是网络上",{"2":{"34":1}}],["无论是通过",{"2":{"17":1}}],["无法以此来修改已有类型",{"2":{"254":1}}],["无法执行对等类型转换",{"2":{"252":1}}],["无法在结构体",{"2":{"249":1}}],["无法推导时",{"2":{"231":1}}],["无法编译的情况",{"2":{"220":1}}],["无法作为普通的函数参数使用",{"2":{"99":1}}],["无法扩容",{"2":{"27":1}}],["无法正常使用",{"2":{"19":1}}],["无法翻译的宏会被转为",{"2":{"19":1}}],["无法转换或处理时",{"2":{"18":1}}],["无法被正确翻译的",{"2":{"18":1}}],["翻译错误",{"0":{"18":1}}],["翻译功能",{"2":{"17":1}}],["翻译缓存",{"0":{"17":1}}],["指示不使用默认标准库",{"2":{"196":1}}],["指的是全局的错误集合",{"2":{"131":1}}],["指令",{"2":{"101":1,"102":2}}],["指向常量数组的指针",{"2":{"45":1}}],["指将数据从一种类型转换到另一种类型的过程",{"2":{"40":1}}],["指针强制转换为",{"0":{"283":1}}],["指针对齐转换可能发生错误",{"2":{"280":1}}],["指针对齐错误",{"0":{"280":1}}],["指针运算",{"2":{"81":1}}],["指针是指向一块内存区域地址的变量",{"2":{"79":1}}],["指针类型具有对齐值",{"2":{"85":1}}],["指针类型",{"2":{"76":1,"81":1}}],["指针转为可选指针",{"2":{"42":1}}],["指针指向一个数组时",{"2":{"20":1}}],["指针指向一个结构体时",{"2":{"20":1}}],["指针引入一个位来跟踪",{"2":{"20":1}}],["指针",{"0":{"20":1,"45":1,"79":1},"1":{"80":1,"81":1,"82":1,"83":1,"84":1,"85":1,"86":1,"87":1},"2":{"79":2,"86":1,"101":1,"283":1}}],["指针修改为",{"2":{"16":1}}],["指定依赖",{"2":{"193":1,"194":1}}],["指定该",{"2":{"186":1,"193":1,"194":1}}],["指定一个",{"2":{"186":1,"193":1,"194":1}}],["指定枚举的标记类型",{"2":{"68":1}}],["指定",{"2":{"15":1}}],["事实上我们使用的",{"2":{"136":1}}],["事实上",{"2":{"16":1,"25":2,"128":1,"132":1,"151":1,"188":1,"199":1,"250":1}}],["查看这里",{"2":{"296":1}}],["查看",{"2":{"15":1,"33":1,"192":1}}],["将允许地址为",{"2":{"283":1}}],["将其转换为编译期计算",{"2":{"254":1}}],["将其过滤掉",{"2":{"201":1}}],["将报告跳过的测试总数",{"2":{"201":1}}],["将会输出类似",{"2":{"199":1}}],["将会提供默认值",{"2":{"133":1}}],["将引入一个额外的机制",{"2":{"191":1}}],["将在当前作用域末尾执行表达式",{"2":{"153":1}}],["将不会执行",{"2":{"135":1,"200":1}}],["将一个源码文件看作是一个容器",{"2":{"144":1}}],["将一个切片转换为向量",{"2":{"102":1}}],["将一定是一个",{"2":{"133":1}}],["将向量转为数组",{"2":{"102":1}}],["将指针更改为更对齐的指针",{"2":{"85":1}}],["将整数显式强制转换为浮点数",{"2":{"52":1}}],["将大浮点数转为小浮点数",{"2":{"52":1}}],["将枚举转换为联合类型",{"2":{"49":1}}],["将联合类型转换为枚举",{"2":{"49":1}}],["将浏览器作为渲染前端",{"2":{"39":1}}],["将",{"2":{"16":2,"44":2,"52":1,"142":1,"249":1}}],["将任意附加命令行参数传递给",{"2":{"15":1}}],["将导致堆栈溢出",{"2":{"9":1}}],["定义一个函数效果是给传入的参数执行加一操作",{"2":{"199":1}}],["定义一个可选类型并且赋值为null",{"2":{"146":1}}],["定义一个数组",{"2":{"102":1}}],["定义文档注释",{"2":{"144":1}}],["定义了一个结构体",{"2":{"89":1}}],["定义了几个对应",{"2":{"12":1}}],["定义预处理器宏",{"2":{"15":1}}],["默认开启",{"2":{"208":1}}],["默认测试器将报告使用该分配器发现的任何内存泄漏",{"2":{"202":1}}],["默认为",{"2":{"185":1,"186":1}}],["默认情况下",{"2":{"73":1}}],["默认优化模式",{"2":{"37":1}}],["默认构建目标",{"2":{"37":1}}],["默认不包含当前目录",{"2":{"15":1}}],["默认包含了输入和输出寄存器",{"2":{"4":1}}],["文档子文件夹",{"2":{"190":1}}],["文档",{"0":{"190":1}}],["文档注释指南",{"0":{"265":1}}],["文档注释记录了紧随其后的内容",{"2":{"144":1}}],["文档注释",{"2":{"144":3}}],["文档注释会优先使用运算符左侧的注释",{"2":{"136":1}}],["文档可能存在错误之处",{"2":{"0":1}}],["文件名分为两类",{"2":{"264":1}}],["文件和",{"2":{"249":1}}],["文件",{"2":{"220":2,"231":1}}],["文件生成",{"0":{"197":1}}],["文件中可见",{"2":{"117":1}}],["文件解析库",{"2":{"39":1}}],["文件的存储库",{"2":{"23":1}}],["文件的搜索目录",{"2":{"15":1}}],["供我们使用",{"2":{"14":1}}],["提供类型反射的具体功能",{"2":{"254":1}}],["提供全球语言支持",{"2":{"212":1}}],["提供的一个内嵌文件的方式",{"2":{"193":1}}],["提供的处理方案",{"2":{"90":1}}],["提供了几个溢出检测函数来处理溢出问题",{"2":{"271":1}}],["提供了不少函数来获取已有类型的信息",{"2":{"251":1}}],["提供了函数",{"2":{"195":1,"196":1}}],["提供了四种构建模式",{"2":{"184":1}}],["提供了一些内建函数来进行原子操作",{"2":{"235":1}}],["提供了一个方便的函数允许我们直接运行构建结果",{"2":{"186":1,"193":1,"194":1}}],["提供了一个命令行工具",{"2":{"14":1}}],["提供了一种简短方式来定义",{"2":{"130":1}}],["提供了",{"2":{"102":1}}],["提供了类似数组的语法来访问元组",{"2":{"96":1}}],["提供了三种类型转换",{"2":{"40":1}}],["提示",{"2":{"1":1,"2":1,"3":1,"4":1,"6":1,"7":1,"8":1,"9":2,"10":1,"11":1,"13":2,"15":1,"19":1,"23":1,"25":1,"30":1,"35":2,"36":2,"37":1,"57":1,"72":1,"76":1,"80":1,"81":1,"85":1,"89":1,"92":1,"94":1,"96":1,"102":1,"104":1,"105":1,"108":1,"111":1,"112":1,"117":1,"122":1,"126":1,"127":1,"128":1,"129":1,"133":1,"134":1,"135":1,"136":1,"139":1,"166":1,"170":1,"178":1,"183":1,"185":1,"186":1,"188":1,"195":1,"196":1,"199":1,"200":1,"208":1,"211":1,"213":1,"215":1,"224":1,"231":2,"232":1,"257":1,"262":1,"281":1}}],["两者的标准库实现略有不同",{"2":{"196":1}}],["两个不相关的错误集不可以相互转换",{"2":{"279":1}}],["两个文件",{"2":{"223":1,"224":1}}],["两个文件均定义了相同的标识符",{"2":{"13":1}}],["两个参数",{"2":{"195":1,"196":1}}],["两个错误集",{"2":{"136":1}}],["两种操作",{"2":{"124":1}}],["两种输出方式的结果应该是一样的",{"2":{"108":1}}],["两种是完全可以共存的",{"2":{"36":1}}],["两种方式引入外部汇编",{"2":{"3":1}}],["标准库集成",{"2":{"295":1}}],["标准库提供的函数可能存在溢出",{"2":{"271":1}}],["标准库提供了不少有用的函数",{"2":{"199":1}}],["标准库混入到",{"2":{"249":1}}],["标准库",{"2":{"196":1}}],["标准库和",{"2":{"195":1}}],["标准库的",{"2":{"13":1}}],["标准构建会产生两个目录",{"2":{"185":1}}],["标准构建模式",{"2":{"185":1,"187":1,"188":1,"191":1,"193":1,"194":1}}],["标准构建目标",{"2":{"185":1,"187":1,"188":1,"191":1,"193":1,"194":1}}],["标识符命名",{"0":{"140":1}}],["标识符规范",{"2":{"111":1}}],["标志",{"2":{"15":2}}],["标记的指针",{"2":{"283":1}}],["标记的联合类型并没有这种安全监测",{"2":{"281":1}}],["标记的值必须是在编译期已知的",{"2":{"6":1}}],["标记联合",{"0":{"179":1}}],["标记联合类型可以自动转换为对应的枚举",{"2":{"49":1}}],["标记",{"0":{"160":1,"165":1}}],["标记为外部连接函数",{"2":{"18":1}}],["标记告诉编译器表达式需要在编译期完成计算",{"2":{"9":1}}],["标记绑定到变量上",{"2":{"4":1}}],["标记了返回值",{"2":{"4":1}}],["功能的包只有",{"2":{"232":1}}],["功能的函数",{"2":{"7":1}}],["功能结合起来",{"2":{"133":1}}],["功能并不完善",{"2":{"14":1}}],["功能",{"2":{"13":1,"30":1,"208":1}}],["导致在windows下向控制台打印输出中文会发生乱码的现象",{"2":{"212":1}}],["导致浮点数往往是以近似值的方式存储",{"2":{"126":1}}],["导致翻译出错",{"2":{"19":1}}],["导致其不如汇编语言来的方便",{"2":{"2":1}}],["导入的包的",{"2":{"37":1}}],["导入",{"0":{"13":1},"2":{"20":1}}],["导出",{"2":{"11":1}}],["还不想使用心智负担太高的其他高级语言",{"2":{"294":1}}],["还旨在提高代码的安全性",{"2":{"293":1}}],["还包括求余运算",{"2":{"273":1}}],["还包含一个将它们组合成一个数据集的工具",{"2":{"23":1}}],["还在快速开发迭代中",{"2":{"220":1}}],["还没有发布",{"2":{"211":1}}],["还允许我们将",{"2":{"164":1}}],["还允许我们访问并操作枚举的标记值",{"2":{"68":1}}],["还支持使用",{"2":{"179":1}}],["还支持用",{"2":{"171":1}}],["还支持一个被称为",{"2":{"163":1}}],["还支持将错误从子集转换到超集",{"2":{"129":1}}],["还要求所有的非顶层定义的变量",{"2":{"139":1}}],["还有",{"2":{"271":1}}],["还有在标准库",{"2":{"125":1}}],["还有一种使用场景是",{"2":{"116":1}}],["还有一个额外的语法",{"2":{"81":1}}],["还有一个特殊标记",{"2":{"4":1}}],["还有一些你可能用不到的分配模型",{"2":{"25":1}}],["还可用于布尔",{"2":{"104":1}}],["还可以用来初始化泛型实例",{"2":{"286":1}}],["还可以用于浮点型",{"2":{"104":1}}],["还可以使用",{"2":{"249":1}}],["还可以使用else分支",{"2":{"167":2}}],["还可以对",{"2":{"99":1}}],["还可以配置使用的mutex",{"2":{"27":1}}],["还可以作为",{"2":{"11":1}}],["还具有",{"2":{"77":1}}],["还提供了在编译期构建全新类型的能力",{"2":{"260":1}}],["还提供了内存池的功能",{"2":{"25":1}}],["还提供了一个比较",{"2":{"23":1}}],["还是很有希望成为",{"2":{"292":1}}],["还是需要自行下载并添加环境变量",{"2":{"216":1}}],["还是返回",{"2":{"132":1}}],["还是",{"2":{"17":1,"112":1}}],["仍然具有非常强大的与",{"2":{"11":1}}],["与cpu指令集实现有关",{"2":{"136":1}}],["与或非",{"2":{"127":1}}],["与",{"0":{"11":1},"1":{"12":1,"13":1,"14":1,"15":1,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"22":1,"23":1,"24":1},"2":{"17":1}}],["来声明零位整数类型",{"2":{"287":1}}],["来声明并定义一个数组",{"2":{"55":1}}],["来强制指定在单独的块中是否开启安全检查",{"2":{"266":1}}],["来强制对",{"2":{"99":1}}],["来为你演示一下",{"2":{"231":1}}],["来向",{"2":{"230":1}}],["来使用",{"2":{"209":1}}],["来查看当前是否运行在测试器下",{"2":{"203":1}}],["来链接",{"2":{"195":1}}],["来作为演",{"2":{"195":1}}],["来捕获标准错误输出",{"2":{"194":1}}],["来捕获额外的错误",{"2":{"134":1}}],["来添加",{"2":{"195":1}}],["来添加单个参数",{"2":{"194":1}}],["来添加当前目录",{"2":{"15":1}}],["来输出",{"2":{"194":1}}],["来将",{"2":{"188":1}}],["来指定构建过程之间的依赖管理",{"2":{"186":1}}],["来保证它遵守",{"2":{"178":1}}],["来对代码进行优化",{"2":{"176":1}}],["来要求编译器帮我们展开这个switch",{"2":{"175":1}}],["来要求编译器生成该分支对应的所有可能分支",{"2":{"175":1}}],["来解构它",{"2":{"152":1}}],["来解决此问题",{"2":{"139":1}}],["来告诉",{"2":{"145":1}}],["来匹配错误集来解决该问题",{"2":{"136":1}}],["来通知编译器忽略它即可",{"2":{"134":1}}],["来看一个例子",{"2":{"133":1}}],["来看个例子",{"2":{"126":1}}],["来表示当违反事先预定情况时会发生未定义行为",{"2":{"265":1}}],["来表示",{"2":{"107":1}}],["来从",{"2":{"105":1}}],["来确定",{"2":{"82":1}}],["来操作切片的指针",{"2":{"77":1}}],["来描述一个元素为类型",{"2":{"57":1}}],["来进行正确性检验的测试工作",{"2":{"198":1}}],["来进行变量的声明",{"2":{"139":1}}],["来进行矩阵的打印",{"2":{"56":1}}],["来进行一些检查",{"2":{"30":1}}],["来获取枚举时",{"2":{"278":1}}],["来获取枚举的大小和对应的",{"2":{"70":1}}],["来获取类型",{"2":{"254":1}}],["来获取命令参数决定是否剥离调试信息",{"2":{"187":1}}],["来获取到对应的",{"2":{"179":1}}],["来获取有效的信息",{"2":{"128":1}}],["来获取对应的指针",{"2":{"52":1}}],["来获取",{"2":{"35":1}}],["来帮助我们实现这个数组的初始化",{"2":{"66":1}}],["来帮助我们实现",{"2":{"24":1}}],["来实现从命令行读取一个参数决定是否剥离二进制程序的调试信息",{"2":{"187":1}}],["来实现的",{"2":{"149":1}}],["来实现",{"2":{"21":1}}],["来提高类型安全性",{"2":{"16":1}}],["来生成数据结构",{"2":{"10":1}}],["来修改默认的堆栈嵌套",{"2":{"9":1}}],["函数调用",{"2":{"293":1}}],["函数的原型为",{"2":{"261":1}}],["函数的返回值是",{"2":{"232":1}}],["函数的参数是不可变的",{"2":{"112":1}}],["函数接受两个参数",{"2":{"231":1}}],["函数接受一个表达式作为参数",{"2":{"13":1}}],["函数来输出语句",{"2":{"231":1}}],["函数查找对应名称的模块或者",{"2":{"231":1}}],["函数将联合类型作为声明的枚举来使用",{"2":{"179":1}}],["函数也同理",{"2":{"136":1}}],["函数无论是返回",{"2":{"132":1}}],["函数参数可以用",{"2":{"115":1}}],["函数体是仅限编译时的类型",{"2":{"111":1}}],["函数体和函数指针之间是有区别的",{"2":{"111":1}}],["函数是编程语言中最为基本的语句",{"2":{"110":1}}],["函数指针略有特殊",{"2":{"80":1}}],["函数要求返回一个数组的元素或者一个数组",{"2":{"65":1}}],["函数暴露的模块是完全公开的",{"2":{"36":1}}],["函数传入的参数",{"2":{"36":1,"37":1}}],["函数原型",{"2":{"18":1,"237":1,"238":1,"239":1,"240":1,"241":1,"242":1}}],["函数",{"0":{"110":1},"1":{"111":1,"112":1,"113":1,"114":1,"115":1,"116":1,"117":1,"118":1,"119":1},"2":{"13":2,"19":2,"102":1,"116":1,"185":1,"231":2}}],["函数初始化变量",{"2":{"10":1}}],["函数作为编译期可执行函数",{"2":{"9":1}}],["函数仅仅只能比较整数和浮点数",{"2":{"7":1}}],["使得无法在运行时计算索引来便利",{"2":{"254":1}}],["使构建脚本部分配置由用户决定",{"2":{"187":1}}],["使变量保持未初始化状态",{"2":{"142":1}}],["使其内存布局保证匹配对应目标的",{"2":{"98":1}}],["使用驼峰命名法",{"2":{"264":3}}],["使用蛇形命名法",{"2":{"264":1}}],["使用任意一个没有区别",{"2":{"215":1}}],["使用构建系统执行单元测试时",{"2":{"191":1}}],["使用默认提供的优化方案",{"2":{"189":1}}],["使用默认提供的构建目标",{"2":{"189":1}}],["使用它出现无法预知的情况",{"2":{"142":1}}],["使用它需要在",{"2":{"30":1}}],["使用传入的运算符对向量进行水平按顺序合并",{"2":{"104":1}}],["使用位转换",{"2":{"99":1}}],["使用位域",{"2":{"18":1}}],["使用函数初始化数组",{"0":{"65":1}}],["使用方式和",{"2":{"36":1}}],["使用起来也很简单",{"2":{"36":1}}],["使用了",{"2":{"35":1}}],["使用了宏的",{"2":{"19":1}}],["使用模型",{"2":{"26":1,"28":1}}],["使用相同源文件",{"2":{"17":1}}],["使用时请注意查询",{"2":{"14":1}}],["使用",{"2":{"11":1,"12":1,"17":1,"21":1,"24":1,"27":2,"35":1,"39":4,"55":1,"94":1,"112":1,"115":1,"122":1,"134":1,"137":2,"141":1,"179":1,"187":2,"207":1,"212":1,"228":1,"252":1,"264":7,"265":1,"270":1,"277":1}}],["使用自己的堆栈进行comptime函数调用",{"2":{"9":1}}],["使之支持布尔值",{"2":{"7":1}}],["799248",{"2":{"196":1}}],["7",{"2":{"9":2,"60":2,"102":1,"105":1,"106":2,"196":2}}],["只是一个有那么一丁点热度的高级语言",{"2":{"292":1}}],["只是翻译宏可能失败",{"2":{"19":1}}],["只读的",{"2":{"254":1}}],["只能通过",{"2":{"254":1}}],["只能获取到公共成员",{"2":{"200":1}}],["只需要使用",{"2":{"199":1}}],["只需要指定好恰当的",{"2":{"192":1}}],["只需要在普通类型的前面增加一个",{"2":{"132":1}}],["只需要在定义结构体的时候声明默认值即可",{"2":{"93":1}}],["只需要记住",{"2":{"112":1}}],["只需要编写普通的函数就行",{"2":{"9":1}}],["只有一个值的",{"2":{"289":1}}],["只有一个值的错误集",{"0":{"130":1}}],["只有初次声明时可以赋值",{"2":{"141":1}}],["只有在使用哨兵时",{"2":{"57":1}}],["只有为了避免符号冲突",{"2":{"13":1}}],["只要能让",{"2":{"91":1}}],["只要代码不依赖于未定义的内存布局",{"2":{"87":1}}],["只要两个数组类型",{"2":{"60":1}}],["只要对",{"2":{"24":1}}],["只要编译器知道去哪里找到函数的具体实现",{"2":{"18":1}}],["只保留运行时所需要的分支",{"2":{"7":1}}],["则它们必定是零位类型",{"2":{"288":1}}],["则它应该使用",{"2":{"264":1}}],["则推荐使用",{"2":{"208":2}}],["则us容器中的测试块也会被执行测试",{"2":{"200":1}}],["则我们可以这样子来执行检测",{"2":{"199":1}}],["则使用",{"2":{"189":1}}],["则构建系统会接收命令行的参数来决定实际构建模式",{"2":{"184":1}}],["则是对应的标签名",{"2":{"175":1}}],["则是完全只使用",{"2":{"30":1}}],["则类似于return",{"2":{"164":1}}],["则不会执行",{"2":{"153":1}}],["则两个类型均为",{"2":{"122":1}}],["则结果中的相应元素将为",{"2":{"106":1}}],["则结果元素也是",{"2":{"105":1}}],["则",{"2":{"105":1}}],["则编译器将默认一次对每个向量元素进行操作",{"2":{"102":1}}],["则编译器会报错",{"2":{"45":1}}],["则可以定义一个名字为空的定义测试块",{"2":{"200":1}}],["则可以从类型中省略它",{"2":{"85":1}}],["则可以这样解引用",{"2":{"20":2}}],["则需要使用",{"2":{"84":1}}],["则需要使用两个",{"2":{"4":1}}],["则会触发安全保护中的未定义问题",{"2":{"78":1}}],["则会由",{"2":{"41":1}}],["则会发出编译错误",{"2":{"9":1}}],["则发出编译错误",{"2":{"9":1}}],["所安装的",{"2":{"208":1}}],["所设计的跨平台",{"2":{"207":1}}],["所指的交互并不仅仅是使用",{"2":{"11":1}}],["所有测试运行后",{"2":{"201":1}}],["所有常量都是",{"2":{"141":1}}],["所有的运算符均可用于整型",{"2":{"104":1}}],["所有的转义字符均可以在字符串和",{"2":{"61":1}}],["所有表达式都是隐式的",{"2":{"9":1}}],["所有函数调用都会导致编译器在编译时解释该函数",{"2":{"9":1}}],["所有具有运行时副作用或依赖于运行时值的代码都会发出编译错误",{"2":{"9":1}}],["所有",{"2":{"9":2}}],["所有变量都是",{"2":{"9":1}}],["所以我写了这个文档",{"2":{"292":1}}],["所以我们可能需要添加一个锁来保证打印函数的先后执行顺序",{"2":{"233":1}}],["所以我们如何解决这个问题呢",{"2":{"232":1}}],["所以我们先看一下什么是运行时",{"2":{"6":1}}],["所以官方鼓励用户使用",{"2":{"211":1}}],["所以任何没有明确说明内存布局的容器在",{"2":{"184":1}}],["所以当调试应用程序时",{"2":{"134":1}}],["所以当传入的",{"2":{"7":1}}],["所以你可以使用",{"2":{"108":1}}],["所以",{"2":{"23":1,"96":1,"100":1}}],["通用",{"2":{"293":1}}],["通常为",{"2":{"231":1}}],["通常",{"2":{"189":1}}],["通常我们定义一个",{"2":{"189":1}}],["通常仅使用",{"2":{"185":1}}],["通常用于记录一个文件的作用",{"2":{"144":1}}],["通常只需要设置对应的寄存器即可",{"2":{"112":1}}],["通常不足8位的仍然使用8位",{"2":{"99":1}}],["通常自引用方式为函数参数第一个为结构体指针类型",{"2":{"90":1}}],["通常是我们使用",{"2":{"37":1}}],["通常是为了修改翻译后的代码",{"2":{"16":1}}],["通常编写内核会使用这个",{"2":{"20":1}}],["通常它仅出现在翻译输出代码中",{"2":{"20":1}}],["通常情况下",{"2":{"13":1}}],["通常一个编译期已知的语句或函数带有",{"2":{"6":1}}],["通过句柄写入buffer",{"2":{"232":1}}],["通过在",{"2":{"231":1}}],["通过官方的发布页面下载对应的",{"2":{"215":1,"219":1}}],["通过标准库获取时间戳",{"2":{"188":1}}],["通过命令行参数传递",{"2":{"187":1}}],["通过可选类型我们可以解决这个问题",{"2":{"145":1}}],["通过函数",{"2":{"129":1}}],["通过它使用",{"2":{"96":1}}],["通过字段获取基指针",{"0":{"95":1}}],["通过编译期来初始化数组",{"2":{"66":1}}],["通过调用",{"2":{"17":1}}],["通过",{"2":{"9":1,"36":1,"37":1,"79":1,"178":1,"179":1,"185":1,"187":1,"232":1,"253":1,"254":1}}],["预处理器的场景",{"2":{"8":1}}],["代替类型来声明",{"2":{"115":1}}],["代替",{"2":{"55":1,"72":1,"82":1}}],["代码管控工具",{"2":{"206":1}}],["代码重构功能",{"2":{"205":1}}],["代码自动补全",{"2":{"205":1}}],["代码交互时的类型安全",{"2":{"74":1}}],["代码转换并不会出问题",{"2":{"19":1}}],["代码链接时出现微妙的",{"2":{"15":1}}],["代码",{"2":{"11":1,"13":1}}],["代码翻译为",{"2":{"11":1}}],["代码生成",{"2":{"8":1}}],["代表它的值是null或者这个类型",{"2":{"145":1}}],["代表有符号的7位整数",{"2":{"122":1}}],["代表着我们接下来定义了一个函数",{"2":{"111":1}}],["代表可以接受任何类型的",{"2":{"75":1}}],["代表这个值尚未初始化",{"2":{"50":1}}],["代表只能进行写入操作数",{"2":{"4":1}}],["代表我们整个内联汇编表达式需要返回一个值",{"2":{"4":1}}],["代表我们使用",{"2":{"4":1}}],["xmake",{"2":{"292":1}}],["xmlparser",{"2":{"264":1}}],["xml",{"2":{"264":2}}],["xxx",{"2":{"255":1,"256":1}}],["xbps",{"2":{"218":1}}],["x++",{"2":{"196":1}}],["x0",{"2":{"196":1}}],["xor",{"2":{"104":1}}],["xiaoming",{"2":{"90":1}}],["xfe",{"2":{"61":1}}],["xff",{"2":{"61":1}}],["xf0",{"2":{"61":1}}],["xaf",{"2":{"61":1}}],["x92",{"2":{"61":1}}],["x9f",{"2":{"61":1}}],["x65llo",{"2":{"61":1}}],["x65",{"2":{"61":1}}],["xnn",{"2":{"61":2,"62":1}}],["x4",{"2":{"45":1}}],["x3",{"2":{"45":1,"196":1}}],["x3c",{"2":{"8":1,"9":1,"21":1,"63":1,"119":2,"127":10,"162":2,"163":3,"164":1,"165":1,"166":2,"195":1,"196":17,"220":4,"264":3}}],["x",{"2":{"45":5,"48":2,"57":3,"61":2,"65":2,"78":3,"81":2,"82":2,"85":3,"87":3,"91":2,"93":1,"95":4,"100":1,"105":1,"115":3,"127":11,"132":6,"143":4,"173":5,"176":2,"196":24,"257":7,"258":4,"264":2}}],["x2",{"2":{"45":4,"196":1}}],["x26",{"2":{"8":1,"10":1,"19":2,"21":2,"27":2,"45":11,"53":2,"66":1,"77":1,"80":1,"81":2,"85":4,"87":1,"90":1,"99":2,"127":3,"143":1,"155":1,"186":1,"190":1,"191":1,"193":1,"194":3,"195":2,"196":18,"200":1,"252":1,"258":2,"261":2}}],["x1",{"2":{"45":2,"196":1}}],["xz",{"2":{"35":1}}],["x86",{"2":{"2":2,"4":3,"23":1,"24":4,"85":2,"192":1,"215":3}}],["下载",{"2":{"220":1}}],["下的函数均是测试使用的",{"2":{"199":1}}],["下一行代表返回到blk这个tag处",{"2":{"171":1}}],["下划线",{"2":{"140":1}}],["下划线可以放在数字之间作为视觉分隔符",{"2":{"122":1}}],["下",{"2":{"99":1,"189":2}}],["下标索引从",{"2":{"55":1}}],["下面来进行说明",{"2":{"111":1}}],["下面是一个日常会用到的一个结构体例子",{"2":{"90":1}}],["下面语句执行为",{"2":{"53":1}}],["下面的内容可能有点难",{"2":{"231":1}}],["下面的",{"2":{"8":1,"49":1}}],["下可用",{"2":{"29":1}}],["下输出",{"2":{"4":1}}],["36",{"2":{"266":1}}],["300",{"2":{"270":2}}],["30",{"2":{"196":1}}],["3089",{"2":{"149":2}}],["399424",{"2":{"196":1}}],["32",{"2":{"122":2}}],["3509",{"2":{"100":1}}],["348480",{"2":{"196":1}}],["34",{"2":{"43":1,"49":1,"53":1,"96":1,"281":1}}],["3",{"2":{"8":1,"9":1,"44":1,"45":1,"49":2,"53":1,"57":1,"59":6,"60":2,"65":1,"76":3,"77":2,"78":3,"81":2,"87":1,"89":2,"90":1,"94":2,"96":2,"99":1,"102":3,"105":2,"106":1,"126":2,"151":1,"152":2,"155":2,"157":1,"158":1,"159":1,"163":1,"166":2,"167":1,"168":1,"171":1,"176":1,"196":1}}],["+|=",{"2":{"127":1}}],["+|",{"2":{"127":2}}],["++r",{"2":{"196":1}}],["++tick",{"2":{"196":1}}],["++",{"2":{"60":2,"96":1,"127":2}}],["+=",{"2":{"8":1,"21":2,"87":2,"127":1,"132":1,"143":2,"155":2,"160":2,"161":2,"162":2,"163":1,"164":1,"165":1,"166":4,"167":2,"168":2,"173":2,"179":1,"196":2,"252":1}}],["+",{"2":{"8":3,"9":2,"19":2,"53":1,"65":1,"76":1,"80":1,"81":1,"102":2,"111":1,"115":1,"125":2,"126":2,"127":5,"132":2,"171":2,"176":1,"196":17,"199":3,"215":2,"257":1,"259":1,"271":2}}],["实在是太多营销号视频无脑说",{"2":{"292":1}}],["实现的",{"2":{"39":2}}],["实现内存分配器",{"0":{"33":1}}],["实现了一套",{"2":{"11":1}}],["实现",{"2":{"11":1,"37":1,"39":1,"134":1}}],["实现更加高效或者更直白的操作",{"2":{"4":1}}],["实际上就是声明结构体类型",{"2":{"100":1}}],["实际上就是嵌套数组",{"2":{"56":1}}],["实际上枚举仅仅是一种命名空间",{"2":{"69":1}}],["实际上",{"2":{"23":1,"144":1,"254":1}}],["实际上会在编译期生成不同的代码",{"2":{"8":1}}],["实际没有必要这么操作",{"2":{"8":1}}],["该语言不使用宏或预处理器指令",{"2":{"293":1}}],["该语法将会告诉",{"2":{"232":1}}],["该内建函数用于获取类型的信息",{"2":{"254":1}}],["该内建函数用于获取类型的名字",{"2":{"253":1}}],["该内建函数用于使用获取变量的类型",{"2":{"252":1}}],["该命令为",{"2":{"228":1}}],["该插件已经有两年无人维护",{"2":{"210":1}}],["该软件以扩展的方式支持语法高亮",{"2":{"205":1}}],["该字段是为",{"2":{"195":1,"196":1}}],["该函数实际上就是",{"2":{"261":1}}],["该函数的效果是返回一个",{"2":{"254":1}}],["该函数的具体效果取决于我们如何对待返回的",{"2":{"132":1}}],["该函数返回的类型名字完全是一个字符串字面量",{"2":{"253":1}}],["该函数仅在函数作用域内有效",{"2":{"118":1}}],["该类型包含了所有",{"2":{"254":1}}],["该类型一般用在内核开发中",{"2":{"116":1}}],["该类型不保证在此之前不存在哨兵元素",{"2":{"78":1}}],["该变量长度相当于另一个非",{"2":{"105":1}}],["该变量的读取和写入完全是在编译期执行的",{"2":{"8":1}}],["该节内容",{"2":{"84":1}}],["该示例中使用了",{"2":{"82":1}}],["该表达式会在编译期执行",{"2":{"13":1}}],["该特性可以与",{"2":{"8":1}}],["该值为枚举的一个值",{"2":{"49":1}}],["该值",{"2":{"6":1}}],["裁剪掉",{"2":{"7":1}}],["时间和语言",{"2":{"212":1}}],["时语法出现在",{"2":{"168":1}}],["时触发并退出循环",{"2":{"167":2}}],["时终止循环",{"2":{"167":1}}],["时使用零指针",{"2":{"86":1}}],["时",{"2":{"7":1,"29":1,"49":1,"55":1,"77":1,"157":1,"175":1,"213":1,"228":1,"275":1,"276":1,"288":1}}],["时效性高的程序",{"2":{"2":1}}],["是很明显的零位类型",{"2":{"286":1}}],["是可被调用",{"2":{"264":1}}],["是可以被调用的",{"2":{"264":1}}],["是可选类型的标志",{"2":{"145":1}}],["是否包含指定名字的字段",{"2":{"256":1}}],["是指计算机程序在运行时",{"2":{"250":1}}],["是充当保存变量和函数声明的命名空间的任何语法结构",{"2":{"248":1}}],["是编辑器之神",{"2":{"209":1}}],["是一种命令式",{"2":{"293":1}}],["是一种通用的编程语言和工具链",{"2":{"293":1}}],["是一门",{"2":{"294":1}}],["是一门静态语言并不具有过多的运行时功能",{"2":{"254":1}}],["是一门强类型的静态语言",{"2":{"250":1}}],["是一款专为开发",{"2":{"207":1}}],["是一款由微软开发且跨平台的免费源代码编辑器",{"2":{"205":1}}],["是一个运行时可知的值",{"2":{"175":1}}],["是一个特殊的类型",{"2":{"116":1}}],["是一个切片",{"2":{"78":1}}],["是一个比较特殊的类型",{"2":{"75":1}}],["是一个神奇的值",{"2":{"50":1}}],["是一个参数",{"2":{"7":1}}],["是针对程序模块",{"2":{"198":1}}],["是由",{"2":{"193":1}}],["是将构建放入",{"2":{"186":1}}],["是这样的",{"2":{"185":1}}],["是不可复现的",{"2":{"184":1}}],["是当",{"2":{"164":1}}],["是索引",{"2":{"157":1}}],["是值",{"2":{"157":1}}],["是如何解构错误联合可选类型的呢",{"2":{"152":1}}],["是许多运行时异常的根源",{"2":{"145":1}}],["是顶层文档注释",{"2":{"144":1}}],["是标签名字",{"2":{"143":1}}],["是标识符",{"2":{"111":1}}],["是相同大小",{"2":{"127":1}}],["是相等的",{"2":{"43":1}}],["是函数的返回类型",{"2":{"111":1}}],["是参数的标识符和类型",{"2":{"111":1}}],["是关键字",{"2":{"111":1}}],["是访问修饰符",{"2":{"111":1}}],["是哨兵值",{"2":{"78":1}}],["是多项指针",{"2":{"78":1}}],["是长度为",{"2":{"53":1}}],["是错误联合类型时",{"2":{"45":1}}],["是在在",{"2":{"37":1}}],["是对应的",{"2":{"35":1}}],["是源代码地址",{"2":{"35":1}}],["是依赖包的名字",{"2":{"35":1}}],["是为了指定静态链接",{"2":{"24":1}}],["是为了防止编译失败",{"2":{"24":1}}],["是正常可以工作的",{"2":{"19":1}}],["是正确的",{"2":{"15":1}}],["是文件依赖项列表",{"2":{"17":1}}],["是默认的构建变量",{"2":{"13":1}}],["是",{"2":{"7":1,"56":1,"72":1,"104":2,"105":1,"106":1,"139":1,"141":1,"142":1}}],["参考",{"2":{"220":1}}],["参照页面配置即可",{"2":{"209":1}}],["参照",{"2":{"44":2}}],["参数的具体类型可以参考",{"2":{"261":1}}],["参数来实现效果",{"2":{"228":1}}],["参数类型为",{"2":{"184":1}}],["参数上的",{"2":{"113":1}}],["参数传递是一个非常古老的问题",{"2":{"112":1}}],["参数传递",{"0":{"112":1}}],["参数为包的包构建根目录和通过",{"2":{"37":1}}],["参数",{"0":{"187":1},"2":{"17":1,"37":1,"185":1}}],["参数在",{"2":{"7":1}}],["参与贡献本文档",{"2":{"1":1}}],["参与贡献",{"0":{"1":1}}],["上最棒的开发",{"2":{"206":1}}],["上",{"2":{"190":1,"191":1}}],["上的区别",{"2":{"145":1}}],["上的编译器崩溃",{"2":{"102":1}}],["上方的代码的内容",{"2":{"89":1}}],["上方的",{"2":{"24":1,"143":1}}],["上述的",{"2":{"7":1}}],["上面我们已经完成了带有缓冲区的",{"2":{"233":1}}],["上面仅仅只是一个示例而已",{"2":{"231":1}}],["上面的内容你应该已经看完了",{"2":{"231":1}}],["上面的这些限制可能在未来会被改善",{"2":{"136":1}}],["上面几条规则看着很模糊是吧",{"2":{"100":1}}],["上面这段代码毫无疑问会失败",{"2":{"270":1}}],["上面这段代码是通过内联汇编实现在",{"2":{"4":1}}],["上面这句话看起来有点云里雾里",{"2":{"136":1}}],["上面这个语句执行会成功",{"2":{"53":1}}],["上面操作可行的原因",{"2":{"7":1}}],["上面就是基本的内联汇编的一个外部结构说明",{"2":{"4":1}}],["也都是",{"2":{"292":1}}],["也保证与源文件中出现的顺序相同",{"2":{"254":1}}],["也安装了对应的编辑器",{"2":{"221":1}}],["也会运行非命名测试",{"2":{"201":1}}],["也会尝试解构可选类型",{"2":{"167":1}}],["也支持自动推断联合类型",{"2":{"180":1}}],["也是零位类型",{"2":{"289":1,"291":1}}],["也是true",{"2":{"72":1}}],["也是没有对应的类型",{"2":{"49":1}}],["也有效",{"2":{"45":1}}],["也没有问题",{"2":{"43":1}}],["也就是不同编译器支持的语法实际上是",{"2":{"292":1}}],["也就是说它仅仅会执行容器的顶层测试块和它引用的容器的顶层测试块",{"2":{"200":1}}],["也就是说一个包本身可以包含多个模块",{"2":{"36":1}}],["也就是字符串",{"2":{"179":1}}],["也就是一个类型",{"2":{"7":1}}],["也可以用来给",{"2":{"221":1}}],["也可以通过内置的扩展程序商店安装其他扩展以拓展软件功能",{"2":{"205":1}}],["也可以使用诸如",{"2":{"214":1}}],["也可以使用",{"2":{"194":2,"209":1}}],["也可以继续对枚举类型进行自动推断",{"2":{"174":1}}],["也可以作为表达式来使用",{"2":{"159":1}}],["也可以访问索引",{"2":{"157":1}}],["也可以将",{"2":{"131":1}}],["也可以没有返回值",{"2":{"4":1}}],["也可以不返回值",{"2":{"4":1}}],["叫起来也像鸭子",{"2":{"7":1}}],["否则会触发编译器错误",{"2":{"274":1}}],["否则会编译错误",{"2":{"144":1}}],["否则应使用",{"2":{"264":1}}],["否则将会编译无法通过",{"2":{"254":1}}],["否则将会是由编译器推导的",{"2":{"152":1}}],["否则仅读取值返回",{"2":{"240":1,"241":1}}],["否则的话我们直接会返回",{"2":{"145":1}}],["否则我们需要释放这个块内存",{"2":{"135":1}}],["否则解构它",{"2":{"134":1}}],["否则失败",{"2":{"119":1}}],["否则为",{"2":{"106":1}}],["否则可能会出现解析失败或者与",{"2":{"15":1}}],["否则",{"2":{"6":1}}],["类型作为一等公民",{"2":{"295":1}}],["类型无法容纳下",{"2":{"270":1}}],["类型无法进行比较",{"2":{"252":1}}],["类型和命名空间",{"2":{"264":1}}],["类型声明",{"2":{"264":4}}],["类型声明使用",{"2":{"264":1}}],["类型声明一个具有未知",{"2":{"74":1}}],["类型的",{"2":{"127":1}}],["类型的字段",{"2":{"99":1}}],["类型的时候",{"2":{"12":1}}],["类型是",{"2":{"92":1}}],["类型是一等公民",{"2":{"6":1,"88":1,"295":1}}],["类型类似",{"2":{"85":1}}],["类型可以强制转换为",{"2":{"85":1}}],["类型后再进行计算",{"2":{"79":1}}],["类型为u16",{"2":{"139":1}}],["类型为",{"2":{"76":4,"77":1,"152":1}}],["类型转换",{"0":{"40":1},"1":{"41":1,"42":1,"43":1,"44":1,"45":1,"46":1,"47":1,"48":1,"49":1,"50":1,"51":1,"52":1,"53":1},"2":{"40":1}}],["类型或者代码结构无法被翻译的函数会使用",{"2":{"18":1}}],["类型",{"0":{"12":1,"122":1},"2":{"6":1,"49":1,"75":1,"108":3,"122":1,"144":1,"151":1,"254":1}}],["类似于",{"2":{"231":1}}],["类似makefile一样的存在",{"2":{"183":1}}],["类似循环中的",{"2":{"171":1}}],["类似在命令行构建时使用的",{"2":{"37":1}}],["类似",{"2":{"4":1,"54":1,"256":1}}],["对交叉编译的一流支持",{"2":{"295":1}}],["对不变量使用",{"2":{"265":1}}],["对指定的源文件运行test",{"2":{"227":1}}],["对指定文件进行ast语法检查",{"2":{"225":1}}],["对指针的操作应假定为没有副作用",{"2":{"84":1}}],["对枚举类型进行自动推断",{"0":{"174":1}}],["对字段值的修改可以通过在捕获变量名称之前放置",{"2":{"173":1}}],["对标记联合类型进行捕获操作",{"2":{"173":1}}],["对比一下",{"2":{"145":1}}],["对等类型解析",{"2":{"127":1}}],["对等类型转换处理",{"2":{"53":4}}],["对等类型转换处理数组到常量切片",{"2":{"53":1}}],["对等类型转换处理不同大小的数组到切片",{"2":{"53":1}}],["对等类型转换处理整数转换",{"2":{"53":1}}],["对等类型转换发生时",{"2":{"53":1}}],["对等类型转换",{"0":{"53":1},"2":{"53":1,"252":1}}],["对整数的类型划分很详细",{"2":{"122":1}}],["对齐整数的位宽",{"2":{"99":1}}],["对齐的",{"2":{"97":1}}],["对齐",{"0":{"85":1}}],["对数组做乘法操作",{"2":{"59":1}}],["对",{"2":{"39":2}}],["对通用内存分配器进行一层包裹",{"2":{"28":1}}],["对应的是用户的环境变量",{"2":{"215":1}}],["对应的系统全局的环境变量",{"2":{"215":1}}],["对应的枚举值可以直接自动转换为标记联合类型",{"2":{"49":1}}],["对应c",{"2":{"126":1}}],["对应c类型",{"2":{"122":1}}],["对应",{"2":{"12":1,"21":3,"153":1}}],["对应地",{"2":{"6":1}}],["对于上面的问题",{"2":{"136":1}}],["对于外部函数",{"2":{"112":1}}],["对于每个",{"2":{"105":1}}],["对于数组和切片",{"2":{"81":1}}],["对于一个编译期表达式",{"2":{"9":1}}],["对于这个概念",{"2":{"6":1}}],["对于",{"2":{"2":1}}],["异步",{"0":{"5":1}}],["old",{"2":{"196":2}}],["otherfunction",{"2":{"264":1}}],["otherwise",{"2":{"196":1}}],["other",{"2":{"148":1}}],["overflowed",{"2":{"271":1}}],["overflow",{"2":{"132":2,"134":1,"136":3}}],["overaligned",{"2":{"99":1}}],["ov",{"2":{"132":6,"136":6,"271":4}}],["outer",{"2":{"160":5,"165":5}}],["outofmemory",{"2":{"129":5,"135":1}}],["out",{"2":{"124":2,"185":2,"186":1,"189":2,"208":1,"232":12,"266":5}}],["output",{"2":{"17":1,"84":1,"194":2,"232":1}}],["outputoperands",{"2":{"4":1}}],["object",{"2":{"117":1,"195":1}}],["ostree",{"2":{"218":1}}],["os",{"2":{"86":1,"172":5,"192":1}}],["ok",{"2":{"68":3,"82":1,"179":16,"199":2}}],["offsetof",{"2":{"99":4}}],["off",{"2":{"71":1,"174":3}}],["of",{"2":{"39":1,"44":1,"60":2,"85":2,"89":1,"102":1,"200":1,"220":1}}],["operand",{"2":{"239":1}}],["operands",{"2":{"44":1}}],["op",{"2":{"104":1,"239":1}}],["optinal",{"2":{"175":1}}],["optional",{"2":{"145":3,"146":2,"152":5,"175":1}}],["option",{"2":{"37":1,"187":4,"188":2,"295":1}}],["options",{"0":{"188":1},"2":{"36":1,"37":1,"185":1,"186":2,"187":1,"188":11}}],["optimized",{"2":{"126":2}}],["optimize",{"2":{"37":3,"185":4,"187":3,"188":3,"189":5,"191":5,"192":2,"193":3,"194":3,"195":3,"196":3}}],["opaque",{"0":{"74":1},"1":{"75":1},"2":{"18":3,"74":3,"75":2}}],["o",{"2":{"8":2,"17":3,"55":2,"105":1,"266":1}}],["order",{"2":{"240":2,"241":2,"242":1}}],["ordering",{"2":{"237":1,"238":1,"239":1,"244":1}}],["ordered",{"2":{"99":5}}],["org",{"2":{"195":1}}],["orelse",{"2":{"127":1,"135":1,"145":2,"187":1}}],["or",{"2":{"7":2,"104":1,"127":2}}],["only",{"2":{"249":1}}],["one",{"2":{"8":4,"49":2,"60":2,"68":1,"70":1,"72":6,"122":1,"196":1,"199":2}}],["on",{"2":{"4":1,"71":1,"174":2,"244":1}}],["hot",{"2":{"244":1}}],["host",{"2":{"124":2,"266":4}}],["horizontal",{"2":{"104":1}}],["homebrewmacports",{"2":{"216":1}}],["home",{"2":{"17":3,"124":3,"266":6}}],["hundred",{"2":{"68":1}}],["h>",{"2":{"63":1,"195":1,"196":4}}],["hit",{"2":{"196":6}}],["hi",{"2":{"53":2,"96":4,"255":4,"256":3}}],["https",{"2":{"35":3,"205":1,"206":1,"208":3,"220":1,"228":2}}],["happens",{"2":{"244":2}}],["hasfield",{"0":{"256":1},"2":{"251":1,"256":5}}],["hasdecl",{"0":{"255":1},"2":{"251":1,"255":5,"256":1}}],["has",{"2":{"196":1}}],["hash",{"2":{"35":5}}],["half1",{"2":{"99":2}}],["hacker",{"2":{"23":1}}],["handle",{"2":{"4":1,"29":1}}],["h",{"2":{"13":1,"17":5,"43":3,"45":4,"55":3,"61":1,"105":1,"108":3,"196":1,"249":3}}],["hendriknielaender",{"2":{"220":1}}],["help",{"2":{"187":1}}],["hello",{"0":{"230":1},"1":{"231":1,"232":1,"233":1,"234":1},"2":{"4":2,"13":1,"45":9,"55":1,"61":2,"63":3,"78":1,"82":1,"90":1,"105":1,"186":2,"193":7,"194":6,"195":6,"230":2,"231":1,"232":7,"234":1,"249":1}}],["here",{"2":{"124":1}}],["hearts",{"2":{"69":1}}],["heapapi",{"2":{"29":1}}],["heapallocator",{"0":{"29":1},"2":{"25":1,"29":1}}],["heap",{"2":{"25":5,"26":1,"27":3,"28":2,"29":5,"30":1,"31":1,"32":1,"33":2,"90":1}}],["headers",{"2":{"23":1}}],["header",{"0":{"13":1}}],["可被调用",{"2":{"264":5}}],["可执行二进制文件",{"2":{"223":1}}],["可复现构建",{"2":{"184":3}}],["可选指针会保证和指针有一样的大小",{"2":{"147":1}}],["可选指针",{"0":{"147":1},"2":{"283":1}}],["可选类型代替",{"2":{"295":1}}],["可选类型值是",{"2":{"275":1}}],["可选类型仅仅能保证你不使用空指针",{"2":{"145":1}}],["可选类型在整数上没什么大用",{"2":{"145":1}}],["可选类型的载荷",{"2":{"46":1}}],["可选类型",{"0":{"46":1,"145":1},"1":{"146":1,"147":1}}],["可选类型也有效",{"2":{"45":1}}],["可选类型也有效果",{"2":{"45":1}}],["可选的",{"2":{"20":1}}],["可用",{"2":{"35":1}}],["可变参数的访问可以使用",{"2":{"21":1}}],["可变参数函数",{"0":{"21":1},"2":{"21":1}}],["可多次使用",{"2":{"15":1}}],["可能导致结果溢出",{"2":{"272":1}}],["可能造成溢出",{"2":{"271":1}}],["可能会导致当前版本的",{"2":{"102":1}}],["可能会调用",{"2":{"30":1}}],["可能存在某些",{"2":{"14":1}}],["可能有自己的汇编器",{"2":{"2":1}}],["可以简单看作在编译时执行的函数",{"2":{"295":1}}],["可以简单看作裸机器",{"2":{"20":1}}],["可以通过重新分配来更改联合类型的有效字段",{"2":{"281":1}}],["可以获取结构体的基指针",{"2":{"258":1}}],["可以访问",{"2":{"250":1}}],["可以将一个容器中的所有",{"2":{"249":1}}],["可以增加一个缓冲区",{"2":{"232":1}}],["可以手动构建一个",{"2":{"192":1}}],["可以很方便的处理交叉编译",{"2":{"192":1}}],["可以发现",{"2":{"188":1}}],["可以看作仅仅进行来类型计算",{"2":{"252":1}}],["可以看作时",{"2":{"135":1}}],["可以看一看这个视频",{"2":{"234":1}}],["可以看到输出多了一行",{"2":{"187":1}}],["可以称之为构建时的步骤",{"2":{"186":1}}],["可以额外捕获",{"2":{"175":1}}],["可以展开所有的",{"2":{"175":1}}],["可以任意复杂",{"2":{"171":1}}],["可以这样做",{"2":{"157":1}}],["可以选择捕获对应的指针",{"2":{"151":1}}],["可以直接使用这个函数",{"2":{"111":1}}],["可以直接使用普通的可选指针",{"2":{"20":1}}],["可以能会对值进行缓存",{"2":{"84":1}}],["可以无缝与",{"2":{"82":1}}],["可以参考这里std",{"2":{"119":1}}],["可以参考这里https",{"2":{"29":1}}],["可以参照",{"2":{"111":1}}],["可以参照以下示例",{"2":{"61":1}}],["可以分配给元素为常量的切片",{"2":{"45":1}}],["可以转换为可以表示旧类型全部值的浮点类型",{"2":{"43":1}}],["可以做到比",{"0":{"23":1}}],["可以强制转换为其他的任意指针类型",{"2":{"20":1}}],["可以在线执行",{"2":{"296":1}}],["可以在此处",{"2":{"192":1}}],["可以在如此多环境",{"2":{"25":1}}],["可以在",{"2":{"13":1,"164":1}}],["可以使用的动态链接库",{"2":{"292":1}}],["可以使用将",{"2":{"249":1}}],["可以使用函数来初始化数组",{"2":{"65":1}}],["可以使用转义",{"2":{"61":1}}],["可以使用",{"2":{"9":1,"28":1,"36":1,"37":2,"59":1,"63":1,"102":2,"173":2,"178":2,"186":1,"191":1,"195":1,"196":1,"244":1,"269":2}}],["可以查看该",{"2":{"5":1}}],["可以查看我的这篇文章",{"2":{"4":1}}],["dropfn",{"2":{"244":5}}],["draw",{"2":{"196":2}}],["dnf",{"2":{"218":1}}],["download",{"2":{"220":1}}],["down",{"2":{"196":1}}],["don",{"2":{"196":1}}],["doptimize=releasesafe",{"2":{"208":1}}],["doptimize=debug",{"2":{"184":1}}],["doptimize",{"2":{"184":1}}],["dosomethingwithfoo",{"2":{"145":2}}],["dosomethingwithnumber",{"2":{"134":2}}],["doadifferentthing",{"2":{"134":1}}],["doathing",{"2":{"133":1,"134":3,"145":2}}],["do",{"2":{"133":1,"145":7,"156":1,"157":1,"158":1,"196":2}}],["double",{"2":{"126":1}}],["dothetest",{"2":{"99":3}}],["document>",{"2":{"264":2}}],["document",{"2":{"264":1}}],["documentation",{"2":{"4":2}}],["docs",{"2":{"190":9}}],["docgen",{"2":{"44":1,"124":2,"266":1}}],["data",{"2":{"78":2,"92":1,"195":2,"252":3}}],["different",{"2":{"220":1}}],["dir",{"2":{"190":2,"264":2}}],["dis",{"2":{"187":1}}],["digit",{"2":{"132":4}}],["divexact",{"2":{"125":1,"271":2,"274":1}}],["divtrunc",{"2":{"125":1,"271":2}}],["divfloor",{"2":{"102":1,"125":1,"271":2}}],["divided",{"2":{"99":7}}],["division",{"2":{"44":1,"124":10}}],["diamonds",{"2":{"69":1}}],["duckdb",{"2":{"39":2}}],["dt",{"2":{"39":1}}],["decrement",{"2":{"244":2}}],["decremented",{"2":{"244":1}}],["decls",{"2":{"261":1}}],["decl",{"2":{"200":1}}],["declared",{"2":{"200":1}}],["declarations",{"2":{"200":2}}],["declaration",{"2":{"200":1,"261":1}}],["decltest",{"2":{"199":3}}],["dev",{"2":{"213":1,"218":2}}],["demo",{"2":{"200":3}}],["deallocatetmpbuffer",{"2":{"135":1}}],["deallocatefoo",{"2":{"135":1}}],["derp",{"2":{"74":2,"85":2}}],["dependon",{"2":{"186":2,"190":1,"191":1,"193":2,"194":2,"195":2,"196":2}}],["dependency",{"2":{"35":1,"37":7}}],["dependencies",{"2":{"35":2}}],["dep",{"2":{"35":2}}],["destroy",{"2":{"32":1}}],["deinit",{"2":{"26":3,"28":5,"29":1,"32":1,"90":3}}],["default",{"2":{"195":2,"261":1}}],["defaultoutput",{"2":{"100":1}}],["defaultmore",{"2":{"89":1,"90":1,"94":1,"149":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1}}],["defaultthread",{"2":{"27":1}}],["defererror",{"2":{"135":1}}],["defererrorcaptureexample",{"2":{"135":1}}],["defer",{"0":{"153":1},"2":{"21":1,"26":3,"27":2,"28":4,"29":2,"30":1,"31":1,"32":1,"90":7,"135":6,"153":9}}],["define",{"2":{"19":1}}],["debug",{"2":{"3":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"76":1,"77":1,"78":1,"80":1,"81":2,"89":1,"90":4,"94":1,"100":3,"102":1,"108":2,"124":1,"126":1,"129":1,"131":1,"134":1,"135":1,"139":1,"141":1,"142":2,"145":1,"148":1,"149":1,"153":1,"162":2,"167":2,"168":2,"170":1,"173":1,"176":1,"178":1,"184":9,"188":1,"193":1,"194":1,"230":1,"231":1,"232":1,"249":2,"253":2,"254":1,"255":4,"256":4,"257":2,"258":1,"259":1,"261":1,"271":1}}],["d",{"2":{"15":2,"17":3,"24":1,"37":1,"43":2,"61":4,"68":1,"74":1,"89":1,"105":1,"152":2,"171":2,"173":4,"196":2,"231":1,"261":2}}],["就会发生非法越界",{"2":{"282":1}}],["就会将rax寄存器的值通过",{"2":{"4":1}}],["就很方便",{"2":{"216":1}}],["就只是和其他编程语言中",{"2":{"144":1}}],["就行了",{"2":{"112":1}}],["就像",{"2":{"43":1}}],["就是一个零位类型",{"2":{"290":1}}],["就是一个函数指针类型",{"2":{"111":1}}],["就是零位类型",{"2":{"288":1}}],["就是以",{"2":{"184":1}}],["就是标记",{"2":{"160":1,"165":1}}],["就是可选类型",{"2":{"152":1}}],["就是文档注释",{"2":{"144":1}}],["就是普通的注释",{"2":{"144":1}}],["就是推断错误集",{"2":{"136":1}}],["就是代表这个类型变成错误联合类型",{"2":{"132":1}}],["就是匿名结构体要如何实现自引用呢",{"2":{"90":1}}],["就是这个语法表示数组的长度索引处的元素应该是",{"2":{"57":1}}],["就是",{"2":{"44":2,"151":1}}],["就是获取变量",{"2":{"79":1}}],["就是获取",{"2":{"35":1}}],["就是分支名",{"2":{"35":1}}],["就是对应的仓库名",{"2":{"35":1}}],["就是组织名或者用户名",{"2":{"35":1}}],["就是全局汇编",{"2":{"3":1}}],["就支持",{"2":{"35":1}}],["就可以在本机实现完善的交叉编译",{"2":{"24":1}}],["就可以实现在没有",{"2":{"23":1}}],["其目标是更小",{"2":{"293":1}}],["其还支持九种操作符",{"2":{"239":1}}],["其次你可能注意到路径前面还有一个",{"2":{"215":1}}],["其发布周期约为",{"2":{"211":1}}],["其参数为",{"2":{"185":1}}],["其内部可以是一个语句或者是一个作用域",{"2":{"163":1}}],["其实更好的解决办法就是显示声明一个错误集",{"2":{"136":1}}],["其中有一个字段是",{"2":{"254":1}}],["其中目前最为激进的应该是",{"2":{"145":1}}],["其中包含是否存在溢出",{"2":{"125":1}}],["其中包含着许多的",{"2":{"120":1}}],["其中你可以选择指明数组的大小或者使用",{"2":{"55":1}}],["其中",{"2":{"37":1,"78":1,"157":1}}],["其中的每个节点",{"2":{"185":1}}],["其中的",{"2":{"35":1,"111":1}}],["其他情况",{"2":{"264":5}}],["其他情况下",{"2":{"100":1,"264":1}}],["其他情况下建议使用",{"2":{"98":1}}],["其他的包管理器",{"0":{"214":1}}],["其他的文件import该文件后",{"2":{"111":1}}],["其他仅支持动态链接",{"2":{"24":1}}],["其他平台仍使用",{"2":{"23":1}}],["其后的",{"2":{"4":1}}],["其对",{"2":{"2":1}}],["寄存器中的值",{"2":{"4":1}}],["寄存器就是",{"2":{"4":1}}],["vcpkg",{"2":{"292":1}}],["vim",{"0":{"208":1},"2":{"208":7,"209":1}}],["visual",{"2":{"205":1,"206":1}}],["visualstudio",{"2":{"205":1,"206":1}}],["v",{"2":{"104":3,"196":2,"200":1}}],["vec2",{"2":{"102":3}}],["vec",{"2":{"102":3}}],["vectors",{"2":{"105":1}}],["vector",{"2":{"101":1,"102":7,"103":1,"104":1,"105":11,"106":6}}],["version=",{"2":{"264":1}}],["version>",{"2":{"220":4}}],["versions",{"2":{"213":2,"220":3}}],["version",{"2":{"35":3,"213":1,"215":2}}],["verbose",{"2":{"17":2}}],["vs是一个基本完整的开发工具集",{"2":{"206":1}}],["vs",{"0":{"16":1,"205":1,"206":1}}],["val",{"2":{"56":3}}],["value|",{"2":{"151":1,"152":4,"155":1,"179":1}}],["values",{"2":{"96":3}}],["value3",{"2":{"68":1}}],["value2",{"2":{"53":2,"68":1}}],["value1",{"2":{"53":2}}],["value",{"2":{"4":1,"8":14,"66":3,"68":2,"104":3,"124":1,"139":1,"151":1,"152":8,"155":4,"157":1,"159":2,"167":2,"168":2,"175":1,"179":2,"196":1,"238":1,"240":2,"241":2,"244":3,"261":1,"286":1}}],["va",{"2":{"21":3}}],["variable",{"2":{"85":2,"100":1,"139":5,"142":4,"275":1}}],["var",{"2":{"8":5,"10":2,"19":2,"21":3,"26":1,"27":5,"28":2,"29":2,"30":1,"32":1,"45":3,"49":1,"65":1,"66":2,"76":4,"77":3,"78":2,"80":1,"81":5,"85":2,"86":2,"87":1,"89":2,"90":6,"91":1,"99":4,"102":1,"108":3,"124":4,"132":2,"139":3,"142":1,"143":1,"146":1,"148":1,"155":1,"161":2,"162":1,"163":1,"164":1,"166":4,"167":2,"168":2,"170":1,"173":2,"178":4,"179":1,"232":8,"244":1,"252":1,"255":1,"256":1,"257":2,"258":1,"264":3,"281":1}}],["volatile",{"0":{"84":1},"2":{"4":4,"42":1,"84":4,"124":1,"266":1}}],["void`",{"2":{"238":1}}],["void",{"0":{"286":1},"2":{"3":1,"12":1,"13":1,"17":1,"19":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"49":4,"53":2,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"70":1,"71":1,"74":2,"75":1,"76":1,"77":1,"78":1,"80":1,"81":2,"82":1,"85":4,"89":1,"90":6,"94":1,"95":1,"99":1,"100":1,"102":1,"108":2,"111":1,"116":1,"118":1,"124":1,"126":1,"129":1,"133":1,"134":4,"135":1,"139":1,"140":1,"141":1,"142":1,"145":4,"148":1,"149":1,"153":1,"161":2,"162":1,"166":2,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":4,"185":2,"186":1,"187":1,"188":2,"189":2,"190":1,"191":1,"193":2,"194":2,"195":3,"196":7,"199":1,"200":1,"218":1,"230":1,"232":3,"242":1,"244":4,"249":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"261":1,"264":2,"271":1,"286":2}}],["占位符",{"2":{"4":2}}],["硬件",{"2":{"4":1}}],["例如字符串就是",{"2":{"231":1}}],["例如我们在这里使用的就是函数名字",{"2":{"199":1}}],["例如我们可以让",{"2":{"194":1}}],["例如我们可以以此实现让程序打印构建时的时间戳",{"2":{"188":1}}],["例如我们可以在",{"2":{"186":1}}],["例如依赖中的包",{"2":{"191":1}}],["例如某些",{"2":{"186":1}}],["例如要构建的二进制程序",{"2":{"186":1}}],["例如以上示例中的",{"2":{"185":1}}],["例如以下代码是非法的",{"2":{"143":1}}],["例如内存结构不同",{"2":{"184":1}}],["例如与外部库的链接",{"2":{"140":1}}],["例如获取函数指针或者在不同构建目标之间保持相同的错误集合",{"2":{"136":1}}],["例如panic",{"2":{"133":1}}],["例如有些分数无法用小数表示",{"2":{"126":1}}],["例如可以把一个源文件看作是一个匿名的结构体",{"2":{"100":1}}],["例如非",{"2":{"42":1}}],["例如链接库",{"2":{"37":1}}],["例如动态链接库和静态链接库",{"2":{"36":1}}],["例如web",{"2":{"28":1}}],["例如对齐",{"2":{"20":1}}],["例如",{"2":{"9":1,"16":1,"19":1,"35":2,"36":1,"44":1,"85":1,"90":2,"91":1,"96":1,"102":1,"108":1,"117":1,"122":1,"127":1,"184":1,"186":1,"189":1,"194":1,"249":1,"270":1,"282":1,"286":1,"290":1}}],["例如上方的示例中",{"2":{"4":1}}],["例如使用示例",{"2":{"245":1}}],["例如使用内存映射输入输出",{"2":{"84":1}}],["例如使用",{"2":{"4":1}}],["例如操作系统",{"2":{"4":1}}],["例如工业控制的程序",{"2":{"2":1}}],["关于原子顺序六个级别的具体说明",{"2":{"236":1}}],["关于流这个概念可能不好解释",{"2":{"232":1}}],["关于头文件的引入",{"2":{"195":1,"196":1}}],["关于所有的",{"2":{"192":1}}],["关于为什么",{"2":{"184":1}}],["关于可以使用的调用约定格式",{"2":{"119":1}}],["关于函数指针",{"2":{"111":1}}],["关于函数命名",{"2":{"111":1}}],["关于零指针的使用",{"2":{"86":1}}],["关于指针运算",{"2":{"79":1}}],["关于循环我们放在后面再聊",{"2":{"56":1}}],["关于越界问题",{"2":{"55":1}}],["关于二进制构建结果",{"2":{"36":1}}],["关于这个我们会在",{"2":{"66":1}}],["关于这个模型的更多信息",{"2":{"29":1}}],["关于这个结构体的名字",{"2":{"10":1}}],["关于更多的细节",{"2":{"23":1}}],["关于更多的内联汇编约束信息",{"2":{"4":1}}],["关于",{"2":{"19":1,"108":1,"135":1,"184":1,"196":1,"223":1}}],["关于本站",{"0":{"0":1},"1":{"1":1}}],["关键字进行修饰",{"2":{"249":1}}],["关键字会将",{"2":{"161":1,"166":1}}],["关键字会通知编译器",{"2":{"4":1}}],["关键字保证解构了可选类型",{"2":{"145":1}}],["关键字保证函数可以在生成的",{"2":{"117":1}}],["关键字定义了两个错误类型",{"2":{"129":1}}],["关键字告诉函数的调用约定",{"2":{"119":1}}],["关键字后面带引号的标识符指定具有该函数的库",{"2":{"117":1}}],["关键字意味着该参数必须在编译期已知",{"2":{"113":1}}],["关键字修饰结构体",{"2":{"99":1}}],["关键字用于修饰结构体",{"2":{"98":1}}],["关键字来修饰",{"2":{"84":1}}],["关键字来很轻松地声明并使用枚举",{"2":{"68":1}}],["关键字",{"2":{"6":1,"73":1,"199":1,"249":1}}],["关键字开头的一个表达式",{"2":{"4":1}}],[">=",{"2":{"127":1,"132":1}}],[">>=",{"2":{"127":1}}],[">>",{"2":{"127":1,"196":1}}],[">",{"2":{"4":3,"7":2,"104":1,"111":1,"127":1,"135":1,"186":2,"196":5,"264":1}}],["u0",{"2":{"287":1}}],["upgrade",{"2":{"220":1}}],["update",{"2":{"196":4}}],["updating",{"2":{"23":1,"244":1}}],["ubuntu",{"2":{"218":1}}],["utc",{"2":{"144":1}}],["utf8",{"2":{"61":2}}],["utf",{"2":{"61":5,"62":1,"212":2,"264":1}}],["u3",{"2":{"99":2}}],["u32",{"2":{"9":2,"32":1,"43":1,"68":1,"96":1,"99":3,"103":2,"119":2,"122":1,"124":2,"144":1,"149":4,"151":3,"152":6,"167":3,"168":3,"171":2,"173":4,"175":2,"257":3,"258":1,"261":1,"264":1,"281":1}}],["u4",{"2":{"68":1,"99":2}}],["u2",{"2":{"49":4,"68":2,"70":1,"99":1}}],["u",{"2":{"49":14,"61":2,"62":1,"122":1,"175":4,"200":5}}],["u1",{"2":{"70":1,"125":1}}],["u128",{"2":{"43":1,"122":1}}],["u16",{"2":{"43":3,"53":1,"99":1,"122":1,"129":2,"139":1,"141":1,"142":1,"270":1}}],["u64",{"2":{"43":2,"48":1,"122":1,"132":6,"133":1,"171":3}}],["url",{"2":{"35":3}}],["ulonglong",{"2":{"12":1}}],["ulong",{"2":{"12":1}}],["uintptr",{"2":{"122":1}}],["uint64",{"2":{"122":1}}],["uint32",{"2":{"122":1}}],["uint16",{"2":{"122":1}}],["uint8",{"2":{"122":1}}],["uint",{"2":{"12":1,"116":1}}],["usingnamespace",{"0":{"249":1},"2":{"249":5}}],["usize",{"2":{"4":13,"9":3,"10":1,"21":1,"49":1,"52":2,"53":5,"66":1,"76":1,"77":1,"78":1,"85":1,"86":1,"90":1,"92":1,"122":2,"145":1,"158":2,"160":2,"161":4,"162":2,"163":3,"164":3,"165":1,"166":4,"175":2,"244":2,"264":2}}],["use",{"2":{"244":1}}],["user",{"2":{"90":11,"172":4,"195":1,"215":3}}],["username",{"2":{"17":3,"35":2,"90":18}}],["usleep",{"2":{"196":1}}],["usable",{"2":{"30":1}}],["us",{"2":{"29":1,"200":3}}],["ushort",{"2":{"12":1}}],["unreachabel",{"2":{"267":1}}],["unreachable",{"0":{"176":1},"2":{"4":1,"116":1,"134":4,"137":1,"151":1,"152":4,"161":2,"166":2,"176":4,"179":2,"266":3}}],["unrefs",{"2":{"244":1}}],["unref",{"2":{"195":1,"244":3}}],["unsigned",{"2":{"122":1}}],["unaligned",{"2":{"85":2}}],["unable",{"2":{"19":1}}],["uninstall",{"2":{"220":1}}],["unistd",{"2":{"196":1}}],["unit",{"2":{"191":7,"198":1}}],["unicode",{"2":{"61":4,"62":1,"212":1,"293":1}}],["unioninit",{"2":{"178":4}}],["union",{"0":{"173":1,"181":1,"182":1},"2":{"49":2,"173":2,"175":2,"177":1,"178":7,"179":3,"180":1,"181":1,"182":1,"200":2,"281":1}}],["unixepoch",{"2":{"144":1}}],["unix",{"2":{"39":1,"144":1}}],["unexpected",{"2":{"19":1}}],["undefined",{"0":{"50":1,"142":1},"2":{"10":1,"27":2,"50":1,"66":1,"105":7,"124":1,"142":3,"167":1,"168":1,"264":1,"266":2}}],["u8",{"2":{"8":2,"21":1,"26":1,"27":4,"28":3,"29":1,"30":1,"31":1,"36":1,"37":2,"43":6,"45":22,"48":2,"51":3,"53":21,"55":2,"57":1,"61":4,"70":2,"72":1,"78":2,"82":1,"84":2,"85":6,"89":5,"90":17,"96":2,"99":2,"105":6,"108":6,"111":6,"122":1,"127":1,"132":5,"133":1,"134":4,"145":1,"148":1,"170":2,"173":2,"178":1,"179":4,"195":1,"254":2,"264":1,"270":2,"271":1}}],["615744",{"2":{"196":1}}],["615696",{"2":{"196":1}}],["614928",{"2":{"196":1}}],["610832",{"2":{"196":1}}],["67",{"2":{"91":1}}],["666",{"2":{"80":1,"139":2,"141":1,"142":1,"178":1,"261":1}}],["6f35761b17b87ee4c9f26e643a06e289",{"2":{"17":2}}],["6",{"2":{"8":2,"51":1,"60":2,"99":1,"102":2,"105":2,"106":2,"124":1,"158":1,"160":3,"161":4,"173":2,"211":1}}],["60",{"2":{"4":1}}],["64",{"2":{"2":1,"4":3,"23":1,"24":4,"85":2,"122":1,"192":1,"215":3}}],["00",{"2":{"144":3}}],["0000",{"2":{"122":3}}],["000",{"2":{"122":3}}],["0o755",{"2":{"123":1}}],["0o7",{"2":{"122":1}}],["0b11110000",{"2":{"123":1}}],["0b1",{"2":{"122":1}}],["0xaa",{"2":{"142":1}}],["0x0",{"2":{"124":1,"266":1}}],["0xff",{"2":{"123":1,"140":1}}],["0xff80",{"2":{"122":1}}],["0x12",{"2":{"99":2}}],["0x1234",{"2":{"99":1}}],["0x12345678",{"2":{"84":1}}],["0x123456780",{"2":{"53":2}}],["0x1",{"2":{"99":1,"280":2}}],["0x222cf1",{"2":{"266":1}}],["0x222c65",{"2":{"266":1}}],["0x22319c",{"2":{"266":1}}],["0x223c8a",{"2":{"266":1}}],["0x22da7d",{"2":{"266":1}}],["0x21dbd1",{"2":{"124":1}}],["0x21e082",{"2":{"124":1}}],["0x21e83e",{"2":{"124":1}}],["0x2",{"2":{"99":1}}],["0x34",{"2":{"99":3}}],["0x",{"2":{"61":2}}],["0",{"2":{"4":1,"8":4,"10":1,"20":3,"21":3,"34":1,"35":3,"44":5,"52":1,"53":9,"55":2,"56":29,"57":2,"61":3,"63":1,"66":1,"76":3,"77":3,"78":5,"81":3,"82":1,"85":1,"86":2,"90":6,"94":1,"99":6,"104":1,"105":5,"107":1,"124":2,"126":6,"129":2,"132":7,"136":4,"144":2,"147":1,"152":4,"155":3,"156":1,"157":2,"159":1,"160":2,"161":2,"162":2,"163":1,"165":1,"166":6,"167":2,"168":2,"171":1,"175":1,"179":1,"196":25,"207":2,"208":1,"211":1,"244":1,"245":1,"252":2,"257":2,"258":2,"264":2,"271":3,"283":3,"285":2,"287":1,"288":1,"290":1}}],["0版本",{"2":{"0":1}}],["won",{"2":{"196":1,"200":1}}],["work",{"2":{"124":3,"266":6}}],["world",{"0":{"230":1},"1":{"231":1,"232":1,"233":1,"234":1},"2":{"4":2,"63":3,"82":1,"90":1,"105":1,"193":1,"195":3,"230":2,"231":1,"232":1,"234":1,"249":1}}],["whether",{"2":{"187":2}}],["while",{"0":{"162":1},"1":{"163":1,"164":1,"165":1,"166":1,"167":1,"168":1},"2":{"8":2,"9":1,"21":1,"53":1,"116":1,"118":1,"154":1,"159":1,"160":1,"162":3,"163":3,"164":4,"165":5,"166":4,"167":4,"168":4,"196":3}}],["wrapping",{"2":{"104":1,"271":1}}],["writer",{"2":{"90":2,"232":11}}],["write",{"2":{"4":2}}],["we",{"2":{"90":1,"172":2,"244":1}}],["webui",{"2":{"39":2}}],["wasm",{"0":{"284":1}}],["wasd",{"2":{"196":1}}],["wat",{"2":{"74":2}}],["warning",{"2":{"4":1,"7":1,"14":1,"36":1,"111":1,"135":1,"152":1,"195":1,"196":1,"223":1,"224":1,"228":1,"230":1,"254":1,"261":1}}],["widnows",{"2":{"212":1}}],["widget",{"2":{"195":1}}],["will",{"2":{"153":1,"196":1}}],["wingetchocolatey",{"2":{"214":1}}],["winget",{"2":{"214":1}}],["window",{"2":{"195":15}}],["windows",{"0":{"212":1},"1":{"213":1,"214":1,"215":1},"2":{"29":3,"206":1,"212":2,"215":3}}],["winapi",{"2":{"116":1}}],["win32",{"2":{"29":1}}],["withswitch",{"2":{"175":1}}],["with",{"2":{"4":1,"23":1,"89":1,"140":1,"145":1,"195":1,"196":1}}],["w",{"2":{"8":2,"74":2,"105":2,"196":2}}],["save=limine",{"2":{"228":1}}],["save",{"2":{"228":2}}],["safety",{"2":{"266":3}}],["safe",{"2":{"27":6}}],["snap",{"2":{"218":2}}],["srand",{"2":{"196":1}}],["src",{"2":{"37":1,"185":1,"187":1,"188":1,"189":2,"191":2,"192":1,"193":2,"194":1,"195":1,"196":1,"223":2,"224":2,"230":1,"231":1}}],["slowly",{"2":{"196":1}}],["slice4",{"2":{"85":1}}],["slice类型",{"2":{"78":2}}],["slice",{"2":{"53":4,"76":11,"77":6,"78":4,"81":5,"85":4,"175":1}}],["skipzigtest",{"2":{"201":1}}],["skip",{"2":{"191":2}}],["something",{"2":{"145":1,"156":1,"157":1,"158":1}}],["some",{"2":{"145":4}}],["so",{"2":{"117":1,"196":1}}],["source",{"2":{"13":1,"17":1,"24":1,"36":3,"37":1,"185":2,"186":1,"187":1,"188":1,"189":3,"190":1,"191":2,"192":1,"193":3,"194":3,"195":1,"196":1,"208":2}}],["scoop",{"0":{"213":1},"2":{"213":5}}],["score++",{"2":{"196":1}}],["score",{"2":{"196":4}}],["scopedloggingallocator",{"2":{"25":1}}],["scalar",{"2":{"103":4}}],["spinloophint",{"0":{"245":1},"2":{"245":3}}],["specific",{"2":{"187":1}}],["spartan",{"2":{"270":2}}],["spaces",{"2":{"140":1}}],["spades",{"2":{"69":1}}],["splat",{"0":{"103":1},"2":{"102":1,"103":2,"104":1}}],["sqrt",{"2":{"102":1}}],["sqlite",{"2":{"39":2}}],["side",{"2":{"252":1}}],["silverblue",{"2":{"218":1}}],["signal",{"2":{"124":1,"195":2}}],["simd",{"2":{"101":1,"102":5}}],["single",{"2":{"79":1}}],["sizeof",{"2":{"85":1,"94":1,"99":2}}],["size",{"2":{"30":1,"122":1,"145":3,"195":1,"264":2}}],["success",{"2":{"240":1,"241":1}}],["su",{"2":{"218":1}}],["support",{"2":{"207":1}}],["sublime",{"0":{"210":1},"2":{"210":1}}],["subdir",{"2":{"190":1}}],["subwithoverflow",{"2":{"125":1,"271":1}}],["sub",{"2":{"117":1,"271":1}}],["suit",{"2":{"69":3}}],["sum1",{"2":{"168":3}}],["sum2",{"2":{"167":3}}],["sum",{"2":{"21":3,"155":2,"161":6,"166":6}}],["small2",{"2":{"179":2}}],["small",{"2":{"59":2,"70":5}}],["s",{"2":{"55":2,"63":1,"90":6,"99":3,"100":3,"135":1,"144":1,"193":1,"194":1,"196":2,"200":5,"218":1,"231":1,"232":4,"244":2,"253":2,"254":1,"257":2}}],["swarkland",{"2":{"39":1}}],["switch",{"0":{"169":1,"175":1},"1":{"170":1,"171":1,"172":1,"173":1,"174":1,"175":1},"2":{"7":1,"9":1,"49":1,"53":1,"72":2,"99":1,"124":1,"132":1,"134":2,"136":1,"161":2,"166":2,"169":1,"170":3,"171":2,"172":2,"173":3,"174":2,"175":4,"179":2,"266":1}}],["se",{"2":{"200":1}}],["second",{"2":{"153":1}}],["seconds",{"2":{"144":2}}],["sequential",{"2":{"104":1}}],["select",{"0":{"106":1},"2":{"102":1,"106":2}}],["self",{"2":{"49":2,"69":2,"89":6,"90":16,"186":1}}],["setruntimesafety",{"2":{"266":1}}],["setenvironmentvariable",{"2":{"215":2}}],["setevalbranchquota",{"2":{"9":1}}],["set",{"2":{"195":3,"196":7,"286":1}}],["setfloatmode",{"2":{"126":2}}],["setcold",{"0":{"118":1},"2":{"118":2}}],["setybasedonx",{"2":{"95":1}}],["sentinel",{"2":{"57":1}}],["semantic",{"2":{"35":1}}],["server",{"2":{"28":1,"39":1,"205":1,"208":1}}],["sbrkallocator",{"2":{"25":1}}],["shl",{"2":{"271":1}}],["shlwithoverflow",{"2":{"125":1,"271":1}}],["shport",{"2":{"216":1}}],["shproject",{"2":{"187":1}}],["shbrew",{"2":{"216":1}}],["shchoco",{"2":{"214":1}}],["shcc=",{"2":{"24":2}}],["shwinget",{"2":{"214":1}}],["shscoop",{"2":{"213":2}}],["share",{"2":{"208":1}}],["sh",{"2":{"194":2,"208":2,"223":1,"224":1}}],["shiftleftone",{"2":{"119":1}}],["ships",{"2":{"23":1}}],["shuffle",{"0":{"105":1},"2":{"102":1,"105":4}}],["shvariable",{"2":{"100":1}}],["sh第1个元素为",{"2":{"76":1}}],["shell$",{"2":{"44":1,"199":1}}],["should",{"2":{"196":1}}],["show",{"2":{"38":1}}],["shortlist",{"2":{"264":1}}],["short",{"2":{"12":1}}],["sh$",{"2":{"17":1,"124":2,"228":1,"253":1,"266":1}}],["stb",{"2":{"249":1}}],["stbi",{"2":{"249":2}}],["studio是微软公司的开发工具包系列产品",{"2":{"206":1}}],["studio",{"2":{"205":1}}],["stuff",{"2":{"145":4}}],["stick",{"2":{"196":1}}],["step",{"0":{"186":1},"2":{"185":5,"186":16,"187":1,"188":1,"189":1,"190":7,"191":8,"193":8,"194":8,"195":7,"196":7}}],["string",{"2":{"196":1,"264":1}}],["strip=",{"2":{"187":1}}],["strip",{"2":{"187":7}}],["strict",{"2":{"126":1}}],["str",{"2":{"78":3,"133":3,"134":8}}],["structalias",{"2":{"264":1}}],["structname",{"2":{"264":2}}],["structfield",{"2":{"254":1}}],["structs",{"2":{"99":1}}],["struct",{"2":{"8":1,"10":1,"20":4,"51":1,"69":1,"89":3,"90":4,"91":1,"92":2,"93":1,"94":2,"95":1,"96":1,"99":5,"100":8,"144":2,"145":3,"173":1,"175":1,"181":1,"182":1,"200":4,"244":1,"249":1,"253":2,"254":6,"255":1,"256":1,"257":1,"258":1,"261":1,"264":4,"290":1}}],["stamp",{"2":{"188":4}}],["standardoptimizeoption",{"2":{"37":1,"184":1,"185":2,"187":1,"188":1,"189":1,"191":1,"193":1,"194":1,"195":1,"196":1}}],["standardtargetoptions",{"2":{"37":1,"185":2,"187":1,"188":1,"189":1,"191":1,"192":1,"193":1,"194":1,"195":1,"196":1}}],["stat",{"2":{"140":1}}],["status",{"2":{"26":2,"28":2,"90":2,"195":3}}],["static",{"2":{"24":1,"195":2}}],["stackfallbackallocator",{"2":{"25":1}}],["started",{"2":{"220":1}}],["start",{"2":{"8":8,"21":1,"78":1,"81":1,"124":3,"196":2,"266":3}}],["stderr",{"2":{"232":4}}],["stdscr",{"2":{"196":1}}],["stdlib",{"2":{"196":1}}],["stdin",{"2":{"191":2}}],["stdio",{"2":{"13":2,"17":2,"63":1,"249":1}}],["stdout",{"2":{"4":2,"191":1,"232":3}}],["std",{"0":{"243":1},"1":{"244":1,"245":1},"2":{"3":3,"8":1,"9":1,"21":2,"25":7,"26":3,"27":7,"28":4,"29":3,"30":3,"31":3,"32":4,"33":3,"36":5,"37":7,"49":3,"53":4,"55":1,"56":1,"57":1,"59":1,"60":1,"61":3,"63":1,"65":1,"66":1,"70":4,"76":1,"77":1,"78":1,"80":1,"81":2,"82":3,"84":1,"85":4,"86":3,"87":1,"89":3,"90":12,"94":3,"99":9,"100":5,"102":3,"104":1,"108":2,"124":5,"125":1,"126":8,"129":3,"132":3,"135":1,"139":3,"140":1,"141":3,"142":3,"146":1,"148":1,"149":1,"153":3,"161":3,"162":4,"166":3,"167":4,"168":4,"170":3,"173":3,"178":1,"179":7,"185":6,"186":3,"187":3,"188":7,"189":6,"190":3,"191":3,"192":1,"193":6,"194":6,"195":3,"196":3,"199":4,"200":8,"202":1,"230":3,"231":1,"232":10,"233":1,"235":1,"244":1,"245":1,"249":2,"252":3,"253":4,"254":5,"255":6,"256":6,"257":4,"258":3,"259":3,"261":4,"266":2,"269":1,"271":8,"286":3}}],["system",{"2":{"215":1}}],["systemuser",{"2":{"215":1}}],["syscall",{"2":{"4":2}}],["syscall1",{"2":{"4":2}}],["syscall3",{"2":{"4":2}}],["sys",{"2":{"4":4,"194":3}}],["lspconfig",{"2":{"208":1}}],["lsp",{"2":{"208":1,"209":1}}],["lua",{"2":{"208":1}}],["lt",{"2":{"85":2,"102":3,"127":6}}],["l",{"2":{"43":2,"45":8,"55":4,"105":1}}],["lang",{"2":{"218":1}}],["language这个插件即可",{"2":{"205":1}}],["language",{"2":{"39":1,"131":1,"205":1,"208":1,"210":1}}],["landed",{"2":{"196":1}}],["layout",{"2":{"196":1,"261":1}}],["label",{"2":{"195":1}}],["last",{"2":{"92":1}}],["largefile64",{"2":{"24":1}}],["ld",{"2":{"39":1}}],["ldfalgs",{"2":{"24":1}}],["ldflags=",{"2":{"24":1}}],["lc",{"2":{"13":1,"17":1}}],["loris",{"2":{"234":1}}],["local",{"2":{"208":1,"220":1,"266":1}}],["loop",{"2":{"196":1}}],["lola",{"2":{"39":1}}],["log",{"2":{"102":1,"232":1}}],["logtowriterallocator",{"2":{"25":1}}],["loggingallocator",{"2":{"25":1}}],["longdouble",{"2":{"12":1,"126":1}}],["longlong",{"2":{"12":1}}],["long",{"2":{"12":1,"126":1}}],["low",{"2":{"4":1,"79":1,"292":2,"294":1}}],["limit",{"2":{"129":1}}],["limine",{"2":{"35":3,"228":4}}],["little",{"2":{"99":1}}],["libstdc++",{"2":{"196":1}}],["libz",{"2":{"189":2}}],["library",{"2":{"37":3}}],["lib",{"0":{"224":1},"2":{"36":4,"124":2,"189":10,"190":2,"199":1,"223":1,"224":1,"230":1,"266":4}}],["libc++",{"2":{"196":2}}],["libc",{"0":{"24":1},"2":{"11":1,"13":1,"23":5,"24":1,"82":1,"117":1,"189":1,"294":1,"295":1}}],["line",{"2":{"196":4}}],["linksystemlibrary",{"2":{"189":2,"195":2,"196":1}}],["linkedlist",{"2":{"92":1}}],["linklibrary",{"2":{"37":1,"189":1}}],["linklibcpp",{"2":{"196":1}}],["linklibc",{"2":{"13":1,"30":1,"82":1,"189":1,"195":2}}],["link",{"2":{"35":1,"36":1}}],["linkmode=external",{"2":{"24":1}}],["linux安装的话",{"2":{"217":1}}],["linux",{"0":{"217":1},"1":{"218":1,"219":1},"2":{"4":1,"23":2,"24":5,"172":6,"196":1,"218":2}}],["listtemplatefunction",{"2":{"264":1}}],["list",{"2":{"10":6,"90":7,"100":3,"220":1,"264":1}}],["llvm",{"2":{"4":1,"23":2,"192":2,"196":1,"211":1,"236":1}}],["lets",{"2":{"220":1}}],["let",{"2":{"208":1}}],["left",{"2":{"167":5,"168":5}}],["leftover",{"2":{"134":1}}],["legend",{"2":{"39":1}}],["lemm",{"2":{"38":1}}],["length",{"2":{"78":2,"90":2}}],["len",{"2":{"4":1,"8":1,"10":2,"53":2,"57":3,"61":1,"70":1,"76":5,"77":3,"78":1,"81":4,"90":5,"92":1,"96":1,"105":4,"106":4,"161":2,"166":2,"175":2}}],["level",{"2":{"4":1,"79":1,"131":1,"200":1,"292":2,"294":1}}],["learn",{"2":{"29":1}}],["leak",{"2":{"26":1,"28":1,"90":1}}],["lea",{"2":{"3":1}}],["的平台",{"2":{"296":1}}],["的高级语言",{"2":{"294":1}}],["的社区需要更多的人来构建",{"2":{"292":1}}],["的特性也的确在这个方向发展",{"2":{"292":1}}],["的特性实现中断处理的文章",{"2":{"4":1}}],["的替代",{"2":{"292":1}}],["的替代品了",{"2":{"292":1}}],["的替代品",{"2":{"39":1,"292":1}}],["的的确确比",{"2":{"292":1}}],["的代替品的",{"2":{"292":1}}],["的代码",{"2":{"14":1}}],["的代码翻译为",{"2":{"14":1}}],["的未来也可能是这样子",{"2":{"292":1}}],["的超集",{"2":{"292":1}}],["的长度为",{"2":{"288":1}}],["的长度决定返回的向量的长度",{"2":{"105":1}}],["的安全检查",{"2":{"266":1}}],["的习惯",{"2":{"263":1}}],["的反函数",{"2":{"261":1}}],["的字段或者容器类型的声明",{"2":{"257":1}}],["的信息",{"2":{"254":1}}],["的世界打一声招呼",{"2":{"230":1}}],["的版本管理工具主要有如下几个",{"2":{"220":1}}],["的发行版和对应命令",{"2":{"218":1}}],["的发布往往要间隔很久",{"2":{"211":1}}],["的发布",{"2":{"34":1}}],["的编码修改为utf",{"2":{"212":1}}],["的编译器并且支持将",{"2":{"11":1}}],["的编译器",{"2":{"11":1,"23":1}}],["的新版本关联",{"2":{"211":1}}],["的插件",{"2":{"209":1}}],["的内置",{"2":{"208":1}}],["的内存地址",{"2":{"79":1}}],["的保存自动格式化功能",{"2":{"208":1}}],["的开发ide",{"2":{"207":1}}],["的开发手册所述",{"2":{"53":1}}],["的实现如下",{"2":{"200":1}}],["的标准库还为我们提供了一个函数",{"2":{"200":1}}],["的标准库",{"2":{"196":1,"231":1}}],["的标准构建器会以此为入口点",{"2":{"185":1}}],["的标准构建器位置",{"2":{"183":1}}],["的工具链使用的是",{"2":{"196":1}}],["的问题",{"2":{"196":1}}],["的指南",{"2":{"195":1}}],["的指针转换为地址不可能为",{"2":{"283":1}}],["的指针略有不同",{"2":{"79":1}}],["的指针和",{"2":{"79":1}}],["的指针特性",{"2":{"20":1}}],["的指针",{"2":{"20":1,"283":1}}],["的指针可以同时作为单项指针和多项指针使用",{"2":{"20":1}}],["的依赖",{"2":{"195":1}}],["的官方示例",{"2":{"195":1}}],["的存在",{"2":{"192":1}}],["的方法",{"2":{"217":1}}],["的方式如下",{"2":{"189":1}}],["的方案",{"2":{"25":1}}],["的构建系统",{"2":{"223":1}}],["的构建系统还允许我们执行一些额外的命令",{"2":{"194":1}}],["的构建系统提供了另外一种方式来处理当项目变得复杂时的测试",{"2":{"191":1}}],["的构建依赖于",{"2":{"186":1}}],["的构建目标三元组",{"2":{"15":1}}],["的有向无环图",{"2":{"185":1}}],["的文档并未给出具体说明",{"2":{"184":1}}],["的文档中出现过",{"2":{"53":1}}],["的规则",{"2":{"178":1}}],["的分支可以标记为",{"2":{"175":1}}],["的范围选择符",{"2":{"171":1}}],["的匹配必须要要穷尽所有",{"2":{"170":1}}],["的效果并不会真正生效",{"2":{"252":1}}],["的效果就是在标记处的",{"2":{"160":1,"165":1}}],["的效果类似于",{"2":{"160":1,"165":1}}],["的效果类似",{"2":{"3":1}}],["的还有",{"2":{"153":1}}],["的这个块中保证了",{"2":{"145":1}}],["的目标则是",{"2":{"292":1}}],["的目标是",{"2":{"292":1}}],["的目标代码",{"2":{"192":1}}],["的目标",{"2":{"145":1}}],["的变量",{"2":{"145":1}}],["的变体来创建",{"2":{"78":1}}],["的一个特殊变体",{"2":{"135":1}}],["的一等公民",{"2":{"92":1}}],["的语句",{"2":{"133":1}}],["的语言",{"2":{"11":1,"292":1}}],["的负担",{"2":{"131":1,"145":1}}],["的基本定义和使用",{"2":{"129":1}}],["的基本类型",{"2":{"12":1}}],["的错误处理方案笔者认为是比较简陋的",{"2":{"128":1}}],["的大小",{"2":{"127":1}}],["的精度和运算",{"2":{"126":1}}],["的操作指令",{"2":{"120":1}}],["的关键语法",{"2":{"111":1}}],["的函数明显",{"2":{"111":1}}],["的原因见",{"2":{"108":1}}],["的逻辑基本相同",{"2":{"108":1}}],["的向量",{"2":{"105":1}}],["的名字也可以使用标识符",{"2":{"199":1}}],["的名字",{"2":{"100":1}}],["的朋友对这个可能很熟悉",{"2":{"94":1}}],["的幂",{"2":{"85":1}}],["的值赋值给一个不能是",{"2":{"145":1}}],["的值是相同的",{"2":{"129":1}}],["的值是",{"2":{"105":1}}],["的值的方法",{"2":{"101":1}}],["的值就是",{"2":{"96":1}}],["的值",{"2":{"84":1,"105":1,"129":1,"133":1,"155":1}}],["的值进行操作",{"2":{"84":1}}],["的索引",{"2":{"77":1}}],["的索引处的值应该是",{"2":{"57":1}}],["的性质",{"2":{"66":1}}],["的源代码编码格式是",{"2":{"212":1}}],["的源文件本身就是",{"2":{"61":1}}],["的源码分支打包返回的",{"2":{"35":1}}],["的哨兵数组",{"2":{"61":1}}],["的数组类型",{"2":{"61":1}}],["的数组",{"2":{"57":1}}],["的数组的指针",{"2":{"53":1}}],["的数组指针",{"2":{"45":2}}],["的表达式",{"2":{"53":4}}],["的类型将会是",{"2":{"152":1}}],["的类型",{"2":{"44":2,"122":1}}],["的类型是",{"2":{"7":1,"53":1}}],["的包裹",{"2":{"39":1}}],["的游戏生态库",{"2":{"39":1}}],["的游戏引擎和图形套件",{"2":{"39":1}}],["的解析器",{"2":{"39":1}}],["的强大的",{"2":{"39":1}}],["的匿名结构和数组初始化语法",{"2":{"35":1}}],["的静态链接的二进制可执行文件",{"2":{"24":1}}],["的使用经验",{"2":{"111":1}}],["的使用",{"2":{"24":1,"231":1,"254":1}}],["的交叉编译",{"2":{"24":1}}],["的情况下仍然正确地进行动态链接",{"2":{"23":1}}],["的东西",{"2":{"23":1}}],["的宏",{"2":{"21":3}}],["的声明",{"2":{"21":1}}],["的全部语法",{"2":{"20":1}}],["的结构体的指针设置内存对齐来访问对应的字段",{"2":{"99":1}}],["的结构体",{"2":{"18":1}}],["的结构",{"2":{"18":1}}],["的后续构建将使用缓存",{"2":{"17":1}}],["的",{"2":{"13":1,"14":1,"15":2,"23":1,"24":1,"30":1,"35":1,"39":4,"41":1,"75":1,"128":1,"139":1,"175":1,"179":2,"187":1,"190":1,"196":1,"207":2,"213":1,"231":1,"286":1,"291":1,"295":2}}],["的库",{"2":{"11":1,"189":1,"224":1}}],["的寄存器",{"2":{"4":1}}],["的汇编代码和高级语言相组合",{"2":{"4":1}}],["的资料",{"2":{"3":1}}],["cd",{"2":{"208":2}}],["cdefine",{"2":{"13":2,"17":2,"249":2}}],["cmpxchgstrong",{"0":{"241":1},"2":{"241":1}}],["cmpxchgweak",{"0":{"240":1},"2":{"240":1}}],["cmake",{"2":{"207":1,"292":1}}],["cmd",{"2":{"8":4,"193":4,"194":7,"195":4,"196":4}}],["cmdfn",{"2":{"8":5}}],["ctime>",{"2":{"196":1}}],["curs",{"2":{"196":1}}],["curses",{"2":{"196":3}}],["cundef",{"2":{"13":1,"17":1}}],["c++",{"0":{"196":1},"2":{"194":1,"196":2,"207":2,"221":1,"292":1}}],["cp",{"2":{"208":1}}],["cpp",{"2":{"183":1,"196":1}}],["cpu运算器",{"2":{"120":1}}],["cpu",{"2":{"85":2,"99":1,"122":2,"192":1}}],["cvoid",{"2":{"145":1}}],["cvacopy",{"2":{"21":1}}],["cvaarg",{"2":{"21":2}}],["cvaend",{"2":{"21":2}}],["cvastart",{"2":{"21":2}}],["czig",{"2":{"145":1}}],["ceil",{"2":{"102":1}}],["c指针",{"2":{"41":1}}],["cyber",{"2":{"39":1}}],["chocolatey",{"2":{"214":1}}],["checking",{"2":{"196":1}}],["check",{"0":{"225":1},"2":{"196":7,"266":3}}],["checks",{"2":{"191":2}}],["chan",{"2":{"94":1}}],["chartodigit",{"2":{"132":2}}],["char",{"2":{"8":2,"12":1,"63":1,"108":13,"145":1,"195":1}}],["childtype",{"2":{"264":2}}],["child",{"2":{"27":1,"146":1,"195":1}}],["cxx=",{"2":{"24":2}}],["cc",{"2":{"24":4,"196":2}}],["cgo",{"2":{"24":5}}],["capturestdout",{"2":{"194":1}}],["capturestderr",{"2":{"194":1}}],["capy",{"2":{"39":1}}],["causes",{"2":{"124":1}}],["catch",{"0":{"133":1},"2":{"90":1,"127":1,"133":4,"134":2,"137":1}}],["can",{"2":{"90":1}}],["cast",{"2":{"44":1,"86":1}}],["call",{"0":{"259":1},"2":{"244":1,"251":1,"259":3}}],["called",{"2":{"244":1}}],["callback",{"2":{"195":2}}],["call2op",{"2":{"80":1}}],["callconv",{"0":{"119":1},"2":{"21":2,"74":1,"116":1,"117":1,"119":2}}],["callingconvention",{"2":{"119":1}}],["calling",{"2":{"3":1}}],["cache",{"2":{"17":3,"185":1,"266":1}}],["cflags=",{"2":{"24":1}}],["cflags",{"2":{"15":2,"17":1,"24":1}}],["classic",{"2":{"218":1}}],["clang",{"2":{"13":1,"15":3,"23":1}}],["clone",{"2":{"208":1}}],["clobbers",{"2":{"4":1}}],["clubs",{"2":{"69":2}}],["clion",{"0":{"207":1},"2":{"207":3}}],["clicked",{"2":{"195":1}}],["cli",{"0":{"14":1,"187":1},"1":{"15":1,"16":1}}],["ci",{"2":{"124":3,"266":6}}],["circle",{"2":{"89":13}}],["cinclude",{"2":{"13":2,"17":2,"249":3}}],["cimport",{"0":{"16":1},"2":{"13":4,"16":1,"17":11,"249":1}}],["crashed",{"2":{"266":1}}],["cro",{"2":{"234":1}}],["crosstarget",{"2":{"192":3}}],["createfoo",{"2":{"135":1}}],["createmodule",{"2":{"36":1}}],["createmoduleoptions",{"2":{"36":1}}],["create",{"2":{"32":4,"196":1}}],["crt",{"2":{"13":1,"17":1}}],["cr3",{"2":{"4":2}}],["c",{"0":{"11":1,"12":1,"13":1,"14":1,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"23":1,"30":1,"195":1},"1":{"12":1,"13":1,"14":1,"15":2,"16":2,"17":1,"18":1,"19":1,"20":1,"21":1,"22":1,"23":1,"24":1},"2":{"9":1,"11":8,"12":12,"13":6,"14":3,"15":1,"16":3,"17":7,"18":2,"19":7,"20":5,"21":12,"23":1,"24":2,"25":4,"30":10,"39":2,"43":2,"53":4,"54":1,"61":1,"63":2,"68":2,"73":3,"74":2,"75":2,"79":1,"82":4,"98":1,"99":3,"102":5,"106":2,"108":10,"111":1,"112":1,"116":1,"117":3,"124":6,"126":1,"132":6,"140":7,"145":5,"151":2,"152":2,"171":2,"173":6,"178":1,"179":7,"181":1,"183":1,"186":3,"194":2,"195":8,"196":18,"207":2,"215":2,"221":1,"231":1,"249":1,"283":1,"292":11,"294":1,"295":2}}],["coc",{"2":{"208":1}}],["coords",{"2":{"196":1}}],["cool",{"2":{"32":1}}],["colours",{"2":{"196":1}}],["color1",{"2":{"71":2}}],["color",{"2":{"71":2,"140":3,"174":4,"196":1}}],["collision",{"2":{"196":1}}],["cold",{"2":{"118":1}}],["could",{"2":{"244":1}}],["course",{"2":{"90":2}}],["counter",{"2":{"244":1}}],["count",{"2":{"21":2,"160":4,"244":11,"270":2}}],["coercion",{"2":{"44":3}}],["command",{"2":{"266":1}}],["community",{"2":{"220":1}}],["combining",{"2":{"105":1}}],["comrak",{"2":{"39":1}}],["com",{"2":{"29":1,"35":2,"90":1,"205":1,"206":1,"208":3,"220":1,"228":2}}],["complextype",{"2":{"179":5}}],["complextypetag",{"2":{"179":11}}],["compilation",{"2":{"17":3}}],["compilers",{"2":{"220":1}}],["compileerror",{"2":{"18":2,"19":2}}],["compile",{"2":{"9":1,"185":1,"186":1,"191":2}}],["comptime",{"2":{"3":2,"6":2,"7":2,"8":3,"9":9,"10":2,"37":1,"44":5,"53":2,"61":1,"87":2,"90":1,"92":1,"99":2,"100":1,"104":1,"105":2,"106":1,"111":2,"113":1,"118":1,"122":1,"124":2,"126":1,"136":2,"146":1,"161":2,"166":4,"175":2,"178":2,"179":1,"200":2,"237":2,"238":2,"239":3,"240":1,"241":1,"252":3,"254":1,"261":2,"264":4}}],["code",{"0":{"205":1},"2":{"4":1,"116":1,"176":1,"205":2,"244":2,"266":1}}],["connect",{"2":{"195":2}}],["continue",{"0":{"163":1},"2":{"116":1,"155":2,"160":2,"162":2,"163":1,"165":2,"196":1}}],["conversion",{"2":{"40":1}}],["convention",{"2":{"3":1}}],["constant",{"2":{"141":3}}],["const",{"2":{"4":4,"8":3,"17":1,"19":1,"21":1,"26":3,"27":5,"28":3,"29":1,"30":1,"31":2,"32":4,"36":2,"37":8,"42":2,"43":11,"44":2,"45":25,"46":1,"48":1,"49":10,"51":2,"53":16,"55":2,"56":1,"57":1,"59":2,"60":3,"61":4,"63":1,"68":3,"70":3,"71":1,"72":3,"74":1,"78":3,"80":3,"81":3,"82":1,"84":2,"85":7,"86":1,"87":1,"89":3,"90":14,"92":1,"93":1,"94":3,"95":1,"96":3,"99":10,"100":1,"102":7,"103":1,"104":3,"105":5,"106":4,"111":1,"122":4,"124":4,"126":3,"129":3,"132":3,"133":2,"134":2,"135":2,"136":3,"140":4,"141":2,"143":1,"144":2,"145":3,"149":5,"153":1,"158":1,"159":1,"161":5,"163":1,"166":3,"170":1,"171":5,"172":1,"173":4,"174":2,"175":1,"176":1,"178":3,"179":8,"180":1,"185":3,"186":3,"187":4,"188":6,"189":5,"190":2,"191":6,"192":1,"193":7,"194":8,"195":6,"196":5,"200":5,"237":1,"244":2,"252":2,"253":2,"254":3,"255":2,"256":2,"257":1,"258":2,"261":2,"264":11,"270":1,"271":2,"280":1,"282":1,"290":1}}],["以允许使用反射访问有关这些类型的信息",{"2":{"293":1}}],["以至于",{"2":{"292":1}}],["以目前的开发速度",{"2":{"211":1}}],["以便同时运行多个测试",{"2":{"191":1}}],["以便两个索引都可以从",{"2":{"105":1}}],["以数组索引的语法来访问向量的元素",{"2":{"102":1}}],["以及一小组新的编译器指令",{"2":{"293":1}}],["以及相较",{"2":{"292":1}}],["以及操作中可能溢出的位",{"2":{"125":1}}],["以及内联",{"2":{"96":1}}],["以及",{"2":{"90":1}}],["以避免没有触发",{"2":{"84":1}}],["以此来抵消运行时的开销",{"2":{"66":1}}],["以下说明各种未定义行为",{"2":{"266":1}}],["以下示例为我们构建一个新的结构体",{"2":{"261":1}}],["以下示例代码不应用于生产环境中",{"2":{"232":1}}],["以下示例中",{"2":{"70":1,"160":1,"165":1}}],["以下仅列出常用的命令",{"2":{"221":1}}],["以下列出了",{"2":{"296":1}}],["以下列出了支持通过包管理器安装",{"2":{"218":1}}],["以下列出了一些",{"2":{"38":1}}],["以下讲述四种构建模式的区别",{"2":{"184":1}}],["以下内容涉及到了联合类型和可选类型",{"2":{"150":1}}],["以下展示了",{"2":{"129":1}}],["以下有一部分运算符你么见过不要紧",{"2":{"127":1}}],["以下特性如果你连名字都没有听说过",{"2":{"97":1}}],["以下两句均为true",{"2":{"53":1}}],["以下是演示",{"2":{"171":1}}],["以下是示例",{"2":{"156":1}}],["以下是类型表格",{"2":{"122":1}}],["以下是一个简单的示例",{"2":{"254":1}}],["以下是一个简短的结构体声明",{"2":{"89":1}}],["以下是一个示例",{"2":{"139":1,"264":1}}],["以下是一个将英文字符串解析为数字的示例",{"2":{"132":1}}],["以下是一个链表的类型实现",{"2":{"92":1}}],["以下是一些示例",{"2":{"53":1}}],["以下是经过实践和总结出来的额外信息",{"2":{"22":1}}],["以下的是指针的额外特性",{"2":{"83":1}}],["以下的变量",{"2":{"8":1}}],["以下的示例仅仅是示范作用",{"2":{"8":1}}],["以上程序中",{"2":{"231":1}}],["以上构建中我们先使用了",{"2":{"195":1}}],["以上构建的其他说明",{"2":{"185":1}}],["以上的约束是在一般情况下",{"2":{"264":1}}],["以上的示例中",{"2":{"254":1}}],["以上的",{"2":{"185":1,"215":1}}],["以上的语法很啰嗦",{"2":{"96":1}}],["以上所说的错误类型实际上用的大概不多",{"2":{"132":1}}],["以上这些内建函数会返回一个元组",{"2":{"271":1}}],["以上这段测试完全可以运行通过",{"2":{"252":1}}],["以上这段函数中",{"2":{"3":1}}],["以上这行代码相当于",{"2":{"130":1}}],["以上几个特性就有很多有意思的点值得我们使用和注意",{"2":{"99":1}}],["以上我们对数组取切片",{"2":{"76":1}}],["以上字段含义为",{"2":{"35":1}}],["以上代码定义了一个名为",{"2":{"190":1}}],["以上代码中的value是一个指针",{"2":{"155":1}}],["以上代码中的",{"2":{"152":1,"155":1}}],["以上代码中",{"2":{"152":2,"157":1,"191":1}}],["以上代码的",{"2":{"151":1}}],["以上代码使用",{"2":{"129":1}}],["以上代码编译需要额外连接",{"2":{"82":1}}],["以上代码展示了定义一个字面量数组的方式",{"2":{"55":1}}],["以上代码翻译完成后",{"2":{"19":1}}],["以上代码",{"2":{"10":1}}],["以上函数实现了斐波那契数列",{"2":{"9":1}}],["以上",{"2":{"7":1,"187":1}}],["以",{"2":{"4":1}}],["以实现加法功能",{"2":{"3":1}}],["575",{"2":{"266":1}}],["595540",{"2":{"196":1}}],["598336",{"2":{"196":1}}],["598356",{"2":{"196":1}}],["599636",{"2":{"196":1}}],["5678",{"2":{"145":1}}],["564",{"2":{"124":1}}],["54",{"2":{"44":5}}],["5",{"2":{"3":1,"44":5,"45":9,"49":2,"51":1,"55":1,"60":2,"61":3,"89":1,"90":2,"93":1,"102":3,"103":1,"105":2,"106":1,"122":2,"124":1,"149":2,"155":1,"156":1,"157":1,"158":1,"159":2,"162":2,"170":8,"171":3,"252":2,"257":1,"266":2}}],["28",{"2":{"266":2}}],["21",{"2":{"196":1}}],["262176",{"2":{"196":2}}],["247872",{"2":{"196":1}}],["243",{"2":{"124":1}}],["2456131",{"2":{"124":1}}],["22",{"2":{"124":1,"196":2,"266":1}}],["2^20",{"2":{"102":1}}],["2^32",{"2":{"102":1}}],["200",{"2":{"195":2}}],["2000",{"2":{"163":2}}],["20",{"2":{"90":3,"196":2}}],["29",{"2":{"85":1}}],["253",{"2":{"266":1}}],["255",{"2":{"48":1,"127":2,"271":1}}],["25",{"2":{"44":1}}],["250",{"2":{"43":2}}],["2",{"2":{"3":1,"8":1,"9":3,"19":2,"45":2,"49":4,"51":1,"57":1,"59":4,"60":2,"62":1,"76":5,"77":1,"78":2,"81":2,"85":2,"89":1,"90":1,"99":5,"102":4,"105":2,"106":1,"126":2,"148":2,"151":1,"155":1,"158":1,"161":4,"163":1,"166":2,"171":2,"173":2,"176":1,"196":9,"199":4,"252":3,"259":1,"263":1,"264":1,"266":1,"292":1}}],["nix",{"2":{"218":1}}],["nixos",{"2":{"218":1}}],["nightly",{"2":{"35":3,"36":1,"139":1,"208":1,"211":1,"213":1,"216":1,"223":1,"224":1,"228":1,"230":1}}],["nvim",{"2":{"208":6}}],["nvim作为",{"2":{"208":1}}],["ncurses",{"2":{"196":2}}],["necessary",{"2":{"244":1}}],["neovim",{"0":{"208":1},"2":{"208":6}}],["nested",{"2":{"200":1}}],["new",{"2":{"195":3,"196":6,"240":1,"241":1}}],["news",{"2":{"23":1,"38":1}}],["negative",{"2":{"126":1}}],["next",{"2":{"92":1}}],["n是数组的长度",{"2":{"81":1}}],["nnnnnn",{"2":{"62":1}}],["nums",{"2":{"161":4}}],["num",{"2":{"108":2,"129":1,"148":6,"170":4,"175":3,"196":10}}],["numbers",{"2":{"167":5,"168":5}}],["number",{"2":{"4":8,"72":5,"99":2,"133":5,"134":7,"164":2,"180":2,"196":1,"199":2}}],["null",{"0":{"275":1,"283":1},"2":{"20":1,"46":3,"53":1,"61":1,"86":2,"145":11,"146":1,"147":1,"151":1,"159":1,"167":6,"195":2,"261":1,"275":1,"293":1,"295":1}}],["nope1234",{"2":{"255":2,"256":2}}],["nope",{"2":{"255":3,"256":3}}],["nostdlib++",{"2":{"196":1}}],["nostdinc++",{"2":{"196":1}}],["noecho",{"2":{"196":1}}],["normal",{"2":{"145":1}}],["noreturn",{"0":{"116":1},"2":{"4":1,"116":2,"118":1,"133":1}}],["node",{"2":{"92":5}}],["noop",{"2":{"244":2}}],["noop4",{"2":{"85":3}}],["noop1",{"2":{"85":3}}],["not",{"2":{"68":1,"153":1,"170":2,"172":2,"179":6}}],["none",{"2":{"192":1}}],["nonnull",{"2":{"145":1}}],["non",{"2":{"44":1,"99":1}}],["no",{"2":{"13":1,"17":1,"244":1,"249":1,"252":1}}],["nanos",{"2":{"144":2}}],["nan",{"2":{"126":3}}],["native",{"2":{"99":2,"124":1,"266":1}}],["namespace",{"2":{"264":1}}],["named",{"2":{"133":1}}],["name",{"2":{"8":5,"19":2,"35":7,"36":1,"37":11,"70":2,"90":3,"100":3,"178":1,"179":1,"185":2,"186":1,"187":1,"188":1,"189":3,"191":1,"192":1,"193":1,"194":1,"195":1,"196":1,"200":1,"228":3,"254":2,"261":1,"264":7}}],["nasm",{"2":{"2":1}}],["n",{"2":{"3":1,"4":1,"13":1,"29":2,"30":2,"55":2,"56":1,"57":6,"59":1,"61":12,"62":1,"63":2,"65":1,"66":1,"76":3,"77":2,"78":2,"80":1,"81":6,"82":1,"89":1,"90":2,"94":1,"100":3,"102":4,"108":3,"124":1,"129":1,"135":1,"139":1,"141":1,"142":1,"148":3,"149":1,"162":2,"167":2,"168":2,"170":4,"173":1,"178":2,"188":1,"195":1,"230":1,"232":4,"249":1,"253":2,"254":1,"255":4,"256":4,"257":2,"258":1,"259":1,"261":1,"264":2,"271":2}}],["png",{"2":{"249":1}}],["pwd",{"2":{"220":1}}],["play",{"2":{"296":1}}],["playground",{"2":{"296":1}}],["placing",{"2":{"196":1}}],["plugin",{"2":{"220":1}}],["p",{"2":{"196":9,"257":6,"258":3}}],["py",{"2":{"196":8}}],["px",{"2":{"196":9}}],["ps",{"2":{"144":1}}],["piece",{"2":{"196":18}}],["pi",{"2":{"89":5,"94":2}}],["pipe",{"2":{"39":1}}],["possibly",{"2":{"244":1}}],["position",{"2":{"196":2}}],["posixcallmainandexit",{"2":{"124":1,"266":1}}],["powershell",{"2":{"215":2}}],["point",{"2":{"91":2,"95":4,"173":5,"257":5,"258":3}}],["pointers",{"2":{"87":1}}],["pointer",{"2":{"85":4,"86":1,"99":2}}],["pool",{"2":{"32":8}}],["pt",{"2":{"66":2,"91":1}}],["ptr",{"2":{"76":1,"77":4,"80":4,"81":13,"84":4,"86":2,"87":3,"99":4,"145":5,"237":1,"238":1,"239":1,"240":1,"241":1,"252":3,"280":2}}],["ptrcast",{"2":{"52":1,"99":1}}],["ptrfromint",{"2":{"52":1,"53":2,"84":1,"86":1,"280":1}}],["permissions",{"2":{"122":1}}],["perform",{"2":{"8":1}}],["performfn",{"2":{"8":10}}],["peertypeemptyarrayandsliceanderror",{"2":{"53":1}}],["peertypeemptyarrayandslice",{"2":{"53":3}}],["peertypetandoptionalt",{"2":{"53":2}}],["peer",{"2":{"40":1,"53":1}}],["p4",{"2":{"32":2}}],["p3",{"2":{"32":2}}],["p2",{"2":{"32":2}}],["p1",{"2":{"32":2}}],["pair",{"2":{"196":1}}],["param",{"2":{"135":2,"264":1}}],["parseu64",{"2":{"132":1,"133":2,"134":5}}],["particular",{"2":{"196":1}}],["part",{"2":{"60":4}}],["passed",{"2":{"199":1}}],["passwd",{"2":{"90":3}}],["password",{"2":{"90":17}}],["pasting",{"2":{"18":1}}],["payload",{"2":{"46":1,"47":1,"128":1,"178":15}}],["packed",{"0":{"99":1,"182":1},"2":{"98":1,"99":10,"178":1,"182":1,"281":1}}],["packages",{"2":{"208":1}}],["package",{"2":{"35":1,"36":1,"37":4}}],["pacman",{"2":{"39":1,"218":1}}],["path",{"2":{"36":1,"37":1,"185":1,"186":1,"187":1,"188":1,"189":3,"191":2,"192":1,"193":2,"194":1,"195":3,"196":3,"215":6,"219":1,"244":1}}],["paths",{"2":{"35":3}}],["patterns",{"2":{"32":1}}],["panic",{"2":{"26":1,"28":1,"90":1,"124":1,"134":1,"176":1,"191":1,"266":1}}],["page",{"0":{"31":1},"2":{"25":1,"31":1}}],["primitive",{"2":{"264":1}}],["printw",{"2":{"196":2}}],["printf",{"2":{"13":2,"21":2,"63":1,"82":3,"231":1}}],["print",{"2":{"3":1,"55":4,"56":3,"57":5,"59":3,"60":2,"61":14,"63":3,"65":3,"66":3,"76":5,"77":4,"78":4,"80":3,"81":9,"89":1,"90":9,"94":1,"100":3,"102":6,"108":7,"124":1,"129":1,"135":1,"139":1,"141":1,"142":1,"148":5,"149":3,"153":6,"162":2,"167":2,"168":2,"170":6,"173":1,"178":4,"188":1,"193":1,"194":1,"195":3,"230":1,"231":2,"232":6,"249":1,"253":2,"254":1,"255":4,"256":4,"257":2,"258":1,"259":1,"261":1,"271":4}}],["pr",{"2":{"196":7}}],["present",{"2":{"195":1}}],["pred",{"2":{"106":5}}],["previous",{"2":{"244":1}}],["prev",{"2":{"92":1}}],["prefix",{"2":{"8":2,"185":1,"190":1}}],["process",{"2":{"23":1,"124":1}}],["purpose",{"2":{"26":1,"28":1}}],["pub",{"2":{"3":1,"4":5,"13":1,"17":1,"19":1,"21":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"49":1,"53":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"69":1,"70":1,"71":1,"76":1,"77":1,"78":1,"80":1,"81":2,"82":2,"89":3,"90":10,"92":1,"94":1,"100":1,"102":1,"108":2,"111":2,"124":1,"126":1,"129":1,"132":1,"136":2,"139":1,"140":2,"141":1,"142":1,"144":1,"148":1,"149":1,"153":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":2,"185":1,"186":1,"187":1,"188":2,"189":2,"190":1,"191":1,"193":2,"194":2,"195":1,"196":1,"200":1,"230":1,"232":2,"249":3,"253":1,"254":1,"255":2,"256":2,"257":2,"258":1,"259":1,"261":1,"271":1}}],["pull",{"2":{"1":1}}],["mkdir",{"2":{"208":1}}],["monotonic",{"2":{"244":1}}],["move",{"2":{"196":3}}],["modula",{"2":{"292":1}}],["module",{"2":{"36":3,"37":7}}],["mode",{"2":{"184":1,"209":2}}],["mutex",{"2":{"233":1}}],["mulwithoverflow",{"2":{"125":1,"132":1,"271":1}}],["mul",{"2":{"104":2,"271":1}}],["musl",{"2":{"24":3}}],["methodname",{"2":{"264":1}}],["meta",{"2":{"179":2,"200":2}}],["meet",{"2":{"167":2,"168":2}}],["message",{"2":{"55":4}}],["memcpy",{"2":{"90":3,"196":1}}],["memset",{"2":{"90":3,"196":1}}],["mem",{"2":{"33":1,"53":9,"61":4,"70":4}}],["member",{"2":{"20":2}}],["memorypool",{"0":{"32":1},"2":{"25":1,"32":1}}],["memory",{"2":{"4":1,"27":4,"31":2,"84":1}}],["min",{"2":{"104":1}}],["minisign",{"2":{"39":2}}],["million",{"2":{"68":1}}],["microsoft",{"2":{"29":1,"206":2}}],["m",{"2":{"23":1}}],["map",{"2":{"286":1}}],["mapped",{"2":{"84":1}}],["manage",{"2":{"220":1}}],["many",{"2":{"79":1}}],["marler8997",{"2":{"220":1}}],["markdown",{"2":{"39":1}}],["mason",{"2":{"208":4}}],["mask2",{"2":{"105":2}}],["mask1",{"2":{"105":2}}],["mask",{"2":{"105":7,"122":1}}],["math",{"2":{"125":1,"126":3,"132":1,"269":1,"271":7}}],["matrix",{"2":{"56":2}}],["mail",{"2":{"90":3}}],["mainterminal",{"2":{"266":2}}],["main",{"2":{"3":2,"4":1,"13":1,"17":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"37":1,"49":1,"53":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":2,"65":1,"66":1,"70":1,"71":1,"76":1,"77":1,"78":1,"80":1,"81":2,"82":1,"89":1,"90":3,"94":1,"100":3,"102":1,"108":2,"124":3,"126":1,"129":1,"137":1,"139":1,"141":1,"142":1,"148":1,"149":1,"153":1,"161":2,"162":1,"166":2,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":2,"185":1,"187":1,"188":3,"189":2,"191":2,"192":1,"193":3,"194":3,"195":3,"196":3,"213":3,"223":2,"224":4,"230":2,"231":2,"232":3,"249":2,"253":3,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"261":1,"266":2,"271":1}}],["make",{"2":{"65":2}}],["makelocal",{"2":{"19":5}}],["mac安装",{"2":{"216":1}}],["mac",{"0":{"216":1}}],["machine",{"2":{"215":2}}],["mach",{"2":{"39":1}}],["macro",{"0":{"19":1}}],["malloc",{"2":{"25":1,"30":4,"145":5}}],["magic",{"2":{"23":1}}],["maxint",{"2":{"132":3,"269":1}}],["max",{"2":{"7":5,"104":1,"111":1}}],["mmio",{"2":{"4":1,"84":4}}],["msg",{"2":{"4":3,"172":3}}],["my",{"2":{"3":5,"35":1,"37":1,"163":2}}],["effects",{"2":{"252":1}}],["epoxy",{"2":{"249":1}}],["easily",{"2":{"220":1}}],["each",{"2":{"196":1}}],["eax",{"2":{"3":1}}],["echo",{"2":{"194":1}}],["eventuallyerrorsequence",{"2":{"168":3}}],["eventuallynullsequence",{"2":{"167":3}}],["emerge",{"2":{"218":1}}],["emacs",{"0":{"209":1},"2":{"209":2}}],["email",{"2":{"90":17}}],["embedfile",{"0":{"193":1},"2":{"193":3,"194":2}}],["emit",{"2":{"190":1}}],["empty",{"2":{"94":3}}],["element",{"2":{"102":1}}],["ele",{"2":{"76":1,"102":3,"106":3}}],["else",{"2":{"7":3,"53":4,"72":1,"111":1,"132":1,"134":4,"148":4,"149":3,"151":2,"152":6,"159":1,"161":2,"164":3,"166":2,"167":3,"168":5,"170":3,"171":2,"172":2,"175":6,"196":1,"266":1,"271":1}}],["eql",{"2":{"53":7,"61":2,"70":2}}],["equal",{"2":{"19":1}}],["errdefer结合使用",{"2":{"135":1}}],["errdefer",{"0":{"135":1},"2":{"135":7,"153":2}}],["err|",{"2":{"134":1}}],["err",{"2":{"129":4,"130":2,"134":3,"135":1,"152":4,"168":4,"232":12}}],["errsetcast",{"2":{"52":1}}],["errorcast转换两个不相关的错误集",{"2":{"279":1}}],["errorfromint",{"2":{"277":1}}],["errorreturntrace",{"2":{"137":1}}],["errorsettwo",{"2":{"136":1}}],["errorsetone",{"2":{"136":1}}],["errorname",{"2":{"135":1}}],["error",{"0":{"276":1},"2":{"44":1,"47":1,"124":1,"128":1,"129":7,"130":2,"132":6,"134":2,"135":4,"136":5,"140":1,"152":1,"168":1,"175":1,"201":1,"266":1,"276":1}}],["e",{"2":{"43":2,"45":4,"49":9,"55":2,"61":2,"68":1,"104":1,"105":5,"171":2,"173":4,"214":1}}],["encoding=",{"2":{"264":1}}],["ensures",{"2":{"244":2}}],["env",{"2":{"218":1}}],["environment",{"2":{"215":4}}],["entry",{"2":{"196":1}}],["enumfromint",{"2":{"52":1,"72":1,"278":1}}],["enum",{"2":{"49":2,"68":5,"69":1,"70":4,"71":1,"72":1,"73":1,"128":1,"140":1,"173":2,"174":1,"175":1,"179":3,"200":1}}],["en",{"2":{"29":1}}],["endwin",{"2":{"196":1}}],["endian",{"2":{"99":3}}],["end",{"2":{"21":1,"78":1,"81":1,"164":2}}],["example",{"2":{"189":1,"195":1}}],["extra",{"2":{"244":1}}],["extract",{"2":{"196":1}}],["extldflags",{"2":{"24":1}}],["extern",{"0":{"73":1,"98":1,"117":1,"181":1},"2":{"3":1,"18":2,"21":2,"73":1,"74":1,"82":1,"98":1,"112":1,"117":2,"140":2,"178":1,"181":2,"182":1,"281":1}}],["explicit",{"2":{"136":1}}],["expr",{"2":{"19":1,"178":1}}],["export",{"2":{"19":1}}],["expected",{"2":{"240":1,"241":1}}],["expect",{"2":{"8":8,"9":4,"49":7,"53":8,"70":6,"84":3,"85":13,"86":3,"87":3,"90":1,"99":22,"146":3,"151":1,"152":3,"161":4,"163":1,"166":4,"171":1,"179":8,"199":6,"200":6,"252":4}}],["exec",{"2":{"153":4}}],["executed",{"2":{"90":1}}],["executableoptions",{"2":{"185":1}}],["executable",{"2":{"36":1,"187":2}}],["exe",{"0":{"223":1},"2":{"13":3,"17":1,"37":3,"82":1,"124":1,"185":3,"186":8,"187":4,"188":4,"189":9,"191":7,"192":1,"193":5,"194":5,"195":8,"196":8,"223":1,"224":2,"230":2}}],["exitprocess",{"2":{"116":1}}],["exit",{"2":{"4":2,"116":2}}],["181",{"2":{"266":1}}],["18",{"2":{"196":2}}],["16",{"2":{"196":3}}],["1月1日",{"2":{"144":1}}],["1smallstep4man",{"2":{"140":1}}],["15",{"2":{"124":1}}],["1970年",{"2":{"144":1}}],["19",{"2":{"124":1,"196":1}}],["14",{"2":{"89":2,"94":2}}],["1f4a9",{"2":{"61":1}}],["12202809180bab2c7ae3382781b2fc65395e74b49d99ff2595f3fea9f7cf66cfa963",{"2":{"228":1}}],["12200f41f9804eb9abff259c5d0d84f27caa0a25e0f72451a0243a806c8f94fdc433",{"2":{"35":1}}],["123",{"2":{"143":1}}],["123456",{"2":{"90":2}}],["1234",{"2":{"45":1,"85":3,"93":1,"96":1,"134":1,"145":3,"146":1,"178":4}}],["128175",{"2":{"61":1}}],["128169",{"2":{"61":1}}],["12",{"2":{"43":1,"49":1,"53":1,"96":1,"281":1}}],["112358",{"2":{"140":1}}],["1111",{"2":{"122":2}}],["111",{"2":{"45":4}}],["11",{"2":{"34":1,"35":1,"129":1,"207":1}}],["107",{"2":{"171":1}}],["101",{"2":{"171":1}}],["103",{"2":{"171":1}}],["104",{"2":{"108":2}}],["100",{"2":{"26":1,"27":2,"28":1,"31":1,"68":1,"85":2,"171":2}}],["10000",{"2":{"196":1}}],["1000000",{"2":{"68":1}}],["1000",{"2":{"9":1,"27":2,"68":1}}],["10",{"2":{"10":1,"28":1,"44":2,"65":1,"66":1,"132":2,"133":2,"134":5,"162":2,"163":1,"165":1,"171":1,"196":5,"245":1,"271":1}}],["1337",{"2":{"135":1}}],["13",{"2":{"9":2,"91":1,"133":3}}],["1",{"2":{"3":1,"4":2,"8":6,"9":2,"13":1,"17":1,"19":2,"21":1,"28":1,"29":1,"30":1,"35":1,"45":4,"49":2,"52":1,"53":3,"56":5,"57":2,"59":4,"60":2,"61":3,"62":1,"65":1,"70":1,"76":3,"77":1,"78":2,"80":1,"81":4,"85":4,"87":3,"90":1,"99":3,"102":5,"104":4,"105":6,"106":2,"107":1,"119":1,"122":1,"124":2,"126":2,"127":1,"132":2,"136":2,"143":3,"148":3,"155":1,"158":1,"160":6,"162":2,"163":3,"164":1,"165":1,"166":4,"167":1,"168":1,"171":4,"173":4,"175":1,"176":1,"178":2,"179":1,"196":17,"199":2,"211":1,"244":3,"252":1,"255":1,"256":1,"257":3,"259":1,"264":1,"266":2,"271":1,"280":1}}],["rc",{"2":{"244":9}}],["rcx",{"2":{"4":3}}],["rpm",{"2":{"218":1}}],["row++",{"2":{"196":1}}],["row",{"2":{"196":4}}],["root",{"2":{"36":1,"37":2,"124":1,"185":2,"186":1,"187":1,"188":1,"189":3,"191":2,"192":1,"193":1,"194":1,"195":1,"196":1,"231":2,"266":1}}],["rust",{"2":{"145":1,"184":1,"194":1,"292":4,"295":1}}],["runloop",{"2":{"196":3}}],["runner",{"2":{"124":3,"199":1,"266":8}}],["run",{"2":{"9":1,"186":10,"191":5,"193":10,"194":13,"195":9,"196":8,"200":1,"253":1}}],["runtime",{"2":{"6":1,"78":2,"124":6,"250":1,"252":1}}],["r",{"2":{"62":1,"105":1,"196":24}}],["river",{"2":{"39":1}}],["rand",{"2":{"196":3}}],["rangehasnumber",{"2":{"164":1}}],["radix",{"2":{"132":4}}],["radius",{"2":{"89":17}}],["raw",{"2":{"30":2}}],["rax",{"2":{"4":8}}],["rdx",{"2":{"4":2}}],["rdi",{"2":{"3":1,"4":3}}],["r11",{"2":{"4":3}}],["rsi",{"2":{"3":1,"4":2}}],["reflection",{"2":{"250":1}}],["ref",{"2":{"244":5}}],["refcount",{"2":{"244":8}}],["refalldecls",{"2":{"200":4}}],["refresh",{"2":{"196":1}}],["re",{"2":{"196":1}}],["remove",{"2":{"196":5}}],["remainder",{"2":{"44":1}}],["reached",{"2":{"266":1}}],["reachedzero",{"2":{"168":1}}],["readu32be",{"2":{"264":1}}],["real",{"2":{"151":1}}],["really",{"2":{"140":2}}],["red",{"2":{"140":3}}],["reduction",{"2":{"104":1}}],["reduceop",{"2":{"104":1}}],["reduce",{"0":{"104":1},"2":{"102":1,"104":2}}],["releasenightly",{"2":{"213":1}}],["release",{"2":{"213":1,"244":2,"292":1}}],["releasefast",{"2":{"134":1,"176":1,"184":2}}],["releasesafe",{"2":{"134":1,"176":1,"184":2,"266":1}}],["releasesmall",{"2":{"124":1,"134":1,"176":1,"184":2}}],["relative",{"2":{"37":1}}],["repo",{"2":{"35":2}}],["res",{"2":{"258":2}}],["resizeterm",{"2":{"196":1}}],["resizefn",{"2":{"33":1}}],["res2",{"2":{"105":2}}],["res的值是",{"2":{"105":1}}],["res1",{"2":{"105":1}}],["resolution",{"2":{"40":1,"53":1}}],["result",{"2":{"8":17,"72":2,"103":1,"104":3,"149":4,"159":1,"174":1,"259":1,"271":2}}],["ret",{"2":{"4":6}}],["return",{"2":{"4":2,"7":5,"8":7,"9":4,"10":1,"19":2,"21":1,"49":2,"53":7,"63":1,"65":1,"69":1,"85":1,"89":4,"90":5,"92":1,"100":2,"111":2,"115":1,"116":1,"117":1,"119":1,"129":1,"132":5,"134":2,"135":4,"136":4,"144":1,"145":2,"161":2,"164":1,"166":2,"167":1,"168":1,"175":5,"195":1,"196":6,"199":1,"200":1,"252":1,"259":1,"264":2,"266":1}}],["retq",{"2":{"3":1}}],["review",{"2":{"1":1}}],["request",{"2":{"1":1}}],["fence",{"0":{"242":1},"2":{"242":1,"244":1}}],["fedora",{"2":{"218":2}}],["fetchsub",{"2":{"244":2}}],["fetchadd",{"2":{"244":1}}],["fetch",{"0":{"228":1},"2":{"35":1,"228":2}}],["fmt",{"0":{"226":1},"2":{"208":2}}],["frame",{"2":{"196":2}}],["from",{"2":{"196":3}}],["free",{"2":{"26":1,"27":2,"28":1,"29":2,"30":1,"31":1,"90":3}}],["freestanding",{"2":{"20":1,"86":1,"192":1}}],["fd",{"2":{"140":2}}],["fstat$inode64",{"2":{"140":1}}],["f80",{"2":{"126":1}}],["full",{"2":{"99":6,"196":1}}],["funcname",{"2":{"100":1}}],["functionalias",{"2":{"264":1}}],["functionpointer",{"2":{"264":4}}],["functionname",{"2":{"264":3}}],["function",{"2":{"3":1,"85":1,"100":2,"259":1}}],["func",{"2":{"3":5,"8":5,"266":1}}],["flush",{"2":{"232":2}}],["floatfromint",{"2":{"52":1,"89":2}}],["floatcast",{"2":{"52":1}}],["float",{"2":{"44":2,"126":1,"178":3,"180":1,"252":2,"281":2,"282":2}}],["flags",{"2":{"15":1,"195":3,"196":2}}],["f128",{"2":{"43":1,"126":3}}],["f16",{"2":{"43":1,"89":6,"126":1}}],["f64",{"2":{"43":1,"96":1,"117":3,"126":2,"178":3,"180":1}}],["f32",{"2":{"43":1,"44":4,"45":2,"49":3,"56":5,"95":4,"102":4,"126":2,"161":2,"166":2,"175":1,"264":1,"281":1,"282":1}}],["f",{"2":{"43":2,"44":5,"281":2}}],["falls",{"2":{"196":1}}],["false",{"2":{"52":1,"53":7,"72":3,"90":1,"104":3,"106":2,"109":1,"153":1,"164":1,"174":2,"187":1,"200":1,"208":1,"255":2,"256":3,"261":2}}],["fancy",{"2":{"66":2}}],["fast",{"2":{"32":1,"220":1}}],["failure",{"2":{"47":1}}],["fail",{"2":{"26":1,"28":1,"90":2,"240":1,"241":1}}],["failingallocator",{"2":{"25":1}}],["fba",{"2":{"27":6}}],["following",{"2":{"266":1}}],["fo",{"2":{"196":1}}],["found",{"2":{"172":2}}],["four",{"2":{"70":1}}],["foo",{"2":{"19":3,"73":1,"74":1,"85":4,"93":2,"99":2,"100":3,"129":3,"135":4,"145":16,"146":3,"252":3,"255":5,"256":5,"281":3}}],["foreign",{"2":{"191":2}}],["format",{"2":{"21":1,"82":1}}],["for",{"0":{"155":1},"1":{"156":1,"157":1,"158":1,"159":1,"160":1,"161":1},"2":{"9":1,"53":1,"56":3,"66":1,"76":1,"96":1,"132":1,"135":2,"154":1,"155":3,"157":1,"158":1,"159":2,"160":4,"161":4,"196":9,"200":2,"208":2,"245":1,"254":5}}],["fork",{"2":{"1":1}}],["ffi",{"2":{"11":1,"295":1}}],["fixed",{"2":{"264":2}}],["fixedbufferallocator",{"0":{"27":1},"2":{"25":1,"27":2}}],["filter",{"2":{"201":2}}],["file`",{"2":{"193":2,"194":2}}],["fileopenerror",{"2":{"129":5}}],["filename",{"2":{"100":1}}],["filenotfound",{"2":{"129":1,"130":3}}],["fileno",{"2":{"4":2}}],["file",{"2":{"17":1,"36":3,"37":1,"185":2,"186":1,"187":1,"188":1,"189":3,"191":2,"192":1,"193":2,"194":2,"195":2,"196":2,"264":1}}],["field",{"0":{"257":1},"2":{"99":1,"175":2,"178":1,"200":1,"251":1,"254":4,"257":6,"264":3}}],["fieldparentptr",{"0":{"258":1},"2":{"95":2,"251":1,"258":2}}],["fields",{"2":{"70":2,"175":4,"254":1,"261":1}}],["first",{"2":{"92":1,"153":1}}],["fibonacci",{"2":{"9":8}}],["fns",{"2":{"8":4}}],["fn",{"2":{"3":2,"4":3,"8":9,"9":2,"13":1,"17":1,"19":1,"21":2,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"49":2,"53":2,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":2,"66":1,"69":1,"70":1,"71":1,"74":2,"76":1,"77":1,"78":1,"80":2,"81":2,"82":2,"85":5,"89":5,"90":10,"94":1,"95":1,"99":1,"100":2,"102":1,"108":2,"111":3,"116":1,"117":2,"119":1,"124":1,"126":1,"129":2,"132":2,"133":1,"136":2,"139":1,"140":2,"141":1,"142":1,"144":1,"145":4,"148":1,"149":1,"153":1,"161":4,"162":1,"166":4,"167":2,"168":2,"170":1,"172":1,"173":1,"175":2,"178":1,"179":2,"185":2,"186":1,"187":1,"188":2,"189":2,"190":1,"191":1,"193":2,"194":2,"195":1,"196":1,"199":1,"200":1,"230":1,"232":2,"244":4,"249":1,"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":2,"261":1,"264":5,"266":1,"271":1}}],["gc",{"2":{"293":1}}],["gcc",{"2":{"4":1,"145":1}}],["git",{"2":{"208":2,"220":1}}],["github",{"2":{"1":1,"35":3,"39":1,"183":1,"208":3,"220":1,"228":2}}],["game",{"2":{"196":1}}],["gamedev",{"2":{"39":1}}],["gpointer",{"2":{"195":2}}],["gpa",{"2":{"26":3,"28":3,"90":3}}],["gentoo",{"2":{"218":1}}],["generalpurposeallocator",{"0":{"26":1},"2":{"25":1,"26":1,"28":1,"33":1,"90":1}}],["getstderr",{"2":{"232":2}}],["getstdout",{"2":{"232":2}}],["getting",{"2":{"220":1}}],["getenvironmentvariable",{"2":{"215":2}}],["getemitteddocs",{"2":{"190":1}}],["getch",{"2":{"196":1}}],["getinstallstep",{"2":{"186":1,"193":1,"194":1,"195":1,"196":1}}],["getnum",{"2":{"175":1}}],["g",{"2":{"43":2,"195":9,"208":2}}],["gui",{"2":{"39":1}}],["gz",{"2":{"35":4,"228":2}}],["gnu",{"2":{"24":2,"196":1}}],["gotta",{"2":{"32":1}}],["goto",{"2":{"18":1,"160":2,"165":2}}],["go",{"2":{"24":6,"94":2,"292":1}}],["glfw3",{"2":{"249":1}}],["glfw",{"2":{"249":1}}],["gl",{"2":{"249":1}}],["glibc",{"2":{"23":2}}],["global",{"2":{"3":1,"85":1,"213":1,"220":1,"264":1}}],["gtkapplication",{"2":{"195":2}}],["gtkwidget",{"2":{"195":3}}],["gtk",{"2":{"195":16,"196":1}}],["gtk4",{"2":{"39":1,"195":3}}],["gt",{"2":{"4":2,"42":1,"102":3,"117":1,"127":4}}],["i0",{"2":{"287":1}}],["image",{"2":{"249":1}}],["implicit",{"2":{"44":1}}],["import",{"2":{"3":1,"8":1,"9":1,"17":3,"21":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":2,"49":1,"53":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":2,"63":1,"65":1,"66":1,"70":1,"76":1,"77":1,"78":1,"80":1,"81":2,"82":1,"84":1,"85":3,"86":1,"87":1,"89":1,"90":3,"94":1,"99":4,"100":1,"102":1,"108":2,"124":1,"125":1,"126":2,"129":1,"132":1,"139":1,"140":1,"141":1,"142":1,"146":1,"148":1,"149":1,"153":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":2,"185":1,"186":1,"187":1,"188":5,"189":2,"190":1,"191":1,"193":3,"194":2,"195":1,"196":1,"199":1,"200":1,"203":1,"230":1,"231":2,"232":2,"249":2,"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"261":1,"264":2,"271":8}}],["io",{"2":{"232":7}}],["i++",{"2":{"196":3}}],["ij",{"2":{"163":2}}],["i7",{"2":{"122":1}}],["i128",{"2":{"122":1}}],["i16",{"2":{"43":3,"53":1,"80":1,"122":1}}],["i64",{"2":{"122":1,"144":1,"178":3,"188":1}}],["ide",{"2":{"206":1,"207":2,"265":1}}],["identifier",{"2":{"140":1}}],["idx",{"2":{"175":1}}],["id",{"2":{"100":1,"214":1}}],["isfieldoptional",{"2":{"175":1}}],["isize",{"2":{"122":2}}],["is",{"2":{"72":2,"89":1,"90":2,"102":4,"104":2,"118":1,"129":1,"135":1,"148":3,"149":1,"162":2,"170":4,"187":3,"188":1,"196":1,"200":3,"203":1,"244":2,"254":2,"257":6,"258":2,"259":1,"261":2}}],["isclubs",{"2":{"69":1}}],["issue",{"2":{"4":1,"5":1,"9":1,"14":1,"196":1,"261":1}}],["i|",{"2":{"66":1,"157":1}}],["item|",{"2":{"173":2}}],["item",{"2":{"79":2,"173":16}}],["items2",{"2":{"158":2}}],["items",{"2":{"10":2,"90":3,"155":4,"157":2,"158":2,"159":2}}],["it",{"2":{"60":2,"140":1,"196":1,"244":1}}],["i8",{"2":{"53":1,"59":3,"80":3,"111":3,"117":3,"122":1,"161":2,"166":2}}],["i",{"2":{"8":6,"15":3,"21":3,"43":3,"66":1,"81":1,"106":3,"122":1,"157":1,"161":2,"162":12,"163":7,"164":4,"165":3,"166":8,"180":1,"196":28,"218":1}}],["if",{"2":{"7":4,"8":1,"9":2,"26":1,"28":1,"53":8,"85":1,"90":1,"111":1,"129":1,"132":3,"134":3,"135":1,"136":2,"145":3,"148":6,"149":3,"151":2,"152":8,"153":1,"155":1,"159":1,"162":2,"164":1,"167":2,"168":1,"175":1,"176":1,"186":1,"193":1,"194":1,"195":1,"196":14,"200":1,"244":1,"271":1,"275":1,"276":1}}],["inside",{"2":{"200":1}}],["installartifact",{"2":{"185":2,"186":5,"187":1,"188":1,"189":3,"191":1,"193":1,"194":1,"195":1,"196":1}}],["install",{"2":{"36":1,"185":2,"186":3,"187":1,"188":1,"189":2,"190":4,"191":1,"193":1,"194":1,"195":1,"196":1,"213":2,"214":2,"216":2,"218":4,"220":2}}],["inferred",{"2":{"136":1}}],["inf",{"2":{"126":4}}],["info",{"2":{"17":3,"254":4,"261":1}}],["input",{"2":{"84":1,"196":1,"232":1}}],["inputoperands",{"2":{"4":1}}],["in",{"2":{"63":2,"90":1,"124":4,"140":1,"196":1,"234":1,"244":1,"266":6}}],["invalidparam",{"2":{"135":1}}],["invalidchar",{"2":{"132":1,"134":1}}],["invalid",{"2":{"61":2,"86":1}}],["ini",{"2":{"39":2,"186":1}}],["initscr",{"2":{"196":1}}],["initial",{"2":{"66":3}}],["init",{"0":{"223":1,"224":1},"2":{"19":2,"27":2,"28":1,"29":1,"32":1,"66":2,"89":4,"90":3,"178":1,"196":2,"223":3,"224":4,"230":4,"244":1,"286":1}}],["include",{"2":{"15":1,"63":1,"195":1,"196":5}}],["indexed",{"2":{"196":1}}],["indexoutofbounds",{"2":{"175":1}}],["index|",{"2":{"56":2,"76":1}}],["index",{"2":{"9":5,"20":1,"56":2,"76":1,"175":2}}],["inline",{"0":{"161":1,"166":1},"2":{"8":2,"13":1,"17":1,"119":1,"161":3,"166":3,"175":6,"200":1,"254":5}}],["introduction",{"2":{"199":2}}],["intptr",{"2":{"122":1}}],["int128",{"2":{"122":2}}],["int16",{"2":{"122":1}}],["int64",{"2":{"122":1}}],["int32",{"2":{"122":1}}],["int8",{"2":{"122":1}}],["intfromfloat",{"2":{"52":1,"175":1,"282":1}}],["intfromerror",{"2":{"52":1}}],["intfromenum",{"2":{"52":1}}],["intfrombool",{"2":{"52":1}}],["intfromptr",{"2":{"4":1,"52":1,"86":1}}],["intcast",{"2":{"52":1,"72":1,"270":1}}],["int",{"2":{"12":1,"19":5,"21":5,"44":3,"61":1,"63":2,"73":1,"82":1,"90":2,"122":1,"140":1,"145":2,"178":10,"180":2,"195":3,"196":22,"254":1,"281":2,"282":1}}],["integer",{"2":{"79":2,"80":3}}],["interrupt",{"2":{"4":1}}],["intellij",{"2":{"207":1}}],["intel",{"2":{"2":2}}],["i32的可选类型",{"2":{"145":1}}],["i32",{"2":{"3":3,"8":20,"10":4,"45":3,"46":2,"47":1,"49":1,"60":3,"65":3,"76":3,"77":1,"81":5,"85":10,"86":1,"87":1,"91":2,"93":2,"100":2,"102":1,"104":1,"105":4,"106":2,"122":1,"124":2,"135":1,"143":2,"145":3,"146":2,"155":3,"157":1,"159":1,"161":2,"179":1,"180":1,"199":2,"252":3,"255":1,"256":1,"259":3,"264":3,"280":2,"282":1,"286":2}}],["=>",{"2":{"49":2,"72":5,"99":2,"132":4,"134":3,"161":8,"166":8,"170":4,"171":6,"172":4,"173":6,"174":3,"175":4,"179":4}}],["==",{"2":{"7":1,"8":7,"9":2,"26":1,"28":1,"49":5,"53":4,"61":1,"69":1,"70":2,"84":1,"85":10,"86":1,"87":1,"90":1,"99":16,"102":1,"126":1,"127":2,"129":1,"146":1,"148":2,"152":3,"155":1,"159":1,"161":2,"162":2,"164":1,"166":2,"167":1,"168":1,"171":1,"175":2,"179":4,"196":5,"199":2,"244":1,"252":2,"258":1}}],["=",{"2":{"3":1,"4":11,"8":19,"9":2,"10":4,"13":2,"17":2,"19":6,"21":4,"26":5,"27":12,"28":9,"29":4,"30":3,"31":3,"32":9,"35":7,"36":5,"37":12,"43":12,"44":3,"45":23,"46":2,"47":1,"48":2,"49":13,"51":3,"53":10,"55":3,"56":2,"57":2,"59":3,"60":5,"61":4,"63":2,"65":2,"66":4,"68":10,"69":1,"70":4,"71":3,"72":4,"73":1,"74":2,"76":5,"77":4,"78":5,"80":5,"81":8,"82":2,"84":2,"85":10,"86":4,"87":3,"89":9,"90":34,"91":4,"92":1,"93":4,"94":5,"95":3,"96":3,"99":20,"100":2,"102":9,"103":2,"104":4,"105":6,"106":5,"108":5,"122":4,"124":10,"126":5,"127":15,"129":4,"130":2,"132":10,"133":3,"134":5,"135":2,"136":5,"139":3,"140":5,"141":2,"142":3,"143":4,"144":4,"145":7,"146":3,"148":2,"149":9,"151":3,"152":8,"153":2,"155":3,"157":1,"158":2,"159":2,"160":2,"161":8,"162":3,"163":6,"164":1,"165":1,"166":8,"167":5,"168":5,"170":4,"171":6,"172":4,"173":14,"174":3,"175":2,"176":3,"178":13,"179":13,"180":3,"185":9,"186":7,"187":11,"188":13,"189":20,"190":6,"191":17,"192":10,"193":16,"194":16,"195":17,"196":50,"199":1,"200":11,"208":2,"230":1,"232":10,"244":7,"249":1,"252":6,"253":3,"254":4,"255":4,"256":4,"257":8,"258":6,"259":1,"261":14,"264":13,"270":2,"271":4,"280":2,"281":5,"282":2,"286":1,"290":1}}],["不足以容纳数据的值",{"2":{"270":1}}],["不得不说",{"2":{"261":1}}],["不检查字段",{"2":{"255":1}}],["不要认为这是一个简单的问题",{"2":{"232":1}}],["不只是",{"2":{"194":1}}],["不会出现只完成部分操作的情况",{"2":{"235":1}}],["不会将错误混到一起",{"2":{"191":1}}],["不会发生内存对齐",{"2":{"99":1}}],["不是吗",{"2":{"230":1}}],["不是由项目决定",{"2":{"185":1}}],["不是一个可选类型的指针",{"2":{"145":1}}],["不可达代码",{"0":{"267":1}}],["不可复现的原因",{"2":{"184":1}}],["不可直接对其指针进行更改",{"2":{"79":1}}],["不仅仅是以上两种方式",{"2":{"193":1}}],["不仅仅是",{"2":{"183":1}}],["不保证普通联合类型在内存中的表现形式",{"2":{"178":1}}],["不保证枚举和",{"2":{"73":1}}],["不处理错误",{"2":{"134":1}}],["不等于",{"2":{"127":1}}],["不过我们可以通过借引用指针来操作数组",{"2":{"155":1}}],["不过在",{"2":{"145":1}}],["不过可以使用",{"2":{"136":1}}],["不过",{"2":{"76":1,"186":1}}],["不能是常量",{"2":{"26":1,"28":1}}],["不支持声明极大地降低了",{"2":{"261":1}}],["不支持",{"2":{"20":1}}],["不允许取消引用地址为",{"2":{"20":1}}],["不兼容问题",{"2":{"15":1}}],["不依赖",{"2":{"11":1}}],["不同构建目标之间可能存在着专属于架构的错误定义",{"2":{"136":1}}],["不同进制",{"0":{"123":1}}],["不同类型的整数间",{"2":{"52":1}}],["不同的指针类型之间进行显式强制转换",{"2":{"52":1}}],["不同",{"2":{"3":1,"248":1}}],["不透明",{"2":{"3":1,"248":1}}],["你有没有想过",{"2":{"232":1}}],["你暂时就当作像水流一样的数据的就行",{"2":{"232":1}}],["你是不是觉得自己被耍了",{"2":{"231":1}}],["你确定展开后会代码效率会更高",{"2":{"166":1}}],["你大概是这样处理的",{"2":{"145":1}}],["你也可以指定包的",{"2":{"228":1}}],["你也可以同时迭代多个目标",{"2":{"158":1}}],["你也可以在这里做点额外的事情",{"2":{"134":1}}],["你也可以这样理解",{"2":{"3":1,"248":1}}],["你只能通过",{"2":{"128":1}}],["你只需要保证符合变量声明的",{"2":{"111":1}}],["你只需要在你的",{"2":{"82":1}}],["你现在只需要知道加法结果最多只是该类型的极限即可",{"2":{"127":1}}],["你一定以为这个可以通过断言",{"2":{"126":1}}],["你如果自行看了",{"2":{"108":1}}],["你还可以使用空结构体",{"2":{"94":1}}],["你还可以自己尝试实现一个内存模型",{"2":{"25":1}}],["你在函数中也可以使用",{"2":{"92":1}}],["你需要设置使用的内存分配器",{"2":{"27":1}}],["你可实现很多花哨的操作",{"2":{"295":1}}],["你可能很陌生",{"2":{"111":1}}],["你可能注意到了有的函数定义是这样子的",{"2":{"111":1}}],["你可能需要查看官方文档",{"2":{"84":1}}],["你可能会注意到",{"2":{"292":1}}],["你可能会疑惑",{"2":{"292":1}}],["你可能会想要使用切片",{"2":{"76":1}}],["你可能会一脸懵逼",{"2":{"6":1}}],["你可能对上面的多种内存模型感到很迷惑",{"2":{"25":1}}],["你可能对于容器这个概念比较疑惑",{"2":{"3":1}}],["你可以暂时跳过这里",{"2":{"231":1}}],["你可以把它看作是一个匿名结构体",{"2":{"231":1}}],["你可以附加",{"2":{"228":1}}],["你可以在阅读完这两章节后再回来学习",{"2":{"150":1}}],["你可以将它放在类型的前面",{"2":{"145":1}}],["你可以将所有的错误强制转换到",{"2":{"131":1}}],["你可以通过使用",{"2":{"136":1}}],["你可以使用",{"2":{"179":1,"233":1}}],["你可以使用以下方式书写字面量",{"2":{"123":1}}],["你可以使用以下的方法",{"2":{"55":1}}],["你可以使用它来代替",{"2":{"116":1}}],["你可以一眼就看出来它的组成",{"2":{"111":1}}],["你可以对数组",{"2":{"76":1}}],["你可以看作是一类",{"2":{"69":1}}],["你可以进行参考和学习",{"2":{"39":1}}],["你可以参考以下链接",{"2":{"23":1}}],["你可以阅读这里",{"2":{"4":1}}],["你可以继续查询有关调用约定",{"2":{"3":1}}],["语句可以进行匹配",{"2":{"169":1}}],["语句",{"2":{"53":1}}],["语句是描述程序运行操作的一个单位",{"2":{"3":1,"248":1}}],["语言简单性的改进与流控制",{"2":{"293":1}}],["语言和区域",{"2":{"212":1}}],["语言",{"2":{"79":1,"292":1}}],["语言中不就是",{"2":{"25":1}}],["语言共享类型通常是通过引入头文件实现",{"2":{"13":1}}],["语法捕获指针类型",{"2":{"179":1}}],["语法出现在",{"2":{"167":1}}],["语法访问元组中的元素",{"2":{"96":1}}],["语法来解开可选类型",{"2":{"275":1,"276":1}}],["语法来解开可选",{"2":{"275":1}}],["语法来捕获对应的指针进行修改操作",{"2":{"173":2}}],["语法来访问",{"2":{"96":1}}],["语法来使用外",{"2":{"89":1}}],["语法兼容",{"2":{"2":1}}],["语法的支持存在",{"2":{"2":1}}],["语法",{"2":{"2":2,"78":1,"90":1,"140":1,"171":1}}],["但不依赖它",{"2":{"295":1}}],["但不排除当前因为",{"2":{"19":1}}],["但改善旧问题并提供了完善的工具链",{"2":{"294":1}}],["但就现在来看",{"2":{"292":1}}],["但由于历史原因",{"2":{"292":1}}],["但由于宏是在词法分析的级别上生效",{"2":{"19":1}}],["但普通指针是不允许的",{"2":{"283":1}}],["但作用于字段",{"2":{"256":1}}],["但作为开发者",{"2":{"112":1}}],["但我更推荐你结合标准库的源码来了解它",{"2":{"233":1}}],["但我们可以以此为基础在编译期构建新的类型",{"2":{"254":1}}],["但我们可以捕获它们并有效地报告给用户",{"2":{"128":1}}],["但我们可以使用",{"2":{"24":1}}],["但我们仍需要汇编语言的帮助",{"2":{"2":1}}],["但这样子实现效果内存占用会更少",{"2":{"286":1}}],["但这导致了无法在单元测试中写入",{"2":{"191":1}}],["但这些指针并不是普通指针",{"2":{"99":1}}],["但实际开发中这样很不方便",{"2":{"191":1}}],["但实际上在运行时会直接奔溃",{"2":{"126":1}}],["但其实这是不必要的",{"2":{"189":1}}],["但更加的现代化",{"2":{"183":1}}],["但同一时间只能存储一个类型",{"2":{"177":1}}],["但好处大大是减少了你在运行时",{"2":{"145":1}}],["但好处是线程安全并且无锁",{"2":{"31":1}}],["但可以使用",{"2":{"266":1}}],["但可以增加一个修饰符",{"2":{"96":1}}],["但可通过将其分配给",{"2":{"139":1}}],["但错误联合类型大概是你经常用的",{"2":{"132":1}}],["但在安装插件后可以作为",{"2":{"207":1}}],["但在执行某些操作时会变得有些棘手",{"2":{"136":1}}],["但在编译时如果传入参数",{"2":{"129":1}}],["但在",{"2":{"99":1}}],["但在实践中",{"2":{"76":1}}],["但保证它是",{"2":{"97":1}}],["但插入了安全检查",{"2":{"85":1}}],["但知道它实际上具有较大的对齐方式",{"2":{"85":1}}],["但反之则不然",{"2":{"85":1}}],["但始终是",{"2":{"85":1}}],["但非零",{"2":{"74":1}}],["但是使用可选类型代替",{"2":{"293":1}}],["但是在未来谁说的准呢",{"2":{"292":1}}],["但是在开发版中",{"2":{"129":1}}],["但是不同的编译器却有着不同的",{"2":{"292":1}}],["但是这就面临着性能问题",{"2":{"232":1}}],["但是请记住",{"2":{"232":1}}],["但是如果要使用",{"2":{"216":1}}],["但是注意我们获得的捕获是只读的",{"2":{"151":1}}],["但是可以使用",{"2":{"126":1}}],["但是它是否有符号取决于",{"2":{"108":1}}],["但是它无法通过正常的",{"2":{"96":1}}],["但是需要注意",{"2":{"108":1}}],["但是",{"2":{"95":1,"142":1,"233":1}}],["但是当我们给指针增加上",{"2":{"86":1}}],["但是对切片指针做操作则不会有边界检查",{"2":{"77":1}}],["但是我们可以通过指定序列类型来达到这一效果",{"2":{"73":1}}],["但是存在着变体",{"2":{"27":1}}],["但需明确指出枚举大小并且不能已经将整个大小空间消耗干净",{"2":{"72":1}}],["但需要手动",{"2":{"36":1}}],["但需要注意的是",{"2":{"200":1}}],["但需要注意需要注意不要超出枚举的大小空间",{"2":{"72":1}}],["但需要注意",{"2":{"6":1}}],["但用处颇多的类型",{"2":{"67":1}}],["但有时也会给我们带来困扰",{"2":{"136":1}}],["但有一个例外",{"2":{"41":1}}],["但有一点需要注意",{"2":{"29":1,"79":1}}],["但有些系统还支持2m和1g的页",{"2":{"31":1}}],["但仅仅是少量的保护",{"2":{"25":1}}],["但通常它没有这样做",{"2":{"20":1}}],["但得益于",{"2":{"18":1}}],["但",{"2":{"11":1,"135":1}}],["但它不止这一种用法",{"2":{"286":1}}],["但它只携带每个版本的符号库",{"2":{"23":1}}],["但它可以存在多个输入",{"2":{"4":1}}],["但它和普通的内联语句不同",{"2":{"4":1}}],["但容器并不能包含语句",{"2":{"3":1,"248":1}}],["甚至你可以用它来部署你的项目",{"2":{"221":1}}],["甚至被指责为计算机科学中最严重的错误",{"2":{"145":1}}],["甚至",{"2":{"3":1,"248":1}}],["联合起来",{"2":{"134":1}}],["联合类型字段访问错误",{"0":{"281":1}}],["联合类型可以在定义时使用枚举进行标记",{"2":{"179":1}}],["联合类型的基本使用",{"2":{"178":1}}],["联合类型",{"0":{"177":1,"291":1},"1":{"178":1,"179":1,"180":1,"181":1,"182":1},"2":{"177":1,"254":1,"256":1,"291":1}}],["联合类型只使用其最大位宽",{"2":{"99":1}}],["联合类型和枚举",{"0":{"49":1}}],["联合和枚举相同的声明",{"2":{"74":1}}],["联合错误可选类型也有效",{"2":{"45":1}}],["联合错误类型也有效",{"2":{"45":1}}],["联合",{"2":{"3":1,"112":1,"248":1,"254":1}}],["枚举类型",{"2":{"256":1}}],["枚举类型只使用其整数标志位的位宽",{"2":{"99":1}}],["枚举和不透明的类型信息都有声明",{"2":{"254":1}}],["枚举和错误集的类型信息具有保证与源文件中出现的顺序相同的字段",{"2":{"254":1}}],["枚举也支持让",{"2":{"71":1}}],["枚举也可以拥有方法",{"2":{"69":1}}],["枚举推断",{"0":{"71":1}}],["枚举的大小是会经过",{"2":{"70":1}}],["枚举大小",{"0":{"70":1}}],["枚举方法",{"0":{"69":1}}],["枚举是一种相对简单",{"2":{"67":1}}],["枚举",{"0":{"67":1,"289":1},"1":{"68":1,"69":1,"70":1,"71":1,"72":1,"73":1},"2":{"3":1,"248":1,"289":1}}],["容器类型",{"2":{"257":1}}],["容器",{"0":{"248":1},"2":{"248":1}}],["容器和块",{"2":{"3":1,"248":1}}],["容器是一个只包含变量或常量定义以及函数定义的命名空间",{"2":{"3":1,"248":1}}],["容器是充当保存变量和函数声明的命名空间的任何语法结构",{"2":{"3":1}}],["容器也是可以实例化的类型定义",{"2":{"3":1,"248":1}}],["当将浮点数转换为整数时",{"2":{"282":1}}],["当出现安全检查失败时",{"2":{"266":1}}],["当包提供",{"2":{"228":1}}],["当测试失败时",{"2":{"199":1}}],["当测试名字是一个标识符时",{"2":{"199":1}}],["当使用",{"2":{"175":1,"278":1}}],["当错误发生时",{"2":{"168":1}}],["当它有标签时",{"2":{"143":1}}],["当它编译为机器码时",{"2":{"120":1}}],["当一个变量未定义时",{"2":{"142":1}}],["当一个函数不会返回时",{"2":{"116":1}}],["当函数使用推导错误集时",{"2":{"136":1}}],["当发生错误时",{"2":{"133":1}}],["当编译器无法完成推断时",{"2":{"92":1}}],["当从内存加载或存储该类型的值时",{"2":{"85":1}}],["当我们使用自动推导时",{"2":{"136":1}}],["当我们对切片元素取地址",{"2":{"77":1}}],["当我们在处理复杂数据时很有用",{"2":{"9":1}}],["当元组中的所有值均为同一个类型时",{"2":{"51":1}}],["当需要一种类型时却提供了另一种类型",{"2":{"41":1}}],["当你需要动态内存时",{"2":{"26":1}}],["当",{"2":{"20":2,"167":1,"168":1,"231":1}}],["当被转换为非可选指针时",{"2":{"20":1}}],["当顶层空间",{"2":{"18":1}}],["当宿主机器并没有提供足够大的堆栈时",{"2":{"9":1}}],["当看到一只鸟走起来像鸭子",{"2":{"7":1}}],["当然如果你想将包直接添加到",{"2":{"228":1}}],["当然在",{"2":{"145":1}}],["当然进阶点我们还可以和命名",{"2":{"133":1}}],["当然这两个迭代的目标要长度一致防止出现未定义的行为",{"2":{"158":1}}],["当然这在",{"2":{"145":1}}],["当然这种操作不局限于声明变量",{"2":{"92":1}}],["当然这里如果是一个变量",{"2":{"4":1}}],["当然还涉及到一点点的汇编知识",{"2":{"25":1}}],["当然不仅仅如此",{"2":{"23":1}}],["当然也包括可选指针类型",{"2":{"20":1}}],["当然我们这里可以直接赋值为",{"2":{"9":1}}],["当然",{"2":{"3":1,"96":1,"145":1,"158":1,"159":1,"160":1,"165":1,"228":1,"248":1,"273":1,"292":1}}],["当汇编表达式出现在容器级",{"2":{"3":1}}],["当前可用的类型信息",{"2":{"254":1}}],["当前是将参数传递给运行构建结果",{"2":{"186":1}}],["当前包的参数并不会向包传递",{"2":{"37":1}}],["当前仅",{"2":{"35":1}}],["当前你所开发的包的名字",{"2":{"35":1}}],["当前你可以通过实现",{"2":{"33":1}}],["当前并没有一个中心化存储库",{"2":{"34":1}}],["当前的包管理模式为",{"2":{"34":1}}],["当前的自托管编译期设计存在某些缺陷",{"2":{"9":1}}],["当前的异步处于冻结状态",{"2":{"5":1}}],["当前汇编语法为",{"2":{"2":1}}],["当前",{"2":{"0":1,"14":1,"35":1,"139":1,"183":1,"211":1,"223":1,"224":1,"230":1,"261":1}}],["一切都是强制显示声明式",{"2":{"294":1}}],["一切都是自动完成的",{"2":{"51":1}}],["一些额外知识的补充",{"2":{"247":1}}],["一些二元操作符",{"2":{"53":1}}],["一样",{"2":{"167":1}}],["一样难以把控",{"2":{"160":1,"165":1}}],["一样纯粹",{"2":{"30":1}}],["一模一样",{"2":{"159":1}}],["一定不会失败",{"2":{"232":1}}],["一定是一个错误",{"2":{"232":1}}],["一定是一个可用的指针",{"2":{"145":1}}],["一定要是变量",{"2":{"26":1,"28":1}}],["一眼就可以看出来各自的作用",{"2":{"111":1}}],["一种是",{"2":{"154":2}}],["一种是环绕操作符",{"2":{"125":1}}],["一种是使用内置的溢出处理函数",{"2":{"125":1}}],["一种是多项",{"2":{"79":1}}],["一种是在",{"2":{"3":1}}],["一种单项",{"2":{"79":1}}],["一个元组作为参数",{"2":{"259":1}}],["一个元素全为布尔类型的向量",{"2":{"106":1}}],["一个函数",{"2":{"259":1}}],["一个函数只能返回一个值",{"2":{"111":1}}],["一个是",{"2":{"185":2}}],["一个最简单的",{"2":{"185":1}}],["一个普通的i32整数",{"2":{"145":1}}],["一个向量",{"2":{"105":1}}],["一个声明",{"2":{"89":1}}],["一个简单的",{"2":{"39":1}}],["一个快速高效且并发的脚本语言",{"2":{"39":1}}],["一个小型轻量的静态类型脚本语言",{"2":{"39":1}}],["一个轻量强类型嵌入式语言",{"2":{"39":1}}],["一个实现",{"2":{"7":1}}],["一块内存区域",{"2":{"27":2}}],["一旦使用了它",{"2":{"24":1}}],["一般而言",{"2":{"220":1}}],["一般填测试的用途",{"2":{"199":1}}],["一般是出现问题的",{"2":{"196":1}}],["一般是在以下场景下",{"2":{"2":1}}],["一般用于使用",{"2":{"16":1}}],["一起使用",{"2":{"8":1}}],["外部汇编",{"0":{"3":1}}],["而构建系统则被很多",{"2":{"295":1}}],["而作用于类型时只能访问声明",{"2":{"257":1}}],["而gnu的则是",{"2":{"196":1}}],["而链接库的构建结果会输出在",{"2":{"189":1}}],["而在",{"2":{"145":1}}],["而无需尝试确保覆盖每个退出路径的冗长和认知开销",{"2":{"135":1}}],["而函数指针可能是运行时已知的",{"2":{"111":1}}],["而比目标机器",{"2":{"102":1}}],["而是一个标准",{"2":{"292":1}}],["而是一个指针",{"2":{"145":1}}],["而是由用户决定",{"2":{"185":1}}],["而是为了安全",{"2":{"26":1}}],["而是近乎原生的调用",{"2":{"11":1}}],["而且目前",{"2":{"292":1}}],["而且均有上手难度",{"2":{"292":1}}],["而且纠正起来很简单",{"2":{"145":1}}],["而且是哨兵字符为",{"2":{"61":1}}],["而且不仅仅是这些",{"2":{"25":1}}],["而且它们之间有一部分还可以叠加使用",{"2":{"25":1}}],["而不是语言语义",{"2":{"142":1}}],["而不是",{"2":{"30":1}}],["而不是重复翻译相同的代码",{"2":{"17":1}}],["而不是更流行的",{"2":{"2":1}}],["而",{"2":{"16":1,"30":1,"43":1,"157":1,"164":1,"175":1,"186":1}}],["而汇编语言完全由程序员控制",{"2":{"2":1}}],["txthello",{"2":{"193":1}}],["txt",{"2":{"193":2}}],["txtbuild",{"2":{"193":1}}],["tt",{"2":{"90":3}}],["t是所指向内存区域的类型",{"2":{"80":1,"81":1}}],["thing",{"2":{"145":2}}],["things",{"2":{"133":1}}],["third",{"2":{"102":1,"153":1}}],["this",{"2":{"90":2,"170":4,"200":2,"244":1}}],["then",{"2":{"244":1}}],["their",{"2":{"196":1}}],["they",{"2":{"196":1}}],["the",{"2":{"89":1,"102":1,"135":1,"186":1,"193":1,"194":1,"195":1,"196":9,"200":2,"244":2,"259":1,"266":1}}],["thousand",{"2":{"68":1}}],["thread",{"2":{"27":4,"124":1,"233":1,"266":1}}],["threadsafeallocator",{"2":{"27":4}}],["three",{"2":{"8":4,"49":9,"70":3,"72":2}}],["tuple",{"2":{"51":4,"96":1,"231":1,"261":1}}],["tab",{"2":{"62":1}}],["tag|",{"2":{"175":1}}],["tag形式的分配匹配",{"2":{"171":1}}],["tagname",{"2":{"70":2,"128":1,"129":2,"179":2}}],["tag",{"0":{"173":1},"2":{"49":3,"70":2,"171":1,"172":2,"175":4,"179":2,"192":1}}],["tar",{"2":{"35":5,"228":2}}],["target",{"2":{"15":2,"24":4,"37":3,"85":1,"99":1,"108":1,"172":2,"185":4,"187":3,"188":3,"189":5,"191":5,"192":8,"193":3,"194":3,"195":3,"196":3}}],["tmp",{"2":{"44":1,"90":2,"124":2,"135":2,"266":1}}],["text",{"0":{"210":1},"2":{"201":2}}],["terminated",{"2":{"57":1,"124":1}}],["tetris",{"2":{"39":1}}],["tests",{"2":{"191":7,"199":1}}],["testpeerresolvearrayconstslice",{"2":{"53":2}}],["test",{"0":{"191":1,"227":1},"2":{"8":1,"9":3,"17":1,"26":1,"28":1,"44":3,"84":1,"85":3,"86":1,"87":1,"90":2,"99":3,"124":3,"146":1,"191":5,"199":9,"200":13,"201":3,"203":1,"252":1,"258":2,"266":15}}],["testing",{"2":{"8":1,"9":1,"25":2,"32":1,"49":1,"53":1,"70":1,"84":1,"85":2,"86":1,"87":1,"90":1,"99":3,"146":1,"161":1,"166":1,"179":2,"198":1,"199":5,"200":4,"202":1,"252":1,"286":1}}],["tick",{"2":{"196":5}}],["tinytetris",{"2":{"196":1}}],["titlecase",{"2":{"264":10}}],["title",{"2":{"195":1}}],["tigerbeetle",{"2":{"39":1}}],["timeout",{"2":{"196":1}}],["timestamp",{"2":{"144":4,"188":7}}],["time",{"2":{"9":2,"188":4,"196":1}}],["ts",{"2":{"39":1}}],["top",{"2":{"200":1}}],["todo",{"2":{"37":1,"75":1,"197":1,"229":1,"245":1,"246":1,"254":1,"284":1}}],["tool",{"2":{"23":2,"220":2}}],["to",{"2":{"19":1,"20":2,"35":1,"44":1,"85":2,"99":4,"196":1,"199":2,"244":1}}],["token",{"2":{"18":1,"19":1}}],["tristanisham",{"2":{"220":1}}],["truncate",{"2":{"52":1,"270":1}}],["trunk",{"2":{"35":1,"228":2}}],["true",{"2":{"52":1,"53":10,"61":3,"72":3,"90":1,"96":1,"104":4,"106":3,"109":1,"116":1,"118":2,"151":1,"164":1,"165":3,"174":1,"191":1,"199":1,"200":3,"252":1,"255":2,"256":1,"258":1}}],["translation",{"0":{"14":1},"1":{"15":1,"16":1}}],["translate",{"0":{"16":1},"2":{"13":1,"14":2,"16":1,"17":1,"19":1}}],["trytoallocatefoo",{"2":{"135":1}}],["trycatch",{"2":{"134":1}}],["try",{"0":{"134":1},"2":{"8":3,"9":3,"26":1,"27":2,"28":3,"29":1,"31":1,"32":4,"37":1,"49":5,"53":6,"70":4,"84":1,"85":9,"86":1,"87":1,"90":4,"99":18,"134":3,"135":1,"137":1,"146":1,"151":1,"152":3,"161":2,"163":1,"166":2,"171":1,"179":4,"199":3,"200":4,"232":6,"252":2}}],["two",{"2":{"8":4,"49":4,"60":2,"68":1,"70":2,"72":2,"105":1,"196":1}}],["typenamelength",{"2":{"161":4,"166":4}}],["typename",{"0":{"253":1},"2":{"100":3,"161":2,"166":2,"251":1,"253":3,"264":3}}],["typeinfo",{"0":{"254":1},"2":{"70":4,"85":2,"115":1,"146":1,"175":2,"251":1,"254":5,"261":1}}],["typeof",{"0":{"252":1},"2":{"61":1,"76":2,"77":2,"78":2,"84":1,"85":6,"115":2,"146":1,"251":1,"252":6}}],["type",{"0":{"261":1},"2":{"3":1,"7":3,"10":2,"37":1,"40":2,"53":1,"68":2,"70":2,"90":2,"92":2,"100":2,"105":1,"106":1,"111":2,"136":4,"139":1,"146":1,"161":2,"166":2,"175":2,"178":1,"200":1,"237":1,"238":1,"239":1,"240":1,"241":1,"252":2,"254":6,"260":1,"261":5,"264":5,"285":1}}],["t",{"2":{"2":1,"7":14,"8":2,"10":2,"16":3,"20":4,"53":4,"57":2,"62":1,"76":1,"78":1,"79":1,"80":1,"81":4,"82":1,"90":3,"92":2,"100":2,"106":4,"111":5,"122":11,"136":9,"140":1,"145":1,"161":8,"166":8,"175":2,"196":2,"200":4,"237":3,"238":3,"239":4,"240":5,"241":5,"249":4,"252":5,"253":5,"254":3,"261":2,"264":2}}],["ada",{"2":{"292":1}}],["advanced",{"2":{"234":1}}],["addone",{"2":{"199":9}}],["addoption",{"2":{"188":1}}],["addoptions",{"2":{"188":3}}],["addincludepath",{"2":{"195":1,"196":1}}],["addinstalldirectory",{"2":{"190":2}}],["addinstallartifact",{"2":{"186":2}}],["addcsourcefiles",{"2":{"195":1,"196":2}}],["addcsourcefile",{"2":{"195":2,"196":1}}],["adds",{"2":{"199":2}}],["addsystemcommand",{"2":{"194":1}}],["addstaticlibrary",{"2":{"189":1,"192":1}}],["addtest",{"2":{"191":2}}],["addarg",{"2":{"194":1}}],["addargs",{"2":{"186":1,"193":1,"194":2,"195":1,"196":1}}],["addanonymousmodule",{"2":{"193":1,"194":1}}],["addassemblyfile",{"2":{"3":2}}],["addrunartifact",{"2":{"186":1,"191":1,"193":1,"194":1,"195":1,"196":1}}],["address",{"2":{"122":1}}],["addwithoverflow",{"2":{"125":1,"132":1,"136":2,"271":2}}],["addfortytwo",{"2":{"115":1}}],["addexecutable",{"2":{"37":1,"185":3,"186":1,"187":1,"188":1,"189":2,"191":1,"192":2,"193":1,"194":1,"195":1,"196":1}}],["addmodule",{"2":{"36":5,"37":1}}],["add",{"2":{"9":3,"21":1,"104":2,"111":2,"136":2,"213":2,"220":1,"259":3,"271":1}}],["av",{"2":{"218":1}}],["aur",{"2":{"218":1}}],["autohashmap",{"2":{"286":2}}],["autosave",{"2":{"208":2}}],["auto",{"2":{"71":2,"174":2,"259":1,"261":1}}],["acqrel",{"2":{"244":1}}],["acquire",{"2":{"244":2}}],["accessdenied",{"2":{"129":1}}],["activate",{"2":{"195":3}}],["active",{"2":{"90":12,"178":1}}],["actions",{"2":{"124":3,"266":6}}],["action",{"2":{"1":1}}],["abort",{"2":{"118":1}}],["abi等等",{"2":{"189":1}}],["abi的",{"2":{"126":1}}],["abilist",{"2":{"23":1}}],["abi",{"0":{"12":1},"2":{"11":1,"12":1,"15":1,"23":1,"73":1,"97":1,"98":1,"99":2,"112":1,"117":1,"181":1,"192":1,"196":1,"292":1}}],["after",{"2":{"90":1}}],["amp",{"2":{"77":1,"79":2,"102":1,"127":1}}],["ambiguous",{"2":{"44":3}}],["aoeu",{"2":{"53":3}}],["a2",{"2":{"45":1}}],["a1",{"2":{"45":1}}],["another",{"2":{"244":1}}],["anonymous",{"2":{"100":2}}],["anonymousdependency",{"2":{"37":3,"193":1}}],["andrew",{"2":{"293":1}}],["and",{"2":{"44":1,"104":2,"127":2,"196":3,"220":2,"232":1,"244":1}}],["anyslice",{"2":{"175":1}}],["any",{"2":{"59":1,"65":1,"66":1,"102":3,"173":1,"175":2}}],["anyerror",{"2":{"45":6,"46":1,"47":1,"53":2,"82":1,"131":4,"132":1,"152":5,"168":1,"199":1}}],["anytype",{"0":{"115":1},"2":{"16":1,"37":2,"103":2,"104":1,"115":2}}],["anyopaque",{"0":{"75":1},"2":{"12":1,"75":1,"81":1}}],["alias",{"2":{"264":2}}],["alignment",{"2":{"85":5,"261":1}}],["alignof",{"2":{"85":2}}],["aligncast",{"2":{"52":1,"85":2,"280":1}}],["aligned",{"2":{"30":1,"99":1,"280":1}}],["align",{"2":{"20":1,"85":13,"99":2,"280":2}}],["alternative",{"2":{"244":1}}],["allowzero",{"2":{"86":3,"283":1}}],["allocatetmpbuffer",{"2":{"135":1}}],["allocationerror",{"2":{"129":5}}],["allocator=thread",{"2":{"27":1}}],["allocator善后工作",{"2":{"26":1,"28":1}}],["allocator",{"0":{"30":1,"31":1},"2":{"25":3,"26":4,"27":11,"28":8,"29":4,"30":7,"31":4,"32":1,"33":1,"90":8,"202":1,"286":1}}],["allocfn",{"2":{"33":1}}],["alloc",{"2":{"26":1,"27":2,"28":3,"29":1,"30":2,"31":1,"32":1,"90":3}}],["all",{"2":{"60":2,"104":2,"199":1,"220":1}}],["apt",{"2":{"220":1}}],["app",{"2":{"193":1,"194":1,"195":8,"196":1}}],["application",{"2":{"186":1,"195":5}}],["api包装库",{"2":{"39":1}}],["api",{"0":{"190":1},"2":{"29":1,"39":1,"249":1}}],["ap",{"2":{"21":3}}],["area",{"2":{"89":5}}],["arena",{"2":{"28":7}}],["arenaallocator",{"0":{"28":1},"2":{"25":1,"28":1}}],["arch",{"2":{"85":1,"99":1,"124":1,"192":1,"218":1,"266":1}}],["archive",{"2":{"35":2,"228":2}}],["arr1",{"2":{"102":3}}],["arr",{"2":{"56":3,"81":3,"90":2}}],["arrays",{"2":{"57":1}}],["array",{"2":{"20":1,"51":1,"57":6,"65":2,"66":2,"76":4,"77":2,"78":2,"81":6,"85":2}}],["arocc",{"2":{"39":1}}],["artifact",{"2":{"37":2,"186":1}}],["argv",{"2":{"63":1,"195":2}}],["argc",{"2":{"63":1,"195":2}}],["args",{"2":{"37":3,"186":2,"193":2,"194":2,"195":2,"196":2}}],["arg",{"2":{"21":1}}],["arg3",{"2":{"4":5}}],["arg2",{"2":{"4":5,"186":1}}],["arg1",{"2":{"4":8,"186":1}}],["ast",{"0":{"225":1}}],["asdf",{"2":{"220":12}}],["assert",{"2":{"126":1,"131":1}}],["assert用于断言",{"2":{"126":1}}],["assemblertemplate",{"2":{"4":1}}],["assembly",{"2":{"4":1}}],["ascii",{"2":{"61":1,"107":1,"108":2}}],["as",{"2":{"53":4,"85":7,"89":2,"90":1,"96":2,"102":1,"104":1,"105":1,"179":2,"244":1}}],["asm",{"2":{"3":1,"4":4,"124":1,"266":1}}],["a",{"2":{"3":1,"7":9,"9":2,"19":5,"43":3,"49":4,"53":8,"68":1,"73":1,"80":1,"89":1,"93":1,"99":5,"102":2,"105":10,"106":5,"111":8,"117":3,"119":2,"124":6,"127":1,"132":4,"136":4,"145":2,"149":4,"152":4,"167":2,"168":2,"171":2,"172":4,"173":8,"175":1,"179":3,"186":3,"196":7,"200":2,"244":1,"254":1,"259":2}}],["atomicrmwop",{"2":{"239":1}}],["atomicrmw",{"0":{"239":1},"2":{"239":1}}],["atomicstore",{"0":{"238":1},"2":{"238":1}}],["atomicorder",{"2":{"237":1,"238":1,"239":1,"240":2,"241":2,"242":1}}],["atomicload",{"0":{"237":1},"2":{"237":1}}],["atomic",{"0":{"243":1},"1":{"244":1,"245":1},"2":{"235":1,"244":1,"245":1}}],["attroff",{"2":{"196":1}}],["attron",{"2":{"196":1}}],["attribute",{"2":{"145":1}}],["atan2",{"2":{"117":1}}],["at",{"2":{"2":1,"9":2,"196":1}}],["和普通的函数调用方式相同",{"2":{"259":1}}],["和通过",{"2":{"224":1}}],["和对应的",{"2":{"175":1}}],["和上面类似",{"2":{"168":1}}],["和上面一样",{"2":{"127":1}}],["和乘的倍数",{"2":{"127":1}}],["和数组索引语法以从向量转换为标量",{"2":{"102":1}}],["和向量的混合使用数学运算符",{"2":{"102":1}}],["和指针转换",{"2":{"99":1}}],["和其他的函数没有任何区别",{"2":{"89":1}}],["和其他任意不透明类型",{"2":{"81":1}}],["和变量定义一样的结构体名字",{"2":{"89":1}}],["和长度",{"2":{"76":1}}],["和包管理",{"2":{"39":1}}],["和传递的",{"2":{"15":1}}],["和分析具有不同预处理定义的代码时才出现多个",{"2":{"13":1}}],["和相关的约束",{"2":{"4":1}}],["和",{"2":{"2":1,"9":2,"17":1,"20":1,"21":1,"24":1,"33":2,"35":1,"36":1,"37":2,"43":3,"45":1,"53":1,"61":1,"66":1,"68":1,"70":1,"76":1,"81":1,"85":1,"89":1,"96":1,"99":1,"102":1,"104":1,"107":1,"108":1,"109":1,"111":1,"112":1,"115":1,"122":1,"124":1,"129":1,"134":3,"135":3,"136":1,"155":1,"164":1,"176":2,"191":1,"192":1,"195":1,"207":1,"208":1,"213":1,"223":2,"224":2,"230":1,"231":1,"232":3,"252":1,"256":1,"281":1,"287":1,"288":1,"292":1}}],["内部直接使用混入的声明",{"2":{"249":1}}],["内部返回值",{"2":{"164":1}}],["内部是一连串的匿名结构体",{"2":{"35":1}}],["内联",{"0":{"161":1,"166":1,"175":1},"2":{"161":1}}],["内联汇编特性在未来可能会发生更改以支持新的特性",{"2":{"4":1}}],["内联汇编的表达式会被某些编译器未知的因素更改",{"2":{"4":1}}],["内联汇编是以",{"2":{"4":1}}],["内联汇编给予了我们可以将",{"2":{"4":1}}],["内联汇编",{"0":{"4":1}}],["内联汇编大概是使用最多的情况",{"2":{"2":1}}],["内置溢出处理函数",{"2":{"125":1}}],["内建函数由编译器提供",{"2":{"113":1}}],["内建函数",{"0":{"113":1,"236":1,"246":1},"1":{"237":1,"238":1,"239":1,"240":1,"241":1,"242":1}}],["内建函数来轻松从标量转换为向量",{"2":{"102":1}}],["内存对齐大小取决于",{"2":{"85":1}}],["内存地址必须能被该数字整除",{"2":{"85":1}}],["内存池还支持预分配和指针对齐设置等",{"2":{"32":1}}],["内存池",{"2":{"32":1}}],["内存",{"2":{"29":1}}],["内存管理",{"0":{"25":1},"1":{"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1,"33":1}}],["内核上利用",{"2":{"4":1}}],["内核的开发",{"2":{"2":1}}],["优化",{"2":{"2":1}}],["它和",{"2":{"294":1}}],["它和输出位置类似",{"2":{"4":1}}],["它不提供垃圾回收",{"2":{"293":1}}],["它旨在替代c编程语言",{"2":{"293":1}}],["它本身有着一套自己的标准",{"2":{"292":1}}],["它本质是一个胖指针",{"2":{"76":1}}],["它非常成功",{"2":{"292":1}}],["它需要保证被除数可以整除除数",{"2":{"274":1}}],["它将类型信息具体化为一个类型",{"2":{"261":1}}],["它将以父结构体和前面的规则推断出的名称命名",{"2":{"100":1}}],["它接收一个调用修饰符",{"2":{"259":1}}],["它接受任意个表达式作为参数",{"2":{"252":1}}],["它还没有多线程支持",{"2":{"233":1}}],["它还有一个变体",{"2":{"30":1}}],["它可能会出现错误导致写入失败",{"2":{"232":1}}],["它可以作为任何语言的构建系统",{"2":{"183":1}}],["它可以是你设置的任何名字",{"2":{"143":1}}],["它可以赋值给所有类型",{"2":{"50":1}}],["它可以提供更加完善的工具链",{"2":{"24":1}}],["它可以将",{"2":{"14":1}}],["它可以使用",{"2":{"4":1}}],["它囊括了项目建立",{"2":{"221":1}}],["它包括了整个软件生命周期中所需要的大部分工具",{"2":{"206":1}}],["它包含编译单元中的所有错误集",{"2":{"131":1}}],["它包含一个方法",{"2":{"36":1,"37":1}}],["它包含一个编译期参数",{"2":{"7":1}}],["它所使用的",{"2":{"200":1}}],["它默认会使用标准库提供的",{"2":{"199":1}}],["它实际上用户定义的一种特殊的类型",{"2":{"177":1}}],["它支持搜索查询",{"2":{"190":1}}],["它支持",{"2":{"155":1}}],["它支持线程安全",{"2":{"26":1}}],["它真的是非常的激进",{"2":{"145":1}}],["它兼顾了代码的可读性和效率问题",{"2":{"145":1}}],["它无法再被更改",{"2":{"141":1}}],["它用于处理错误",{"2":{"135":1}}],["它用于显式声明包含的源文件",{"2":{"35":1}}],["它代表以下内容",{"2":{"116":1}}],["它使用的是小驼峰命名法",{"2":{"111":1}}],["它对应",{"2":{"108":1}}],["它尽可能使用",{"2":{"101":1}}],["它保证了内存布局",{"2":{"99":1}}],["它就以该变量命名",{"2":{"100":1}}],["它就变成合法的行为了",{"2":{"86":1}}],["它就是",{"2":{"61":1}}],["它相当于一个胖指针",{"2":{"81":1}}],["它相当于一个指向数组的单项指针",{"2":{"81":1}}],["它存储了一个地址",{"2":{"79":1}}],["它具有运行时已知的长度",{"2":{"78":1}}],["它大小等效于",{"2":{"70":1}}],["它发生在以下情况",{"2":{"53":1}}],["它看起来与前面提到的普通类型解析很像",{"2":{"53":1}}],["它返回一个",{"2":{"37":1,"192":1}}],["它都会向操作系统申请整个内存页面",{"2":{"31":1}}],["它仅仅是实现了不同系统的分页申请系统调用",{"2":{"31":1}}],["它会返回一个结构体类型",{"2":{"256":1}}],["它会返回一个新的",{"2":{"186":1}}],["它会允许读取命令行输入来决定构建目标",{"2":{"192":1}}],["它会使用具有表示所有错误值所需的最少位数的整数类型",{"2":{"129":1}}],["它会根据给定字段指针",{"2":{"95":1}}],["它会给出一个完整的堆栈跟踪",{"2":{"92":1}}],["它会报告如下的错误",{"2":{"44":1}}],["它会直接尝试调用",{"2":{"30":1}}],["它会通知编译器内联汇编会写入任意为声明的内存位置",{"2":{"4":1}}],["它的大小为",{"2":{"290":1}}],["它的文档在这里",{"2":{"233":1}}],["它的引入规则与",{"2":{"193":1}}],["它的行为和",{"2":{"159":1}}],["它的内存大小为",{"2":{"94":1}}],["它的内部可以包含与结构",{"2":{"74":1}}],["它的长度有标记值",{"2":{"82":1}}],["它的指针",{"2":{"76":1}}],["它的原型为",{"2":{"37":1,"186":1}}],["它的原型如下",{"2":{"36":1,"37":1}}],["它的实现很巧妙",{"2":{"32":1}}],["它的实际作用就和使用",{"2":{"3":1}}],["它的速度很慢",{"2":{"31":1}}],["它的确分发",{"2":{"23":1}}],["它是以",{"2":{"207":1}}],["它是用来实现鸭子类型",{"2":{"111":1}}],["它是一个元组",{"2":{"231":1}}],["它是一个多项指针",{"2":{"77":1}}],["它是一个结构体的示例",{"2":{"10":1}}],["它是",{"2":{"35":1}}],["它是由编译器决定的",{"2":{"10":1}}],["它有以下特性",{"2":{"9":1}}],["它有时会做出反而使程序变慢的",{"2":{"2":1}}],["它们按照强度顺序排列",{"2":{"236":1}}],["它们作为一个整体来执行",{"2":{"235":1}}],["它们都是依靠系统调用来实现输出效果",{"2":{"232":1}}],["它们都以",{"2":{"231":1}}],["它们均是抽象的io",{"2":{"232":1}}],["它们均会分配一个大于",{"2":{"129":1}}],["它们可以很方便地帮助开发者找出错误",{"2":{"266":1}}],["它们可以构成一个有向无环图",{"2":{"186":1}}],["它们可以分配给变量",{"2":{"6":1}}],["它们只会增加你的代码复杂性",{"2":{"160":1,"165":1}}],["它们只能用于编译期已知的语句或函数中",{"2":{"6":1}}],["它们将会按照出栈方式执行",{"2":{"153":1}}],["它们会取计算后溢出的值",{"2":{"125":1,"271":1}}],["它们会在编译时进行解析并转换为",{"2":{"13":1}}],["它们的大小也是",{"2":{"287":1}}],["它们的大小是",{"2":{"285":1}}],["它们的特点是",{"2":{"285":1}}],["它们的原因",{"2":{"188":1}}],["它们的类型均是",{"2":{"111":1}}],["它们的解引用的方式也略有不同",{"2":{"79":1}}],["它们在内存中占用的大小为1个字节",{"2":{"109":1}}],["它们也有对应的指针类型",{"2":{"81":1}}],["它们就可以串联",{"2":{"60":1}}],["它表示你需要将值输出到哪里",{"2":{"4":1}}],["它允许我们对硬件直接进行操作",{"2":{"2":1}}],["中间不会被任何其他的操作打断",{"2":{"235":1}}],["中作为依赖",{"2":{"185":1,"186":1,"187":1,"188":1,"189":1,"191":1,"193":1,"194":1,"195":1,"196":1}}],["中等的运行效率",{"2":{"184":2}}],["中你可以使用",{"2":{"145":1}}],["中不存在",{"2":{"145":1}}],["中如何正确的书写注释",{"2":{"144":1}}],["中只是略微加工后的",{"2":{"128":1}}],["中独具特色的小玩意",{"2":{"127":1}}],["中字符就是",{"2":{"108":1}}],["中按元素选择值",{"2":{"106":1}}],["中很多结构是匿名的",{"2":{"100":1}}],["中传递",{"2":{"94":1}}],["中经常用空结构体做实体在",{"2":{"94":1}}],["中实现了相关的函数来处理它们",{"2":{"61":1}}],["中实现了调用",{"2":{"3":1}}],["中文语言社区",{"2":{"38":1}}],["中文社区",{"2":{"1":1}}],["中对外暴露出多个模块",{"2":{"36":1}}],["中引入包",{"2":{"34":1}}],["中的三元表达式是通过",{"2":{"149":1}}],["中的函数可能导致溢出发生",{"2":{"125":1}}],["中的",{"2":{"108":1,"188":1}}],["中的元素索引越界会产生编译错误",{"2":{"105":1}}],["中的选出的值是",{"2":{"105":1}}],["中的索引使用",{"2":{"105":1}}],["中的值",{"2":{"105":1}}],["中的是索引的边界值",{"2":{"76":1}}],["中的包名字",{"2":{"37":1}}],["中的文档注释",{"2":{"33":1}}],["中的宏",{"2":{"19":1}}],["中无缝工作的原因",{"2":{"25":1}}],["中添加一个运行程序的步骤",{"2":{"186":1}}],["中添加上",{"2":{"30":1}}],["中添加",{"2":{"13":1,"82":1,"188":1}}],["中可以无缝做到",{"2":{"13":1}}],["中均是只读的",{"2":{"7":1}}],["中",{"2":{"3":1,"6":1,"35":1,"54":1,"55":1,"61":1,"85":1,"88":1,"109":1,"111":1,"122":1,"125":1,"126":1,"129":1,"139":1,"140":1,"145":2,"148":1,"154":1,"186":1,"199":2,"228":1,"230":1,"248":1,"285":1}}],["中使用在标准库",{"2":{"231":1}}],["中使用了",{"2":{"184":1}}],["中使用",{"2":{"3":1}}],["中使用汇编有两种方式",{"2":{"2":1}}],["中断处理等",{"2":{"2":1}}],["bash",{"2":{"220":1}}],["bashasdf",{"2":{"220":1}}],["badvalue",{"2":{"152":1}}],["barrier",{"2":{"244":1}}],["bar",{"2":{"74":2}}],["b|",{"2":{"151":1}}],["blah",{"2":{"255":3,"256":3}}],["blk",{"2":{"133":2,"143":3,"167":2,"168":2,"171":4,"173":4}}],["blocks",{"2":{"66":1,"133":1}}],["block",{"2":{"3":1,"143":1,"196":5,"248":1}}],["below",{"2":{"244":1}}],["before",{"2":{"244":4}}],["beta",{"2":{"218":1}}],["between",{"2":{"99":1,"220":1}}],["be",{"2":{"196":1,"244":1}}],["begin",{"2":{"164":2}}],["behavior",{"2":{"124":1,"266":2}}],["byte",{"2":{"270":1,"271":2}}],["bytes",{"2":{"26":2,"61":5}}],["by",{"2":{"124":11,"196":1,"244":1}}],["b选出值",{"2":{"105":1}}],["brew",{"2":{"220":1}}],["break",{"2":{"53":1,"66":2,"116":1,"133":1,"143":2,"155":1,"159":1,"160":3,"164":4,"165":3,"167":1,"168":1,"171":2,"173":2}}],["branch",{"2":{"35":2}}],["box",{"2":{"196":2}}],["board",{"2":{"196":13}}],["bog",{"2":{"39":1}}],["bootstrap",{"2":{"124":3,"266":6}}],["bootloader",{"2":{"2":1,"35":1,"228":2}}],["boolean",{"2":{"178":3}}],["booltostr",{"2":{"53":5}}],["bool",{"2":{"7":5,"53":6,"69":1,"90":4,"99":1,"106":2,"118":1,"161":2,"164":1,"166":2,"175":1,"178":3,"179":1,"187":2,"252":1}}],["billion",{"2":{"122":1}}],["big",{"2":{"59":2,"99":1,"122":1}}],["bit不占任何空间",{"2":{"285":1}}],["bits",{"2":{"196":1}}],["bit",{"2":{"99":1,"196":1,"285":1,"287":1}}],["bitfield",{"2":{"99":7}}],["bitfields",{"2":{"18":1}}],["bitoffsetof",{"2":{"99":4}}],["bitcast",{"2":{"52":1,"99":4,"269":1}}],["bin",{"2":{"186":1,"189":1,"194":1,"208":2,"218":1}}],["binary",{"2":{"37":1,"122":1}}],["bindings",{"2":{"11":1,"295":1}}],["b",{"2":{"3":1,"7":9,"9":2,"19":5,"36":4,"37":9,"43":2,"49":4,"53":11,"68":1,"73":1,"80":1,"93":2,"99":8,"102":2,"105":9,"106":5,"111":7,"117":3,"124":6,"127":1,"136":4,"149":4,"151":3,"152":1,"171":2,"173":3,"175":2,"179":1,"185":9,"186":14,"187":8,"188":7,"189":10,"190":3,"191":9,"192":2,"193":10,"194":10,"195":9,"196":9,"254":1,"259":2,"261":3}}],["but",{"2":{"244":1}}],["button",{"2":{"195":5}}],["bucket",{"2":{"213":2}}],["builtin",{"2":{"85":3,"99":1,"104":1,"119":1,"172":4,"200":1,"203":1,"231":1,"237":1,"238":1,"239":2,"254":2,"261":1}}],["build",{"0":{"222":1},"2":{"3":1,"13":2,"17":1,"24":2,"30":1,"34":2,"35":1,"36":7,"37":13,"82":1,"124":1,"184":3,"185":10,"186":5,"187":3,"188":4,"189":4,"190":2,"191":2,"193":3,"194":2,"195":3,"196":3,"208":1,"222":1,"223":3,"224":4,"253":1}}],["buf这个临时资源",{"2":{"135":1}}],["buf4",{"2":{"45":2}}],["buf3",{"2":{"45":2}}],["buf2",{"2":{"45":4}}],["buf",{"2":{"45":4,"132":2,"135":2,"140":1}}],["bufferedwriter",{"2":{"232":2}}],["buffer中",{"2":{"27":2}}],["buffer",{"2":{"10":2,"27":4,"232":6}}],["buzz",{"2":{"39":1}}],["bun",{"2":{"39":1}}],["bunjs",{"2":{"1":1}}],["bug",{"2":{"2":1,"14":1,"19":1,"25":1}}],["如加",{"2":{"271":1}}],["如uml工具",{"2":{"206":1}}],["如golang",{"2":{"194":1}}],["如以上的枚举类型",{"2":{"70":1}}],["如何打印东西",{"2":{"232":1}}],["如何将模块对外暴露呢",{"2":{"36":1}}],["如何直接使用指定分支的源码",{"2":{"35":1}}],["如多个返回值",{"2":{"4":1}}],["如果它们的元素类型是零位类型",{"2":{"288":1}}],["如果它从",{"2":{"105":1}}],["如果浮点数的值超出了整数类型的范围",{"2":{"282":1}}],["如果访问的联合类型字段并非是它当前的有效字段",{"2":{"281":1}}],["如果强制使用",{"2":{"279":1}}],["如果直接使用",{"2":{"275":1}}],["如果仅仅是想要将负数当作无符号整数看待",{"2":{"269":1}}],["如果程序执行到它",{"2":{"267":1}}],["如果已经有了内部约定",{"2":{"264":1}}],["如果文件具有字段",{"2":{"264":1}}],["如果目标指针是给定值",{"2":{"240":1,"241":1}}],["如果是个人电脑",{"2":{"215":1}}],["如果是错误从当前函数向上返回",{"2":{"134":1}}],["如果说",{"2":{"209":1}}],["如果使用",{"2":{"208":1}}],["如果使用coc",{"2":{"208":1}}],["如果想要获取到无符号整数的最大值",{"2":{"269":1}}],["如果想要跳过外部来自于其他包的单元测试",{"2":{"191":1}}],["如果想执行非顶级的测试块",{"2":{"200":1}}],["如果想表示",{"2":{"86":1}}],["如果我们想要重新创建一个全新的",{"2":{"186":1}}],["如果我们想操纵值的内容",{"2":{"151":1}}],["如果应用程序运行依赖于其他已存在的文件",{"2":{"186":1}}],["如果在编译期就检测到了未定义的行为",{"2":{"266":1}}],["如果在",{"2":{"184":1}}],["如果有需要",{"2":{"178":1}}],["如果有一个指针或切片的对齐方式较小",{"2":{"85":1}}],["如果存在多个",{"2":{"153":1}}],["如果存在副作用",{"2":{"84":1}}],["如果一个变量",{"2":{"263":1}}],["如果一个变量是未定义的",{"2":{"142":1}}],["如果一个结构体位于",{"2":{"100":1}}],["如果一个结构体位于变量的初始化表达式中",{"2":{"100":1}}],["如果一定要使用不符合这些规定的名称",{"2":{"140":1}}],["如果未被使用编译器会报告错误",{"2":{"139":1}}],["如果函数可以执行到这里",{"2":{"135":1}}],["如果函数执行成功就正常返回它",{"2":{"135":1}}],["如果函数执行到了这里",{"2":{"134":1}}],["如果没有对应整数的枚举",{"2":{"278":1}}],["如果没有对应整数的错误",{"2":{"277":1}}],["如果没有分母会被转换为",{"2":{"126":1}}],["如果没有返回值",{"2":{"111":1}}],["如果两个向量均是",{"2":{"105":1}}],["如果两个边界值均是编译期可知的话",{"2":{"76":1}}],["如果给定的目标体系架构上不支持",{"2":{"102":1}}],["如果该结构体在另一个结构体中声明",{"2":{"100":1}}],["如果该值等于基础类型的对齐方式",{"2":{"85":1}}],["如果该函数尝试执行具有全局运行时副作用的操作",{"2":{"9":1}}],["如果不通过则报告错误",{"2":{"199":1}}],["如果不想处理错误怎么办呢",{"2":{"134":1}}],["如果不知道什么是指针操作的",{"2":{"84":1}}],["如果不是这种情况",{"2":{"78":1}}],["如果不可能",{"2":{"9":1}}],["如果要连接到系统的库",{"2":{"189":1}}],["如果要修改实际的载荷",{"2":{"179":1}}],["如果要初始化一个在编译期已知的字段名的联合类型",{"2":{"178":1}}],["如果要了解更多",{"2":{"84":1}}],["如果要使用多行字符串",{"2":{"63":1}}],["如果要设置这些",{"2":{"20":1}}],["如果另外一个类型可以表示它",{"2":{"48":1}}],["如果",{"2":{"45":1,"105":1,"106":1,"264":2}}],["如果此时这种转换是安全",{"2":{"41":1}}],["如果需要",{"2":{"208":1}}],["如果需要手动指定一个",{"2":{"192":1}}],["如果需要忽略可将返回值分配给",{"2":{"111":1}}],["如果需要重新排列元素",{"2":{"102":1}}],["如果需要引入一个本地包",{"2":{"37":1}}],["如果需要使用它们",{"2":{"126":1}}],["如果需要使用私有的模块",{"2":{"36":1}}],["如果需要使用寄存器",{"2":{"4":1}}],["如果代码托管平台提供分支源码打包直接返回功能",{"2":{"35":1}}],["如果包含全部则指定为空",{"2":{"35":1}}],["如果你是嵌入式开发",{"2":{"294":1}}],["如果你是中文简体用户",{"2":{"212":1}}],["如果你已经对计算机有了基础的了解",{"2":{"292":1}}],["如果你想写一个",{"2":{"224":1}}],["如果你想在迭代数组",{"2":{"157":1}}],["如果你想了解更多内容",{"2":{"234":1}}],["如果你想了解更多信息",{"2":{"5":1}}],["如果你想了解更多这些相关的内容",{"2":{"3":1}}],["如果你打算定义一个只有一个值的错误集",{"2":{"130":1}}],["如果你需要一个命名的推荐规则的话",{"2":{"111":1}}],["如果你有使用复数的需求",{"2":{"127":1}}],["如果你有",{"2":{"111":1}}],["如果你不知道内存对齐的含义是什么",{"2":{"85":1}}],["如果你的程序是一个命令行程序或者没有什么特别的循环模式",{"2":{"28":1}}],["如果地址为",{"2":{"20":1}}],["如果超过了这个值",{"2":{"9":1}}],["如果无法完成计算",{"2":{"9":1}}],["如",{"2":{"2":1,"18":1,"79":1,"192":1,"193":1,"220":1,"251":1,"280":1}}],["这避免了空指针的出现",{"2":{"293":1}}],["这门语言并不适合计算机初学者",{"2":{"292":1}}],["这本身就是非法行为",{"2":{"269":1}}],["这将忽略构建模式",{"2":{"266":1}}],["这将使汇编能够更加无缝地集成到语言中",{"2":{"2":1}}],["这有助于",{"2":{"265":1}}],["这有助于格式化",{"2":{"263":1}}],["这有助于加快下次构建",{"2":{"185":1}}],["这常用于组织",{"2":{"249":1}}],["这很棒",{"2":{"233":1}}],["这段代码将会分别输出",{"2":{"232":1}}],["这段函数用来判断一个结构体的字段是否是",{"2":{"175":1}}],["这单单一个命令可神了",{"2":{"221":1}}],["这时候一方面可以跟踪上游进展",{"2":{"220":1}}],["这时我们可以将",{"2":{"134":1}}],["这使得代码阅读很轻松",{"2":{"294":1}}],["这使得测试构建仅包含名称包含提供的过滤器文本的测试",{"2":{"201":1}}],["这使得在任何地方使用",{"2":{"137":1}}],["这使得在不同架构上构建出来的代码的实际错误集并不相同",{"2":{"136":1}}],["这代替原本的",{"2":{"189":1}}],["这代表着函数是公共可访问的",{"2":{"111":1}}],["这一切都是得益于",{"2":{"221":1}}],["这一",{"2":{"186":1}}],["这可以确保它们正确的运行",{"2":{"186":1}}],["这几个字段",{"2":{"185":1}}],["这并不会影响程序正常运行",{"2":{"184":1}}],["这便于我们在",{"2":{"184":1}}],["这允许代码执行一些一些仅在编译时有效的操作",{"2":{"161":1,"166":1}}],["这增加了程序员在写代码时的心智负担",{"2":{"145":1}}],["这种方式才可以",{"2":{"249":1}}],["这种函数",{"2":{"232":1}}],["这种语法看起来并不好看",{"2":{"200":1}}],["这种信息",{"2":{"199":1}}],["这种多行注释",{"2":{"144":1}}],["这种编译期变量的实现",{"2":{"8":1}}],["这对于在清理期间打印错误信息很有用",{"2":{"135":1}}],["这意味函数返回的是一个",{"2":{"132":1}}],["这意味着原子操作要么全部完成",{"2":{"235":1}}],["这意味着多行注释的最佳实践形式就是多行的",{"2":{"144":1}}],["这意味着你可以在任何你用普通函数的地方使用结构体的方法",{"2":{"89":1}}],["这意味着它不能是",{"2":{"81":1}}],["这意味着我们可以通过语法",{"2":{"77":1}}],["这意味着我们可以使用函数来初始化复杂的静态数据",{"2":{"9":1}}],["这意味着参数类型与返回值类型是一致的",{"2":{"7":1}}],["这涉及到计算机相当底层的涉及哲学",{"2":{"232":1}}],["这涉及到",{"2":{"127":1}}],["这无疑大大增加了程序员在编程时的心智负担",{"2":{"112":1}}],["这和",{"2":{"108":1,"295":1}}],["这样的概念解释可能比较模糊",{"2":{"293":1}}],["这样就会获得一个",{"2":{"286":1}}],["这样在编译时可以检查分支是否均能被正确地处理",{"2":{"175":1}}],["这样做的好处是",{"2":{"135":1,"175":1}}],["这样做的好处就是提供了针对缓冲区溢出和过度读取的保护",{"2":{"82":1}}],["这样",{"2":{"85":1,"213":1}}],["这样编译器就不会额外优化这段内联汇编",{"2":{"4":1}}],["这容易破坏切片的内部结构",{"2":{"76":1}}],["这通常用于保证与不公开结构详细信息的",{"2":{"74":1}}],["这在对外暴漏函数或者裸汇编时会很有用",{"2":{"119":1}}],["这在运行时无操作",{"2":{"85":1}}],["这在嵌入式开发和内核开发时很常用",{"2":{"52":2}}],["这在处理字符串时很有用",{"2":{"45":1}}],["这往往是由于编译器推断类型出现歧义导致的",{"2":{"44":1}}],["这句话看起来可能有点绕",{"2":{"43":1}}],["这两个类型实现了几种错误的定义",{"2":{"129":1}}],["这两个东西的底层实现是一样的",{"2":{"16":1}}],["这两种类型的的大小取决于",{"2":{"122":1}}],["这两种情况",{"2":{"112":1}}],["这两者的区别仅仅是",{"2":{"30":1}}],["这些都是允许地址为",{"2":{"283":1}}],["这些print函数是如何实现的",{"2":{"232":1}}],["这些操作符保证了环绕语义",{"2":{"125":1}}],["这些操作是按元素执行",{"2":{"102":1}}],["这些内建函数返回一个元组",{"2":{"125":1}}],["这些传递均是由编译器来决定究竟是使用",{"2":{"112":1}}],["这些转换实际上在运行时没有任何操作",{"2":{"42":1}}],["这些特性均可手动配置是否开启",{"2":{"26":1}}],["这些模型均有着不同的特点",{"2":{"25":1}}],["这些额外未使用的分支在编译时会被",{"2":{"7":1}}],["这就是",{"2":{"266":1}}],["这就是它们的区别",{"2":{"232":1}}],["这就是我们为何能够像普通包一样",{"2":{"188":1}}],["这就是一个最基本的包暴露实现",{"2":{"36":1}}],["这就是一个占位符",{"2":{"4":1}}],["这就使得在递归上出现了不兼容",{"2":{"136":1}}],["这就涉及到计算机组成原理和操作系统的理论知识了",{"2":{"25":1}}],["这就要求程序员在需要明白数据在内存中真实存在的模样",{"2":{"25":1}}],["这也可用于依赖于当前包的其他包",{"2":{"187":1}}],["这也是精度问题导致的",{"2":{"126":1}}],["这也是为什么",{"2":{"25":1}}],["这也适用于",{"2":{"7":1}}],["这导致他们之间可以互相访问",{"2":{"255":1}}],["这导致错误类型无法携带有效的",{"2":{"128":1}}],["这导致",{"2":{"23":1}}],["这会触发非法行为",{"2":{"283":1}}],["这会导致混用可能出现问题",{"2":{"196":1}}],["这会导致歧义",{"2":{"20":1}}],["这会扰乱测试器的正常工作",{"2":{"191":1}}],["这会链接一个名为",{"2":{"189":1}}],["这会允许我们通过",{"2":{"188":1}}],["这会使运行是从构建输出目录",{"2":{"186":1}}],["这会使切片长度直接等于数组",{"2":{"45":1}}],["这会明确告诉编译器返回的错误种类都有什么",{"2":{"136":1}}],["这会告诉编译器此次函数执行不会返回错误",{"2":{"134":1}}],["这会破坏切片的内部结构",{"2":{"79":1}}],["这会牵扯到",{"2":{"72":1}}],["这会通知编译器",{"2":{"8":1}}],["这点在",{"2":{"13":1}}],["这归功于",{"2":{"11":1}}],["这表示变量是编译期已知的",{"2":{"8":1}}],["这个数",{"2":{"270":1}}],["这个容器中",{"2":{"249":1}}],["这个句柄实现流print函数",{"2":{"232":1}}],["这个是操作系统负责保证的",{"2":{"232":1}}],["这个内建函数",{"2":{"231":1}}],["这个内存分配器来检测内存泄漏",{"2":{"202":1}}],["这个文件的内容涉及到了",{"2":{"223":1}}],["这个文件存储了包的信息",{"2":{"35":1}}],["这个命令用于初始化项目",{"2":{"223":1}}],["这个命令来执行单个文件的",{"2":{"199":1}}],["这个步骤不是必要的",{"2":{"186":1}}],["这个返回值将会是",{"2":{"179":1}}],["这个语法的作用可就大了",{"2":{"148":1}}],["这个函数相对来说会变得更加的通用",{"2":{"136":1}}],["这个大小固定使用",{"2":{"129":1}}],["这个类型其实平常使用不算多",{"2":{"108":1}}],["这个情况可以使用",{"2":{"99":1}}],["这个关键字适合使用于嵌入式或者裸机器上",{"2":{"98":1}}],["这个关键字表示",{"2":{"6":1}}],["这个指针标记了边界的值",{"2":{"82":1}}],["这个枚举类型之中任意切换了",{"2":{"68":1}}],["这个示例中",{"2":{"66":1}}],["这个表达式的值为",{"2":{"53":1}}],["这个词汇仅仅在",{"2":{"53":1}}],["这个包的主分支源码打包",{"2":{"35":1}}],["这个善后工作只有在你指定",{"2":{"29":1}}],["这个分配器的特点是你可以多次申请内存",{"2":{"28":1}}],["这个分配器的目的不是为了性能",{"2":{"26":1}}],["这个分配器是固定大小的内存缓冲区",{"2":{"27":1}}],["这个",{"2":{"7":1}}],["这里我需要向你讲述一下",{"2":{"232":1}}],["这里我们需要说的是",{"2":{"231":1}}],["这里我们就是将子集",{"2":{"129":1}}],["这里列举一些",{"2":{"220":1}}],["这里列出一些仍在积极维护的",{"2":{"39":1}}],["这里介绍一个通用的版本管理工具",{"2":{"220":1}}],["这里每次都是不同的值",{"2":{"175":1}}],["这里最后一个联合类型",{"2":{"173":2}}],["这里你只需要知道一下就行",{"2":{"231":1}}],["这里你也可以使用",{"2":{"134":1}}],["这里你看起来可能会感到迷惑",{"2":{"84":1}}],["这里",{"2":{"113":1,"175":1}}],["这里命名规则没什么强制性的要求",{"2":{"111":1}}],["这里有两个参数",{"2":{"111":1}}],["这里有一篇关于最初这个内存池是如何实现的文章",{"2":{"32":1}}],["这里说明可能有些不清楚",{"2":{"99":1}}],["这里说的是边界值有一个是变量",{"2":{"76":1}}],["这里获取目标架构是字节排序方式",{"2":{"99":1}}],["这里使用了内建函数",{"2":{"95":1}}],["这里保证每次都使用",{"2":{"84":1}}],["这里包括",{"2":{"49":1}}],["这里的名字是根据官方的文档直接翻译过来的",{"2":{"57":1}}],["这里的",{"2":{"35":1,"124":1,"164":1}}],["这里仅仅作为示例",{"2":{"9":1}}],["这里是改动的寄存器",{"2":{"4":1}}],["这里讲述全局汇编功能",{"2":{"3":1}}],["这说明它可以返回值",{"2":{"4":1}}],["这是联合错误类型",{"2":{"232":1}}],["这是规定",{"2":{"231":1}}],["这是编译期可知的",{"2":{"175":1}}],["这是编译期参数",{"2":{"111":1}}],["这是由我们之前显式声明的",{"2":{"152":1}}],["这是由于",{"2":{"61":1,"254":1}}],["这是由于技术限制",{"2":{"2":1}}],["这是为了尽早发现错误",{"2":{"142":1}}],["这是",{"2":{"90":1,"184":1}}],["这是传给对应的包构建的参数",{"2":{"37":1}}],["这是最基本的分配器",{"2":{"31":1}}],["这是纯粹的",{"2":{"30":1}}],["这是一个很好的特性",{"2":{"136":1}}],["这是一个依赖",{"2":{"29":1}}],["这是一个通用的分配器",{"2":{"26":1}}],["这是一个收集每个版本的",{"2":{"23":1}}],["这是一篇关于如何在",{"2":{"4":1}}],["这是对应",{"2":{"21":1}}],["这是因为",{"2":{"19":1,"254":1}}],["这是因为汇编语言更加接近硬件",{"2":{"2":1}}],["这是防止编译器重复调用",{"2":{"13":1}}],["这是输入操作数",{"2":{"4":1}}],["这需要直接操控硬件",{"2":{"2":1}}],["驱动程序",{"2":{"2":1}}],["在裸机器上也可以",{"2":{"295":1}}],["在我看来",{"2":{"292":1}}],["在讲述下列的内建函数前",{"2":{"236":1}}],["在zig中有很多的内置函数",{"2":{"231":1}}],["在当前路径下创建",{"2":{"223":1,"224":1}}],["在当前作用域的末尾执行语句",{"2":{"90":1}}],["在新打开的窗口中点击",{"2":{"212":1}}],["在初次初始化时会推荐安装",{"2":{"205":1}}],["在测试中",{"2":{"202":1}}],["在其内部引用你需要执行测试的容器即可",{"2":{"200":1}}],["在进行本部分教程前请先安装好",{"2":{"195":1}}],["在构建时调用系统的",{"2":{"194":1}}],["在构建时自动构建",{"2":{"189":1}}],["在迭代时操作数组",{"2":{"155":1}}],["在错误联合可选类型上也可以使用指针捕获",{"2":{"152":1}}],["在接下来的代码中",{"2":{"145":1}}],["在解决空指针上采取的方式比较保守",{"2":{"145":1}}],["在不损害效率和可读性的前提下提高代码安全性的一个方案就是可选类型",{"2":{"145":1}}],["在不同字段之间不会存在位填充",{"2":{"99":1}}],["在不同的整数类型中显式强制转换",{"2":{"52":1}}],["在最新的稳定版",{"2":{"129":1}}],["在高级语言的角度来看",{"2":{"112":1}}],["在表中对应的值是",{"2":{"108":1}}],["在计算机学中",{"2":{"250":1}}],["在计算机编程中",{"2":{"198":1}}],["在计算机中定义的",{"2":{"107":1}}],["在计算机科学",{"2":{"40":1}}],["在计算机科学中代表一个计算机程序从开始执行到终止执行的运作",{"2":{"6":1}}],["在整型上的操作是",{"2":{"104":1}}],["在使用",{"2":{"174":1,"213":1}}],["在使用该特性时需要谨慎对待",{"2":{"135":1}}],["在使用结构体的时候还支持省略结构体类型",{"2":{"91":1}}],["在使用翻译功能时",{"2":{"15":1}}],["在编译时",{"2":{"129":1}}],["在编译代码时",{"2":{"84":1}}],["在编译期和运行时也分别有类似",{"2":{"125":1}}],["在编译期和运行时均有完整的越界保护和完善的堆栈错误跟踪",{"2":{"55":1}}],["在编译期",{"2":{"9":1}}],["在编译期它们会被提取出来作为单独的汇编文件进行编译和链接",{"2":{"3":1}}],["在以上的代码中",{"2":{"90":1}}],["在以上的示例中",{"2":{"56":1}}],["在以下代码中",{"2":{"84":1}}],["在实际使用时",{"2":{"76":1}}],["在此基础上",{"2":{"68":1}}],["在此基础上给我们提供了少量的保护",{"2":{"25":1}}],["在它对应",{"2":{"57":1}}],["在内存管理方面采取了类似",{"2":{"25":1}}],["在非",{"2":{"20":1}}],["在容器级别",{"2":{"9":1}}],["在函数定义中",{"2":{"6":1}}],["在这里我们也不例外",{"2":{"230":1}}],["在这里我们使用",{"2":{"195":1}}],["在这里我们使用了单元测试功能",{"2":{"84":1}}],["在这里",{"2":{"145":1}}],["在这种情况下",{"2":{"115":1}}],["在这方面的处理则是",{"2":{"112":1}}],["在这方面提供了更多的选择",{"2":{"25":1}}],["在这个调用点",{"2":{"6":1}}],["在这其中我用了内联汇编",{"2":{"4":1}}],["在开始之前",{"2":{"6":1}}],["在未来可用时将会更新此部分内容",{"2":{"5":1}}],["在未来的某一天",{"2":{"2":1}}],["在",{"2":{"2":1,"3":1,"6":1,"25":1,"54":1,"55":1,"61":1,"85":1,"88":1,"94":1,"108":1,"109":1,"111":1,"122":1,"126":1,"134":2,"139":1,"140":1,"142":1,"145":1,"148":1,"154":1,"176":2,"188":1,"193":1,"199":1,"248":1,"285":1}}],["在某些特殊的场景下",{"2":{"2":1}}],["在提交时请勿将其他nodejs的包管理工具的额外配置文件添加到仓库中",{"2":{"1":1}}],["汇编解析由llvm提供",{"2":{"2":1}}],["汇编语言可以发挥出比高级语言更好的性能",{"2":{"2":1}}],["汇编",{"0":{"2":1},"1":{"3":1,"4":1}}],["🅿️",{"2":{"1":1,"2":1,"3":1,"4":1,"6":1,"7":1,"8":1,"9":2,"10":1,"11":1,"13":2,"15":1,"19":1,"23":1,"25":1,"30":1,"35":2,"36":2,"37":1,"57":1,"72":1,"76":1,"80":1,"81":1,"85":1,"89":1,"92":1,"94":1,"96":1,"102":1,"104":1,"105":1,"108":1,"111":1,"112":1,"117":1,"122":1,"126":1,"127":1,"128":1,"129":1,"133":1,"134":1,"135":1,"136":1,"139":1,"166":1,"170":1,"178":1,"183":1,"185":1,"186":1,"188":1,"195":1,"196":1,"199":1,"200":1,"208":1,"211":1,"213":1,"215":1,"224":1,"231":2,"232":1,"257":1,"262":1,"281":1}}],["并养成在最后一个元素后添加",{"2":{"263":1}}],["并允许我们通过该类型观察并获取指定类型的具体信息",{"2":{"254":1}}],["并根据已有类型的信息来创造新的类型",{"2":{"250":1}}],["并没有真正地执行函数体的内容",{"2":{"252":1}}],["并没有内置类似与",{"2":{"232":1}}],["并没有一个内置的打印功能",{"2":{"232":1}}],["并没有对应的类型",{"2":{"49":1}}],["并导入它",{"2":{"231":1}}],["并设置环境变量",{"2":{"217":1}}],["并通知测试运行器测试结果未通过",{"2":{"199":1}}],["并链接",{"2":{"196":1}}],["并使用",{"2":{"194":1}}],["并将",{"2":{"190":1}}],["并将其转换为指针来完成",{"2":{"173":1}}],["并将其输出到标准输出",{"2":{"14":1}}],["并返回它们的公共可转换类型",{"2":{"252":1}}],["并返回null",{"2":{"240":1,"241":1}}],["并返回对应的指针",{"2":{"185":1}}],["并返回与输入向量长度相同的向量",{"2":{"102":1}}],["并显示消息达到",{"2":{"176":1}}],["并退出",{"2":{"168":1}}],["并帮助检测调试器中未定义内存的使用",{"2":{"142":1}}],["并指定值为",{"2":{"139":1}}],["并未像其他语言那样默认提供了",{"2":{"126":1}}],["并未提供",{"2":{"22":1}}],["并以",{"2":{"113":1}}],["并用点分隔",{"2":{"100":1}}],["并序列化参数",{"2":{"100":1}}],["并保证了代码执行的顺序",{"2":{"84":1}}],["并写入到",{"2":{"35":1}}],["并无需每次用完时进行",{"2":{"28":1}}],["并不支持构建的类型包含声明",{"2":{"261":1}}],["并不相同",{"2":{"224":1}}],["并不会递归",{"2":{"200":1}}],["并不推荐使用",{"2":{"160":1,"165":1}}],["并不是一个赛道上的东西",{"2":{"292":1}}],["并不是全等的",{"2":{"108":1}}],["并不是通过",{"2":{"11":1}}],["并不保证结构体字段的顺序和结构体大小",{"2":{"97":1}}],["并不准确",{"2":{"23":1}}],["并不知道如何处理指针",{"2":{"20":1}}],["并非所有宏均可以转为函数",{"2":{"19":1}}],["并远超其他语言",{"2":{"11":1}}],["并从函数返回",{"2":{"6":1}}],["并且编译时就会跟踪你的内存是否发生泄漏",{"2":{"295":1}}],["并且能够较为熟练的掌握一门高级编程语言",{"2":{"292":1}}],["并且返回非类型",{"2":{"264":1}}],["并且返回值就是",{"2":{"4":1}}],["并且包含其父容器的名字",{"2":{"253":1}}],["并且不会产生任何副作用",{"2":{"252":1}}],["并且不得与关键字重叠",{"2":{"140":1}}],["并且修改自己的行为",{"2":{"250":1}}],["并且提供了",{"2":{"235":1}}],["并且遵循",{"2":{"231":1}}],["并且内置了命令行工具和git",{"2":{"205":1}}],["并且默认测试运行程序将认为该测试被跳过",{"2":{"201":1}}],["并且us在此处被引用",{"2":{"200":1}}],["并且测试在正常构建时会被忽略",{"2":{"199":1}}],["并且可以有效地报告错误",{"2":{"191":1}}],["并且向其中添加了",{"2":{"188":1}}],["并且switch匹配不能出现遗漏匹配的情况",{"2":{"169":1}}],["并且如果控制流不经过",{"2":{"153":1}}],["并且如果错误最终从应用程序中一直冒出来",{"2":{"137":1}}],["并且申请一块内存",{"2":{"145":1}}],["并且保证你不会将一个可能为",{"2":{"145":1}}],["并且保证与",{"2":{"39":1}}],["并且这种检测不是很深奥",{"2":{"145":1}}],["并且使用默认的",{"2":{"185":1}}],["并且使用",{"2":{"117":1}}],["并且使用了切片和多行字符串",{"2":{"90":1}}],["并且需要是",{"2":{"108":1}}],["并且逐个根据",{"2":{"105":1}}],["并且它可选支持",{"2":{"294":1}}],["并且它返回一个类型",{"2":{"264":1}}],["并且它支持",{"2":{"102":1}}],["并且它也支持",{"2":{"4":1}}],["并且支持",{"2":{"96":1}}],["并且小于",{"2":{"85":1}}],["并且还保证由该长度索引的元素的标记值",{"2":{"78":1}}],["并且还不知道自己应该用什么分配器模型",{"2":{"26":1}}],["并且在编译期可以确定联合类型的某一个字段仅有一个可能值",{"2":{"49":1}}],["并且避免内联函数被重复",{"2":{"13":1}}],["并且",{"2":{"11":1,"36":1}}],["并且会删掉未使用的分支",{"2":{"7":1}}],["并在所有测试运行后将报告失败数目",{"2":{"199":1}}],["并在遇到",{"2":{"167":1}}],["并在转换时增加一个语言级断言",{"2":{"131":1}}],["并在",{"2":{"3":1}}],["并与流行的",{"2":{"2":1}}],["并由",{"2":{"1":1}}],["并一起壮大",{"2":{"1":1}}],["本风格指南并不是强制性的",{"2":{"262":1}}],["本部分是关于",{"2":{"247":1}}],["本质就是",{"2":{"108":1}}],["本身没有一个属于自己的包管理器",{"2":{"292":1}}],["本身有许多未定义行为",{"2":{"266":1}}],["本身有着良好的错误堆栈跟踪",{"2":{"137":1}}],["本身提供了一个实验性的文档生成器",{"2":{"190":1}}],["本身就是一套完整的工具链",{"2":{"183":1}}],["本身并未提供类似",{"2":{"144":1}}],["本身支持三种注释方式",{"2":{"144":1}}],["本身支持指针运算",{"2":{"79":1}}],["本身的编译期",{"2":{"221":1}}],["本身的标准库为我们提供了多种内存分配模型",{"2":{"25":1}}],["本身的全局汇编功能",{"2":{"3":1}}],["本身所谓的",{"2":{"23":1}}],["本身实现了一个",{"2":{"23":1}}],["本文档所使用的构建工具为",{"2":{"1":1}}],["本文档仓库",{"2":{"1":1}}],["本网站仅仅用于帮助用户快速学习和了解",{"2":{"0":1}}],["贡献方法",{"2":{"1":1}}],["道友",{"2":{"1":1}}],["欢迎各位志同道合的",{"2":{"1":1}}],["敬请谅解",{"2":{"0":1}}]],"serializationVersion":2}';export{e as default};
diff --git a/assets/chunks/@localSearchIndexroot.HClziMeA.js b/assets/chunks/@localSearchIndexroot.HClziMeA.js
deleted file mode 100644
index 990b8481..00000000
--- a/assets/chunks/@localSearchIndexroot.HClziMeA.js
+++ /dev/null
@@ -1 +0,0 @@
-const e='{"documentCount":298,"nextId":298,"documentIds":{"0":"/zig-course/about.html#关于本站","1":"/zig-course/about.html#参与贡献","2":"/zig-course/advanced/assembly.html#汇编","3":"/zig-course/advanced/assembly.html#外部汇编","4":"/zig-course/advanced/assembly.html#内联汇编","5":"/zig-course/advanced/async.html#异步","6":"/zig-course/advanced/comptime.html#编译期","7":"/zig-course/advanced/comptime.html#编译期参数实现鸭子类型","8":"/zig-course/advanced/comptime.html#编译期变量","9":"/zig-course/advanced/comptime.html#编译期表达式","10":"/zig-course/advanced/comptime.html#生成数据结构","11":"/zig-course/advanced/interact-with-c.html#与-c-交互","12":"/zig-course/advanced/interact-with-c.html#c-abi-类型","13":"/zig-course/advanced/interact-with-c.html#c-header-导入","14":"/zig-course/advanced/interact-with-c.html#c-translation-cli","15":"/zig-course/advanced/interact-with-c.html#命令行参数","16":"/zig-course/advanced/interact-with-c.html#cimport-vs-translate-c","17":"/zig-course/advanced/interact-with-c.html#c-翻译缓存","18":"/zig-course/advanced/interact-with-c.html#c-翻译错误","19":"/zig-course/advanced/interact-with-c.html#c-macro","20":"/zig-course/advanced/interact-with-c.html#c-指针","21":"/zig-course/advanced/interact-with-c.html#c-可变参数函数","22":"/zig-course/advanced/interact-with-c.html#额外内容","23":"/zig-course/advanced/interact-with-c.html#为什么-zig-可以做到比-c-更好的编译","24":"/zig-course/advanced/interact-with-c.html#zig-能静态链接-libc-吗","25":"/zig-course/advanced/memory_manage.html#内存管理","26":"/zig-course/advanced/memory_manage.html#generalpurposeallocator","27":"/zig-course/advanced/memory_manage.html#fixedbufferallocator","28":"/zig-course/advanced/memory_manage.html#arenaallocator","29":"/zig-course/advanced/memory_manage.html#heapallocator","30":"/zig-course/advanced/memory_manage.html#c-allocator","31":"/zig-course/advanced/memory_manage.html#page-allocator","32":"/zig-course/advanced/memory_manage.html#memorypool","33":"/zig-course/advanced/memory_manage.html#实现内存分配器","34":"/zig-course/advanced/package_management.html#包管理","35":"/zig-course/advanced/package_management.html#新的文件结构","36":"/zig-course/advanced/package_management.html#编写包","37":"/zig-course/advanced/package_management.html#引入包","38":"/zig-course/advanced/type_cast.html#类型转换","39":"/zig-course/advanced/type_cast.html#普通类型转换","40":"/zig-course/advanced/type_cast.html#限制更严格","41":"/zig-course/advanced/type_cast.html#整数与浮点数拓宽","42":"/zig-course/advanced/type_cast.html#立即数整数和浮点数出现歧义","43":"/zig-course/advanced/type_cast.html#切片、数组、指针","44":"/zig-course/advanced/type_cast.html#可选类型","45":"/zig-course/advanced/type_cast.html#错误联合类型","46":"/zig-course/advanced/type_cast.html#编译期数字","47":"/zig-course/advanced/type_cast.html#联合类型和枚举","48":"/zig-course/advanced/type_cast.html#undefined","49":"/zig-course/advanced/type_cast.html#元组和数组","50":"/zig-course/advanced/type_cast.html#显式强制转换","51":"/zig-course/advanced/type_cast.html#对等类型转换","52":"/zig-course/appendix/community.html#社区","53":"/zig-course/appendix/well-known-lib.html#第三方库","54":"/zig-course/basic/advanced_type/array.html#数组","55":"/zig-course/basic/advanced_type/array.html#创建数组","56":"/zig-course/basic/advanced_type/array.html#多维数组","57":"/zig-course/basic/advanced_type/array.html#哨兵数组","58":"/zig-course/basic/advanced_type/array.html#操作","59":"/zig-course/basic/advanced_type/array.html#乘法","60":"/zig-course/basic/advanced_type/array.html#串联","61":"/zig-course/basic/advanced_type/array.html#字符串","62":"/zig-course/basic/advanced_type/array.html#转义字符","63":"/zig-course/basic/advanced_type/array.html#多行字符串","64":"/zig-course/basic/advanced_type/array.html#奇技淫巧","65":"/zig-course/basic/advanced_type/array.html#使用函数初始化数组","66":"/zig-course/basic/advanced_type/array.html#编译期初始化数组","67":"/zig-course/basic/advanced_type/enum.html#枚举","68":"/zig-course/basic/advanced_type/enum.html#声明枚举","69":"/zig-course/basic/advanced_type/enum.html#枚举方法","70":"/zig-course/basic/advanced_type/enum.html#枚举大小","71":"/zig-course/basic/advanced_type/enum.html#枚举推断","72":"/zig-course/basic/advanced_type/enum.html#非详尽枚举","73":"/zig-course/basic/advanced_type/enum.html#extern","74":"/zig-course/basic/advanced_type/opaque.html#opaque","75":"/zig-course/basic/advanced_type/opaque.html#anyopaque","76":"/zig-course/basic/advanced_type/pointer.html#指针","77":"/zig-course/basic/advanced_type/pointer.html#单项指针","78":"/zig-course/basic/advanced_type/pointer.html#多项指针","79":"/zig-course/basic/advanced_type/pointer.html#哨兵指针","80":"/zig-course/basic/advanced_type/pointer.html#额外特性","81":"/zig-course/basic/advanced_type/pointer.html#volatile","82":"/zig-course/basic/advanced_type/pointer.html#对齐","83":"/zig-course/basic/advanced_type/pointer.html#零指针","84":"/zig-course/basic/advanced_type/pointer.html#编译期","85":"/zig-course/basic/advanced_type/silce.html#切片","86":"/zig-course/basic/advanced_type/silce.html#切片指针","87":"/zig-course/basic/advanced_type/silce.html#哨兵切片","88":"/zig-course/basic/advanced_type/struct.html#结构体","89":"/zig-course/basic/advanced_type/struct.html#基本语法","90":"/zig-course/basic/advanced_type/struct.html#自引用","91":"/zig-course/basic/advanced_type/struct.html#自动推断","92":"/zig-course/basic/advanced_type/struct.html#泛型实现","93":"/zig-course/basic/advanced_type/struct.html#字段默认值","94":"/zig-course/basic/advanced_type/struct.html#空结构体","95":"/zig-course/basic/advanced_type/struct.html#通过字段获取基指针","96":"/zig-course/basic/advanced_type/struct.html#元组","97":"/zig-course/basic/advanced_type/struct.html#高级特性","98":"/zig-course/basic/advanced_type/struct.html#extern","99":"/zig-course/basic/advanced_type/struct.html#packed","100":"/zig-course/basic/advanced_type/struct.html#命名规则","101":"/zig-course/basic/advanced_type/vector.html#向量","102":"/zig-course/basic/advanced_type/vector.html#基本使用","103":"/zig-course/basic/advanced_type/vector.html#splat","104":"/zig-course/basic/advanced_type/vector.html#reduce","105":"/zig-course/basic/advanced_type/vector.html#shuffle","106":"/zig-course/basic/advanced_type/vector.html#select","107":"/zig-course/basic/basic_type/char-and-boolean.html#字符与布尔值","108":"/zig-course/basic/basic_type/char-and-boolean.html#字符","109":"/zig-course/basic/basic_type/char-and-boolean.html#布尔值","110":"/zig-course/basic/basic_type/function.html#函数","111":"/zig-course/basic/basic_type/function.html#基本使用","112":"/zig-course/basic/basic_type/function.html#参数传递","113":"/zig-course/basic/basic_type/function.html#内建函数","114":"/zig-course/basic/basic_type/function.html#高阶使用","115":"/zig-course/basic/basic_type/function.html#anytype","116":"/zig-course/basic/basic_type/function.html#noreturn","117":"/zig-course/basic/basic_type/function.html#extern","118":"/zig-course/basic/basic_type/function.html#setcold","119":"/zig-course/basic/basic_type/function.html#callconv","120":"/zig-course/basic/basic_type/number.html#数值类型","121":"/zig-course/basic/basic_type/number.html#整数","122":"/zig-course/basic/basic_type/number.html#类型","123":"/zig-course/basic/basic_type/number.html#不同进制","124":"/zig-course/basic/basic_type/number.html#除零","125":"/zig-course/basic/basic_type/number.html#溢出","126":"/zig-course/basic/basic_type/number.html#浮点数","127":"/zig-course/basic/basic_type/number.html#运算","128":"/zig-course/basic/define-variable.html#基本类型","129":"/zig-course/basic/define-variable.html#变量声明","130":"/zig-course/basic/define-variable.html#标识符命名","131":"/zig-course/basic/define-variable.html#常量","132":"/zig-course/basic/define-variable.html#undefined","133":"/zig-course/basic/define-variable.html#块","134":"/zig-course/basic/define-variable.html#注释","135":"/zig-course/basic/error_handle.html#错误处理","136":"/zig-course/basic/error_handle.html#基本使用","137":"/zig-course/basic/error_handle.html#只有一个值的错误集","138":"/zig-course/basic/error_handle.html#全局错误集","139":"/zig-course/basic/error_handle.html#错误联合类型","140":"/zig-course/basic/error_handle.html#catch","141":"/zig-course/basic/error_handle.html#try","142":"/zig-course/basic/error_handle.html#errdefer","143":"/zig-course/basic/error_handle.html#合并和推断错误","144":"/zig-course/basic/error_handle.html#堆栈跟踪","145":"/zig-course/basic/optional_type.html#可选类型","146":"/zig-course/basic/optional_type.html#编译期反射访问可选类型","147":"/zig-course/basic/optional_type.html#可选指针","148":"/zig-course/basic/process_control/decision.html#条件","149":"/zig-course/basic/process_control/decision.html#三元表达式","150":"/zig-course/basic/process_control/decision.html#高级用法","151":"/zig-course/basic/process_control/decision.html#解构可选类型","152":"/zig-course/basic/process_control/decision.html#解构错误联合类型","153":"/zig-course/basic/process_control/defer.html#defer","154":"/zig-course/basic/process_control/loop.html#循环","155":"/zig-course/basic/process_control/loop.html#for","156":"/zig-course/basic/process_control/loop.html#迭代数字","157":"/zig-course/basic/process_control/loop.html#迭代索引","158":"/zig-course/basic/process_control/loop.html#多目标迭代","159":"/zig-course/basic/process_control/loop.html#作为表达式使用","160":"/zig-course/basic/process_control/loop.html#标记","161":"/zig-course/basic/process_control/loop.html#内联-inline","162":"/zig-course/basic/process_control/loop.html#while","163":"/zig-course/basic/process_control/loop.html#continue-表达式","164":"/zig-course/basic/process_control/loop.html#作为表达式使用-1","165":"/zig-course/basic/process_control/loop.html#标记-1","166":"/zig-course/basic/process_control/loop.html#内联-inline-1","167":"/zig-course/basic/process_control/loop.html#解构可选类型","168":"/zig-course/basic/process_control/loop.html#解构错误联合类型","169":"/zig-course/basic/process_control/switch.html#switch","170":"/zig-course/basic/process_control/switch.html#基本使用","171":"/zig-course/basic/process_control/switch.html#进阶使用","172":"/zig-course/basic/process_control/switch.html#作为表达式使用","173":"/zig-course/basic/process_control/switch.html#捕获-tag-union","174":"/zig-course/basic/process_control/switch.html#对枚举类型进行自动推断","175":"/zig-course/basic/process_control/switch.html#内联-switch","176":"/zig-course/basic/process_control/unreachable.html#unreachable","177":"/zig-course/basic/union.html#联合类型","178":"/zig-course/basic/union.html#基本使用","179":"/zig-course/basic/union.html#标记联合","180":"/zig-course/basic/union.html#自动推断","181":"/zig-course/basic/union.html#extern-union","182":"/zig-course/basic/union.html#packed-union","183":"/zig-course/engineering/unit-test.html#单元测试","184":"/zig-course/engineering/unit-test.html#基本使用","185":"/zig-course/engineering/unit-test.html#嵌套测试","186":"/zig-course/engineering/unit-test.html#跳过测试","187":"/zig-course/engineering/unit-test.html#检测内存泄漏","188":"/zig-course/engineering/unit-test.html#检查测试模式","189":"/zig-course/engineering/build-system.html#构建系统","190":"/zig-course/engineering/build-system.html#构建模式","191":"/zig-course/engineering/build-system.html#普通构建","192":"/zig-course/engineering/build-system.html#step","193":"/zig-course/engineering/build-system.html#cli-参数","194":"/zig-course/engineering/build-system.html#options-编译期配置","195":"/zig-course/engineering/build-system.html#构建静-动态链接库","196":"/zig-course/engineering/build-system.html#构建-api-文档","197":"/zig-course/engineering/build-system.html#test","198":"/zig-course/engineering/build-system.html#交叉编译","199":"/zig-course/engineering/build-system.html#embedfile","200":"/zig-course/engineering/build-system.html#执行其他命令","201":"/zig-course/engineering/build-system.html#构建纯-c-项目","202":"/zig-course/engineering/build-system.html#构建纯-c-项目-1","203":"/zig-course/engineering/build-system.html#文件生成","204":"/zig-course/environment/editor.html#编辑器选择","205":"/zig-course/environment/editor.html#vs-code","206":"/zig-course/environment/editor.html#vs","207":"/zig-course/environment/editor.html#clion","208":"/zig-course/environment/editor.html#vim-neovim","209":"/zig-course/environment/editor.html#emacs","210":"/zig-course/environment/editor.html#sublime-text","211":"/zig-course/environment/install-environment.html#环境安装","212":"/zig-course/environment/install-environment.html#windows","213":"/zig-course/environment/install-environment.html#scoop","214":"/zig-course/environment/install-environment.html#其他的包管理器","215":"/zig-course/environment/install-environment.html#手动安装","216":"/zig-course/environment/install-environment.html#mac","217":"/zig-course/environment/install-environment.html#linux","218":"/zig-course/environment/install-environment.html#包管理器安装","219":"/zig-course/environment/install-environment.html#手动安装-1","220":"/zig-course/environment/install-environment.html#通用linux安装方式","221":"/zig-course/environment/install-environment.html#个人目录安装","222":"/zig-course/environment/zig-command.html#zig-命令","223":"/zig-course/environment/zig-command.html#zig-build","224":"/zig-course/environment/zig-command.html#zig-init-exe","225":"/zig-course/environment/zig-command.html#zig-init-lib","226":"/zig-course/environment/zig-command.html#zig-ast-check","227":"/zig-course/environment/zig-command.html#zig-fmt","228":"/zig-course/environment/zig-command.html#zig-test","229":"/zig-course/environment/zig-command.html#zig-fetch","230":"/zig-course/epilogue.html#后记","231":"/zig-course/hello-world.html#hello-world","232":"/zig-course/hello-world.html#简单说明","233":"/zig-course/hello-world.html#换一种方式","234":"/zig-course/hello-world.html#更进一步","235":"/zig-course/hello-world.html#了解更多","236":"/zig-course/more/atomic.html#原子操作","237":"/zig-course/more/atomic.html#内建函数","238":"/zig-course/more/atomic.html#atomicload","239":"/zig-course/more/atomic.html#atomicstore","240":"/zig-course/more/atomic.html#atomicrmw","241":"/zig-course/more/atomic.html#cmpxchgweak","242":"/zig-course/more/atomic.html#cmpxchgstrong","243":"/zig-course/more/atomic.html#fence","244":"/zig-course/more/atomic.html#std-atomic-包","245":"/zig-course/more/atomic.html#原子数据结构","246":"/zig-course/more/atomic.html#spinloophint-自旋锁","247":"/zig-course/more/builtin_func.html#内建函数","248":"/zig-course/more/miscellaneous.html#杂项","249":"/zig-course/more/miscellaneous.html#容器","250":"/zig-course/more/miscellaneous.html#usingnamespace","251":"/zig-course/more/reflection.html#反射","252":"/zig-course/more/reflection.html#观察已有类型","253":"/zig-course/more/reflection.html#typeof","254":"/zig-course/more/reflection.html#typename","255":"/zig-course/more/reflection.html#typeinfo","256":"/zig-course/more/reflection.html#hasdecl","257":"/zig-course/more/reflection.html#hasfield","258":"/zig-course/more/reflection.html#field","259":"/zig-course/more/reflection.html#fieldparentptr","260":"/zig-course/more/reflection.html#call","261":"/zig-course/more/reflection.html#构建新的类型","262":"/zig-course/more/reflection.html#type","263":"/zig-course/more/style_guide.html#风格指南","264":"/zig-course/more/style_guide.html#空白","265":"/zig-course/more/style_guide.html#命名","266":"/zig-course/more/style_guide.html#文档注释指南","267":"/zig-course/more/undefined_behavior.html#未定义操作","268":"/zig-course/more/undefined_behavior.html#不可达代码","269":"/zig-course/more/undefined_behavior.html#索引越界访问","270":"/zig-course/more/undefined_behavior.html#负数转换为无符号整数","271":"/zig-course/more/undefined_behavior.html#数据截断","272":"/zig-course/more/undefined_behavior.html#整数溢出","273":"/zig-course/more/undefined_behavior.html#移位溢出","274":"/zig-course/more/undefined_behavior.html#除零操作","275":"/zig-course/more/undefined_behavior.html#精确除法溢出","276":"/zig-course/more/undefined_behavior.html#尝试解开可选类型-null","277":"/zig-course/more/undefined_behavior.html#尝试解开错误联合类型-error","278":"/zig-course/more/undefined_behavior.html#无效错误码","279":"/zig-course/more/undefined_behavior.html#无效枚举转换","280":"/zig-course/more/undefined_behavior.html#无效错误集合转换","281":"/zig-course/more/undefined_behavior.html#指针对齐错误","282":"/zig-course/more/undefined_behavior.html#联合类型字段访问错误","283":"/zig-course/more/undefined_behavior.html#浮点转换整数发生越界","284":"/zig-course/more/undefined_behavior.html#指针强制转换为-null","285":"/zig-course/more/wasm.html#wasm","286":"/zig-course/more/zero-type.html#零位类型","287":"/zig-course/more/zero-type.html#void","288":"/zig-course/more/zero-type.html#整数","289":"/zig-course/more/zero-type.html#数组和切片","290":"/zig-course/more/zero-type.html#枚举","291":"/zig-course/more/zero-type.html#结构体","292":"/zig-course/more/zero-type.html#联合类型","293":"/zig-course/prologue.html#前言","294":"/zig-course/what-is-zig.html#什么是-zig","295":"/zig-course/what-is-zig.html#为何使用-zig","296":"/zig-course/what-is-zig.html#特点","297":"/zig-course/what-is-zig.html#了解更多"},"fieldIds":{"title":0,"titles":1,"text":2},"fieldLength":{"0":[1,1,8],"1":[1,1,27],"2":[1,1,56],"3":[1,1,80],"4":[1,1,149],"5":[1,1,6],"6":[1,1,39],"7":[1,1,57],"8":[1,1,73],"9":[1,1,86],"10":[1,1,34],"11":[3,1,33],"12":[3,3,23],"13":[3,3,64],"14":[3,3,20],"15":[1,5,37],"16":[5,5,20],"17":[2,3,65],"18":[2,3,37],"19":[2,3,57],"20":[2,3,63],"21":[2,3,51],"22":[1,3,5],"23":[5,4,57],"24":[5,4,61],"25":[1,1,59],"26":[1,1,49],"27":[1,1,50],"28":[1,1,54],"29":[1,1,48],"30":[2,1,48],"31":[2,1,30],"32":[1,1,49],"33":[1,1,19],"34":[1,1,18],"35":[1,1,87],"36":[1,1,64],"37":[1,1,87],"38":[1,1,16],"39":[1,1,14],"40":[1,2,13],"41":[1,2,44],"42":[1,2,48],"43":[3,2,63],"44":[1,2,14],"45":[1,2,12],"46":[1,2,13],"47":[1,2,63],"48":[1,2,5],"49":[1,2,16],"50":[1,1,45],"51":[1,1,93],"52":[1,1,10],"53":[1,1,87],"54":[1,1,13],"55":[1,1,40],"56":[1,2,37],"57":[1,1,48],"58":[1,1,1],"59":[1,2,26],"60":[1,2,36],"61":[1,1,90],"62":[1,2,28],"63":[1,2,35],"64":[1,1,5],"65":[1,2,25],"66":[1,2,42],"67":[1,1,5],"68":[1,1,42],"69":[1,1,21],"70":[1,1,46],"71":[1,1,17],"72":[1,1,33],"73":[1,1,20],"74":[1,1,23],"75":[1,1,18],"76":[1,1,39],"77":[1,1,34],"78":[1,1,67],"79":[1,2,50],"80":[1,1,4],"81":[1,2,46],"82":[1,2,100],"83":[1,2,39],"84":[1,2,23],"85":[1,1,79],"86":[1,1,46],"87":[1,1,51],"88":[1,1,7],"89":[1,1,59],"90":[1,1,118],"91":[1,1,17],"92":[1,1,33],"93":[1,1,14],"94":[1,1,33],"95":[1,1,21],"96":[1,1,46],"97":[1,1,9],"98":[1,2,10],"99":[1,2,118],"100":[1,2,55],"101":[1,1,12],"102":[1,1,101],"103":[2,1,15],"104":[2,1,49],"105":[2,1,90],"106":[2,1,40],"107":[1,1,12],"108":[1,1,60],"109":[1,1,11],"110":[1,1,2],"111":[1,1,78],"112":[1,1,38],"113":[1,1,12],"114":[1,1,1],"115":[1,2,17],"116":[1,2,27],"117":[1,2,28],"118":[2,2,15],"119":[1,2,19],"120":[1,1,6],"121":[1,1,1],"122":[1,2,93],"123":[1,2,12],"124":[1,2,95],"125":[2,2,42],"126":[1,1,78],"127":[1,1,87],"128":[1,1,2],"129":[1,1,45],"130":[1,2,47],"131":[1,2,27],"132":[1,2,43],"133":[1,1,25],"134":[1,1,63],"135":[1,1,21],"136":[1,1,62],"137":[1,1,11],"138":[1,1,20],"139":[1,1,67],"140":[1,2,38],"141":[1,2,70],"142":[1,2,72],"143":[1,2,68],"144":[1,1,20],"145":[1,1,123],"146":[1,1,25],"147":[1,1,6],"148":[1,1,29],"149":[1,1,28],"150":[1,1,3],"151":[1,2,34],"152":[1,2,54],"153":[1,1,31],"154":[1,1,8],"155":[1,1,42],"156":[1,2,9],"157":[1,2,26],"158":[1,2,22],"159":[1,2,24],"160":[1,2,30],"161":[2,2,51],"162":[1,1,31],"163":[2,2,27],"164":[1,2,35],"165":[1,2,29],"166":[2,2,51],"167":[1,2,50],"168":[1,2,53],"169":[1,1,4],"170":[1,1,30],"171":[1,1,48],"172":[2,2,24],"173":[3,2,53],"174":[1,2,19],"175":[2,2,77],"176":[1,1,25],"177":[1,1,6],"178":[1,1,56],"179":[1,1,63],"180":[1,1,15],"181":[2,1,9],"182":[2,1,7],"183":[1,1,11],"184":[1,1,75],"185":[1,1,85],"186":[1,1,20],"187":[1,1,8],"188":[1,1,8],"189":[1,1,14],"190":[1,1,55],"191":[1,1,78],"192":[1,1,111],"193":[2,1,60],"194":[2,1,74],"195":[2,1,77],"196":[3,1,40],"197":[1,1,82],"198":[1,1,51],"199":[1,1,87],"200":[1,1,105],"201":[3,2,155],"202":[3,2,310],"203":[1,2,2],"204":[1,1,4],"205":[2,1,28],"206":[1,1,19],"207":[1,1,36],"208":[2,1,76],"209":[1,1,16],"210":[2,1,12],"211":[1,1,22],"212":[1,1,30],"213":[1,2,34],"214":[1,2,11],"215":[1,2,35],"216":[1,1,11],"217":[1,1,9],"218":[1,2,36],"219":[1,2,14],"220":[1,3,22],"221":[1,3,25],"222":[2,1,21],"223":[2,2,6],"224":[3,2,26],"225":[3,2,29],"226":[3,2,3],"227":[2,2,3],"228":[2,2,3],"229":[2,2,34],"230":[1,1,2],"231":[2,1,38],"232":[1,2,79],"233":[2,2,101],"234":[2,2,13],"235":[2,2,10],"236":[1,1,16],"237":[1,1,11],"238":[2,2,13],"239":[2,2,14],"240":[2,2,18],"241":[2,2,20],"242":[2,2,20],"243":[2,2,10],"244":[3,1,1],"245":[1,4,76],"246":[2,4,16],"247":[1,1,2],"248":[1,1,5],"249":[1,1,22],"250":[1,1,54],"251":[1,1,19],"252":[1,1,12],"253":[2,2,58],"254":[2,2,27],"255":[2,2,85],"256":[2,2,34],"257":[2,2,36],"258":[2,2,37],"259":[2,2,30],"260":[2,2,31],"261":[1,1,7],"262":[2,2,60],"263":[1,1,7],"264":[1,1,12],"265":[1,1,103],"266":[1,1,14],"267":[1,1,85],"268":[1,1,5],"269":[1,1,3],"270":[1,1,10],"271":[1,1,22],"272":[1,1,62],"273":[1,1,4],"274":[1,1,7],"275":[1,1,5],"276":[2,1,11],"277":[2,1,8],"278":[1,1,6],"279":[1,1,6],"280":[1,1,5],"281":[1,1,18],"282":[1,1,24],"283":[1,1,14],"284":[2,1,13],"285":[1,1,2],"286":[1,1,13],"287":[1,1,23],"288":[1,1,10],"289":[1,1,13],"290":[1,1,4],"291":[1,1,12],"292":[1,1,6],"293":[1,1,106],"294":[2,1,40],"295":[2,2,20],"296":[1,2,39],"297":[2,2,10]},"averageFieldLength":[1.3187919463087245,1.4630872483221484,36.86577181208053],"storedFields":{"0":{"title":"关于本站","titles":[]},"1":{"title":"参与贡献","titles":["关于本站"]},"2":{"title":"汇编","titles":[]},"3":{"title":"外部汇编","titles":["汇编"]},"4":{"title":"内联汇编","titles":["汇编"]},"5":{"title":"异步","titles":[]},"6":{"title":"编译期","titles":[]},"7":{"title":"编译期参数实现鸭子类型","titles":["编译期"]},"8":{"title":"编译期变量","titles":["编译期"]},"9":{"title":"编译期表达式","titles":["编译期"]},"10":{"title":"生成数据结构","titles":["编译期"]},"11":{"title":"与 C 交互","titles":[]},"12":{"title":"C ABI 类型","titles":["与 C 交互"]},"13":{"title":"C Header 导入","titles":["与 C 交互"]},"14":{"title":"C Translation CLI","titles":["与 C 交互"]},"15":{"title":"命令行参数","titles":["与 C 交互","C Translation CLI"]},"16":{"title":"@cImport vs translate-c","titles":["与 C 交互","C Translation CLI"]},"17":{"title":"C 翻译缓存","titles":["与 C 交互"]},"18":{"title":"C 翻译错误","titles":["与 C 交互"]},"19":{"title":"C Macro","titles":["与 C 交互"]},"20":{"title":"C 指针","titles":["与 C 交互"]},"21":{"title":"C 可变参数函数","titles":["与 C 交互"]},"22":{"title":"额外内容","titles":["与 C 交互"]},"23":{"title":"为什么 zig 可以做到比 c 更好的编译","titles":["与 C 交互","额外内容"]},"24":{"title":"zig 能静态链接 libc 吗？","titles":["与 C 交互","额外内容"]},"25":{"title":"内存管理","titles":[]},"26":{"title":"GeneralPurposeAllocator","titles":["内存管理"]},"27":{"title":"FixedBufferAllocator","titles":["内存管理"]},"28":{"title":"ArenaAllocator","titles":["内存管理"]},"29":{"title":"HeapAllocator","titles":["内存管理"]},"30":{"title":"c_allocator","titles":["内存管理"]},"31":{"title":"page_allocator","titles":["内存管理"]},"32":{"title":"MemoryPool","titles":["内存管理"]},"33":{"title":"实现内存分配器","titles":["内存管理"]},"34":{"title":"包管理","titles":[]},"35":{"title":"新的文件结构","titles":["包管理"]},"36":{"title":"编写包","titles":["包管理"]},"37":{"title":"引入包","titles":["包管理"]},"38":{"title":"类型转换","titles":[]},"39":{"title":"普通类型转换","titles":["类型转换"]},"40":{"title":"限制更严格","titles":["类型转换","普通类型转换"]},"41":{"title":"整数与浮点数拓宽","titles":["类型转换","普通类型转换"]},"42":{"title":"立即数整数和浮点数出现歧义","titles":["类型转换","普通类型转换"]},"43":{"title":"切片、数组、指针","titles":["类型转换","普通类型转换"]},"44":{"title":"可选类型","titles":["类型转换","普通类型转换"]},"45":{"title":"错误联合类型","titles":["类型转换","普通类型转换"]},"46":{"title":"编译期数字","titles":["类型转换","普通类型转换"]},"47":{"title":"联合类型和枚举","titles":["类型转换","普通类型转换"]},"48":{"title":"undefined","titles":["类型转换","普通类型转换"]},"49":{"title":"元组和数组","titles":["类型转换","普通类型转换"]},"50":{"title":"显式强制转换","titles":["类型转换"]},"51":{"title":"对等类型转换","titles":["类型转换"]},"52":{"title":"社区","titles":[]},"53":{"title":"第三方库","titles":[]},"54":{"title":"数组","titles":[]},"55":{"title":"创建数组","titles":["数组"]},"56":{"title":"多维数组","titles":["数组","创建数组"]},"57":{"title":"哨兵数组","titles":["数组"]},"58":{"title":"操作","titles":["数组"]},"59":{"title":"乘法","titles":["数组","操作"]},"60":{"title":"串联","titles":["数组","操作"]},"61":{"title":"字符串","titles":["数组"]},"62":{"title":"转义字符","titles":["数组","字符串"]},"63":{"title":"多行字符串","titles":["数组","字符串"]},"64":{"title":"奇技淫巧","titles":["数组"]},"65":{"title":"使用函数初始化数组","titles":["数组","奇技淫巧"]},"66":{"title":"编译期初始化数组","titles":["数组","奇技淫巧"]},"67":{"title":"枚举","titles":[]},"68":{"title":"声明枚举","titles":["枚举"]},"69":{"title":"枚举方法","titles":["枚举"]},"70":{"title":"枚举大小","titles":["枚举"]},"71":{"title":"枚举推断","titles":["枚举"]},"72":{"title":"非详尽枚举","titles":["枚举"]},"73":{"title":"extern","titles":["枚举"]},"74":{"title":"opaque","titles":[]},"75":{"title":"anyopaque","titles":["opaque"]},"76":{"title":"指针","titles":[]},"77":{"title":"单项指针","titles":["指针"]},"78":{"title":"多项指针","titles":["指针"]},"79":{"title":"哨兵指针","titles":["指针","多项指针"]},"80":{"title":"额外特性","titles":["指针"]},"81":{"title":"volatile","titles":["指针","额外特性"]},"82":{"title":"对齐","titles":["指针","额外特性"]},"83":{"title":"零指针","titles":["指针","额外特性"]},"84":{"title":"编译期","titles":["指针","额外特性"]},"85":{"title":"切片","titles":[]},"86":{"title":"切片指针","titles":["切片"]},"87":{"title":"哨兵切片","titles":["切片"]},"88":{"title":"结构体","titles":[]},"89":{"title":"基本语法","titles":["结构体"]},"90":{"title":"自引用","titles":["结构体"]},"91":{"title":"自动推断","titles":["结构体"]},"92":{"title":"泛型实现","titles":["结构体"]},"93":{"title":"字段默认值","titles":["结构体"]},"94":{"title":"空结构体","titles":["结构体"]},"95":{"title":"通过字段获取基指针","titles":["结构体"]},"96":{"title":"元组","titles":["结构体"]},"97":{"title":"高级特性","titles":["结构体"]},"98":{"title":"extern","titles":["结构体","高级特性"]},"99":{"title":"packed","titles":["结构体","高级特性"]},"100":{"title":"命名规则","titles":["结构体","高级特性"]},"101":{"title":"向量","titles":[]},"102":{"title":"基本使用","titles":["向量"]},"103":{"title":"@splat","titles":["向量"]},"104":{"title":"@reduce","titles":["向量"]},"105":{"title":"@shuffle","titles":["向量"]},"106":{"title":"@select","titles":["向量"]},"107":{"title":"字符与布尔值","titles":[]},"108":{"title":"字符","titles":["字符与布尔值"]},"109":{"title":"布尔值","titles":["字符与布尔值"]},"110":{"title":"函数","titles":[]},"111":{"title":"基本使用","titles":["函数"]},"112":{"title":"参数传递","titles":["函数"]},"113":{"title":"内建函数","titles":["函数"]},"114":{"title":"高阶使用","titles":["函数"]},"115":{"title":"anytype","titles":["函数","高阶使用"]},"116":{"title":"noreturn","titles":["函数","高阶使用"]},"117":{"title":"extern","titles":["函数","高阶使用"]},"118":{"title":"@setCold","titles":["函数","高阶使用"]},"119":{"title":"callconv","titles":["函数","高阶使用"]},"120":{"title":"数值类型","titles":[]},"121":{"title":"整数","titles":["数值类型"]},"122":{"title":"类型","titles":["数值类型","整数"]},"123":{"title":"不同进制","titles":["数值类型","整数"]},"124":{"title":"除零","titles":["数值类型","整数"]},"125":{"title":"溢出:","titles":["数值类型","整数"]},"126":{"title":"浮点数","titles":["数值类型"]},"127":{"title":"运算","titles":["数值类型"]},"128":{"title":"基本类型","titles":[]},"129":{"title":"变量声明","titles":["基本类型"]},"130":{"title":"标识符命名","titles":["基本类型","变量声明"]},"131":{"title":"常量","titles":["基本类型","变量声明"]},"132":{"title":"undefined","titles":["基本类型","变量声明"]},"133":{"title":"块","titles":["基本类型"]},"134":{"title":"注释","titles":["基本类型"]},"135":{"title":"错误处理","titles":[]},"136":{"title":"基本使用","titles":["错误处理"]},"137":{"title":"只有一个值的错误集","titles":["错误处理"]},"138":{"title":"全局错误集","titles":["错误处理"]},"139":{"title":"错误联合类型","titles":["错误处理"]},"140":{"title":"catch","titles":["错误处理","错误联合类型"]},"141":{"title":"try","titles":["错误处理","错误联合类型"]},"142":{"title":"errdefer","titles":["错误处理","错误联合类型"]},"143":{"title":"合并和推断错误","titles":["错误处理","错误联合类型"]},"144":{"title":"堆栈跟踪","titles":["错误处理"]},"145":{"title":"可选类型","titles":[]},"146":{"title":"编译期反射访问可选类型","titles":["可选类型"]},"147":{"title":"可选指针","titles":["可选类型"]},"148":{"title":"条件","titles":[]},"149":{"title":"三元表达式","titles":["条件"]},"150":{"title":"高级用法","titles":["条件"]},"151":{"title":"解构可选类型","titles":["条件","高级用法"]},"152":{"title":"解构错误联合类型","titles":["条件","高级用法"]},"153":{"title":"defer","titles":[]},"154":{"title":"循环","titles":[]},"155":{"title":"for","titles":["循环"]},"156":{"title":"迭代数字","titles":["循环","for"]},"157":{"title":"迭代索引","titles":["循环","for"]},"158":{"title":"多目标迭代","titles":["循环","for"]},"159":{"title":"作为表达式使用","titles":["循环","for"]},"160":{"title":"标记","titles":["循环","for"]},"161":{"title":"内联 inline","titles":["循环","for"]},"162":{"title":"while","titles":["循环"]},"163":{"title":"continue 表达式","titles":["循环","while"]},"164":{"title":"作为表达式使用","titles":["循环","while"]},"165":{"title":"标记","titles":["循环","while"]},"166":{"title":"内联 inline","titles":["循环","while"]},"167":{"title":"解构可选类型","titles":["循环","while"]},"168":{"title":"解构错误联合类型","titles":["循环","while"]},"169":{"title":"Switch","titles":[]},"170":{"title":"基本使用","titles":["Switch"]},"171":{"title":"进阶使用","titles":["Switch"]},"172":{"title":"作为表达式使用：","titles":["Switch","进阶使用"]},"173":{"title":"捕获 Tag Union","titles":["Switch","进阶使用"]},"174":{"title":"对枚举类型进行自动推断","titles":["Switch","进阶使用"]},"175":{"title":"内联 switch","titles":["Switch","进阶使用"]},"176":{"title":"unreachable","titles":[]},"177":{"title":"联合类型","titles":[]},"178":{"title":"基本使用","titles":["联合类型"]},"179":{"title":"标记联合","titles":["联合类型"]},"180":{"title":"自动推断","titles":["联合类型"]},"181":{"title":"extern union","titles":["联合类型"]},"182":{"title":"packed union","titles":["联合类型"]},"183":{"title":"单元测试","titles":[]},"184":{"title":"基本使用","titles":["单元测试"]},"185":{"title":"嵌套测试","titles":["单元测试"]},"186":{"title":"跳过测试","titles":["单元测试"]},"187":{"title":"检测内存泄漏","titles":["单元测试"]},"188":{"title":"检查测试模式","titles":["单元测试"]},"189":{"title":"构建系统","titles":[]},"190":{"title":"构建模式","titles":["构建系统"]},"191":{"title":"普通构建","titles":["构建系统"]},"192":{"title":"Step","titles":["构建系统"]},"193":{"title":"CLI 参数","titles":["构建系统"]},"194":{"title":"Options 编译期配置","titles":["构建系统"]},"195":{"title":"构建静/动态链接库","titles":["构建系统"]},"196":{"title":"构建 api 文档","titles":["构建系统"]},"197":{"title":"Test","titles":["构建系统"]},"198":{"title":"交叉编译","titles":["构建系统"]},"199":{"title":"embedFile","titles":["构建系统"]},"200":{"title":"执行其他命令","titles":["构建系统"]},"201":{"title":"构建纯 C 项目","titles":["构建系统","执行其他命令"]},"202":{"title":"构建纯 C++ 项目","titles":["构建系统","执行其他命令"]},"203":{"title":"文件生成","titles":["构建系统","执行其他命令"]},"204":{"title":"编辑器选择","titles":[]},"205":{"title":"VS Code","titles":["编辑器选择"]},"206":{"title":"VS","titles":["编辑器选择"]},"207":{"title":"CLion","titles":["编辑器选择"]},"208":{"title":"Vim / Neovim","titles":["编辑器选择"]},"209":{"title":"Emacs","titles":["编辑器选择"]},"210":{"title":"Sublime Text","titles":["编辑器选择"]},"211":{"title":"环境安装","titles":[]},"212":{"title":"Windows","titles":["环境安装"]},"213":{"title":"Scoop","titles":["环境安装","Windows"]},"214":{"title":"其他的包管理器","titles":["环境安装","Windows"]},"215":{"title":"手动安装","titles":["环境安装","Windows"]},"216":{"title":"Mac","titles":["环境安装"]},"217":{"title":"Linux","titles":["环境安装"]},"218":{"title":"包管理器安装","titles":["环境安装","Linux"]},"219":{"title":"手动安装","titles":["环境安装","Linux"]},"220":{"title":"通用linux安装方式","titles":["环境安装","Linux","手动安装"]},"221":{"title":"个人目录安装","titles":["环境安装","Linux","手动安装"]},"222":{"title":"zig 命令","titles":[]},"223":{"title":"zig build","titles":["zig 命令"]},"224":{"title":"zig init-exe","titles":["zig 命令"]},"225":{"title":"zig init-lib","titles":["zig 命令"]},"226":{"title":"zig ast-check","titles":["zig 命令"]},"227":{"title":"zig fmt","titles":["zig 命令"]},"228":{"title":"zig test","titles":["zig 命令"]},"229":{"title":"zig fetch","titles":["zig 命令"]},"230":{"title":"后记","titles":[]},"231":{"title":"Hello World","titles":[]},"232":{"title":"简单说明","titles":["Hello World"]},"233":{"title":"换一种方式？","titles":["Hello World"]},"234":{"title":"更进一步？","titles":["Hello World"]},"235":{"title":"了解更多？","titles":["Hello World"]},"236":{"title":"原子操作","titles":[]},"237":{"title":"内建函数","titles":["原子操作"]},"238":{"title":"@atomicLoad","titles":["原子操作","内建函数"]},"239":{"title":"@atomicStore","titles":["原子操作","内建函数"]},"240":{"title":"@atomicRmw","titles":["原子操作","内建函数"]},"241":{"title":"@cmpxchgWeak","titles":["原子操作","内建函数"]},"242":{"title":"@cmpxchgStrong","titles":["原子操作","内建函数"]},"243":{"title":"@fence","titles":["原子操作","内建函数"]},"244":{"title":"std.atomic 包","titles":["原子操作"]},"245":{"title":"原子数据结构","titles":["原子操作","std.atomic 包"]},"246":{"title":"spinLoopHint 自旋锁","titles":["原子操作","std.atomic 包"]},"247":{"title":"内建函数","titles":[]},"248":{"title":"杂项","titles":[]},"249":{"title":"容器","titles":["杂项"]},"250":{"title":"usingnamespace","titles":["杂项"]},"251":{"title":"反射","titles":[]},"252":{"title":"观察已有类型","titles":["反射"]},"253":{"title":"@TypeOf","titles":["反射","观察已有类型"]},"254":{"title":"@typeName","titles":["反射","观察已有类型"]},"255":{"title":"@typeInfo","titles":["反射","观察已有类型"]},"256":{"title":"@hasDecl","titles":["反射","观察已有类型"]},"257":{"title":"@hasField","titles":["反射","观察已有类型"]},"258":{"title":"@field","titles":["反射","观察已有类型"]},"259":{"title":"@fieldParentPtr","titles":["反射","观察已有类型"]},"260":{"title":"@call","titles":["反射","观察已有类型"]},"261":{"title":"构建新的类型","titles":["反射"]},"262":{"title":"@Type","titles":["反射","构建新的类型"]},"263":{"title":"风格指南","titles":[]},"264":{"title":"空白","titles":["风格指南"]},"265":{"title":"命名","titles":["风格指南"]},"266":{"title":"文档注释指南","titles":["风格指南"]},"267":{"title":"未定义操作","titles":[]},"268":{"title":"不可达代码","titles":["未定义操作"]},"269":{"title":"索引越界访问","titles":["未定义操作"]},"270":{"title":"负数转换为无符号整数","titles":["未定义操作"]},"271":{"title":"数据截断","titles":["未定义操作"]},"272":{"title":"整数溢出","titles":["未定义操作"]},"273":{"title":"移位溢出","titles":["未定义操作"]},"274":{"title":"除零操作","titles":["未定义操作"]},"275":{"title":"精确除法溢出","titles":["未定义操作"]},"276":{"title":"尝试解开可选类型 Null","titles":["未定义操作"]},"277":{"title":"尝试解开错误联合类型 Error","titles":["未定义操作"]},"278":{"title":"无效错误码","titles":["未定义操作"]},"279":{"title":"无效枚举转换","titles":["未定义操作"]},"280":{"title":"无效错误集合转换","titles":["未定义操作"]},"281":{"title":"指针对齐错误","titles":["未定义操作"]},"282":{"title":"联合类型字段访问错误","titles":["未定义操作"]},"283":{"title":"浮点转换整数发生越界","titles":["未定义操作"]},"284":{"title":"指针强制转换为 Null","titles":["未定义操作"]},"285":{"title":"WASM","titles":[]},"286":{"title":"零位类型","titles":[]},"287":{"title":"void","titles":["零位类型"]},"288":{"title":"整数","titles":["零位类型"]},"289":{"title":"数组和切片","titles":["零位类型"]},"290":{"title":"枚举","titles":["零位类型"]},"291":{"title":"结构体","titles":["零位类型"]},"292":{"title":"联合类型","titles":["零位类型"]},"293":{"title":"前言","titles":[]},"294":{"title":"什么是 Zig","titles":[]},"295":{"title":"为何使用 Zig","titles":["什么是 Zig"]},"296":{"title":"特点","titles":["什么是 Zig"]},"297":{"title":"了解更多 ？","titles":["什么是 Zig"]}},"dirtCount":0,"index":[["列出了一些积极维护的",{"2":{"297":1}}],["计算机科学中最严重的错误",{"2":{"296":1}}],["亦或者对速度有很高的要求",{"2":{"295":1}}],["设计",{"2":{"294":1}}],["设置中的",{"2":{"212":1}}],["设置可能是",{"2":{"198":1}}],["设置正确的target",{"2":{"24":1}}],["设置",{"2":{"24":1,"193":1}}],["静态类型",{"2":{"294":1}}],["什么是",{"0":{"294":1},"1":{"295":1,"296":1,"297":1}}],["什么是编译期",{"2":{"6":1}}],["帮助新人来更好的理解和学习",{"2":{"293":1}}],["帮助开发人员使用智能编辑器来提高代码质量",{"2":{"207":1}}],["披着高抽象皮的",{"2":{"293":1}}],["庞大很多的社区等等",{"2":{"293":1}}],["成为一个不是c的替代品",{"2":{"293":1}}],["他们在某种程度上都算是失败了",{"2":{"293":1}}],["历史上有不少语言都自诩是",{"2":{"293":1}}],["五花八门",{"2":{"293":1}}],["各式各样的第三方包管理器",{"2":{"293":1}}],["难道不好吗",{"2":{"293":1}}],["至少现在不是",{"2":{"293":1}}],["至少zig",{"2":{"145":1}}],["涉及到它们的值不会出现在构建结果中",{"2":{"286":1}}],["涉及到了位偏移",{"2":{"99":1}}],["零位类型",{"0":{"286":1},"1":{"287":1,"288":1,"289":1,"290":1,"291":1,"292":1}}],["零指针实际上是一个未定义的错误行为",{"2":{"83":1}}],["零指针",{"0":{"83":1}}],["地址很明显是不符合",{"2":{"281":1}}],["地使用",{"2":{"233":1}}],["精确的内存泄漏跟踪",{"2":{"296":1}}],["精确除法使用的是",{"2":{"275":1}}],["精确除法溢出",{"0":{"275":1}}],["精度为纳秒",{"2":{"134":1}}],["移位溢出",{"0":{"273":1}}],["乘",{"2":{"272":1}}],["乘法结果最大或最小为该类型的极限",{"2":{"127":1}}],["乘法环绕",{"2":{"125":1,"272":1}}],["乘法",{"0":{"59":1},"2":{"125":1}}],["减少隐式的执行",{"2":{"293":1}}],["减",{"2":{"272":1}}],["减法结果最小为该类型的极限",{"2":{"127":1}}],["减法环绕",{"2":{"125":1,"272":1}}],["减法",{"2":{"125":1}}],["未定义操作",{"0":{"267":1},"1":{"268":1,"269":1,"270":1,"271":1,"272":1,"273":1,"274":1,"275":1,"276":1,"277":1,"278":1,"279":1,"280":1,"281":1,"282":1,"283":1,"284":1}}],["未列出枚举值可以使用",{"2":{"72":1}}],["断言",{"2":{"266":1}}],["断言它为",{"2":{"255":1}}],["假设",{"2":{"266":1}}],["假设以上这段代码在文件",{"2":{"184":1}}],["鼓励将注释信息复制到多个类似的函数上",{"2":{"266":1}}],["蛇形命名法",{"2":{"265":10}}],["驼峰命名法",{"2":{"265":2}}],["采用四空格缩进",{"2":{"264":1}}],["采取的是一种折中的方案",{"2":{"145":1}}],["英文参考文档",{"2":{"263":1}}],["英语",{"2":{"38":1,"183":1}}],["风格指南",{"0":{"263":1},"1":{"264":1,"265":1,"266":1}}],["调用一个函数",{"2":{"260":1}}],["调用函数时将推断参数类型",{"2":{"115":1}}],["作用于变量时只能访问字段",{"2":{"258":1}}],["作为编译或者依赖管理工具",{"2":{"222":1}}],["作为包导入",{"2":{"194":1}}],["作为表达式来使用",{"2":{"164":1}}],["作为表达式使用",{"0":{"159":1,"164":1,"172":1},"2":{"171":1}}],["作为关键字来声明常量",{"2":{"131":1}}],["作为函数的名字",{"2":{"111":1}}],["作为",{"2":{"24":1,"125":1,"213":1}}],["作为对比",{"2":{"23":1}}],["作为一门",{"2":{"76":1}}],["作为一种折中方案",{"2":{"20":1}}],["作为一个可以独立于",{"2":{"11":1}}],["作为参数传递给函数",{"2":{"6":1}}],["观察已有类型",{"0":{"252":1},"1":{"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1}}],["观察",{"2":{"251":1}}],["观察到",{"2":{"99":1}}],["反射就是程序在运行的时候能够",{"2":{"251":1}}],["反射",{"0":{"251":1},"1":{"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"261":1,"262":1},"2":{"251":1}}],["反斜杠",{"2":{"62":1}}],["暂时还没有决定好分类到何处",{"2":{"248":1}}],["杂项",{"0":{"248":1},"1":{"249":1,"250":1}}],["表示当当违反预定情况时会触发安全检查的未定义行为",{"2":{"266":1}}],["表明调用者处于忙等待自旋循环内",{"2":{"246":1}}],["表达式会完全在编译期执行",{"2":{"253":1}}],["表达式上",{"2":{"167":1,"168":1}}],["表达式的方法来便于我们控制循环",{"2":{"163":1}}],["表达式中",{"2":{"100":1}}],["表达式内应仅包含",{"2":{"13":1}}],["表达式都是无效的",{"2":{"9":1}}],["表达式都在编译时求值",{"2":{"9":1}}],["表达式",{"0":{"163":1},"2":{"7":1,"9":1}}],["防止某些类型的内存重新排序",{"2":{"243":1}}],["强大的编译期运行",{"2":{"296":1}}],["强原子的比较与交换操作",{"2":{"242":1}}],["强制该函数在所有被调用位置内联",{"2":{"119":1}}],["弱原子的比较与交换操作",{"2":{"241":1}}],["见此",{"2":{"240":1}}],["见",{"2":{"237":1}}],["见下方执行其他命令部分",{"2":{"199":1}}],["性能更高了",{"2":{"233":1}}],["句柄",{"2":{"233":1}}],["流句柄",{"2":{"233":1}}],["输出",{"2":{"233":1}}],["输出中文乱码问题",{"2":{"212":1}}],["让我们换一种方式来讲述如何",{"2":{"233":1}}],["让对应的",{"2":{"192":1}}],["别担心",{"2":{"232":1}}],["别忘记三个冒号",{"2":{"4":1}}],["好很多",{"2":{"293":1}}],["好",{"2":{"293":1}}],["好了",{"2":{"232":1}}],["好用",{"2":{"145":1}}],["根文件",{"2":{"232":1}}],["根据其官网所述",{"2":{"294":1}}],["根据名称省略冗余信息",{"2":{"266":1}}],["根据给定的指向结构体字段的指针和名字",{"2":{"259":1}}],["根据文档说明",{"2":{"143":1}}],["根据掩码mask",{"2":{"105":1}}],["根据目标的字节顺序",{"2":{"99":1}}],["根据",{"2":{"51":1,"106":1}}],["根据整数",{"2":{"50":1}}],["根据整数值获取对应的联合标记或者枚举值",{"2":{"50":1}}],["根据整数值获取对应的枚举值",{"2":{"50":1}}],["根据创建匿名结构体时调用的函数名称和参数推断出名称为list",{"2":{"10":1}}],["始终支持导入三个模块",{"2":{"232":1}}],["简单来说",{"2":{"265":1}}],["简单说明",{"0":{"232":1}}],["简单地引入",{"2":{"13":1}}],["适用于单元测试",{"2":{"228":1}}],["适用于游戏的小型脚本语言",{"2":{"53":1}}],["└──",{"2":{"224":2,"225":2}}],["├──",{"2":{"224":1,"225":1}}],["备注",{"2":{"218":1}}],["手动内存控制",{"2":{"296":1}}],["手动安装",{"0":{"215":1,"219":1},"1":{"220":1,"221":1}}],["手动编译安装的方法如下",{"2":{"208":1}}],["手动编译依赖的源代码",{"2":{"202":1}}],["仓库分别有着最新的",{"2":{"213":1}}],["仓库和",{"2":{"213":1}}],["工具进行安装",{"2":{"213":1}}],["工欲善其事",{"2":{"204":1}}],["重启计算机",{"2":{"212":1}}],["勾选下方的",{"2":{"212":1}}],["点击下方的",{"2":{"212":1}}],["点击下方的管理语言设置",{"2":{"212":1}}],["管理",{"2":{"212":1}}],["打印输出其字段值",{"2":{"255":1}}],["打印该结构体内部字段的信息",{"2":{"255":1}}],["打印",{"2":{"234":1}}],["打印出",{"2":{"233":1}}],["打印字符串是不能这样子做的",{"2":{"232":1}}],["打印结果如下",{"2":{"85":1}}],["打开",{"2":{"212":1}}],["稳定版最终会变得过时",{"2":{"211":1}}],["发生越界访问会发生错误导致程序终止进而触发堆栈跟踪",{"2":{"269":1}}],["发行版",{"2":{"218":1}}],["发布周期与",{"2":{"211":1}}],["发起",{"2":{"1":1}}],["环境安装",{"0":{"211":1},"1":{"212":1,"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1}}],["环绕操作符",{"2":{"125":1}}],["危险",{"2":{"210":1}}],["⛔",{"2":{"210":1}}],["经典的编辑器",{"2":{"210":1}}],["安装的方式五花八门",{"2":{"217":1}}],["安装方式如下",{"2":{"213":1}}],["安装即可",{"2":{"210":1}}],["安装",{"2":{"208":1,"213":1}}],["安全检查会在debug",{"2":{"267":1}}],["安全检查",{"2":{"26":1}}],["古老的编辑器之一",{"2":{"208":1}}],["插件也是由",{"2":{"210":1}}],["插件的仓库地址为",{"2":{"208":1}}],["插件",{"2":{"207":1,"208":1}}],["及",{"2":{"207":1}}],["集成开发环境等等",{"2":{"206":1}}],["确保你的",{"2":{"293":1}}],["确认即可",{"2":{"205":1}}],["确信本次函数执行后肯定不会发生错误",{"2":{"139":1}}],["微软出品",{"2":{"205":1}}],["官网地址",{"2":{"205":1,"206":1}}],["官方维护",{"2":{"210":1}}],["官方维护了",{"2":{"209":1}}],["官方为其开发了插件",{"2":{"205":1}}],["官方文档中关于类型的部分",{"2":{"108":1}}],["官方的",{"2":{"22":1}}],["必先利其器",{"2":{"204":1}}],["必须放在作用域的顶层",{"2":{"134":1}}],["必须仔细阅读",{"2":{"33":1}}],["必须是编译期已知的",{"2":{"6":1}}],["正确的处理方案是使用",{"2":{"276":1,"277":1}}],["正确的做法是",{"2":{"202":1}}],["正确",{"2":{"233":1}}],["正常使用",{"2":{"232":1}}],["正数是从",{"2":{"105":1}}],["示",{"2":{"201":1}}],["示例",{"2":{"77":1,"78":2,"79":1,"82":1,"83":1,"99":2,"123":1,"179":1,"245":1,"246":1}}],["示例如下",{"2":{"63":1}}],["示例文件",{"2":{"17":1}}],["项目拿去作为工具链使用",{"2":{"296":1}}],["项目",{"0":{"201":1,"202":1}}],["录入根据",{"2":{"200":1}}],["`root",{"2":{"199":1,"200":1}}],["`source",{"2":{"199":1,"200":1}}],["`nightly`",{"2":{"199":1,"200":1}}],["交叉编译",{"0":{"198":1}}],["交互的特性",{"2":{"79":1}}],["交互的函数中",{"2":{"75":1}}],["交互",{"0":{"11":1},"1":{"12":1,"13":1,"14":1,"15":1,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"22":1,"23":1,"24":1}}],["随后将其断言为一个",{"2":{"255":1}}],["随后进行执行并将其绑定到",{"2":{"197":1}}],["随着",{"2":{"34":1}}],["约定库的名字不包含",{"2":{"195":1}}],["链接系统库",{"2":{"202":1}}],["链接系统的gtk4库",{"2":{"201":1}}],["链接c++",{"2":{"202":1}}],["链接标准",{"2":{"201":1}}],["链接到",{"2":{"195":1}}],["链接到系统的",{"2":{"195":1}}],["链接",{"2":{"195":1}}],["链接依赖提供的库",{"2":{"37":1}}],["系统调用的流程",{"2":{"233":1}}],["系统",{"2":{"195":1}}],["系统账号管理的使用",{"2":{"90":1}}],["动态链接库",{"0":{"195":1}}],["塞入二进制程序的构建中",{"2":{"194":1}}],["向处理器发出信号",{"2":{"246":1}}],["向",{"2":{"194":2}}],["向量的类型和长度由编译器推断",{"2":{"103":1}}],["向量的每个元素均是传入的参数",{"2":{"103":1}}],["向量长度",{"2":{"102":1}}],["向量必须拥有编译期已知的长度和类型",{"2":{"102":1,"106":1}}],["向量还支持对具有已知长度的固定长度数组进行赋值",{"2":{"102":1}}],["向量支持与底层基本类型相同的内置运算符",{"2":{"102":1}}],["向量",{"0":{"101":1},"1":{"102":1,"103":1,"104":1,"105":1,"106":1},"2":{"101":1}}],["配置文件",{"2":{"192":1}}],["前言",{"0":{"293":1}}],["前端项目构建等等",{"2":{"200":1}}],["前先构建出数据",{"2":{"192":1}}],["前先构建出",{"2":{"192":1}}],["前面的说法可能比较复杂",{"2":{"57":1}}],["尽量在同一行打开大括号",{"2":{"264":1}}],["尽可能提高安全性但又不至于造成类似",{"2":{"190":1}}],["尽管可以使用其他方式来实现集合功能",{"2":{"287":1}}],["尽管携带了",{"2":{"23":1}}],["尽管现代高级语言的特性已经非常丰富",{"2":{"2":1}}],["效果是在",{"2":{"190":1}}],["较差的运行效率",{"2":{"190":1}}],["禁用安全检查",{"2":{"190":1}}],["禁止变量覆盖外部作用域",{"2":{"130":1}}],["禁止对标量",{"2":{"102":1}}],["启用安全检查",{"2":{"190":3}}],["启动或者禁用某些运行时的安全性功能",{"2":{"16":1}}],["检测和修改它本身状态或行为的一种能力",{"2":{"251":1}}],["检测内存泄漏",{"0":{"187":1}}],["检查测试模式",{"0":{"188":1}}],["检查",{"2":{"145":1}}],["检查是否存在泄露等特性",{"2":{"26":1}}],["名字为空的测试块",{"2":{"186":1}}],["跳过测试的一种方法是使用",{"2":{"186":1}}],["跳过测试",{"0":{"186":1}}],["形式引入测试",{"2":{"185":1}}],["被誉为",{"2":{"208":1}}],["被顶层测试块引用了",{"2":{"185":1}}],["被标记为编译期已知的",{"2":{"8":1}}],["嵌套引用测试在全局测试块中引用另一个容器后",{"2":{"185":1}}],["嵌套测试",{"0":{"185":1}}],["嵌入式设备和低延迟服务器",{"2":{"25":1}}],["测试",{"2":{"197":1,"222":1}}],["测试块具有隐式的返回值类型",{"2":{"184":1}}],["测试器",{"2":{"184":1}}],["测试名字",{"2":{"184":1}}],["软件设计的最小单位",{"2":{"183":1}}],["又称为模块测试来源请求",{"2":{"183":1}}],["又不能",{"2":{"24":1}}],["初始化一个联合类型",{"2":{"178":1}}],["初学者可以直接略过以下部分",{"2":{"80":1}}],["划分出一块内存空间用来存储多种类型",{"2":{"177":1}}],["匹配时",{"2":{"174":1}}],["匹配已经穷尽了",{"2":{"173":2}}],["匹配剩余的分支",{"2":{"171":1}}],["捕获",{"0":{"173":1},"2":{"175":1}}],["捕获的是可选类型的指针",{"2":{"152":1}}],["捕获的错误",{"2":{"144":1}}],["范围匹配",{"2":{"171":1}}],["进入",{"2":{"212":1}}],["进阶使用",{"0":{"171":1},"1":{"172":1,"173":1,"174":1,"175":1}}],["进行左移操作时",{"2":{"273":1}}],["进行构建",{"2":{"223":1}}],["进行编译",{"2":{"202":1}}],["进行通信",{"2":{"197":1}}],["进行检测",{"2":{"124":1}}],["进行串联操作",{"2":{"60":1}}],["进行矩阵的叠加",{"2":{"59":1}}],["碰到第一个",{"2":{"167":2}}],["建议以下情况使用内联",{"2":{"166":1}}],["建议对",{"2":{"105":1}}],["直到某些条件不再成立",{"2":{"162":1}}],["直接使用它会导致程序或者编译器停止运行",{"2":{"277":1}}],["直接使用",{"2":{"199":1}}],["直接使用字面量来定义一个元组",{"2":{"96":1}}],["直接返回",{"2":{"184":1}}],["直接看例子",{"2":{"148":1}}],["直接在捕获错误的地方使用",{"2":{"141":1}}],["直接转换成为一个向量",{"2":{"102":1}}],["直接赋值给",{"2":{"43":1}}],["直接一次回收所有分发出去的内存",{"2":{"28":1}}],["直接交互的能力",{"2":{"11":1}}],["迭代索引",{"0":{"157":1}}],["迭代连续的整数很简单",{"2":{"156":1}}],["迭代数字",{"0":{"156":1}}],["迭代数组和切片",{"2":{"155":1}}],["迭代的指针捕获",{"2":{"155":1}}],["迭代的值捕获",{"2":{"155":1}}],["主要用于迭代数组和切片",{"2":{"155":1}}],["答案是",{"2":{"152":1}}],["答案是使用",{"2":{"90":1}}],["解构错误联合类型类似与解构可选类型",{"2":{"152":1}}],["解构错误联合类型",{"0":{"152":1,"168":1}}],["解构可选类型操作很简单",{"2":{"151":1}}],["解构可选类型",{"0":{"151":1,"167":1}}],["解引用方法支持以下几种",{"2":{"78":1}}],["解引用方法是",{"2":{"77":1}}],["三元表达式",{"0":{"149":1}}],["条件必须是错误联合类型",{"2":{"168":1}}],["条件必须是可选类型",{"2":{"167":1}}],["条件",{"0":{"148":1},"1":{"149":1,"150":1,"151":1,"152":1}}],["考虑",{"2":{"147":1}}],["赋值1234",{"2":{"146":1}}],["嗯",{"2":{"145":1}}],["看起来可能没什么不同",{"2":{"145":1}}],["看起来要比",{"2":{"145":1}}],["看一下两者在处理",{"2":{"145":1}}],["野指针",{"2":{"145":1}}],["迷途指针",{"2":{"145":1}}],["却不能保证你出现悬空指针",{"2":{"145":1}}],["却仍然能保持",{"2":{"23":1}}],["缺省时为",{"2":{"190":1}}],["缺省则使用本机作为构建目标",{"2":{"15":1}}],["缺点是并不能保证你的运行时是绝对安全的",{"2":{"145":1}}],["空白",{"0":{"264":1}}],["空引用",{"2":{"145":1}}],["空结构体",{"0":{"94":1}}],["都受命名约定的约束",{"2":{"265":1}}],["都很实用",{"2":{"144":1}}],["都包含一个额外的参数",{"2":{"37":1}}],["堆栈跟踪",{"0":{"144":1}}],["堆栈的嵌套层数最大是",{"2":{"9":1}}],["推荐将资源文件放置在",{"2":{"221":1}}],["推荐将",{"2":{"213":1}}],["推荐使用",{"2":{"213":1}}],["推荐关闭",{"2":{"208":1}}],["推荐安装插件",{"2":{"208":1}}],["推导出的错误集是最小错误集",{"2":{"143":1}}],["推导错误和递归并不兼容",{"2":{"143":1}}],["推断错误集",{"2":{"143":1}}],["另一个程序生成的数据",{"2":{"192":1}}],["另一种是通过",{"2":{"3":1}}],["另外",{"2":{"143":1,"197":1,"289":1}}],["明确声明的错误集",{"2":{"143":1}}],["由",{"2":{"294":1}}],["由内核执行完成进程需要的系统调用函数后再将控制权返回给进程",{"2":{"233":1}}],["由官方维护",{"2":{"208":1}}],["由编译器推导而出的错误集",{"2":{"143":1}}],["由于发行版的不同",{"2":{"217":1}}],["由于依赖了",{"2":{"202":1}}],["由于计算机是二进制的特性",{"2":{"126":1}}],["由于在",{"2":{"100":1}}],["由于没有字段名",{"2":{"96":1}}],["由于",{"2":{"75":1,"108":1,"202":1,"212":1,"251":1}}],["由于涉及到系统调用",{"2":{"31":1}}],["由于这种特性",{"2":{"23":1}}],["由于高级语言的抽象层次过高",{"2":{"2":1}}],["合并为一个命令",{"2":{"224":1,"225":1,"231":1}}],["合并和推断错误",{"0":{"143":1}}],["合并到上游仓库",{"2":{"1":1}}],["释放代码始终紧跟在分配代码之后",{"2":{"142":1}}],["释放内存",{"2":{"27":2}}],["您可以获得强大的错误处理能力",{"2":{"142":1}}],["申请一块内存",{"2":{"142":1}}],["申请内存",{"2":{"26":1,"27":2}}],["给",{"2":{"140":1}}],["想要无条件的解构它",{"2":{"139":1}}],["全局错误集",{"0":{"138":1}}],["全局变量",{"2":{"18":1}}],["程序默认是从此处开始执行",{"2":{"232":1}}],["程序a",{"2":{"192":1}}],["程序单元是应用的最小可测试部件",{"2":{"183":1}}],["程序会在某些时候因为某些我们知道或者不知道的原因出错",{"2":{"135":1}}],["程序的优化",{"2":{"2":1}}],["顶层文档注释",{"2":{"134":3}}],["纪元",{"2":{"134":1}}],["纳秒数",{"2":{"134":1}}],["像odin",{"2":{"293":1}}],["像meson",{"2":{"293":1}}],["像",{"2":{"167":1}}],["像基础的",{"2":{"148":1}}],["像这里就是多行文档注释",{"2":{"134":1}}],["像复合类型",{"2":{"112":1}}],["存在第三方插件",{"2":{"206":1}}],["存在着",{"2":{"112":1}}],["存储时间戳的结构体",{"2":{"134":1}}],["说实话",{"2":{"134":1}}],["说明符更改函数的调用约定",{"2":{"117":1}}],["说明",{"2":{"108":1}}],["了",{"2":{"134":1}}],["了解更多",{"0":{"235":1,"297":1},"2":{"4":1}}],["起到的注释效果相同",{"2":{"134":1}}],["注释",{"0":{"134":1}}],["注意它也是只读的",{"2":{"155":1}}],["注意它是只读的",{"2":{"155":1}}],["注意函数的返回值",{"2":{"139":1}}],["注意浮点数陷阱",{"2":{"126":1}}],["注意我们这里指的是数据类型的范围变小了",{"2":{"271":1}}],["注意我们这里使用的是浮点类型",{"2":{"102":1}}],["注意我们使用的是递归方法来实现斐波那契数列求值",{"2":{"9":1}}],["注意这里",{"2":{"47":1}}],["注意默认情况下它不是线程安全的",{"2":{"27":1}}],["注意",{"2":{"3":1,"4":1,"7":1,"9":1,"13":1,"14":1,"15":1,"32":1,"36":1,"57":1,"73":1,"85":1,"104":1,"131":1,"136":1,"143":1,"185":1,"192":2,"199":1,"200":1,"201":1,"202":2,"249":1,"250":1,"258":1,"282":1}}],["块即可",{"2":{"184":1}}],["块也可以是一个表达式",{"2":{"133":1}}],["块",{"0":{"133":1},"2":{"133":1}}],["块中的多个",{"2":{"51":1}}],["块中时",{"2":{"3":1}}],["慎重使用",{"2":{"132":1}}],["警告",{"2":{"132":1,"138":1,"293":2}}],["⚠️",{"2":{"132":1,"138":1,"293":2}}],["已经是",{"2":{"293":1}}],["已经将",{"2":{"224":1,"225":1,"231":1}}],["已经将上行代码中的",{"2":{"199":1,"200":1}}],["已经将上方代码中的",{"2":{"36":1}}],["已经修改为默认使用",{"2":{"136":1}}],["已知的",{"2":{"131":1}}],["均支持",{"2":{"207":1}}],["均为第三方作者维护",{"2":{"207":1}}],["均可以",{"2":{"199":1}}],["均会被转换为",{"2":{"139":1}}],["均被使用",{"2":{"129":1}}],["均是我们构建的一部分",{"2":{"191":1}}],["均是可以操作的",{"2":{"85":1}}],["均是在内存中连续分配且固定数量的相同类型元素",{"2":{"54":1}}],["格式化字符串使用的是",{"2":{"232":1}}],["格式是",{"2":{"129":1}}],["格式为",{"2":{"35":1}}],["我要说的是你说的基本是对的",{"2":{"293":1}}],["我要告诉你",{"2":{"233":1}}],["我认为",{"2":{"293":1}}],["我认为这个设计并不太好",{"2":{"134":1}}],["我才推荐你来学习它",{"2":{"293":1}}],["我相信你一定是从",{"2":{"231":1}}],["我还未在社区发现高质量的相关包",{"2":{"127":1}}],["我们显示强制截断位",{"2":{"271":1}}],["我们观察并获得的类型信息是",{"2":{"255":1}}],["我们知道系统调用会造成内核上下文切换的开销",{"2":{"233":1}}],["我们只需要正常打印即可",{"2":{"233":1}}],["我们假定",{"2":{"233":1}}],["我们传入的第二个参数是一个元组",{"2":{"232":1}}],["我们先通过",{"2":{"232":1}}],["我们将会单独讲述",{"2":{"224":1}}],["我们已经安装了",{"2":{"222":1}}],["我们就不需要使用else了",{"2":{"173":2}}],["我们就不说了",{"2":{"148":1}}],["我们称之为对",{"2":{"155":2}}],["我们在此处打印必须要要使用",{"2":{"255":1}}],["我们在这里并没有使用",{"2":{"201":1,"202":1}}],["我们在内部尝试解引用后再一次捕获指针来进行操作",{"2":{"152":1}}],["我们在执行此内联汇编会使用",{"2":{"4":1}}],["我们结构后获得",{"2":{"151":1}}],["我们也可以通过编译期函数来实现反射进而访问可选类型",{"2":{"146":1}}],["我们也可以用",{"2":{"79":1}}],["我们尝试调用",{"2":{"145":1}}],["我们很容易能够知道发生了什么",{"2":{"144":1}}],["我们很容易就可以创建一个多维数组出来",{"2":{"56":1}}],["我们并未显示声明返回的错误",{"2":{"143":1}}],["我们这时再使用以上的定义方法未免过于啰嗦",{"2":{"137":1}}],["我们绝对不能在赋值前使用它",{"2":{"132":1}}],["我们来看看维基百科怎么说的",{"2":{"294":1}}],["我们来看一个比较简单的函数",{"2":{"139":1}}],["我们来通过一个简单的程序",{"2":{"231":1}}],["我们来两个例子来说明就可以",{"2":{"143":1}}],["我们来用一个简单的函数作为说明",{"2":{"111":1}}],["我们来几个小小的示例来演示一下",{"2":{"100":1}}],["我们定义了一个元组类型",{"2":{"96":1}}],["我们定义了一个函数",{"2":{"7":1}}],["我们接下来演示一个示例",{"2":{"79":1}}],["我们不在这里使用",{"2":{"73":1}}],["我们还可以使用环绕",{"2":{"272":1}}],["我们还可以使用",{"2":{"173":1}}],["我们还可以使用捕获语法来捕获错误",{"2":{"142":1}}],["我们还可以覆盖枚举的标记值",{"2":{"68":1}}],["我们还可以构建出",{"2":{"24":1}}],["我们放在这里讲解字符串",{"2":{"61":1}}],["我们使用",{"2":{"129":1,"194":1}}],["我们使用语法",{"2":{"57":1,"79":1}}],["我们使用了内存分配的功能",{"2":{"90":1}}],["我们使用了内建函数",{"2":{"70":1}}],["我们使用了编译期的功能",{"2":{"66":1}}],["我们使用了",{"2":{"56":1,"255":1}}],["我们需要了解一下前置知识",{"2":{"237":1}}],["我们需要显示声明要格式化的参量类型",{"2":{"232":1}}],["我们需要引入",{"2":{"13":1}}],["我们需要先梳理一下",{"2":{"6":1}}],["我们通过使用",{"2":{"145":1,"193":1}}],["我们通过",{"2":{"10":1,"184":1}}],["我们通过全局汇编定义了一个汇编函数",{"2":{"3":1}}],["我们用它来进行数据的初始化",{"2":{"9":1}}],["我们可以在内部继续使用",{"2":{"152":1}}],["我们可以这样做",{"2":{"152":1}}],["我们可以这样处理",{"2":{"145":1}}],["我们可以定义多个重复的错误",{"2":{"136":1}}],["我们可以以此代表1970年前",{"2":{"134":1}}],["我们可以仍然可以通过结构体字段的指针来获取到基指针",{"2":{"95":1}}],["我们可以很容易的实现泛型",{"2":{"92":1}}],["我们可以使用",{"2":{"82":1,"132":1,"187":1}}],["我们可以通过",{"2":{"188":1,"192":1}}],["我们可以通过指针来操作其指向内存区域",{"2":{"76":1}}],["我们可以通过使用",{"2":{"68":1}}],["我们可以实现某些其他语言所不具备的方式来操作数组",{"2":{"64":1}}],["我们可以直接将它转化为数组",{"2":{"49":1}}],["我们可以将它作为",{"2":{"24":1}}],["我们可以正常把它当作常量来使用",{"2":{"7":1}}],["我们可以看到",{"2":{"7":1}}],["我们可以稍稍改造它一下",{"2":{"7":1}}],["我们可以尝试给编译期做一个定义",{"2":{"6":1}}],["法",{"2":{"127":1}}],["结果为",{"2":{"253":1}}],["结果为该类型的极限",{"2":{"127":1}}],["结构",{"2":{"255":1}}],["结构大体是这样的",{"2":{"4":1}}],["结构体代表",{"2":{"134":1}}],["结构体会获得一个类似",{"2":{"100":1}}],["结构体进行转换操作",{"2":{"99":1}}],["结构体字段的顺序是由编译器决定的",{"2":{"95":1}}],["结构体允许使用默认值",{"2":{"93":1}}],["结构体的",{"2":{"255":1}}],["结构体的方法除了使用",{"2":{"89":1}}],["结构体的组成",{"2":{"89":1}}],["结构体本身是一个高级的数据结构",{"2":{"88":1}}],["结构体和联合类型会被翻译为",{"2":{"18":1}}],["结构体",{"0":{"88":1,"291":1},"1":{"89":1,"90":1,"91":1,"92":1,"93":1,"94":1,"95":1,"96":1,"97":1,"98":1,"99":1,"100":1},"2":{"3":1,"96":1,"112":1,"249":1,"255":1,"291":1}}],["饱和左移",{"2":{"127":1}}],["饱和乘法",{"2":{"127":1}}],["饱和减法",{"2":{"127":1}}],["饱和加法",{"2":{"127":1}}],["聊点",{"2":{"127":1}}],["按位非",{"2":{"127":1}}],["按位异或",{"2":{"127":1}}],["按位或",{"2":{"127":1}}],["按位与",{"2":{"127":1}}],["按值传递结构和联合类型",{"2":{"112":1}}],["嘛",{"2":{"126":1}}],["受制于浮点精度",{"2":{"126":1}}],["受益于",{"2":{"64":1}}],["受益于这种特性",{"2":{"24":1}}],["负数转换为无符号整数",{"0":{"270":1}}],["负数是从",{"2":{"105":1}}],["负无穷大这些语法",{"2":{"126":1}}],["详见",{"2":{"126":1,"296":1}}],["切换到",{"2":{"126":1}}],["切片本身还有边界检查",{"2":{"86":1}}],["切片本身除了具有",{"2":{"86":1}}],["切片指针",{"0":{"86":1}}],["切片的本质",{"2":{"85":1}}],["切片的使用方式就是类似数组",{"2":{"85":1}}],["切片和数组看起来上很像",{"2":{"85":1}}],["切片长度为",{"2":{"78":1}}],["切片第一个元素为",{"2":{"78":1}}],["切片语法",{"2":{"78":1}}],["切片",{"0":{"43":1,"85":1},"1":{"86":1,"87":1},"2":{"78":1,"85":1,"155":4,"157":1,"289":2}}],["模块获取到了标准输出和错误输出的",{"2":{"233":1}}],["模式构建",{"2":{"190":1}}],["模式下开启",{"2":{"267":1}}],["模式下快速暴露某些错误",{"2":{"190":1}}],["模式下会产生未定义的行为",{"2":{"141":1}}],["模式下会产生恐慌",{"2":{"141":1}}],["模式下",{"2":{"132":1,"176":2}}],["模式",{"2":{"126":2}}],["模型",{"2":{"25":1}}],["任意整数类型",{"2":{"126":1}}],["任意浮点类型",{"2":{"126":1}}],["任何的非",{"2":{"61":1}}],["任何被执行",{"2":{"36":1}}],["任何函数之外",{"2":{"9":1}}],["任何发生运行时对变量的操作将会在编译时报错",{"2":{"8":1}}],["处理溢出",{"2":{"141":1}}],["处理溢出有两种方式",{"2":{"125":1}}],["处理方式有三种",{"2":{"18":1}}],["取否环绕",{"2":{"272":1}}],["取反环绕",{"2":{"125":1}}],["取反",{"2":{"125":1,"272":1}}],["取地址",{"2":{"76":1,"86":1}}],["加强安全性的一种方式",{"2":{"190":1}}],["加减乘除",{"2":{"127":1}}],["加减操作",{"2":{"76":1}}],["加法环绕",{"2":{"125":1,"272":1}}],["加法",{"2":{"125":1}}],["溢出",{"0":{"125":1}}],["$path",{"2":{"221":1}}],["$",{"2":{"124":1}}],["^=",{"2":{"127":1}}],["^",{"2":{"124":4,"127":2,"267":5}}],["求余",{"2":{"124":1}}],["小驼峰命名法",{"2":{"232":1}}],["小于等于",{"2":{"127":1}}],["小于",{"2":{"127":1}}],["小细节",{"2":{"124":1,"134":2,"208":1}}],["小技巧",{"2":{"35":1}}],["二进制可执行程序的构建结果会输出在",{"2":{"195":1}}],["二进制体积小",{"2":{"190":1}}],["二进制体积大",{"2":{"190":3}}],["二进制",{"2":{"123":1}}],["八进制",{"2":{"123":1}}],["十进制",{"2":{"123":1}}],["十六进制",{"2":{"62":1,"123":1}}],["十六进制八位字节值",{"2":{"62":1}}],["描述",{"2":{"122":1}}],["告诉优化器当前函数很少被调用",{"2":{"118":1}}],["高明的可选类型",{"2":{"296":1}}],["高阶使用",{"0":{"114":1},"1":{"115":1,"116":1,"117":1,"118":1,"119":1}}],["高级用法",{"0":{"150":1},"1":{"151":1,"152":1}}],["高级特性",{"0":{"97":1},"1":{"98":1,"99":1,"100":1}}],["高级语言的编译器并不是完美的",{"2":{"2":1}}],["介于内建函数的数目过多",{"2":{"113":1}}],["传递的",{"2":{"201":1,"202":1}}],["传递给包",{"2":{"200":1}}],["传递给构建",{"2":{"198":1}}],["传递参数",{"2":{"199":1,"200":1}}],["传递完全使用值传递",{"2":{"112":1}}],["传入到fiexed",{"2":{"27":2}}],["引用的是malloc的原型",{"2":{"145":1}}],["引用传递",{"2":{"112":2}}],["引入了",{"2":{"232":1}}],["引入模块",{"2":{"37":1}}],["引入包",{"0":{"37":1}}],["引入一种新类型",{"2":{"20":1}}],["引入的代码时打印缓存文件的存储位置",{"2":{"17":1}}],["引入外部的内联汇编",{"2":{"2":1}}],["值传递",{"2":{"112":2}}],["值得一提的是",{"2":{"134":1}}],["值得一看",{"2":{"32":1}}],["值得注意的是",{"2":{"89":1,"126":1,"192":1,"210":1,"255":1}}],["泛型",{"2":{"111":1}}],["泛型实现",{"0":{"92":1}}],["虽然是",{"2":{"108":1}}],["应该使用",{"2":{"265":1}}],["应该会注意到",{"2":{"108":1}}],["应使用",{"2":{"265":2}}],["应尽量避免使用",{"2":{"138":1}}],["应当避免使用此类型",{"2":{"20":1}}],["应当只存在一个",{"2":{"13":1}}],["绝非我们平常所指的单个文字",{"2":{"107":1}}],["码表中的内容",{"2":{"108":1}}],["码表的值来替换字符",{"2":{"108":1}}],["码表的值",{"2":{"107":1}}],["码点",{"2":{"62":1}}],["码点中使用",{"2":{"61":1}}],["码点字面量类型是",{"2":{"61":1}}],["往往都是",{"2":{"107":1}}],["往往是由于错误的内存管理引起的",{"2":{"25":1}}],["挑选出来的元素",{"2":{"105":1}}],["变小",{"2":{"105":1}}],["变大",{"2":{"105":1}}],["变量名是time",{"2":{"194":1}}],["变量等这些提供注释",{"2":{"134":1}}],["变量是在内存中存储值的单元",{"2":{"129":1}}],["变量声明和",{"2":{"294":1}}],["变量声明",{"0":{"129":1},"1":{"130":1,"131":1,"132":1}}],["变量的声明和定义是编程语言中最基础且最常见的操作之一",{"2":{"128":1}}],["变量的长度",{"2":{"105":1}}],["变量",{"2":{"9":1,"85":1,"129":1,"132":1}}],["变量可以也标记上",{"2":{"8":1}}],["从本质上看",{"2":{"295":1}}],["从现代语言中采用的功能包括添加编译时泛型类型",{"2":{"294":1}}],["从而提高开发人员的工作效率",{"2":{"207":1}}],["从",{"2":{"105":2,"106":1,"144":1}}],["选出指定索引的值",{"2":{"105":2}}],["或许",{"2":{"295":1}}],["或许可能有人会跟我说",{"2":{"293":1}}],["或许有人使用",{"2":{"293":1}}],["或许将来可能是",{"2":{"293":1}}],["或方法",{"2":{"262":1}}],["或不被调用",{"2":{"118":1}}],["或",{"2":{"105":3,"106":1}}],["或者其他工具提供更好的帮助说明",{"2":{"266":1}}],["或者其他线程等等",{"2":{"4":1}}],["或者手动编译",{"2":{"208":1}}],["或者使用",{"2":{"202":1}}],["或者是让",{"2":{"178":1}}],["或者是一个",{"2":{"139":1,"140":1}}],["或者具有",{"2":{"170":1}}],["或者向量",{"2":{"105":1}}],["或者普通结构体",{"2":{"98":1}}],["或者对某一种特定对象的计数",{"2":{"67":1}}],["或者游戏事件循环之类的",{"2":{"28":1}}],["或者",{"2":{"16":1,"122":1,"130":1,"145":1,"178":1}}],["或者我们可以手动执行构建",{"2":{"13":1}}],["或者称之为破坏更合适",{"2":{"4":1}}],["组成一个新的向量",{"2":{"105":1}}],["生成某些特定的文件",{"2":{"200":1}}],["生成一个向量",{"2":{"103":1}}],["生成数据结构",{"0":{"10":1}}],["过长的向量长度",{"2":{"102":1}}],["比",{"2":{"293":1}}],["比目标机器的",{"2":{"102":1}}],["比较远算符",{"2":{"102":1}}],["~x",{"2":{"127":1}}],["~",{"2":{"102":1,"105":2,"127":1,"208":1,"221":6}}],["算术运算符",{"2":{"102":1}}],["算是一个比较巧妙的例子",{"2":{"4":1}}],["浮点转换整数发生越界",{"0":{"283":1}}],["浮点运算时遵循",{"2":{"126":1}}],["浮点字面量则是具有",{"2":{"126":1}}],["浮点数在某些操作上是反直觉的",{"2":{"126":1}}],["浮点数有",{"2":{"126":1}}],["浮点数就是表示带有小数点的数字",{"2":{"126":1}}],["浮点数",{"0":{"126":1}}],["浮点数同理",{"2":{"41":1}}],["浮点",{"2":{"101":1}}],["整型",{"2":{"101":1,"112":1}}],["整数溢出",{"0":{"272":1}}],["整数就是",{"2":{"232":1}}],["整数类型允许的最大位宽为65535",{"2":{"122":1}}],["整数字面量的类型",{"2":{"122":1}}],["整数",{"0":{"121":1,"288":1},"1":{"122":1,"123":1,"124":1,"125":1},"2":{"50":1,"288":1}}],["整数可以转换为可以表示旧类型全部值的整数类型",{"2":{"41":1}}],["整数与浮点数拓宽",{"0":{"41":1}}],["布尔这种",{"2":{"112":1}}],["布尔值有两个",{"2":{"109":1}}],["布尔值",{"0":{"109":1}}],["布尔值往往通过二进制的",{"2":{"107":1}}],["布尔",{"2":{"101":1}}],["基于一套规则来进行命名",{"2":{"100":1}}],["基本都是遵循的c",{"2":{"293":1}}],["基本类型",{"0":{"128":1},"1":{"129":1,"130":1,"131":1,"132":1,"133":1,"134":1}}],["基本",{"2":{"108":1}}],["基本使用",{"0":{"102":1,"111":1,"136":1,"170":1,"178":1,"184":1},"2":{"162":1}}],["基本语法",{"0":{"89":1}}],["基本就要和",{"2":{"24":1}}],["待需要时再来学习即可",{"2":{"97":1}}],["待添加详细注释",{"2":{"201":1}}],["待添加",{"2":{"33":1}}],["匿名模块还支持直接使用其他程序输出",{"2":{"199":1}}],["匿名",{"2":{"96":1}}],["返回错误时",{"2":{"184":1}}],["返回错误时我们想将它向上传递",{"2":{"139":1}}],["返回错误时我们准备一个默认值",{"2":{"139":1}}],["返回值时触发",{"2":{"164":1}}],["返回的是一个",{"2":{"179":1}}],["返回的是一个结构体类型",{"2":{"10":1}}],["返回的错误类型将会由",{"2":{"143":1}}],["返回一个错误",{"2":{"144":1}}],["返回一个",{"2":{"134":1}}],["返回所有元素是",{"2":{"105":1}}],["返回向量",{"2":{"105":1}}],["返回对应的结构体基指针",{"2":{"95":1}}],["后面再来学习",{"2":{"232":1}}],["后面加数字即可",{"2":{"122":1}}],["后记",{"0":{"230":1}}],["后跟任意字母数字或下划线",{"2":{"130":1}}],["后续会讲解",{"2":{"127":1}}],["后续我们会专门讲解泛型这一个利器",{"2":{"92":1}}],["后还是",{"2":{"127":1}}],["后端开发库",{"2":{"53":1}}],["q",{"2":{"202":1}}],["quarter4",{"2":{"99":2}}],["quarter3",{"2":{"99":2}}],["quot",{"2":{"4":2,"62":1,"96":4,"125":2,"130":2,"188":2,"201":2,"202":2,"272":14}}],["qq",{"2":{"90":1}}],["命令初始化一个项目",{"2":{"231":1}}],["命令创建出来的",{"2":{"225":1}}],["命令",{"0":{"222":1},"1":{"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"229":1},"2":{"218":1,"222":1}}],["命令来执行测试",{"2":{"197":1}}],["命令行参数",{"0":{"15":1},"2":{"186":2}}],["命名法",{"2":{"265":10}}],["命名",{"0":{"265":1}}],["命名须以",{"2":{"130":1}}],["命名规则",{"0":{"100":1}}],["命名空间来实现内存排序",{"2":{"236":1}}],["命名空间",{"2":{"90":1,"265":1}}],["专属语法",{"2":{"293":1}}],["专有名词或任何其他在书面英语中具有大写规则的单词与任何其他单词一样",{"2":{"265":1}}],["专门处理上面这种语法",{"2":{"185":1}}],["专门为匿名结构体和文件类的类型声明",{"2":{"90":1}}],["专为关键任务安全性和性能而设计的分布式财务会计数据库",{"2":{"53":1}}],["平常使用过程中会面临另外的一个情况",{"2":{"90":1}}],["首字母缩写词",{"2":{"265":1}}],["首字母缩略词",{"2":{"265":1}}],["首先",{"2":{"233":1}}],["首先确保你的路径是正确的",{"2":{"215":1}}],["首先我们和",{"2":{"145":1}}],["首先是一个内联汇编的语句",{"2":{"4":1}}],["首部关键字",{"2":{"89":1}}],["显示声明运行依赖于构建",{"2":{"192":1}}],["显示声明切片类型",{"2":{"87":1}}],["显式强制转换为错误的子集",{"2":{"50":1}}],["显式强制转换对齐",{"2":{"50":1}}],["显式强制转换是通过内建函数完成的",{"2":{"50":1}}],["显式强制转换",{"0":{"50":1}}],["显式声明包含的源文件",{"2":{"35":1}}],["保证内存布局和声明顺序相同并且尽量紧凑",{"2":{"182":1}}],["保证内存布局与目标",{"2":{"181":1}}],["保证我们这里的",{"2":{"145":1}}],["保证错误一定是目标错误集的值",{"2":{"138":1}}],["保证切片不会被优化为数组指针",{"2":{"86":1}}],["保证使用",{"2":{"81":1}}],["边界使用变量",{"2":{"86":1}}],["属性",{"2":{"86":1}}],["属性外",{"2":{"86":1}}],["属于是一个约束",{"2":{"4":1}}],["右边界值为",{"2":{"85":1}}],["右侧是倍数",{"2":{"59":1}}],["规则",{"2":{"85":1}}],["规范兼容",{"2":{"53":1}}],["左侧",{"2":{"139":1}}],["左移右移",{"2":{"127":1}}],["左边界值为0",{"2":{"85":1}}],["左闭右开",{"2":{"85":1}}],["左右的大小",{"2":{"23":1}}],["遵循",{"2":{"85":1,"112":1}}],["修改方法为",{"2":{"212":1}}],["修改为更加精确的类型",{"2":{"16":1}}],["修饰的",{"2":{"185":1}}],["修饰",{"2":{"112":1}}],["修饰符后",{"2":{"83":1}}],["尝试解开错误联合类型",{"0":{"277":1}}],["尝试解开可选类型",{"0":{"276":1}}],["尝试刷新buffer",{"2":{"233":1}}],["尝试运行命令并捕获标准输出",{"2":{"200":1}}],["尝试添加一个静态库",{"2":{"195":1}}],["尝试在设置内存对齐后再进行类型比较",{"2":{"82":1}}],["尝试比较类型",{"2":{"82":1}}],["架构的指针对齐大小",{"2":{"82":1}}],["架构",{"2":{"82":1,"195":1}}],["找出任何类型的内存对齐大小",{"2":{"82":1}}],["数据截断",{"0":{"271":1}}],["数据c",{"2":{"192":1}}],["数值类型是语言运行时的基本类型",{"2":{"120":1}}],["数值类型",{"0":{"120":1},"1":{"121":1,"122":1,"123":1,"124":1,"125":1,"126":1,"127":1}}],["数个字节",{"2":{"82":1}}],["数组和切片",{"0":{"289":1}}],["数组和切片的指针都存储了长度",{"2":{"78":1}}],["数组或者切片",{"2":{"158":1}}],["数组或切片",{"2":{"87":1}}],["数组等",{"2":{"112":1}}],["数组指针进行切片操作",{"2":{"85":1}}],["数组指针赋值给多项指针",{"2":{"43":1}}],["数组第一个元素为",{"2":{"78":1}}],["数组之间可以使用",{"2":{"60":1}}],["数组才会有索引为数组长度的元素",{"2":{"57":1}}],["数组最后一个元素值",{"2":{"57":1}}],["数组长度为",{"2":{"57":1,"78":1}}],["数组元素是连续放置的",{"2":{"55":1}}],["数组的分配和",{"2":{"54":1}}],["数组是日常敲代码使用相当频繁的类型之一",{"2":{"54":1}}],["数组",{"0":{"43":1,"54":1},"1":{"55":1,"56":1,"57":1,"58":1,"59":1,"60":1,"61":1,"62":1,"63":1,"64":1,"65":1,"66":1},"2":{"78":1,"127":4,"155":2,"289":1}}],["每个级别都包含上一个级别的所有保证",{"2":{"237":1}}],["每个文件可以使用",{"2":{"197":1}}],["每种类型都有一个对齐方式",{"2":{"82":1}}],["每次执行分配时",{"2":{"31":1}}],["副作用",{"2":{"81":2}}],["等到要打印的内容都到一定程度后再一次性全部",{"2":{"233":1}}],["等到你需要时再来查看",{"2":{"82":1}}],["等到你需要时再来学习即可",{"2":{"80":1}}],["等",{"2":{"198":1}}],["等情况的出现",{"2":{"145":1}}],["等你需要时再来查看",{"2":{"81":1}}],["等待",{"2":{"1":1}}],["额外特性",{"0":{"80":1},"1":{"81":1,"82":1,"83":1,"84":1}}],["额外内容",{"0":{"22":1},"1":{"23":1,"24":1}}],["索引越界访问",{"0":{"269":1}}],["索引",{"2":{"87":1}}],["索引语法",{"2":{"78":1}}],["索引它们会返回独立的字节",{"2":{"61":1}}],["尤其是在切片中",{"2":{"76":1}}],["符号来获取某个变量所对应的内存地址",{"2":{"76":1}}],["常规的运算可能导致溢出",{"2":{"272":1}}],["常规的运算有等于",{"2":{"127":1}}],["常量",{"0":{"131":1},"2":{"129":1,"131":1,"262":1,"264":1}}],["常量声明和方法的定义",{"2":{"75":1}}],["常见的加减乘除我们就不聊了",{"2":{"127":1}}],["常用于函数无返回值",{"2":{"287":1}}],["常用于单元测试和调试",{"2":{"126":1}}],["常用于流程控制",{"2":{"109":1}}],["常用于与",{"2":{"75":1}}],["常常在你需要缓冲某些东西时使用",{"2":{"27":1}}],["拥有不同的变量",{"2":{"75":1}}],["兼容",{"2":{"73":1,"181":1}}],["兼容的库供其他程序使用",{"2":{"11":1}}],["非常强大的构建系统",{"2":{"296":1}}],["非常好",{"2":{"293":1}}],["非常的全面",{"2":{"222":1}}],["非公共成员需要我们手动以",{"2":{"185":1}}],["非必要不使用",{"2":{"160":1,"165":1}}],["非",{"2":{"99":1}}],["非详尽枚举",{"0":{"72":1}}],["非utf",{"2":{"61":1}}],["要么全部不完成",{"2":{"236":1}}],["要以编程方式跳过测试",{"2":{"186":1}}],["要更加灵活",{"2":{"85":1}}],["要注意的是",{"2":{"70":1}}],["要在编译使用",{"2":{"17":1}}],["没错误就正常执行",{"2":{"141":1}}],["没错",{"2":{"69":1}}],["没有对应的声明",{"2":{"256":1}}],["没有任何问题",{"2":{"41":1}}],["没有运行时开销的原因",{"2":{"25":1}}],["没有具体的定义",{"2":{"18":1}}],["覆盖部分值",{"2":{"68":1}}],["现在跨语言调用",{"2":{"293":1}}],["现在已经不再是一门语言",{"2":{"293":1}}],["现在我要告诉你",{"2":{"232":1}}],["现在我们可以在",{"2":{"68":1}}],["现在",{"2":{"222":1}}],["现在它的值可以是",{"2":{"145":1}}],["现代操作系统页大小最小为4k",{"2":{"31":1}}],["现代化内核编写时均会使用汇编来完成一些初始化工作",{"2":{"2":1}}],["声明可以使用",{"2":{"288":1}}],["声明混入到当前的容器中",{"2":{"250":1}}],["声明变量",{"2":{"129":1}}],["声明枚举",{"0":{"68":1}}],["声明函数调用约定为",{"2":{"21":1}}],["举常常用来列出一个有限集合的任何成员",{"2":{"67":1}}],["举个比较剑走偏锋的例子",{"2":{"24":1}}],["讲解",{"2":{"66":1}}],["自旋锁",{"0":{"246":1}}],["自纪元开始后的秒数",{"2":{"134":1}}],["自引用",{"0":{"90":1}}],["自身的语言特性",{"2":{"64":1}}],["自动代码重构并且深度整合",{"2":{"207":1}}],["自动推断",{"0":{"91":1,"180":1},"2":{"180":1}}],["自动转换到",{"2":{"46":1}}],["自动转换",{"2":{"43":1,"49":1}}],["自动完成",{"2":{"39":1}}],["自动构建",{"2":{"1":1}}],["奇技淫巧",{"0":{"64":1},"1":{"65":1,"66":1}}],["行尾不会包含在字符串中",{"2":{"63":1}}],["多匹配项",{"2":{"171":1}}],["多目标迭代",{"0":{"158":1}}],["多个",{"2":{"202":1}}],["多个匹配",{"2":{"173":2}}],["多个重复的错误",{"2":{"136":1}}],["多个声明",{"2":{"89":1}}],["多个字段",{"2":{"89":1}}],["多项指针的类型为",{"2":{"78":1}}],["多项指针指向位置数量的多个元素",{"2":{"78":1}}],["多项指针",{"0":{"78":1},"1":{"79":1}}],["多行字符串没有转义",{"2":{"63":1}}],["多行字符串",{"0":{"63":1}}],["多维数组",{"0":{"56":1},"2":{"56":1}}],["位同理",{"2":{"122":1}}],["位操作符",{"2":{"102":1}}],["位或者多位",{"2":{"62":1}}],["位",{"2":{"62":1,"108":1,"122":2}}],["双引号",{"2":{"62":1}}],["制表符",{"2":{"62":1}}],["回车",{"2":{"62":1}}],["回收p2",{"2":{"32":1}}],["换另一个文件就不行了",{"2":{"256":1}}],["换一种方式",{"0":{"233":1}}],["换行符号",{"2":{"63":1}}],["换行",{"2":{"62":1}}],["换种说法",{"2":{"57":1}}],["含义",{"2":{"62":1}}],["⚡",{"2":{"61":1}}],["💯",{"2":{"61":3}}],["串联",{"0":{"60":1},"2":{"127":1}}],["98222",{"2":{"123":1}}],["9",{"2":{"59":2,"139":1,"152":2,"160":1,"161":2,"166":2,"171":1,"202":2}}],["99",{"2":{"8":4}}],["运算可能出现溢出",{"2":{"272":1}}],["运算的优先级",{"2":{"127":1}}],["运算",{"0":{"127":1}}],["运算符就表示我们选择捕获这个值对应的指针",{"2":{"151":1}}],["运算符将两个错误合并到一起",{"2":{"143":1}}],["运算符右侧必须是一个与其左侧函数返回的错误联合类型展开后的类型一致",{"2":{"140":1}}],["运算符",{"2":{"96":1,"105":1}}],["运算符左侧是数组",{"2":{"59":1}}],["运行",{"2":{"222":1}}],["运行的",{"2":{"201":1,"202":1}}],["运行而不是构建缓存中运行",{"2":{"192":1}}],["运行程序的目标计算机",{"2":{"122":1}}],["运行时参数传递",{"2":{"201":1,"202":1}}],["运行时如果出错会给出完整的堆栈跟踪",{"2":{"124":1}}],["运行时可知",{"2":{"85":1}}],["运行时",{"2":{"53":1,"124":1}}],["哨兵终止的切片允许元素访问",{"2":{"87":1}}],["哨兵切片认定哨兵位置处的元素是哨兵值",{"2":{"87":1}}],["哨兵切片也可以使用切片语法",{"2":{"87":1}}],["哨兵切片",{"0":{"87":1}}],["哨兵",{"2":{"79":1}}],["哨兵指针就和哨兵数组类似",{"2":{"79":1}}],["哨兵指针",{"0":{"79":1}}],["哨兵值为",{"2":{"57":1}}],["哨兵数组",{"0":{"57":1}}],["长度无关",{"2":{"289":1}}],["长度",{"2":{"60":1,"78":1,"85":1,"127":2}}],["长度为",{"2":{"57":1}}],["长度固定",{"2":{"54":1}}],["原因在于",{"2":{"253":1}}],["原型为",{"2":{"253":1}}],["原子级别讲解等",{"2":{"246":1}}],["原子性分为六个级别",{"2":{"237":1}}],["原子数据结构",{"0":{"245":1},"2":{"236":1}}],["原子操作的顺序级别",{"2":{"237":1}}],["原子操作是指一个或一系列的操作",{"2":{"236":1}}],["原子操作是在多线程环境中非常重要的一个概念",{"2":{"236":1}}],["原子操作",{"0":{"236":1},"1":{"237":1,"238":1,"239":1,"240":1,"241":1,"242":1,"243":1,"244":1,"245":1,"246":1}}],["原本",{"2":{"207":1}}],["原始类型",{"2":{"112":1}}],["原则上不允许忽略函数的返回值",{"2":{"111":1}}],["原文档应该是",{"2":{"57":1}}],["原生支持",{"2":{"53":1}}],["很适合你",{"2":{"295":1}}],["很像",{"2":{"295":1}}],["很好",{"2":{"293":1}}],["很好的运行效率",{"2":{"190":1}}],["很显然",{"2":{"274":1}}],["很简单",{"2":{"231":1}}],["很抱歉",{"2":{"57":1}}],["很明显就应该是",{"2":{"126":1}}],["很明显",{"2":{"7":1}}],["循环结束并且没有经过",{"2":{"164":1}}],["循环结束前执行",{"2":{"142":1}}],["循环用于重复执行表达式",{"2":{"162":1}}],["循环要求迭代的值和捕获的值均是编译期已知的",{"2":{"161":1}}],["循环展开",{"2":{"161":1,"166":1}}],["循环是另一种循环处理方式",{"2":{"155":1}}],["循环分为两种",{"2":{"154":1}}],["循环的作用域中",{"2":{"142":1}}],["循环",{"0":{"154":1},"1":{"155":1,"156":1,"157":1,"158":1,"159":1,"160":1,"161":1,"162":1,"163":1,"164":1,"165":1,"166":1,"167":1,"168":1},"2":{"56":1,"66":1}}],["循环将会被自动内联",{"2":{"8":1}}],["|field|",{"2":{"255":1}}],["|foo|",{"2":{"145":1}}],["|args|",{"2":{"192":1,"199":1,"200":1,"201":1,"202":1}}],["|arr",{"2":{"56":1}}],["|decl|",{"2":{"185":1}}],["|num",{"2":{"175":1}}],["|number|",{"2":{"141":2}}],["|slice|",{"2":{"175":1}}],["|x|",{"2":{"167":1,"168":1}}],["|idx|",{"2":{"175":1}}],["|item|",{"2":{"173":2}}],["|i",{"2":{"158":1}}],["|i|",{"2":{"156":1,"161":2}}],["|optional",{"2":{"152":1}}],["|real",{"2":{"151":1}}],["|leftover",{"2":{"141":1}}],["|err|",{"2":{"141":2,"142":1,"152":3,"168":2}}],["|ele",{"2":{"85":1}}],["|c|",{"2":{"139":1}}],["|=",{"2":{"127":4}}],["||",{"2":{"127":1,"143":1}}],["|",{"2":{"66":1,"102":1,"127":8,"141":2,"151":1,"152":9,"155":1,"160":8,"173":2,"179":1,"192":5,"202":2,"246":2}}],["|value",{"2":{"157":1}}],["|value|",{"2":{"152":1,"155":1,"159":1,"167":2,"168":2,"179":1}}],["|val",{"2":{"56":1}}],["矩阵乘",{"2":{"127":1}}],["矩阵",{"2":{"56":1,"127":1}}],["创建出来的",{"2":{"225":1}}],["创建目录",{"2":{"220":1}}],["创建了一个",{"2":{"194":1}}],["创建一个运行",{"2":{"201":1,"202":1}}],["创建一个",{"2":{"191":1,"194":1}}],["创建一个节点均为",{"2":{"191":1}}],["创建一个新的分支",{"2":{"1":1}}],["创建数组",{"0":{"55":1},"1":{"56":1}}],["元组还有一个和数组一样的字段",{"2":{"96":1}}],["元组实际上就是不指定字段的",{"2":{"96":1}}],["元组",{"0":{"96":1}}],["元组和数组",{"0":{"49":1}}],["元素类型",{"2":{"60":1}}],["元素",{"2":{"56":1}}],["元素必须有相同的类型",{"2":{"54":1}}],["因此我更愿意称之为",{"2":{"293":1}}],["因此我们可以通过操控指针来修改其值",{"2":{"151":1}}],["因此它的反射是在编译期实现的",{"2":{"251":1}}],["因此它们除了指针默认的语法外",{"2":{"78":1}}],["因此",{"2":{"211":1}}],["因此该错误集是可以被编译器自动推导的",{"2":{"139":1}}],["因此不能保证代码可以观察到它",{"2":{"132":1}}],["因此如果想把非",{"2":{"61":1}}],["因此数组有以下三点特性",{"2":{"54":1}}],["因为相当于不存在",{"2":{"287":1}}],["因为如果有可执行二进制程序构建使用了",{"2":{"195":1}}],["因为你经常需要和编译期斗智斗勇",{"2":{"145":1}}],["因为错误类型在",{"2":{"135":1}}],["因为内核本身应当是一个不会退出的程序",{"2":{"116":1}}],["因为它和",{"2":{"160":1,"165":1}}],["因为它会阻止编译器在编译期就检测出可能存在的错误",{"2":{"138":1}}],["因为它相对数组来说",{"2":{"85":1}}],["因为它有对应的类型",{"2":{"47":1}}],["因为它也是唯一值",{"2":{"47":1}}],["因为值没有任何变化",{"2":{"40":1}}],["因为",{"2":{"20":1,"41":2,"108":1,"253":1,"271":1}}],["因为编译期会在编译期隐式内联",{"2":{"7":1}}],["吃豆人游戏的",{"2":{"53":1}}],["斯沃克兰的传说",{"2":{"53":1}}],["游戏",{"2":{"53":1}}],["游泳起来像鸭子",{"2":{"7":1}}],["依赖上方构建的",{"2":{"197":1}}],["依赖step",{"2":{"196":1}}],["依赖它即可",{"2":{"192":1}}],["依赖于前面的运行",{"2":{"201":1,"202":1}}],["依赖于构建",{"2":{"201":1,"202":1}}],["依赖于",{"2":{"192":1,"199":1,"200":1}}],["依赖一个库",{"2":{"192":1}}],["依赖项",{"2":{"35":1}}],["依次线性排列",{"2":{"54":1}}],["依托于",{"2":{"53":1,"92":1}}],["速度极快的",{"2":{"53":1}}],["社区",{"0":{"52":1}}],["到现在已经处于一种较为割裂的存在",{"2":{"293":1}}],["到枚举大小等价整数类型的安全语义",{"2":{"72":1}}],["到",{"2":{"51":4}}],["执行实现泛型和反射",{"2":{"296":1}}],["执行系统调用",{"2":{"233":1}}],["执行以下命令",{"2":{"215":1}}],["执行其他命令",{"0":{"200":1},"1":{"201":1,"202":1,"203":1}}],["执行单元测试",{"2":{"197":1}}],["执行时会仅执行文件内的顶级测试块",{"2":{"185":1}}],["执行",{"2":{"160":1,"165":1}}],["执行相加的操作",{"2":{"102":1}}],["执行检查内存是否相等",{"2":{"51":1}}],["执行的时期",{"2":{"6":1}}],["截断位",{"2":{"50":1}}],["有异曲同工之妙",{"2":{"296":1}}],["有几点是非常值得单独拿出来说明一下的",{"2":{"296":1}}],["有一些类型是特殊的零位类型",{"2":{"286":1}}],["有两种方案可以选择",{"2":{"208":1}}],["有意思的是",{"2":{"190":1}}],["有时我们需要针对不同的错误做更为细致的处理",{"2":{"141":1}}],["有的错误我们可以预知并处理",{"2":{"135":1}}],["有关浮点运算的模式",{"2":{"126":1}}],["有以下默认操作可以导致溢出",{"2":{"125":1}}],["有符号指针大小的整数",{"2":{"122":1}}],["有符号128位整数",{"2":{"122":1}}],["有符号16位整数",{"2":{"122":1}}],["有符号64位整数",{"2":{"122":1}}],["有符号32位整数",{"2":{"122":1}}],["有符号8位整数",{"2":{"122":1}}],["有且只有一个选择",{"2":{"111":1}}],["有些错误我们无法预知",{"2":{"135":1}}],["有些转换在运行时无操作",{"2":{"50":1}}],["有些转换是安全的",{"2":{"50":1}}],["有些是执行语言级断言",{"2":{"50":1}}],["有许多分配器示例可供查看以获取灵感",{"2":{"33":1}}],["字母",{"2":{"130":1}}],["字节对齐",{"2":{"281":1}}],["字节写入未定义的内存",{"2":{"132":1}}],["字节放入字符串中",{"2":{"61":1}}],["字节均会被作为",{"2":{"61":1}}],["字符",{"0":{"108":1},"2":{"107":1}}],["字符与布尔值",{"0":{"107":1},"1":{"108":1,"109":1}}],["字符看待",{"2":{"61":1}}],["字符串可以使用",{"2":{"61":1}}],["字符串是没有独立的类型的",{"2":{"61":1}}],["字符串",{"0":{"61":1},"1":{"62":1,"63":1},"2":{"184":1}}],["字面量",{"2":{"123":1}}],["字面量推导是错误的",{"2":{"47":1}}],["字面量供",{"2":{"47":2}}],["字段的",{"2":{"265":1}}],["字段类型",{"2":{"255":1}}],["字段会被尽量压缩为占用尽可能小的",{"2":{"99":1}}],["字段严格按照声明的顺序排列",{"2":{"99":1}}],["字段默认值",{"0":{"93":1}}],["字段更换为",{"2":{"36":1,"199":1,"200":1}}],["字段",{"2":{"35":1,"201":1,"202":1}}],["字段是当前",{"2":{"35":1}}],["先使用",{"2":{"231":1}}],["先列出通过包管理器安装",{"2":{"217":1}}],["先通过",{"2":{"197":1}}],["先来看一下在",{"2":{"134":1}}],["先转为长度为",{"2":{"43":1}}],["先在",{"2":{"34":1}}],["单独的一门语言",{"2":{"293":1}}],["单独创建一个source目录",{"2":{"208":1}}],["单元测试的是实现非常简单",{"2":{"184":1}}],["单元测试",{"0":{"183":1},"1":{"184":1,"185":1,"186":1,"187":1,"188":1},"2":{"183":1}}],["单语句多语句",{"2":{"163":1}}],["单个数字",{"2":{"102":1}}],["单个字节的分配可能会剩下数千的字节无法使用",{"2":{"31":1}}],["单项指针的类型为",{"2":{"77":1}}],["单项指针指向单个元素",{"2":{"77":1}}],["单项指针",{"0":{"77":1}}],["单项指针可以赋值给长度只有",{"2":{"43":1}}],["单引号",{"2":{"62":1}}],["允许函数处理各种数据",{"2":{"294":1}}],["允许预测",{"2":{"197":1}}],["允许构建器读取来自命令行参数的构建优化模式",{"2":{"191":1}}],["允许构建器读取来自命令行参数的构建目标三元组",{"2":{"191":1}}],["允许编译器在编译时显示生成所有分支",{"2":{"175":1}}],["允许我们通过非常规的方式来声明一个类型",{"2":{"261":1}}],["允许我们通过一个整数来反推一个枚举",{"2":{"72":1}}],["允许我们观察已有的类型",{"2":{"251":1}}],["允许我们将一些信息传递到项目中",{"2":{"194":1}}],["允许我们获取字段指针",{"2":{"99":1}}],["允许我们不列出所有的枚举值",{"2":{"72":1}}],["允许",{"2":{"53":1}}],["允许自动转换为错误联合类型",{"2":{"45":1}}],["允许自动转换为可选类型",{"2":{"44":1}}],["允许直接将数组的指针赋值给切片",{"2":{"43":1}}],["允许地址为",{"2":{"20":1}}],["your",{"2":{"215":4}}],["y++",{"2":{"202":2}}],["y3",{"2":{"202":1}}],["y0",{"2":{"202":1}}],["y",{"2":{"43":2,"44":1,"45":1,"46":1,"91":2,"95":4,"127":1,"133":3,"173":3,"176":2,"202":23,"254":3,"258":6,"259":1}}],["y2",{"2":{"43":1,"202":1}}],["y1",{"2":{"43":1,"44":1,"202":1}}],["892159",{"2":{"267":1}}],["8编码",{"2":{"212":1}}],["8",{"2":{"42":1,"60":2,"61":6,"62":1,"68":1,"90":1,"102":1,"106":1,"108":1,"173":2,"202":5,"212":2,"262":1,"265":1}}],["86899cd499e4c3f94aa141e400ac265f",{"2":{"17":1}}],["最优和可重用的软件",{"2":{"294":1}}],["最常用的一个",{"2":{"198":1}}],["最好将指针分配给",{"2":{"76":1}}],["最终得到一个标量",{"2":{"104":1}}],["最终",{"2":{"42":2}}],["最后将可执行文件",{"2":{"220":1}}],["最后将整个",{"2":{"194":1}}],["最后释放内存",{"2":{"28":1}}],["最后一定要加",{"2":{"15":1}}],["得到指针类型为",{"2":{"86":1}}],["得到的是单项指针",{"2":{"86":1}}],["得到结果再转换为",{"2":{"42":2}}],["得益于",{"2":{"13":1,"198":1}}],["转到",{"2":{"168":1}}],["转换到所有错误集",{"2":{"138":1}}],["转换到超集",{"2":{"136":1}}],["转换为",{"2":{"42":2,"50":2}}],["转义字符",{"0":{"62":1},"2":{"62":1}}],["转为",{"2":{"41":2}}],["立即数整数和浮点数出现歧义",{"0":{"42":1}}],["kelley",{"2":{"294":1}}],["kernel32",{"2":{"116":1}}],["kernel",{"2":{"4":1}}],["koino",{"2":{"53":1}}],["k",{"2":{"41":2}}],["just",{"2":{"245":1}}],["jinzhongjia",{"2":{"208":1}}],["j++",{"2":{"202":1}}],["j|",{"2":{"158":1}}],["json",{"2":{"200":1}}],["js",{"2":{"53":1}}],["j",{"2":{"41":2,"163":4,"202":5}}],["相对于build",{"2":{"201":1,"202":1}}],["相对来说",{"2":{"145":1}}],["相同",{"2":{"60":1,"199":1}}],["相关的社区",{"2":{"52":1}}],["相等",{"2":{"41":2,"43":1}}],["相当于是",{"2":{"75":1}}],["相当于",{"2":{"15":2}}],["肯定可以容纳",{"2":{"41":1}}],["子集转为超集",{"2":{"40":1}}],["限制",{"2":{"40":1}}],["限制更严格",{"0":{"40":1}}],["增加新的示例",{"2":{"255":1}}],["增加更多的讲解",{"2":{"246":1}}],["增加代码出错",{"2":{"138":1}}],["增加",{"2":{"40":1}}],["大多数编译时无法检测到的未定义行为均会在运行时被检测到",{"2":{"267":1}}],["大致的图如下",{"2":{"192":1}}],["大致的规则如下",{"2":{"39":1}}],["大于等于",{"2":{"127":1}}],["大于",{"2":{"127":1}}],["大端和小端",{"2":{"99":1}}],["大小长的向量将编译为多个",{"2":{"102":1}}],["大小短的向量的操作通常会编译为单个",{"2":{"102":1}}],["大小和对齐方式的新类型",{"2":{"74":1}}],["大小为止的类型",{"2":{"12":1}}],["大的内存对齐转为小的内存对齐",{"2":{"40":1}}],["出现时机",{"2":{"39":1}}],["普通用户选择",{"2":{"215":1,"219":1}}],["普通构建",{"0":{"191":1}}],["普通结构体不同",{"2":{"99":1}}],["普通类型转换",{"0":{"39":1},"1":{"40":1,"41":1,"42":1,"43":1,"44":1,"45":1,"46":1,"47":1,"48":1,"49":1}}],["普通指针",{"2":{"20":1}}],["第二个是参量表",{"2":{"232":1}}],["第二个是安装目录",{"2":{"191":1}}],["第二种是用于避免出现错误的显式强制类型转换",{"2":{"38":1}}],["第3个元素为",{"2":{"85":1}}],["第2个元素为",{"2":{"85":1}}],["第",{"2":{"85":1}}],["第一个参数是要格式化的字符串",{"2":{"232":1}}],["第一个是缓存目录",{"2":{"191":1}}],["第一个元素",{"2":{"78":1}}],["第一种是已知完全安全且不存在歧义的普通类型转换",{"2":{"38":1}}],["第三方库",{"0":{"53":1},"2":{"53":1}}],["第三种是对等类型解析",{"2":{"38":1}}],["特点",{"0":{"296":1}}],["特殊看待",{"2":{"145":1}}],["特别是在程序设计语言中",{"2":{"38":1}}],["特性的分配器模型",{"2":{"29":1}}],["特性一直为人们所吐槽",{"2":{"24":1}}],["需要使用",{"2":{"250":1}}],["需要手动编译gtkmm",{"2":{"202":1}}],["需要手动显式指定转发",{"2":{"37":1}}],["需要在编译期执行循环",{"2":{"166":1}}],["需要在编译期已知矩阵",{"2":{"127":1}}],["需要注意的是",{"2":{"178":1,"255":1,"262":1}}],["需要注意的是如果他们在",{"2":{"142":1}}],["需要注意",{"2":{"161":1}}],["需要两个矩阵",{"2":{"127":1}}],["需要保证",{"2":{"15":1}}],["且返回类型",{"2":{"265":2}}],["且返回非类型",{"2":{"265":3}}],["且该类型是零位类型",{"2":{"292":1}}],["且该类型必须具有明确的大小",{"2":{"78":1}}],["且该包自己有",{"2":{"37":1}}],["且不存在歧义",{"2":{"39":1}}],["且测试​​结果并不理想",{"2":{"2":1}}],["方法",{"2":{"89":1}}],["方法来访问包的链接库和暴露的",{"2":{"37":1}}],["方式",{"2":{"20":1}}],["即当可以立即从命名推断出其用途时",{"2":{"266":1}}],["即使是只有",{"2":{"265":1}}],["即使使用",{"2":{"186":1}}],["即定义的变量",{"2":{"262":1}}],["即便此时还没有新的稳定版",{"2":{"211":1}}],["即便对应的部分不存在也需要有冒号",{"2":{"4":1}}],["即默认的",{"2":{"192":1}}],["即实际的运行",{"2":{"192":1,"199":1,"200":1}}],["即被",{"2":{"185":1}}],["即超集不是子集",{"2":{"138":1}}],["即尽可能使用常量",{"2":{"129":1}}],["即",{"2":{"105":1,"152":1,"268":1}}],["即可",{"2":{"79":1,"111":1,"198":1,"215":1,"219":1}}],["即引入该包的项目均可看到该包的构建结果",{"2":{"36":1}}],["同样可以解构错误联合类型",{"2":{"168":1}}],["同样不推荐使用",{"2":{"160":1,"165":1}}],["同样支持捕获指针来操作值",{"2":{"152":1}}],["同样也容纳",{"2":{"41":1}}],["同之前",{"2":{"127":1}}],["同上",{"2":{"127":1}}],["同理",{"2":{"36":1}}],["同时不像其他语言那样对运行时安全性的要求",{"2":{"294":1}}],["同时还提供现代功能",{"2":{"294":1}}],["同时还利用了",{"2":{"66":1}}],["同时它也是",{"2":{"175":1}}],["同时",{"2":{"68":1,"85":1,"86":1,"122":1,"129":1,"136":1,"293":1}}],["同时这也是为什么",{"2":{"25":1}}],["同时其他的参数和返回值类型也都是",{"2":{"7":1}}],["编程更简单",{"2":{"294":1}}],["编辑器之神",{"2":{"208":1}}],["编辑器选择",{"0":{"204":1},"1":{"205":1,"206":1,"207":1,"208":1,"209":1,"210":1}}],["编码的",{"2":{"61":1}}],["编码",{"2":{"61":1,"62":1}}],["编写的窗口管理器",{"2":{"53":1}}],["编写的俄罗斯方块",{"2":{"53":1}}],["编写的",{"2":{"53":2}}],["编写包",{"0":{"36":1}}],["编译的系统编程语言",{"2":{"294":1}}],["编译时的",{"2":{"232":1}}],["编译时检测出错误则直接停止编译",{"2":{"124":1}}],["编译系统",{"2":{"207":1}}],["编译器假设永远不会执行到",{"2":{"176":1}}],["编译器这里不能是一个",{"2":{"145":1}}],["编译器自行推导而出",{"2":{"143":1}}],["编译器自动进行推断",{"2":{"71":1}}],["编译器会返回错误或者值",{"2":{"233":1}}],["编译器会添加一些随机因素进入到程序中",{"2":{"190":1}}],["编译器会帮我们完成其余的工作",{"2":{"174":1}}],["编译器会做一个额外的工作",{"2":{"136":1}}],["编译器会直接将切片优化为数组指针",{"2":{"85":1}}],["编译器对于除零的处理是分别在编译期和运行时",{"2":{"124":1}}],["编译器将自动忽略该返回值",{"2":{"111":1}}],["编译器将会报告错误",{"2":{"9":1}}],["编译器推断出类型即可",{"2":{"91":1}}],["编译器进行严格的计算",{"2":{"70":1}}],["编译器还不会对字节进行修改",{"2":{"61":1}}],["编译器",{"2":{"53":1}}],["编译器来推导",{"2":{"47":1}}],["编译器来自动推导",{"2":{"47":1}}],["编译器来供",{"2":{"24":1}}],["编译器的替代品使用",{"2":{"24":1}}],["编译后的结果是这个样子",{"2":{"7":1}}],["编译期的特性",{"2":{"262":1}}],["编译期的整数",{"2":{"122":1}}],["编译期配置",{"0":{"194":1}}],["编译期进行推倒",{"2":{"178":1}}],["编译期反射访问可选类型",{"0":{"146":1}}],["编译期仍然会给你检测",{"2":{"145":1}}],["编译期初始化数组",{"0":{"66":1}}],["编译期已知的数字",{"2":{"46":1}}],["编译期数字",{"0":{"46":1}}],["编译期表达式",{"0":{"9":1},"2":{"171":1}}],["编译期变量",{"0":{"8":1}}],["编译期参数实现鸭子类型",{"0":{"7":1}}],["编译期间执行的动作",{"2":{"6":1}}],["编译期是指在",{"2":{"6":1}}],["编译期",{"0":{"6":1,"84":1},"1":{"7":1,"8":1,"9":1,"10":1},"2":{"60":1,"124":1,"131":1,"296":1}}],["版本是最新的",{"2":{"293":1}}],["版本加入",{"2":{"229":1}}],["版本的",{"2":{"224":1,"225":1,"231":1}}],["版本控制系统",{"2":{"205":1}}],["版本不允许使用不会被修改的变量",{"2":{"129":1}}],["版本",{"2":{"53":1,"207":1,"208":1,"211":2,"213":1,"215":1,"219":1,"293":1}}],["版本支持两种打包格式的源文件",{"2":{"35":1}}],["版本新引入的",{"2":{"35":1}}],["版本尚未发布1",{"2":{"0":1}}],["新的优化和各种安全机制",{"2":{"294":1}}],["新的文件结构",{"0":{"35":1}}],["新引入的一种简单数据交换格式",{"2":{"35":1}}],["新类型",{"2":{"20":1}}],["然后再通过",{"2":{"255":1}}],["然后像bash写入环境变量配置",{"2":{"221":1}}],["然后将所有文件内容移动到",{"2":{"220":1}}],["然后在",{"2":{"34":1}}],["然后提供",{"2":{"33":1}}],["添加环境变量",{"2":{"219":1}}],["添加参数",{"2":{"200":1}}],["添加",{"2":{"194":1,"196":1,"201":1,"202":1}}],["添加一个匿名的依赖",{"2":{"199":1,"200":1}}],["添加一个匿名模块即可",{"2":{"199":1}}],["添加一个依赖项",{"2":{"191":1}}],["添加一个二进制可执行程序构建",{"2":{"191":1,"192":1,"193":1,"194":1,"195":1,"197":1,"199":1,"200":1,"201":1,"202":1}}],["添加到顶级",{"2":{"191":1,"192":1,"193":1,"194":1,"195":1,"197":1,"199":1,"200":1,"201":1,"202":1}}],["添加更多关于该类型使用的示例和说明",{"2":{"75":1}}],["添加包的元信息",{"2":{"34":1}}],["添加汇编文件",{"2":{"3":1}}],["zip",{"2":{"195":2}}],["zig`",{"2":{"239":1}}],["zigzig",{"2":{"229":1}}],["zigtools",{"2":{"208":1}}],["zigtest",{"2":{"42":1,"246":1,"267":1}}],["zigbrains",{"2":{"207":1}}],["zigbuild",{"2":{"194":1,"200":1}}],["zigvs",{"2":{"206":1}}],["zigvar",{"2":{"43":3,"133":1,"151":1,"152":2,"155":1,"159":1,"160":2,"162":1,"163":2,"165":1,"170":1,"198":1,"287":1}}],["zigmain",{"2":{"202":1}}],["zigsrc",{"2":{"201":1}}],["zighello",{"2":{"199":1}}],["zigwhile",{"2":{"167":1,"168":1}}],["zigfor",{"2":{"156":1}}],["zigfn",{"2":{"7":3,"10":1,"36":1,"37":2,"51":4,"92":1,"111":1,"115":1,"118":1,"141":4,"142":2,"164":1,"175":1,"192":1}}],["zigif",{"2":{"152":1}}],["zigcomptime",{"2":{"124":1}}],["zigconst",{"2":{"3":1,"8":1,"9":2,"13":1,"21":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"41":1,"43":1,"44":1,"45":1,"46":1,"47":1,"49":1,"51":3,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"68":2,"69":1,"70":1,"71":1,"72":1,"73":1,"74":1,"77":1,"78":2,"79":1,"82":2,"83":1,"84":1,"85":1,"86":1,"87":1,"89":2,"90":4,"91":1,"93":1,"94":2,"95":1,"99":3,"100":1,"102":1,"103":1,"104":1,"105":1,"106":1,"108":2,"124":1,"126":2,"129":1,"130":1,"131":1,"132":1,"136":1,"137":2,"139":1,"141":1,"145":1,"146":1,"148":1,"149":2,"151":1,"152":2,"153":1,"155":1,"157":1,"158":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"171":1,"172":2,"173":2,"174":1,"175":1,"176":1,"178":3,"179":3,"180":1,"184":1,"185":1,"191":1,"192":1,"193":1,"194":2,"195":2,"196":1,"197":1,"199":2,"200":2,"201":1,"202":1,"231":1,"233":2,"245":1,"250":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"262":1,"271":1,"272":1,"281":1,"282":1,"283":1}}],["zigexport",{"2":{"117":1}}],["zigextern",{"2":{"116":1,"117":1,"145":1}}],["zig的标准库",{"2":{"61":1}}],["zig的",{"2":{"53":1}}],["ziggit",{"2":{"52":1}}],["ziglang",{"2":{"22":1,"190":1}}],["zigptr",{"2":{"20":2}}],["zigpub",{"2":{"4":1,"19":1,"111":1,"161":1,"166":1,"185":1,"191":1,"250":1}}],["zigasm",{"2":{"4":1}}],["zig",{"0":{"23":1,"24":1,"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"229":1,"294":1,"295":1},"1":{"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"229":1,"295":1,"296":1,"297":1},"2":{"0":2,"1":1,"2":2,"3":4,"4":2,"6":4,"7":1,"8":3,"10":1,"11":7,"12":1,"13":5,"14":4,"15":1,"17":10,"18":4,"19":3,"20":4,"21":2,"23":5,"24":8,"25":6,"30":1,"32":2,"33":2,"34":4,"35":8,"36":4,"37":4,"38":1,"39":2,"42":3,"47":2,"51":2,"52":4,"53":15,"54":1,"55":3,"61":3,"64":1,"68":2,"70":1,"71":1,"72":1,"73":1,"76":3,"79":2,"81":1,"82":1,"88":1,"90":3,"91":2,"92":1,"96":3,"97":1,"99":2,"100":2,"102":3,"105":1,"106":1,"108":2,"109":1,"111":4,"112":2,"119":1,"122":3,"124":15,"125":1,"126":2,"127":2,"129":3,"130":1,"131":1,"132":1,"133":1,"134":6,"135":2,"136":1,"137":1,"140":2,"143":2,"144":1,"145":9,"148":1,"149":1,"154":1,"164":1,"175":1,"178":3,"179":1,"180":1,"184":7,"185":2,"186":1,"189":3,"190":4,"191":9,"192":5,"193":3,"194":5,"195":6,"196":1,"197":6,"198":5,"199":7,"200":8,"201":4,"202":5,"205":2,"207":4,"208":8,"209":2,"210":2,"211":2,"212":1,"213":4,"214":3,"215":4,"216":3,"217":2,"218":9,"219":3,"220":9,"221":4,"222":3,"223":1,"224":10,"225":13,"229":3,"231":7,"232":8,"233":4,"235":1,"236":1,"238":1,"240":1,"241":1,"242":1,"243":1,"248":1,"249":2,"250":1,"251":1,"252":1,"253":1,"254":1,"255":2,"261":1,"262":2,"265":3,"267":23,"272":1,"286":1,"293":14,"294":3,"295":2,"296":1,"297":4}}],["zls",{"2":{"53":1,"208":7,"209":1}}],["zld",{"2":{"53":1}}],["zap",{"2":{"53":1}}],["zz",{"2":{"51":3,"171":3}}],["z",{"2":{"43":2,"105":1,"139":2,"195":1,"258":4}}],["z2",{"2":{"43":1}}],["z1",{"2":{"43":1}}],["zero",{"2":{"42":1,"68":1,"83":2,"124":10,"286":1,"291":1}}],["zon",{"2":{"34":1,"35":2,"37":1,"229":1}}],["终于迎来了一个正式的官方包管理器",{"2":{"34":1}}],["接着上面的函数写",{"2":{"140":2}}],["接口来实现自己的分配器",{"2":{"33":1}}],["接下来加深一点难度",{"2":{"233":1}}],["接下来",{"2":{"233":1}}],["接下来就了解一下基本的",{"2":{"222":1}}],["接下来我们演示以下切片的使用方式",{"2":{"85":1}}],["接下来我们介绍具体的内部结构",{"2":{"4":1}}],["接下来展示一个例子",{"2":{"13":1}}],["接下来讲解一下它们的组成和使用",{"2":{"4":1}}],["源代码路径",{"2":{"201":1,"202":1}}],["源代码文件可以使用",{"2":{"202":1}}],["源代码文件",{"2":{"201":2,"202":2}}],["源代码",{"2":{"200":1,"201":1}}],["源代码可以参考这里memory",{"2":{"32":1}}],["源码位于",{"2":{"184":1}}],["源码的命名方式",{"2":{"111":1}}],["源文件带后缀",{"2":{"232":1}}],["源文件",{"2":{"232":1}}],["源文件准备的",{"2":{"201":1,"202":1}}],["源文件地址",{"2":{"195":1}}],["源文件内容的",{"2":{"35":1}}],["源文件本身都是容器",{"2":{"3":1,"249":1}}],["再进行学习",{"2":{"293":1}}],["再进一步",{"2":{"24":1}}],["再来一个简单的例子告诉你",{"2":{"233":1}}],["再将以下内容覆写到",{"2":{"231":1}}],["再说明如何手动安装",{"2":{"217":1}}],["再使用",{"2":{"201":1}}],["再解构可选类型",{"2":{"152":1}}],["再转换为多项指针",{"2":{"43":1}}],["再相除",{"2":{"42":2}}],["再申请一快内存",{"2":{"32":1}}],["连续申请三块内存",{"2":{"32":1}}],["既然我们经常要分配内存",{"2":{"32":1}}],["消除频繁调用内存分配和释放函数所带来的开销问题",{"2":{"32":1}}],["库或者实现",{"2":{"297":1}}],["库集成",{"2":{"296":1}}],["库导入",{"2":{"294":1}}],["库的名字",{"2":{"195":1}}],["库的内存分配",{"2":{"30":1}}],["库b",{"2":{"192":1}}],["库获取对应的",{"2":{"179":1}}],["库",{"2":{"53":1,"196":1,"201":2,"202":1}}],["库时引入头文件",{"2":{"16":1}}],["才会执行",{"2":{"142":1}}],["才会涉及到使用汇编语言",{"2":{"2":1}}],["才有效",{"2":{"29":1}}],["善后工作",{"2":{"29":1}}],["操作来处理计算",{"2":{"272":1}}],["操作作为依赖添加到",{"2":{"196":1}}],["操作如下",{"2":{"196":1}}],["操作的检测和堆栈跟踪",{"2":{"125":1}}],["操作的构建结果均会被暴露出去",{"2":{"36":1}}],["操作",{"0":{"58":1},"1":{"59":1,"60":1},"2":{"28":1,"160":1,"165":1}}],["操作系统内核",{"2":{"25":1}}],["获取错误时",{"2":{"278":1}}],["获取类型信息",{"2":{"255":1}}],["获取writer句柄",{"2":{"233":1}}],["获取buffer",{"2":{"233":1}}],["获取有关推断类型的信息",{"2":{"115":1}}],["获取了",{"2":{"82":1}}],["获取内存对齐信息",{"2":{"82":1}}],["获取内存allocator",{"2":{"27":2}}],["获取指针指向的地址",{"2":{"50":1}}],["获取浮点数的整数部分",{"2":{"50":1}}],["获取对应错误的整数值",{"2":{"50":1}}],["获取",{"2":{"37":1}}],["获取包提供的模块",{"2":{"37":1}}],["获取包构建的library",{"2":{"37":1}}],["获取包",{"2":{"37":1}}],["获取分配器模型",{"2":{"29":1}}],["获取分配器",{"2":{"28":1,"29":1}}],["获取线程安全的内存allocator",{"2":{"27":1}}],["延后释放内存",{"2":{"26":1}}],["拿到一个allocator",{"2":{"26":1,"28":1}}],["用比喻来说",{"2":{"251":1}}],["用户可以更改主题和键盘快捷方式实现个性化设置",{"2":{"205":1}}],["用来获取它们的长度",{"2":{"78":1}}],["用起来和",{"2":{"30":1}}],["用这个准没错",{"2":{"26":1}}],["用于维护健壮",{"2":{"294":1}}],["用于获取变量",{"2":{"258":1}}],["用于返回一个容器中是否包含指定名字的声明",{"2":{"256":1}}],["用于转发声明",{"2":{"250":1}}],["用于创建一个内存屏障",{"2":{"243":1}}],["用于原子化的修改值并返回修改前的值",{"2":{"240":1}}],["用于对某个类型指针进行原子化的赋值",{"2":{"239":1}}],["用于某个类型指针进行原子化的读取值",{"2":{"238":1}}],["用于错误输出",{"2":{"233":1}}],["用于正常的输出",{"2":{"233":1}}],["用于将包添加到全局缓存并打印包的hash",{"2":{"229":1}}],["用于将多个数据表示为一个整体",{"2":{"88":1}}],["用于格式化代码源文件",{"2":{"227":1}}],["用于便捷地添加多个源文件",{"2":{"201":1,"202":1}}],["用于执行测试",{"2":{"197":1}}],["用于执行general",{"2":{"26":1,"28":1}}],["用于当",{"2":{"184":1}}],["用于来离开作用域前清理掉tmp",{"2":{"142":1}}],["用于在出现错误时直接向上层返回错误",{"2":{"141":1}}],["用于发生错误时提供一个默认值",{"2":{"140":1}}],["用于给函数",{"2":{"134":1}}],["用于限制变量声明的范围",{"2":{"133":1}}],["用于表示一个圆",{"2":{"89":1}}],["用于比较字节",{"2":{"61":1}}],["用于",{"2":{"53":1}}],["用于控制预处理器指令并引入头文件",{"2":{"13":1}}],["用于通知编译器",{"2":{"4":1}}],["怎么到这里这么多的",{"2":{"25":1}}],["除数为零是也是非法的",{"2":{"274":1}}],["除此以外",{"2":{"272":1}}],["除法",{"2":{"124":1,"125":4}}],["除",{"2":{"124":1,"272":1}}],["除零是非法操作",{"2":{"274":1}}],["除零操作",{"0":{"274":1}}],["除零",{"0":{"124":1},"2":{"124":1,"125":1}}],["除非",{"2":{"271":1}}],["除非是一个",{"2":{"265":1}}],["除非需要换行",{"2":{"264":1}}],["除非你的程序逻辑有问题",{"2":{"190":1}}],["除非你有把握每次都能正确的处理它们",{"2":{"85":1}}],["除非函数本身在编译时被调用",{"2":{"9":1}}],["除了获取类型信息外",{"2":{"261":1}}],["除了基本的分配",{"2":{"32":1}}],["除了这些",{"2":{"25":1}}],["除了这六种内存分配模型外",{"2":{"25":1}}],["开发时过重的心智负担",{"2":{"190":1}}],["开发中最难以调试的",{"2":{"25":1}}],["开始学习其他语言的",{"2":{"231":1}}],["开始",{"2":{"55":1,"105":3}}],["开头将会是",{"2":{"184":1}}],["开头",{"2":{"4":1,"130":1,"232":1}}],["完善的堆栈跟踪",{"2":{"296":1}}],["完全是编译期计算的",{"2":{"256":1,"257":1}}],["完全由程序员管理内存",{"2":{"25":1}}],["完整堆栈跟踪生效的三个方式",{"2":{"144":1}}],["完整的工具链的大小多达好几百",{"2":{"23":1}}],["完整的构架目标三元组可以在这里",{"2":{"15":1}}],["宣称的非常方便的交叉编译说拜拜了",{"2":{"24":1}}],["能",{"2":{"24":1}}],["能静态链接",{"0":{"24":1}}],["吗",{"0":{"24":1},"2":{"25":1}}],["分隔",{"2":{"254":1}}],["分割的多匹配",{"2":{"171":1}}],["分别代表标准库",{"2":{"232":1}}],["分别会捕获错误和有效负载",{"2":{"168":1}}],["分别可以执行单个语句和一个块",{"2":{"153":1}}],["分别是普通注释",{"2":{"134":1}}],["分别是",{"2":{"109":1,"111":1,"136":1,"207":1}}],["分支",{"2":{"170":1,"175":1}}],["分支执行",{"2":{"168":1}}],["分支捕获的是错误",{"2":{"152":1}}],["分支并非必要",{"2":{"151":1}}],["分配内存",{"2":{"29":1}}],["分发的",{"2":{"23":1}}],["分段分页",{"2":{"2":1}}],["4558e134302b78f1a543202d094b3e06",{"2":{"267":1}}],["45mb",{"2":{"23":1}}],["415808",{"2":{"202":1}}],["411985",{"2":{"202":1}}],["41",{"2":{"184":4}}],["432192",{"2":{"202":1}}],["431376",{"2":{"202":1}}],["431424",{"2":{"202":1}}],["43",{"2":{"179":1}}],["47",{"2":{"149":2}}],["4294967296",{"2":{"283":1}}],["428369",{"2":{"202":1}}],["427089",{"2":{"202":1}}],["42",{"2":{"115":1,"179":3,"180":1,"184":2,"265":1,"282":1}}],["4x4",{"2":{"56":2}}],["4",{"2":{"42":1,"43":1,"47":2,"56":2,"57":3,"60":2,"68":1,"70":1,"78":3,"82":9,"85":2,"86":1,"90":1,"99":2,"102":8,"103":1,"104":1,"105":2,"106":7,"124":1,"149":2,"155":3,"157":2,"158":1,"159":1,"161":4,"202":3,"258":2,"281":2}}],["40",{"2":{"23":1,"202":1}}],["个字母的首字母缩略词也受这些约定的约束",{"2":{"265":1}}],["个人目录安装",{"0":{"221":1}}],["个月",{"2":{"211":1}}],["个元素为",{"2":{"85":1}}],["个",{"2":{"23":1}}],["目录名称也应使用",{"2":{"265":1}}],["目录下",{"2":{"220":1}}],["目前情况来看",{"2":{"293":1}}],["目前的语法均是围绕着语义明确化",{"2":{"293":1}}],["目前插件市场活跃的两个",{"2":{"207":1}}],["目前最轻量且生态丰富的编辑器",{"2":{"205":1}}],["目前有以下几种编辑器推荐",{"2":{"204":1}}],["目前",{"2":{"135":1,"236":1,"293":1}}],["目前为止",{"2":{"35":1}}],["目前仅限",{"2":{"23":1}}],["目标机器",{"2":{"108":1}}],["目标为嵌入式系统与移动设备",{"2":{"24":1}}],["目标上",{"2":{"20":1}}],["目标和",{"2":{"17":1}}],["更何况",{"2":{"293":1}}],["更为完善的生态",{"2":{"293":1}}],["更高效的错误跟踪",{"2":{"293":1}}],["更进一步",{"0":{"234":1}}],["更改系统区域设置",{"2":{"212":1}}],["更改类型但保持位不变",{"2":{"50":1}}],["更加进阶的错误处理方案",{"2":{"141":1}}],["更复杂的例子",{"2":{"90":1}}],["更多能拿得出手的代表项目",{"2":{"293":1}}],["更多的类型我们在后面会详细说明",{"2":{"232":1}}],["更多的内建函数文档请看",{"2":{"113":1}}],["更多是在指针上使用",{"2":{"145":1}}],["更多是为了代替需要使用宏",{"2":{"8":1}}],["更多示例说明",{"2":{"37":1}}],["更好的编译",{"0":{"23":1}}],["为何使用",{"0":{"295":1}}],["为空或者字段均为零位类型时",{"2":{"291":1}}],["为稳定版本",{"2":{"208":1}}],["为基础设计的",{"2":{"207":1}}],["为前缀",{"2":{"113":1}}],["为我们提供了并行操纵一组同类型",{"2":{"101":1}}],["为",{"2":{"42":2,"83":1,"105":1,"106":1,"192":1,"199":1,"200":1}}],["为了处理这些情况",{"2":{"272":1}}],["为了实现性能和必要保证之间的平衡",{"2":{"237":1}}],["为了仅检测错误",{"2":{"152":1}}],["为了获得最佳的性能",{"2":{"95":1}}],["为了方便处理",{"2":{"61":1}}],["为了做到这一点",{"2":{"33":1}}],["为了构建这个",{"2":{"13":1}}],["为什么要再学习一门如此",{"2":{"293":1}}],["为什么是作用域顶层呢",{"2":{"134":1}}],["为什么呢",{"2":{"61":1}}],["为什么不回收内存来给新的申请使用而不是释放内存呢",{"2":{"32":1}}],["为什么",{"0":{"23":1}}],["报错并通知出现了未定义行为",{"2":{"20":1}}],["此外",{"2":{"294":1}}],["此风格指南来自官方的",{"2":{"263":1}}],["此声明可以被检测到是因为类型和代码处于同一个文件中",{"2":{"256":1}}],["此方法允许添加多个参数",{"2":{"200":1}}],["此操作允许用户通过构建系统的命令传递参数",{"2":{"192":1}}],["此步骤不是必要的",{"2":{"192":1}}],["此行为只是一种实现功能",{"2":{"132":1}}],["此函数会返回一个当前包裹它的容器的类型",{"2":{"90":1}}],["此处",{"2":{"262":1}}],["此处并不是拼写错误",{"2":{"215":1}}],["此处将编译后的zls直接覆盖mason的zls",{"2":{"208":1}}],["此处开始构建单元测试",{"2":{"197":1}}],["此处测试由于未被引用",{"2":{"185":1}}],["此处假定这个错误不会发生",{"2":{"141":1}}],["此处是普通注释",{"2":{"134":1}}],["此处也是一个文档注释",{"2":{"134":1}}],["此处仅仅是简单提及一下该特性",{"2":{"92":1}}],["此处可以看",{"2":{"90":1}}],["此处歧义为两种情况",{"2":{"42":1}}],["此处的意思是如果有返回值",{"2":{"233":1}}],["此处的",{"2":{"4":1}}],["此前已知是通过第三方包管理器下载并处理包",{"2":{"34":1}}],["此时结构体也是零位类型",{"2":{"291":1}}],["此时与数组",{"2":{"289":1}}],["此时程序或者编译器会停止并发出警告",{"2":{"273":1}}],["此时它被视为一个命名空间",{"2":{"265":1}}],["此时它是一个多项指针",{"2":{"20":1}}],["此时它是单项指针",{"2":{"20":1}}],["此时我们就分别得到了使用缓冲区的",{"2":{"233":1}}],["此时我们可以再指定构建库",{"2":{"192":1}}],["此时控制权会切换回内核",{"2":{"233":1}}],["此时需要搭配",{"2":{"164":1}}],["此时变量的值将会是无意义的值",{"2":{"132":1}}],["此时p2和p4指向同一块内存",{"2":{"32":1}}],["此时会触发安全检查的保护机制",{"2":{"20":1}}],["支持有关",{"2":{"294":1}}],["支持stdin和指定路径",{"2":{"227":1}}],["支持指定文件和标准输入",{"2":{"226":1}}],["支持交叉编译到任何",{"2":{"198":1}}],["支持我们从命令行构建时指定构建模式",{"2":{"195":1}}],["支持我们从命令行构建时指定构建目标",{"2":{"195":1}}],["支持编译期运算",{"2":{"171":1}}],["支持任何已知的最大",{"2":{"102":1}}],["支持任意位宽的整数",{"2":{"99":1,"122":1}}],["支持在一个",{"2":{"36":1}}],["支持通过",{"2":{"35":1}}],["支持静态链接",{"2":{"24":1}}],["支持外部",{"2":{"21":1}}],["支持和整数进行比较",{"2":{"20":1}}],["支持与整数进行强制转换",{"2":{"20":1}}],["支持",{"2":{"20":1}}],["支持仅使用",{"2":{"10":1}}],["具有",{"2":{"126":1}}],["具有较大对齐大小的指针可以隐式转换为具有较小对齐大小的指针",{"2":{"82":1}}],["具有以下特点",{"2":{"20":1}}],["具体原因见此",{"2":{"262":1}}],["具体细节可以查看内存屏障的相关信息",{"2":{"243":1}}],["具体",{"2":{"240":1}}],["具体命令操作如下",{"2":{"220":1}}],["具体安装方法见",{"2":{"201":1}}],["具体见",{"2":{"182":1}}],["具体见这里",{"2":{"153":1}}],["具体见此",{"2":{"4":1}}],["具体的堆栈跟踪实现细节可以看这里",{"2":{"144":1}}],["具体的信息可见这里",{"2":{"144":1}}],["具体可以参考该",{"2":{"202":1}}],["具体可以参照以下例子",{"2":{"108":1}}],["具体可以见",{"2":{"181":1}}],["具体可以看下面的示例",{"2":{"57":1}}],["具体如下",{"2":{"94":1}}],["具体问题可以见这个",{"2":{"9":1}}],["头文件后",{"2":{"20":1}}],["错误堆栈跟踪显示代码中将错误返回到调用函数的所有点",{"2":{"144":1}}],["错误集在这里被保留在",{"2":{"139":1}}],["错误集合转为超集",{"2":{"40":1}}],["错误处理",{"0":{"135":1},"1":{"136":1,"137":1,"138":1,"139":1,"140":1,"141":1,"142":1,"143":1,"144":1}}],["错误联合类型如果是",{"2":{"277":1}}],["错误联合类型的载荷",{"2":{"45":1}}],["错误联合类型",{"0":{"45":1,"139":1},"1":{"140":1,"141":1,"142":1,"143":1}}],["错误联合可选类型也可以",{"2":{"44":1}}],["错误联合可选类型也有效",{"2":{"43":1}}],["错误",{"2":{"19":1}}],["故会引起程序或者编译器报错",{"2":{"274":1}}],["故会直接出现报错",{"2":{"270":1}}],["故值也是编译期已知的",{"2":{"256":1,"257":1}}],["故函数",{"2":{"253":1}}],["故只能在",{"2":{"202":1}}],["故只有在使用它们时才会报告编译错误",{"2":{"18":1}}],["故可能一个函数被推导出",{"2":{"143":1}}],["故可以直接转换",{"2":{"47":1}}],["故不进行系统讲解",{"2":{"113":1}}],["故你可以暂时略过这里",{"2":{"79":1}}],["故称为",{"2":{"79":1}}],["故是不同的类型",{"2":{"75":1}}],["故我们这里选择构建一个",{"2":{"202":1}}],["故我们可以在下面使用inline",{"2":{"175":1}}],["故我们可以使用下标来访问数组的元素",{"2":{"55":1}}],["故我们无需专门为编译期表达式编写函数",{"2":{"9":1}}],["故仅可在",{"2":{"29":1}}],["故",{"2":{"20":1}}],["那肯定要有指针的",{"2":{"76":1}}],["那就会发生",{"2":{"141":1}}],["那就代表你目前无需了解以下部分",{"2":{"97":1}}],["那就是确定错误的数量",{"2":{"136":1}}],["那就是",{"2":{"39":1,"111":1}}],["那就可以正常使用",{"2":{"18":1}}],["那么会触发非法行为",{"2":{"282":1}}],["那么会触发完整的堆栈跟踪",{"2":{"268":1}}],["那么会导致程序或者编译器报告错误",{"2":{"279":1,"280":1}}],["那么会导致程序或编译器报错",{"2":{"278":1}}],["那么会导致出现错误",{"2":{"276":1}}],["那么会自动进行转换",{"2":{"46":1}}],["那么使用",{"2":{"265":1}}],["那么赋值为参数的新值",{"2":{"241":1,"242":1}}],["那么此时的解决方式就如下",{"2":{"233":1}}],["那么建议将",{"2":{"212":1}}],["那么emacs就是神的编辑器",{"2":{"209":1}}],["那么我们可以在构建",{"2":{"192":1}}],["那么",{"2":{"142":1,"152":1,"267":1}}],["那么如何假定函数不会返回错误呢",{"2":{"141":1}}],["那么它会自动被构建",{"2":{"195":1}}],["那么它们会在",{"2":{"142":1}}],["那么它将不会执行默认的初始化操作",{"2":{"132":1}}],["那么它以返回的函数命名",{"2":{"100":1}}],["那么请使用",{"2":{"130":1}}],["那么你需要自己实现相关的结构体了",{"2":{"127":1}}],["那么以下",{"2":{"108":1}}],["那么指针也可以在编译期发挥作用",{"2":{"84":1}}],["那么本节内容你可以跳过了",{"2":{"82":1}}],["那么这里你可以略过",{"2":{"81":1}}],["那么这只鸟就可以被称为鸭子",{"2":{"7":1}}],["那么可以使用该命令",{"2":{"225":1}}],["那么可以使用",{"2":{"37":1}}],["那么推荐你使用这个",{"2":{"28":1}}],["仅具有一种可能类型",{"2":{"292":1}}],["仅作为一份参考",{"2":{"263":1}}],["仅需要安装",{"2":{"205":1}}],["仅在函数作用域返回错误时",{"2":{"142":1}}],["仅在对应章节说明涉及到的内建函数",{"2":{"113":1}}],["仅有一位",{"2":{"99":1}}],["仅仅一个示例不足以说明",{"2":{"255":1}}],["仅仅执行了类型计算",{"2":{"253":1}}],["仅仅是",{"2":{"207":1}}],["仅仅是宏",{"2":{"19":1}}],["仅仅讲述的少量内容",{"2":{"81":1}}],["仅当完全明确如何从一种类型转换为另一种类型并且保证转换安全时才允许自动转换",{"2":{"39":1}}],["仅依赖这个符号库",{"2":{"23":1}}],["仅存在函数的声明",{"2":{"18":1}}],["仅添加参数",{"2":{"15":1}}],["宏",{"2":{"18":2}}],["拼接",{"2":{"18":1}}],["会要求你显示传递和管理你的内存",{"2":{"296":1}}],["会导致编译器错误",{"2":{"281":1}}],["会编译失败并触发堆栈跟踪",{"2":{"267":1}}],["会发出编译错误并停止继续编译",{"2":{"267":1}}],["会触发编译器错误",{"2":{"253":1}}],["会触发未定义行为",{"2":{"20":1}}],["会自动为我们根据后面的参量表推导出对应的类型",{"2":{"232":1}}],["会自动使用包的",{"2":{"229":1}}],["会自动搜索当前目录及父目录的",{"2":{"223":1}}],["会自动下载最新的zls并配置好",{"2":{"208":1}}],["会在编译时转为一个规范的",{"2":{"194":1}}],["会在经过预处理器加工后的代码上进行翻译",{"2":{"19":1}}],["会给顶层的",{"2":{"191":1}}],["会通过该文件对整个项目进行构建操作",{"2":{"191":1}}],["会假定其参数为",{"2":{"184":1}}],["会调用",{"2":{"176":1}}],["会先尝试解构错误联合类型",{"2":{"152":1}}],["会被自动添加进环境变量",{"2":{"213":1}}],["会被自动转换",{"2":{"43":1}}],["会被视作地址",{"2":{"147":1}}],["会将错误堆栈跟踪输出到标准错误输出",{"2":{"184":1}}],["会将",{"2":{"145":1}}],["会将字符串假定为",{"2":{"61":1}}],["会执行",{"2":{"142":1}}],["会尝试计算联合类型表达式",{"2":{"141":1}}],["会尝试自动计算数组的长度",{"2":{"55":1}}],["会从块中返回一个值出来",{"2":{"133":1}}],["会只使用它们的位宽",{"2":{"99":1}}],["会为每个值分配一个整数的字段名",{"2":{"96":1}}],["会尽量转换为所有对等类型可以转换成的类型",{"2":{"51":1}}],["会尽量将类似函数的宏定义转为对应的",{"2":{"19":1}}],["会优先使用",{"2":{"30":1}}],["会使用",{"2":{"18":1}}],["会暂时简单处理一下它们以继续翻译任务",{"2":{"18":1}}],["会无法翻译",{"2":{"18":1}}],["会报告错误",{"2":{"6":1}}],["针对多个",{"2":{"201":1,"202":1}}],["针对不同的错误采取不同的处理方式",{"2":{"139":1}}],["针对不同的参数",{"2":{"8":1}}],["针对原始类型的这种策略开销非常小",{"2":{"112":1}}],["针对linux的另一个",{"2":{"24":1}}],["针对顶级声明使用惰性分析",{"2":{"18":1}}],["针对某些",{"2":{"18":1}}],["构建新类型的能力主要依赖于",{"2":{"261":1}}],["构建新的类型",{"0":{"261":1},"1":{"262":1}}],["构建项目",{"2":{"223":1}}],["构建过于复杂",{"2":{"202":1}}],["构建优化模式",{"2":{"201":1,"202":1}}],["构建纯",{"0":{"201":1,"202":1}}],["构建其他的编程语言",{"2":{"200":1}}],["构建一个运行命令",{"2":{"200":1}}],["构建一个",{"2":{"197":1}}],["构建一个单元测试的",{"2":{"197":2}}],["构建器和测试器会通过",{"2":{"197":1}}],["构建文档",{"2":{"196":1}}],["构建目标相关信息",{"2":{"232":1}}],["构建目标",{"2":{"195":1,"201":1,"202":1}}],["构建静",{"0":{"195":1}}],["构建下可能会有所不同",{"2":{"190":1}}],["构建速度慢",{"2":{"190":3}}],["构建速度很快",{"2":{"190":1}}],["构建模式下",{"2":{"190":1}}],["构建模式",{"0":{"190":1},"2":{"195":1}}],["构建模式外",{"2":{"124":1}}],["构建系统",{"0":{"189":1},"1":{"190":1,"191":1,"192":1,"193":1,"194":1,"195":1,"196":1,"197":1,"198":1,"199":1,"200":1,"201":1,"202":1,"203":1}}],["构建",{"0":{"196":1},"2":{"17":1,"191":1,"195":1,"222":1}}],["包",{"0":{"244":1},"1":{"245":1,"246":1},"2":{"233":1}}],["包和",{"2":{"233":1}}],["包中定义的",{"2":{"232":1}}],["包传递给程序",{"2":{"194":1}}],["包的版本",{"2":{"35":1}}],["包可以来自任何来源",{"2":{"34":1}}],["包管理器安装",{"0":{"218":1}}],["包管理",{"0":{"34":1},"1":{"35":1,"36":1,"37":1}}],["包裹某种类型获取到一个原子数据结构",{"2":{"245":1}}],["包裹",{"2":{"27":1,"53":1,"163":1}}],["包裹一下它即可",{"2":{"27":1}}],["包括编译出来的各种库供其他语言使用",{"2":{"293":1}}],["包括了",{"2":{"124":1}}],["包括错误集",{"2":{"45":1}}],["包括",{"2":{"44":1,"102":1}}],["包括实时软件",{"2":{"25":1}}],["包括参数",{"2":{"6":1}}],["包含计算的结果和是否发生溢出的判断位",{"2":{"272":1}}],["包含的元素数量超过",{"2":{"264":1}}],["包含了许多智能功能来提高开发人员的生产力",{"2":{"207":1}}],["包含了一个",{"2":{"78":1,"85":1}}],["包含一个对外暴露的",{"2":{"191":1}}],["包含两个方法",{"2":{"89":1}}],["包含两种指针",{"2":{"76":1}}],["包含字段",{"2":{"89":1}}],["包含所有则指定为空",{"2":{"35":1}}],["包含",{"2":{"18":1,"233":1}}],["包含翻译后的代码",{"2":{"17":1}}],["包含要翻译的文件",{"2":{"17":1}}],["请将每个元素放在单独的行上",{"2":{"264":1}}],["请使测试返回错误",{"2":{"186":1}}],["请使用内部约定",{"2":{"265":1}}],["请使用标准库",{"2":{"126":1}}],["请使用可选类型",{"2":{"83":1}}],["请使用",{"2":{"17":1,"36":1,"82":1,"111":1}}],["请见谅",{"2":{"99":1}}],["请不要操作它们",{"2":{"85":1}}],["请只在目标",{"2":{"83":1}}],["请转换为普通指针后再进行操作",{"2":{"20":1}}],["请注意",{"2":{"19":1,"102":1,"186":1}}],["请勿直接使用主分支进行修改",{"2":{"1":1}}],["缓存系统集成",{"2":{"17":1}}],["无隐式执行",{"2":{"296":1}}],["无效错误集合转换",{"0":{"280":1}}],["无效错误码",{"0":{"278":1}}],["无效枚举转换",{"0":{"279":1}}],["无需",{"2":{"296":1}}],["无需注释其用途",{"2":{"266":1}}],["无需引入额外的语法",{"2":{"10":1}}],["无副作用是指",{"2":{"253":1}}],["无复现构建",{"2":{"190":1}}],["无穷大",{"2":{"126":1}}],["无",{"2":{"122":1}}],["无符号指针大小的整数",{"2":{"122":1}}],["无符号128位整数",{"2":{"122":1}}],["无符号16位整数",{"2":{"122":1}}],["无符号64位整数",{"2":{"122":1}}],["无符号32位整数",{"2":{"122":1}}],["无符号8位整数",{"2":{"122":1}}],["无论是数组还是切片",{"2":{"269":1}}],["无论是本地还是网络上",{"2":{"34":1}}],["无论是通过",{"2":{"17":1}}],["无法以此来修改已有类型",{"2":{"255":1}}],["无法执行对等类型转换",{"2":{"253":1}}],["无法在结构体",{"2":{"250":1}}],["无法推导时",{"2":{"232":1}}],["无法作为普通的函数参数使用",{"2":{"99":1}}],["无法扩容",{"2":{"27":1}}],["无法正常使用",{"2":{"19":1}}],["无法翻译的宏会被转为",{"2":{"19":1}}],["无法转换或处理时",{"2":{"18":1}}],["无法被正确翻译的",{"2":{"18":1}}],["翻译错误",{"0":{"18":1}}],["翻译功能",{"2":{"17":1}}],["翻译缓存",{"0":{"17":1}}],["指示不使用默认标准库",{"2":{"202":1}}],["指的是全局的错误集合",{"2":{"138":1}}],["指令",{"2":{"101":1,"102":2}}],["指向常量数组的指针",{"2":{"43":1}}],["指将数据从一种类型转换到另一种类型的过程",{"2":{"38":1}}],["指针强制转换为",{"0":{"284":1}}],["指针对齐转换可能发生错误",{"2":{"281":1}}],["指针对齐错误",{"0":{"281":1}}],["指针类型具有对齐值",{"2":{"82":1}}],["指针类型",{"2":{"78":1,"85":1}}],["指针运算",{"2":{"78":1}}],["指针是指向一块内存区域地址的变量",{"2":{"76":1}}],["指针转为可选指针",{"2":{"40":1}}],["指针指向一个数组时",{"2":{"20":1}}],["指针指向一个结构体时",{"2":{"20":1}}],["指针引入一个位来跟踪",{"2":{"20":1}}],["指针",{"0":{"20":1,"43":1,"76":1},"1":{"77":1,"78":1,"79":1,"80":1,"81":1,"82":1,"83":1,"84":1},"2":{"76":2,"83":1,"101":1,"284":1}}],["指针修改为",{"2":{"16":1}}],["指定依赖",{"2":{"199":1,"200":1}}],["指定该",{"2":{"192":1,"199":1,"200":1}}],["指定一个",{"2":{"192":1,"199":1,"200":1}}],["指定枚举的标记类型",{"2":{"68":1}}],["指定",{"2":{"15":1}}],["事实上我们使用的",{"2":{"143":1}}],["事实上",{"2":{"16":1,"25":2,"135":1,"139":1,"151":1,"184":1,"194":1,"251":1}}],["查看这里",{"2":{"297":1}}],["查看",{"2":{"15":1,"33":1,"198":1}}],["将允许地址为",{"2":{"284":1}}],["将其转换为编译期计算",{"2":{"255":1}}],["将其过滤掉",{"2":{"186":1}}],["将引入一个额外的机制",{"2":{"197":1}}],["将报告跳过的测试总数",{"2":{"186":1}}],["将会输出类似",{"2":{"184":1}}],["将会提供默认值",{"2":{"140":1}}],["将在当前作用域末尾执行表达式",{"2":{"153":1}}],["将不会执行",{"2":{"142":1,"185":1}}],["将一定是一个",{"2":{"140":1}}],["将一个源码文件看作是一个容器",{"2":{"134":1}}],["将一个切片转换为向量",{"2":{"102":1}}],["将向量转为数组",{"2":{"102":1}}],["将指针更改为更对齐的指针",{"2":{"82":1}}],["将浏览器作为渲染前端",{"2":{"53":1}}],["将整数显式强制转换为浮点数",{"2":{"50":1}}],["将大浮点数转为小浮点数",{"2":{"50":1}}],["将枚举转换为联合类型",{"2":{"47":1}}],["将联合类型转换为枚举",{"2":{"47":1}}],["将",{"2":{"16":2,"42":2,"50":1,"132":1,"250":1}}],["将任意附加命令行参数传递给",{"2":{"15":1}}],["将导致堆栈溢出",{"2":{"9":1}}],["定义一个函数效果是给传入的参数执行加一操作",{"2":{"184":1}}],["定义一个可选类型并且赋值为null",{"2":{"146":1}}],["定义一个数组",{"2":{"102":1}}],["定义文档注释",{"2":{"134":1}}],["定义了一个结构体",{"2":{"89":1}}],["定义了几个对应",{"2":{"12":1}}],["定义预处理器宏",{"2":{"15":1}}],["默认开启",{"2":{"208":1}}],["默认为",{"2":{"191":1,"192":1}}],["默认测试器将报告使用该分配器发现的任何内存泄漏",{"2":{"187":1}}],["默认情况下",{"2":{"73":1}}],["默认优化模式",{"2":{"37":1}}],["默认构建目标",{"2":{"37":1}}],["默认不包含当前目录",{"2":{"15":1}}],["默认包含了输入和输出寄存器",{"2":{"4":1}}],["文档子文件夹",{"2":{"196":1}}],["文档",{"0":{"196":1}}],["文档注释指南",{"0":{"266":1}}],["文档注释会优先使用运算符左侧的注释",{"2":{"143":1}}],["文档注释记录了紧随其后的内容",{"2":{"134":1}}],["文档注释",{"2":{"134":3}}],["文档可能存在错误之处",{"2":{"0":1}}],["文件名分为两类",{"2":{"265":1}}],["文件和",{"2":{"250":1}}],["文件",{"2":{"232":1}}],["文件生成",{"0":{"203":1}}],["文件中可见",{"2":{"117":1}}],["文件解析库",{"2":{"53":1}}],["文件的存储库",{"2":{"23":1}}],["文件的搜索目录",{"2":{"15":1}}],["供我们使用",{"2":{"14":1}}],["提供类型反射的具体功能",{"2":{"255":1}}],["提供全球语言支持",{"2":{"212":1}}],["提供的一个内嵌文件的方式",{"2":{"199":1}}],["提供的处理方案",{"2":{"90":1}}],["提供了几个溢出检测函数来处理溢出问题",{"2":{"272":1}}],["提供了不少函数来获取已有类型的信息",{"2":{"252":1}}],["提供了函数",{"2":{"201":1,"202":1}}],["提供了四种构建模式",{"2":{"190":1}}],["提供了一些内建函数来进行原子操作",{"2":{"236":1}}],["提供了一个方便的函数允许我们直接运行构建结果",{"2":{"192":1,"199":1,"200":1}}],["提供了一个命令行工具",{"2":{"14":1}}],["提供了一种简短方式来定义",{"2":{"137":1}}],["提供了",{"2":{"102":1}}],["提供了类似数组的语法来访问元组",{"2":{"96":1}}],["提供了三种类型转换",{"2":{"38":1}}],["提示",{"2":{"1":1,"2":1,"3":1,"4":1,"6":1,"7":1,"8":1,"9":2,"10":1,"11":1,"13":2,"15":1,"19":1,"23":1,"25":1,"30":1,"35":2,"36":2,"37":1,"57":1,"72":1,"77":1,"78":1,"82":1,"85":1,"89":1,"92":1,"94":1,"96":1,"102":1,"104":1,"105":1,"108":1,"111":1,"112":1,"117":1,"122":1,"126":1,"127":1,"129":1,"135":1,"136":1,"140":1,"141":1,"142":1,"143":1,"166":1,"170":1,"178":1,"184":1,"185":1,"189":1,"191":1,"192":1,"194":1,"201":1,"202":1,"208":1,"211":1,"213":1,"215":1,"225":1,"232":2,"233":1,"258":1,"263":1,"282":1}}],["两者的标准库实现略有不同",{"2":{"202":1}}],["两个不相关的错误集不可以相互转换",{"2":{"280":1}}],["两个文件",{"2":{"224":1,"225":1}}],["两个文件均定义了相同的标识符",{"2":{"13":1}}],["两个参数",{"2":{"201":1,"202":1}}],["两个错误集",{"2":{"143":1}}],["两种操作",{"2":{"124":1}}],["两种输出方式的结果应该是一样的",{"2":{"108":1}}],["两种是完全可以共存的",{"2":{"36":1}}],["两种方式引入外部汇编",{"2":{"3":1}}],["标准构建会产生两个目录",{"2":{"191":1}}],["标准构建模式",{"2":{"191":1,"193":1,"194":1,"197":1,"199":1,"200":1}}],["标准构建目标",{"2":{"191":1,"193":1,"194":1,"197":1,"199":1,"200":1}}],["标准库集成",{"2":{"296":1}}],["标准库提供的函数可能存在溢出",{"2":{"272":1}}],["标准库提供了不少有用的函数",{"2":{"184":1}}],["标准库混入到",{"2":{"250":1}}],["标准库",{"2":{"202":1}}],["标准库和",{"2":{"201":1}}],["标准库的",{"2":{"13":1}}],["标识符命名",{"0":{"130":1}}],["标识符规范",{"2":{"111":1}}],["标志",{"2":{"15":2}}],["标记的指针",{"2":{"284":1}}],["标记的联合类型并没有这种安全监测",{"2":{"282":1}}],["标记的值必须是在编译期已知的",{"2":{"6":1}}],["标记联合",{"0":{"179":1}}],["标记联合类型可以自动转换为对应的枚举",{"2":{"47":1}}],["标记",{"0":{"160":1,"165":1}}],["标记为外部连接函数",{"2":{"18":1}}],["标记告诉编译器表达式需要在编译期完成计算",{"2":{"9":1}}],["标记绑定到变量上",{"2":{"4":1}}],["标记了返回值",{"2":{"4":1}}],["功能的包只有",{"2":{"233":1}}],["功能的函数",{"2":{"7":1}}],["功能结合起来",{"2":{"140":1}}],["功能并不完善",{"2":{"14":1}}],["功能",{"2":{"13":1,"30":1,"208":1}}],["导致在windows下向控制台打印输出中文会发生乱码的现象",{"2":{"212":1}}],["导致浮点数往往是以近似值的方式存储",{"2":{"126":1}}],["导致翻译出错",{"2":{"19":1}}],["导致其不如汇编语言来的方便",{"2":{"2":1}}],["导入的包的",{"2":{"37":1}}],["导入",{"0":{"13":1},"2":{"20":1}}],["导出",{"2":{"11":1}}],["还不想使用心智负担太高的其他高级语言",{"2":{"295":1}}],["还旨在提高代码的安全性",{"2":{"294":1}}],["还包括求余运算",{"2":{"274":1}}],["还包含一个将它们组合成一个数据集的工具",{"2":{"23":1}}],["还没有发布",{"2":{"211":1}}],["还允许我们将",{"2":{"164":1}}],["还允许我们访问并操作枚举的标记值",{"2":{"68":1}}],["还支持使用",{"2":{"179":1}}],["还支持用",{"2":{"171":1}}],["还支持一个被称为",{"2":{"163":1}}],["还支持将错误从子集转换到超集",{"2":{"136":1}}],["还要求所有的非顶层定义的变量",{"2":{"129":1}}],["还有",{"2":{"272":1}}],["还有在标准库",{"2":{"125":1}}],["还有一种使用场景是",{"2":{"116":1}}],["还有一个额外的语法",{"2":{"78":1}}],["还有一个特殊标记",{"2":{"4":1}}],["还有一些你可能用不到的分配模型",{"2":{"25":1}}],["还可用于布尔",{"2":{"104":1}}],["还可以用来初始化泛型实例",{"2":{"287":1}}],["还可以用于浮点型",{"2":{"104":1}}],["还可以使用",{"2":{"250":1}}],["还可以使用else分支",{"2":{"167":2}}],["还可以对",{"2":{"99":1}}],["还可以配置使用的mutex",{"2":{"27":1}}],["还可以作为",{"2":{"11":1}}],["还具有",{"2":{"86":1}}],["还提供了在编译期构建全新类型的能力",{"2":{"261":1}}],["还提供了内存池的功能",{"2":{"25":1}}],["还提供了一个比较",{"2":{"23":1}}],["还是很有希望成为",{"2":{"293":1}}],["还是需要自行下载并添加环境变量",{"2":{"216":1}}],["还是返回",{"2":{"139":1}}],["还是",{"2":{"17":1,"112":1}}],["仍然具有非常强大的与",{"2":{"11":1}}],["与cpu指令集实现有关",{"2":{"143":1}}],["与或非",{"2":{"127":1}}],["与",{"0":{"11":1},"1":{"12":1,"13":1,"14":1,"15":1,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"22":1,"23":1,"24":1},"2":{"17":1}}],["来声明零位整数类型",{"2":{"288":1}}],["来声明并定义一个数组",{"2":{"55":1}}],["来强制指定在单独的块中是否开启安全检查",{"2":{"267":1}}],["来强制对",{"2":{"99":1}}],["来为你演示一下",{"2":{"232":1}}],["来向",{"2":{"231":1}}],["来使用",{"2":{"209":1}}],["来链接",{"2":{"201":1}}],["来作为演",{"2":{"201":1}}],["来捕获标准错误输出",{"2":{"200":1}}],["来捕获额外的错误",{"2":{"141":1}}],["来添加",{"2":{"201":1}}],["来添加单个参数",{"2":{"200":1}}],["来添加当前目录",{"2":{"15":1}}],["来输出",{"2":{"200":1}}],["来将",{"2":{"194":1}}],["来指定构建过程之间的依赖管理",{"2":{"192":1}}],["来查看当前是否运行在测试器下",{"2":{"188":1}}],["来保证它遵守",{"2":{"178":1}}],["来对代码进行优化",{"2":{"176":1}}],["来要求编译器帮我们展开这个switch",{"2":{"175":1}}],["来要求编译器生成该分支对应的所有可能分支",{"2":{"175":1}}],["来解构它",{"2":{"152":1}}],["来解决此问题",{"2":{"129":1}}],["来告诉",{"2":{"145":1}}],["来匹配错误集来解决该问题",{"2":{"143":1}}],["来通知编译器忽略它即可",{"2":{"141":1}}],["来看一个例子",{"2":{"140":1}}],["来看个例子",{"2":{"126":1}}],["来表示当违反事先预定情况时会发生未定义行为",{"2":{"266":1}}],["来表示",{"2":{"107":1}}],["来从",{"2":{"105":1}}],["来操作切片的指针",{"2":{"86":1}}],["来确定",{"2":{"79":1}}],["来描述一个元素为类型",{"2":{"57":1}}],["来进行正确性检验的测试工作",{"2":{"183":1}}],["来进行变量的声明",{"2":{"129":1}}],["来进行矩阵的打印",{"2":{"56":1}}],["来进行一些检查",{"2":{"30":1}}],["来获取枚举时",{"2":{"279":1}}],["来获取枚举的大小和对应的",{"2":{"70":1}}],["来获取类型",{"2":{"255":1}}],["来获取命令参数决定是否剥离调试信息",{"2":{"193":1}}],["来获取到对应的",{"2":{"179":1}}],["来获取有效的信息",{"2":{"135":1}}],["来获取对应的指针",{"2":{"50":1}}],["来获取",{"2":{"35":1}}],["来帮助我们实现这个数组的初始化",{"2":{"66":1}}],["来帮助我们实现",{"2":{"24":1}}],["来实现从命令行读取一个参数决定是否剥离二进制程序的调试信息",{"2":{"193":1}}],["来实现的",{"2":{"149":1}}],["来实现",{"2":{"21":1}}],["来提高类型安全性",{"2":{"16":1}}],["来生成数据结构",{"2":{"10":1}}],["来修改默认的堆栈嵌套",{"2":{"9":1}}],["函数调用",{"2":{"294":1}}],["函数的原型为",{"2":{"262":1}}],["函数的返回值是",{"2":{"233":1}}],["函数的参数是不可变的",{"2":{"112":1}}],["函数接受两个参数",{"2":{"232":1}}],["函数接受一个表达式作为参数",{"2":{"13":1}}],["函数来输出语句",{"2":{"232":1}}],["函数查找对应名称的模块或者",{"2":{"232":1}}],["函数将联合类型作为声明的枚举来使用",{"2":{"179":1}}],["函数也同理",{"2":{"143":1}}],["函数无论是返回",{"2":{"139":1}}],["函数参数可以用",{"2":{"115":1}}],["函数体是仅限编译时的类型",{"2":{"111":1}}],["函数体和函数指针之间是有区别的",{"2":{"111":1}}],["函数是编程语言中最为基本的语句",{"2":{"110":1}}],["函数指针略有特殊",{"2":{"77":1}}],["函数要求返回一个数组的元素或者一个数组",{"2":{"65":1}}],["函数暴露的模块是完全公开的",{"2":{"36":1}}],["函数传入的参数",{"2":{"36":1,"37":1}}],["函数原型",{"2":{"18":1,"238":1,"239":1,"240":1,"241":1,"242":1,"243":1}}],["函数",{"0":{"110":1},"1":{"111":1,"112":1,"113":1,"114":1,"115":1,"116":1,"117":1,"118":1,"119":1},"2":{"13":2,"19":2,"102":1,"116":1,"191":1,"232":2}}],["函数初始化变量",{"2":{"10":1}}],["函数作为编译期可执行函数",{"2":{"9":1}}],["函数仅仅只能比较整数和浮点数",{"2":{"7":1}}],["使得无法在运行时计算索引来便利",{"2":{"255":1}}],["使构建脚本部分配置由用户决定",{"2":{"193":1}}],["使变量保持未初始化状态",{"2":{"132":1}}],["使其内存布局保证匹配对应目标的",{"2":{"98":1}}],["使用驼峰命名法",{"2":{"265":3}}],["使用蛇形命名法",{"2":{"265":1}}],["使用任意一个没有区别",{"2":{"215":1}}],["使用构建系统执行单元测试时",{"2":{"197":1}}],["使用默认提供的优化方案",{"2":{"195":1}}],["使用默认提供的构建目标",{"2":{"195":1}}],["使用它出现无法预知的情况",{"2":{"132":1}}],["使用它需要在",{"2":{"30":1}}],["使用传入的运算符对向量进行水平按顺序合并",{"2":{"104":1}}],["使用位转换",{"2":{"99":1}}],["使用位域",{"2":{"18":1}}],["使用函数初始化数组",{"0":{"65":1}}],["使用方式和",{"2":{"36":1}}],["使用起来也很简单",{"2":{"36":1}}],["使用了",{"2":{"35":1}}],["使用了宏的",{"2":{"19":1}}],["使用模型",{"2":{"26":1,"28":1}}],["使用相同源文件",{"2":{"17":1}}],["使用时请注意查询",{"2":{"14":1}}],["使用",{"2":{"11":1,"12":1,"17":1,"21":1,"24":1,"27":2,"35":1,"53":4,"55":1,"94":1,"112":1,"115":1,"122":1,"131":1,"141":1,"144":2,"179":1,"193":2,"207":1,"212":1,"229":1,"253":1,"265":7,"266":1,"271":1,"278":1}}],["使用自己的堆栈进行comptime函数调用",{"2":{"9":1}}],["使之支持布尔值",{"2":{"7":1}}],["799248",{"2":{"202":1}}],["7",{"2":{"9":2,"60":2,"102":1,"105":1,"106":2,"202":2}}],["只是一个有那么一丁点热度的高级语言",{"2":{"293":1}}],["只是翻译宏可能失败",{"2":{"19":1}}],["只读的",{"2":{"255":1}}],["只能通过",{"2":{"255":1}}],["只能获取到公共成员",{"2":{"185":1}}],["只需要指定好恰当的",{"2":{"198":1}}],["只需要使用",{"2":{"184":1}}],["只需要在普通类型的前面增加一个",{"2":{"139":1}}],["只需要在定义结构体的时候声明默认值即可",{"2":{"93":1}}],["只需要记住",{"2":{"112":1}}],["只需要编写普通的函数就行",{"2":{"9":1}}],["只有一个值的",{"2":{"290":1}}],["只有一个值的错误集",{"0":{"137":1}}],["只有初次声明时可以赋值",{"2":{"131":1}}],["只有在使用哨兵时",{"2":{"57":1}}],["只有为了避免符号冲突",{"2":{"13":1}}],["只要能让",{"2":{"91":1}}],["只要代码不依赖于未定义的内存布局",{"2":{"84":1}}],["只要两个数组类型",{"2":{"60":1}}],["只要对",{"2":{"24":1}}],["只要编译器知道去哪里找到函数的具体实现",{"2":{"18":1}}],["只保留运行时所需要的分支",{"2":{"7":1}}],["则它们必定是零位类型",{"2":{"289":1}}],["则它应该使用",{"2":{"265":1}}],["则需要用户自己参照所使用的shell的配置来设置path",{"2":{"221":1}}],["则需要使用",{"2":{"81":1}}],["则需要使用两个",{"2":{"4":1}}],["则推荐使用",{"2":{"208":2}}],["则使用",{"2":{"195":1}}],["则构建系统会接收命令行的参数来决定实际构建模式",{"2":{"190":1}}],["则us容器中的测试块也会被执行测试",{"2":{"185":1}}],["则我们可以这样子来执行检测",{"2":{"184":1}}],["则是对应的标签名",{"2":{"175":1}}],["则是完全只使用",{"2":{"30":1}}],["则类似于return",{"2":{"164":1}}],["则不会执行",{"2":{"153":1}}],["则两个类型均为",{"2":{"122":1}}],["则结果中的相应元素将为",{"2":{"106":1}}],["则结果元素也是",{"2":{"105":1}}],["则",{"2":{"105":1}}],["则编译器将默认一次对每个向量元素进行操作",{"2":{"102":1}}],["则编译器会报错",{"2":{"43":1}}],["则可以定义一个名字为空的定义测试块",{"2":{"185":1}}],["则可以从类型中省略它",{"2":{"82":1}}],["则可以这样解引用",{"2":{"20":2}}],["则会触发安全保护中的未定义问题",{"2":{"87":1}}],["则会由",{"2":{"39":1}}],["则会发出编译错误",{"2":{"9":1}}],["则发出编译错误",{"2":{"9":1}}],["所安装的",{"2":{"208":1}}],["所设计的跨平台",{"2":{"207":1}}],["所指的交互并不仅仅是使用",{"2":{"11":1}}],["所有测试运行后",{"2":{"186":1}}],["所有常量都是",{"2":{"131":1}}],["所有的运算符均可用于整型",{"2":{"104":1}}],["所有的转义字符均可以在字符串和",{"2":{"61":1}}],["所有表达式都是隐式的",{"2":{"9":1}}],["所有函数调用都会导致编译器在编译时解释该函数",{"2":{"9":1}}],["所有具有运行时副作用或依赖于运行时值的代码都会发出编译错误",{"2":{"9":1}}],["所有",{"2":{"9":2}}],["所有变量都是",{"2":{"9":1}}],["所以我写了这个文档",{"2":{"293":1}}],["所以我们可能需要添加一个锁来保证打印函数的先后执行顺序",{"2":{"234":1}}],["所以我们如何解决这个问题呢",{"2":{"233":1}}],["所以我们先看一下什么是运行时",{"2":{"6":1}}],["所以官方鼓励用户使用",{"2":{"211":1}}],["所以任何没有明确说明内存布局的容器在",{"2":{"190":1}}],["所以当调试应用程序时",{"2":{"141":1}}],["所以当传入的",{"2":{"7":1}}],["所以你可以使用",{"2":{"108":1}}],["所以",{"2":{"23":1,"96":1,"100":1}}],["通用",{"2":{"294":1}}],["通用linux安装方式",{"0":{"220":1}}],["通常为",{"2":{"232":1}}],["通常",{"2":{"195":1}}],["通常我们定义一个",{"2":{"195":1}}],["通常仅使用",{"2":{"191":1}}],["通常用于记录一个文件的作用",{"2":{"134":1}}],["通常只需要设置对应的寄存器即可",{"2":{"112":1}}],["通常不足8位的仍然使用8位",{"2":{"99":1}}],["通常自引用方式为函数参数第一个为结构体指针类型",{"2":{"90":1}}],["通常是我们使用",{"2":{"37":1}}],["通常是为了修改翻译后的代码",{"2":{"16":1}}],["通常编写内核会使用这个",{"2":{"20":1}}],["通常它仅出现在翻译输出代码中",{"2":{"20":1}}],["通常情况下",{"2":{"13":1}}],["通常一个编译期已知的语句或函数带有",{"2":{"6":1}}],["通过句柄写入buffer",{"2":{"233":1}}],["通过在",{"2":{"232":1}}],["通过软链接映射到",{"2":{"220":1}}],["通过官方的发布页面下载对应的",{"2":{"215":1,"219":1}}],["通过标准库获取时间戳",{"2":{"194":1}}],["通过命令行参数传递",{"2":{"193":1}}],["通过可选类型我们可以解决这个问题",{"2":{"145":1}}],["通过函数",{"2":{"136":1}}],["通过它使用",{"2":{"96":1}}],["通过字段获取基指针",{"0":{"95":1}}],["通过编译期来初始化数组",{"2":{"66":1}}],["通过调用",{"2":{"17":1}}],["通过",{"2":{"9":1,"36":1,"37":1,"76":1,"178":1,"179":1,"191":1,"193":1,"233":1,"254":1,"255":1}}],["预处理器的场景",{"2":{"8":1}}],["代替类型来声明",{"2":{"115":1}}],["代替",{"2":{"55":1,"72":1,"79":1}}],["代码管控工具",{"2":{"206":1}}],["代码重构功能",{"2":{"205":1}}],["代码自动补全",{"2":{"205":1}}],["代码交互时的类型安全",{"2":{"74":1}}],["代码转换并不会出问题",{"2":{"19":1}}],["代码链接时出现微妙的",{"2":{"15":1}}],["代码",{"2":{"11":1,"13":1}}],["代码翻译为",{"2":{"11":1}}],["代码生成",{"2":{"8":1}}],["代表它的值是null或者这个类型",{"2":{"145":1}}],["代表有符号的7位整数",{"2":{"122":1}}],["代表着我们接下来定义了一个函数",{"2":{"111":1}}],["代表可以接受任何类型的",{"2":{"75":1}}],["代表这个值尚未初始化",{"2":{"48":1}}],["代表只能进行写入操作数",{"2":{"4":1}}],["代表我们整个内联汇编表达式需要返回一个值",{"2":{"4":1}}],["代表我们使用",{"2":{"4":1}}],["xmake",{"2":{"293":1}}],["xmlparser",{"2":{"265":1}}],["xml",{"2":{"265":2}}],["xxx",{"2":{"256":1,"257":1}}],["xpf",{"2":{"220":1,"221":1}}],["xbps",{"2":{"218":1}}],["x++",{"2":{"202":1}}],["x0",{"2":{"202":1}}],["xor",{"2":{"104":1}}],["xiaoming",{"2":{"90":1}}],["xfe",{"2":{"61":1}}],["xff",{"2":{"61":1}}],["xf0",{"2":{"61":1}}],["xaf",{"2":{"61":1}}],["x92",{"2":{"61":1}}],["x9f",{"2":{"61":1}}],["x65llo",{"2":{"61":1}}],["x65",{"2":{"61":1}}],["xnn",{"2":{"61":2,"62":1}}],["x4",{"2":{"43":1}}],["x3",{"2":{"43":1,"202":1}}],["x3c",{"2":{"8":1,"9":1,"21":1,"63":1,"119":2,"127":10,"162":2,"163":3,"164":1,"165":1,"166":2,"201":1,"202":17,"265":3}}],["x",{"2":{"43":5,"46":2,"57":3,"61":2,"65":2,"78":2,"79":2,"82":3,"84":3,"87":3,"91":2,"93":1,"95":4,"100":1,"105":1,"115":3,"127":11,"133":4,"139":6,"173":5,"176":2,"202":24,"258":7,"259":4,"265":2}}],["x2",{"2":{"43":4,"202":1}}],["x26",{"2":{"8":1,"10":1,"19":2,"21":2,"27":2,"43":11,"51":2,"66":1,"77":1,"78":2,"82":4,"84":1,"86":1,"90":1,"99":2,"127":3,"133":1,"155":1,"185":1,"192":1,"196":1,"197":1,"199":1,"200":3,"201":2,"202":18,"253":1,"259":2,"262":2}}],["x1",{"2":{"43":2,"202":1}}],["xz",{"2":{"35":1,"220":1,"221":1}}],["x86",{"2":{"2":2,"4":3,"23":1,"24":4,"82":2,"198":1,"215":3,"219":1}}],["下的函数均是测试使用的",{"2":{"184":1}}],["下一行代表返回到blk这个tag处",{"2":{"171":1}}],["下划线",{"2":{"130":1}}],["下划线可以放在数字之间作为视觉分隔符",{"2":{"122":1}}],["下",{"2":{"99":1,"195":2}}],["下标索引从",{"2":{"55":1}}],["下面来进行说明",{"2":{"111":1}}],["下面是一个日常会用到的一个结构体例子",{"2":{"90":1}}],["下面语句执行为",{"2":{"51":1}}],["下面的内容可能有点难",{"2":{"232":1}}],["下面的",{"2":{"8":1,"47":1}}],["下可用",{"2":{"29":1}}],["下输出",{"2":{"4":1}}],["36",{"2":{"267":1}}],["300",{"2":{"271":2}}],["30",{"2":{"202":1}}],["3089",{"2":{"149":2}}],["399424",{"2":{"202":1}}],["32",{"2":{"122":2}}],["3509",{"2":{"100":1}}],["348480",{"2":{"202":1}}],["34",{"2":{"41":1,"47":1,"51":1,"96":1,"282":1}}],["3",{"2":{"8":1,"9":1,"42":1,"43":1,"47":2,"51":1,"57":1,"59":6,"60":2,"65":1,"78":2,"84":1,"85":3,"86":2,"87":3,"89":2,"90":1,"94":2,"96":2,"99":1,"102":3,"105":2,"106":1,"126":2,"151":1,"152":2,"155":2,"157":1,"158":1,"159":1,"163":1,"166":2,"167":1,"168":1,"171":1,"176":1,"202":1}}],["+|=",{"2":{"127":1}}],["+|",{"2":{"127":2}}],["++r",{"2":{"202":1}}],["++tick",{"2":{"202":1}}],["++",{"2":{"60":2,"96":1,"127":2}}],["+=",{"2":{"8":1,"21":2,"84":2,"127":1,"133":2,"139":1,"155":2,"160":2,"161":2,"162":2,"163":1,"164":1,"165":1,"166":4,"167":2,"168":2,"173":2,"179":1,"202":2,"253":1}}],["+",{"2":{"8":3,"9":2,"19":2,"51":1,"65":1,"77":1,"78":1,"85":1,"102":2,"111":1,"115":1,"125":2,"126":2,"127":5,"139":2,"171":2,"176":1,"184":3,"202":17,"215":2,"258":1,"260":1,"272":2}}],["实在是太多营销号视频无脑说",{"2":{"293":1}}],["实现的",{"2":{"53":2}}],["实现内存分配器",{"0":{"33":1}}],["实现了一套",{"2":{"11":1}}],["实现",{"2":{"11":1,"37":1,"53":1,"141":1}}],["实现更加高效或者更直白的操作",{"2":{"4":1}}],["实际上就是声明结构体类型",{"2":{"100":1}}],["实际上就是嵌套数组",{"2":{"56":1}}],["实际上枚举仅仅是一种命名空间",{"2":{"69":1}}],["实际上",{"2":{"23":1,"134":1,"255":1}}],["实际上会在编译期生成不同的代码",{"2":{"8":1}}],["实际没有必要这么操作",{"2":{"8":1}}],["该语言不使用宏或预处理器指令",{"2":{"294":1}}],["该语法将会告诉",{"2":{"233":1}}],["该内建函数用于获取类型的信息",{"2":{"255":1}}],["该内建函数用于获取类型的名字",{"2":{"254":1}}],["该内建函数用于使用获取变量的类型",{"2":{"253":1}}],["该命令为",{"2":{"229":1}}],["该插件已经有两年无人维护",{"2":{"210":1}}],["该软件以扩展的方式支持语法高亮",{"2":{"205":1}}],["该字段是为",{"2":{"201":1,"202":1}}],["该函数实际上就是",{"2":{"262":1}}],["该函数的效果是返回一个",{"2":{"255":1}}],["该函数的具体效果取决于我们如何对待返回的",{"2":{"139":1}}],["该函数返回的类型名字完全是一个字符串字面量",{"2":{"254":1}}],["该函数仅在函数作用域内有效",{"2":{"118":1}}],["该类型包含了所有",{"2":{"255":1}}],["该类型一般用在内核开发中",{"2":{"116":1}}],["该类型不保证在此之前不存在哨兵元素",{"2":{"87":1}}],["该变量长度相当于另一个非",{"2":{"105":1}}],["该变量的读取和写入完全是在编译期执行的",{"2":{"8":1}}],["该节内容",{"2":{"81":1}}],["该示例中使用了",{"2":{"79":1}}],["该表达式会在编译期执行",{"2":{"13":1}}],["该特性可以与",{"2":{"8":1}}],["该值为枚举的一个值",{"2":{"47":1}}],["该值",{"2":{"6":1}}],["裁剪掉",{"2":{"7":1}}],["时间和语言",{"2":{"212":1}}],["时语法出现在",{"2":{"168":1}}],["时触发并退出循环",{"2":{"167":2}}],["时终止循环",{"2":{"167":1}}],["时使用零指针",{"2":{"83":1}}],["时",{"2":{"7":1,"29":1,"47":1,"55":1,"86":1,"157":1,"175":1,"213":1,"229":1,"276":1,"277":1,"289":1}}],["时效性高的程序",{"2":{"2":1}}],["是很明显的零位类型",{"2":{"287":1}}],["是可被调用",{"2":{"265":1}}],["是可以被调用的",{"2":{"265":1}}],["是可选类型的标志",{"2":{"145":1}}],["是否包含指定名字的字段",{"2":{"257":1}}],["是指计算机程序在运行时",{"2":{"251":1}}],["是充当保存变量和函数声明的命名空间的任何语法结构",{"2":{"249":1}}],["是编辑器之神",{"2":{"209":1}}],["是一种命令式",{"2":{"294":1}}],["是一种通用的编程语言和工具链",{"2":{"294":1}}],["是一门",{"2":{"295":1}}],["是一门静态语言并不具有过多的运行时功能",{"2":{"255":1}}],["是一门强类型的静态语言",{"2":{"251":1}}],["是一款专为开发",{"2":{"207":1}}],["是一款由微软开发且跨平台的免费源代码编辑器",{"2":{"205":1}}],["是一个运行时可知的值",{"2":{"175":1}}],["是一个特殊的类型",{"2":{"116":1}}],["是一个切片",{"2":{"87":1}}],["是一个比较特殊的类型",{"2":{"75":1}}],["是一个神奇的值",{"2":{"48":1}}],["是一个参数",{"2":{"7":1}}],["是由",{"2":{"199":1}}],["是将构建放入",{"2":{"192":1}}],["是这样的",{"2":{"191":1}}],["是不可复现的",{"2":{"190":1}}],["是针对程序模块",{"2":{"183":1}}],["是当",{"2":{"164":1}}],["是索引",{"2":{"157":1}}],["是值",{"2":{"157":1}}],["是如何解构错误联合可选类型的呢",{"2":{"152":1}}],["是许多运行时异常的根源",{"2":{"145":1}}],["是顶层文档注释",{"2":{"134":1}}],["是标签名字",{"2":{"133":1}}],["是标识符",{"2":{"111":1}}],["是相同大小",{"2":{"127":1}}],["是相等的",{"2":{"41":1}}],["是函数的返回类型",{"2":{"111":1}}],["是参数的标识符和类型",{"2":{"111":1}}],["是关键字",{"2":{"111":1}}],["是访问修饰符",{"2":{"111":1}}],["是哨兵值",{"2":{"87":1}}],["是多项指针",{"2":{"87":1}}],["是长度为",{"2":{"51":1}}],["是错误联合类型时",{"2":{"43":1}}],["是在在",{"2":{"37":1}}],["是对应的",{"2":{"35":1}}],["是源代码地址",{"2":{"35":1}}],["是依赖包的名字",{"2":{"35":1}}],["是为了指定静态链接",{"2":{"24":1}}],["是为了防止编译失败",{"2":{"24":1}}],["是正常可以工作的",{"2":{"19":1}}],["是正确的",{"2":{"15":1}}],["是文件依赖项列表",{"2":{"17":1}}],["是默认的构建变量",{"2":{"13":1}}],["是",{"2":{"7":1,"56":1,"72":1,"104":2,"105":1,"106":1,"129":1,"131":1,"132":1}}],["参照页面配置即可",{"2":{"209":1}}],["参照",{"2":{"42":2}}],["参数的具体类型可以参考",{"2":{"262":1}}],["参数来实现效果",{"2":{"229":1}}],["参数类型为",{"2":{"190":1}}],["参数上的",{"2":{"113":1}}],["参数传递是一个非常古老的问题",{"2":{"112":1}}],["参数传递",{"0":{"112":1}}],["参数为包的包构建根目录和通过",{"2":{"37":1}}],["参数",{"0":{"193":1},"2":{"17":1,"37":1,"191":1}}],["参数在",{"2":{"7":1}}],["参与贡献本文档",{"2":{"1":1}}],["参与贡献",{"0":{"1":1}}],["上最棒的开发",{"2":{"206":1}}],["上",{"2":{"196":1,"197":1}}],["上的区别",{"2":{"145":1}}],["上的编译器崩溃",{"2":{"102":1}}],["上方的代码的内容",{"2":{"89":1}}],["上方的",{"2":{"24":1,"133":1}}],["上述的",{"2":{"7":1}}],["上面我们已经完成了带有缓冲区的",{"2":{"234":1}}],["上面仅仅只是一个示例而已",{"2":{"232":1}}],["上面的内容你应该已经看完了",{"2":{"232":1}}],["上面的这些限制可能在未来会被改善",{"2":{"143":1}}],["上面几条规则看着很模糊是吧",{"2":{"100":1}}],["上面这段代码毫无疑问会失败",{"2":{"271":1}}],["上面这段代码是通过内联汇编实现在",{"2":{"4":1}}],["上面这句话看起来有点云里雾里",{"2":{"143":1}}],["上面这个语句执行会成功",{"2":{"51":1}}],["上面操作可行的原因",{"2":{"7":1}}],["上面就是基本的内联汇编的一个外部结构说明",{"2":{"4":1}}],["也都是",{"2":{"293":1}}],["也保证与源文件中出现的顺序相同",{"2":{"255":1}}],["也安装了对应的编辑器",{"2":{"222":1}}],["也会运行非命名测试",{"2":{"186":1}}],["也会尝试解构可选类型",{"2":{"167":1}}],["也支持自动推断联合类型",{"2":{"180":1}}],["也是零位类型",{"2":{"290":1,"292":1}}],["也是true",{"2":{"72":1}}],["也是没有对应的类型",{"2":{"47":1}}],["也有效",{"2":{"43":1}}],["也没有问题",{"2":{"41":1}}],["也就是不同编译器支持的语法实际上是",{"2":{"293":1}}],["也就是说它仅仅会执行容器的顶层测试块和它引用的容器的顶层测试块",{"2":{"185":1}}],["也就是说一个包本身可以包含多个模块",{"2":{"36":1}}],["也就是字符串",{"2":{"179":1}}],["也就是一个类型",{"2":{"7":1}}],["也可以用来给",{"2":{"222":1}}],["也可以通过内置的扩展程序商店安装其他扩展以拓展软件功能",{"2":{"205":1}}],["也可以使用诸如",{"2":{"214":1}}],["也可以使用",{"2":{"200":2,"209":1}}],["也可以继续对枚举类型进行自动推断",{"2":{"174":1}}],["也可以作为表达式来使用",{"2":{"159":1}}],["也可以访问索引",{"2":{"157":1}}],["也可以将",{"2":{"138":1}}],["也可以没有返回值",{"2":{"4":1}}],["也可以不返回值",{"2":{"4":1}}],["叫起来也像鸭子",{"2":{"7":1}}],["否则会触发编译器错误",{"2":{"275":1}}],["否则会编译错误",{"2":{"134":1}}],["否则应使用",{"2":{"265":1}}],["否则将会编译无法通过",{"2":{"255":1}}],["否则将会是由编译器推导的",{"2":{"152":1}}],["否则仅读取值返回",{"2":{"241":1,"242":1}}],["否则的话我们直接会返回",{"2":{"145":1}}],["否则我们需要释放这个块内存",{"2":{"142":1}}],["否则解构它",{"2":{"141":1}}],["否则失败",{"2":{"119":1}}],["否则为",{"2":{"106":1}}],["否则可能会出现解析失败或者与",{"2":{"15":1}}],["否则",{"2":{"6":1}}],["类型作为一等公民",{"2":{"296":1}}],["类型无法容纳下",{"2":{"271":1}}],["类型无法进行比较",{"2":{"253":1}}],["类型和命名空间",{"2":{"265":1}}],["类型声明",{"2":{"265":4}}],["类型声明使用",{"2":{"265":1}}],["类型声明一个具有未知",{"2":{"74":1}}],["类型的",{"2":{"127":1}}],["类型的字段",{"2":{"99":1}}],["类型的时候",{"2":{"12":1}}],["类型是",{"2":{"92":1}}],["类型是一等公民",{"2":{"6":1,"88":1,"296":1}}],["类型为u16",{"2":{"129":1}}],["类型为",{"2":{"85":4,"86":1,"152":1}}],["类型类似",{"2":{"82":1}}],["类型可以强制转换为",{"2":{"82":1}}],["类型后再进行计算",{"2":{"76":1}}],["类型转换",{"0":{"38":1},"1":{"39":1,"40":1,"41":1,"42":1,"43":1,"44":1,"45":1,"46":1,"47":1,"48":1,"49":1,"50":1,"51":1},"2":{"38":1}}],["类型或者代码结构无法被翻译的函数会使用",{"2":{"18":1}}],["类型",{"0":{"12":1,"122":1},"2":{"6":1,"47":1,"75":1,"108":3,"122":1,"134":1,"151":1,"255":1}}],["类似于",{"2":{"232":1}}],["类似makefile一样的存在",{"2":{"189":1}}],["类似循环中的",{"2":{"171":1}}],["类似在命令行构建时使用的",{"2":{"37":1}}],["类似",{"2":{"4":1,"54":1,"257":1}}],["对交叉编译的一流支持",{"2":{"296":1}}],["对不变量使用",{"2":{"266":1}}],["对指定的源文件运行test",{"2":{"228":1}}],["对指定文件进行ast语法检查",{"2":{"226":1}}],["对指针的操作应假定为没有副作用",{"2":{"81":1}}],["对枚举类型进行自动推断",{"0":{"174":1}}],["对字段值的修改可以通过在捕获变量名称之前放置",{"2":{"173":1}}],["对标记联合类型进行捕获操作",{"2":{"173":1}}],["对比一下",{"2":{"145":1}}],["对等类型解析",{"2":{"127":1}}],["对等类型转换处理",{"2":{"51":4}}],["对等类型转换处理数组到常量切片",{"2":{"51":1}}],["对等类型转换处理不同大小的数组到切片",{"2":{"51":1}}],["对等类型转换处理整数转换",{"2":{"51":1}}],["对等类型转换发生时",{"2":{"51":1}}],["对等类型转换",{"0":{"51":1},"2":{"51":1,"253":1}}],["对整数的类型划分很详细",{"2":{"122":1}}],["对齐整数的位宽",{"2":{"99":1}}],["对齐的",{"2":{"97":1}}],["对齐",{"0":{"82":1}}],["对数组做乘法操作",{"2":{"59":1}}],["对",{"2":{"53":2}}],["对通用内存分配器进行一层包裹",{"2":{"28":1}}],["对应的是用户的环境变量",{"2":{"215":1}}],["对应的系统全局的环境变量",{"2":{"215":1}}],["对应的枚举值可以直接自动转换为标记联合类型",{"2":{"47":1}}],["对应c",{"2":{"126":1}}],["对应c类型",{"2":{"122":1}}],["对应",{"2":{"12":1,"21":3,"153":1}}],["对应地",{"2":{"6":1}}],["对于上面的问题",{"2":{"143":1}}],["对于外部函数",{"2":{"112":1}}],["对于每个",{"2":{"105":1}}],["对于数组和切片",{"2":{"78":1}}],["对于一个编译期表达式",{"2":{"9":1}}],["对于这个概念",{"2":{"6":1}}],["对于",{"2":{"2":1}}],["异步",{"0":{"5":1}}],["old",{"2":{"202":2}}],["otherfunction",{"2":{"265":1}}],["otherwise",{"2":{"202":1}}],["other",{"2":{"148":1}}],["overflowed",{"2":{"272":1}}],["overflow",{"2":{"139":2,"141":1,"143":3}}],["overaligned",{"2":{"99":1}}],["ov",{"2":{"139":6,"143":6,"272":4}}],["outer",{"2":{"160":5,"165":5}}],["outofmemory",{"2":{"136":5,"142":1}}],["out",{"2":{"124":2,"191":2,"192":1,"195":2,"208":1,"233":12,"267":5}}],["output",{"2":{"17":1,"81":1,"200":2,"233":1}}],["outputoperands",{"2":{"4":1}}],["object",{"2":{"117":1,"201":1}}],["ostree",{"2":{"218":1}}],["os",{"2":{"83":1,"172":5,"198":1}}],["ok",{"2":{"68":3,"79":1,"179":16,"184":2}}],["offsetof",{"2":{"99":4}}],["off",{"2":{"71":1,"174":3}}],["of",{"2":{"42":1,"53":1,"60":2,"82":2,"89":1,"102":1,"185":1}}],["operand",{"2":{"240":1}}],["operands",{"2":{"42":1}}],["op",{"2":{"104":1,"240":1}}],["optinal",{"2":{"175":1}}],["optional",{"2":{"145":3,"146":2,"152":5,"175":1}}],["option",{"2":{"37":1,"193":4,"194":2,"296":1}}],["options",{"0":{"194":1},"2":{"36":1,"37":1,"191":1,"192":2,"193":1,"194":11}}],["optimized",{"2":{"126":2}}],["optimize",{"2":{"37":3,"191":4,"193":3,"194":3,"195":5,"197":5,"198":2,"199":3,"200":3,"201":3,"202":3}}],["opaque",{"0":{"74":1},"1":{"75":1},"2":{"18":3,"74":3,"75":2}}],["o",{"2":{"8":2,"17":3,"55":2,"105":1,"267":1}}],["order",{"2":{"241":2,"242":2,"243":1}}],["ordering",{"2":{"238":1,"239":1,"240":1,"245":1}}],["ordered",{"2":{"99":5}}],["org",{"2":{"201":1}}],["orelse",{"2":{"127":1,"142":1,"145":2,"193":1}}],["or",{"2":{"7":2,"104":1,"127":2}}],["only",{"2":{"250":1}}],["one",{"2":{"8":4,"47":2,"60":2,"68":1,"70":1,"72":6,"122":1,"184":2,"202":1}}],["on",{"2":{"4":1,"71":1,"174":2,"245":1}}],["hot",{"2":{"245":1}}],["host",{"2":{"124":2,"267":4}}],["horizontal",{"2":{"104":1}}],["homebrewmacports",{"2":{"216":1}}],["home",{"2":{"17":3,"124":3,"267":6}}],["hundred",{"2":{"68":1}}],["h>",{"2":{"63":1,"201":1,"202":4}}],["hit",{"2":{"202":6}}],["hi",{"2":{"51":2,"96":4,"256":4,"257":3}}],["https",{"2":{"35":3,"205":1,"206":1,"208":3,"229":2}}],["happens",{"2":{"245":2}}],["hasfield",{"0":{"257":1},"2":{"252":1,"257":5}}],["hasdecl",{"0":{"256":1},"2":{"252":1,"256":5,"257":1}}],["has",{"2":{"202":1}}],["hash",{"2":{"35":5}}],["half1",{"2":{"99":2}}],["hacker",{"2":{"23":1}}],["handle",{"2":{"4":1,"29":1}}],["h",{"2":{"13":1,"17":5,"41":3,"43":4,"55":3,"61":1,"105":1,"108":3,"202":1,"250":3}}],["help",{"2":{"193":1}}],["hello",{"0":{"231":1},"1":{"232":1,"233":1,"234":1,"235":1},"2":{"4":2,"13":1,"43":9,"55":1,"61":2,"63":3,"79":1,"87":1,"90":1,"105":1,"192":2,"199":7,"200":6,"201":6,"231":2,"232":1,"233":7,"235":1,"250":1}}],["here",{"2":{"124":1}}],["hearts",{"2":{"69":1}}],["heapapi",{"2":{"29":1}}],["heapallocator",{"0":{"29":1},"2":{"25":1,"29":1}}],["heap",{"2":{"25":5,"26":1,"27":3,"28":2,"29":5,"30":1,"31":1,"32":1,"33":2,"90":1}}],["headers",{"2":{"23":1}}],["header",{"0":{"13":1}}],["可被调用",{"2":{"265":5}}],["可执行二进制文件",{"2":{"224":1}}],["可复现构建",{"2":{"190":3}}],["可选指针会保证和指针有一样的大小",{"2":{"147":1}}],["可选指针",{"0":{"147":1},"2":{"284":1}}],["可选类型代替",{"2":{"296":1}}],["可选类型值是",{"2":{"276":1}}],["可选类型仅仅能保证你不使用空指针",{"2":{"145":1}}],["可选类型在整数上没什么大用",{"2":{"145":1}}],["可选类型的载荷",{"2":{"44":1}}],["可选类型",{"0":{"44":1,"145":1},"1":{"146":1,"147":1}}],["可选类型也有效",{"2":{"43":1}}],["可选类型也有效果",{"2":{"43":1}}],["可选的",{"2":{"20":1}}],["可用",{"2":{"35":1}}],["可变参数的访问可以使用",{"2":{"21":1}}],["可变参数函数",{"0":{"21":1},"2":{"21":1}}],["可多次使用",{"2":{"15":1}}],["可能导致结果溢出",{"2":{"273":1}}],["可能造成溢出",{"2":{"272":1}}],["可能会导致当前版本的",{"2":{"102":1}}],["可能会调用",{"2":{"30":1}}],["可能存在某些",{"2":{"14":1}}],["可能有自己的汇编器",{"2":{"2":1}}],["可以简单看作在编译时执行的函数",{"2":{"296":1}}],["可以简单看作裸机器",{"2":{"20":1}}],["可以通过重新分配来更改联合类型的有效字段",{"2":{"282":1}}],["可以获取结构体的基指针",{"2":{"259":1}}],["可以访问",{"2":{"251":1}}],["可以将一个容器中的所有",{"2":{"250":1}}],["可以增加一个缓冲区",{"2":{"233":1}}],["可以手动构建一个",{"2":{"198":1}}],["可以很方便的处理交叉编译",{"2":{"198":1}}],["可以发现",{"2":{"194":1}}],["可以看作仅仅进行来类型计算",{"2":{"253":1}}],["可以看作时",{"2":{"142":1}}],["可以看一看这个视频",{"2":{"235":1}}],["可以看到输出多了一行",{"2":{"193":1}}],["可以称之为构建时的步骤",{"2":{"192":1}}],["可以额外捕获",{"2":{"175":1}}],["可以展开所有的",{"2":{"175":1}}],["可以任意复杂",{"2":{"171":1}}],["可以这样做",{"2":{"157":1}}],["可以选择捕获对应的指针",{"2":{"151":1}}],["可以直接使用这个函数",{"2":{"111":1}}],["可以直接使用普通的可选指针",{"2":{"20":1}}],["可以能会对值进行缓存",{"2":{"81":1}}],["可以无缝与",{"2":{"79":1}}],["可以参考这里std",{"2":{"119":1}}],["可以参考这里https",{"2":{"29":1}}],["可以参照",{"2":{"111":1}}],["可以参照以下示例",{"2":{"61":1}}],["可以分配给元素为常量的切片",{"2":{"43":1}}],["可以转换为可以表示旧类型全部值的浮点类型",{"2":{"41":1}}],["可以做到比",{"0":{"23":1}}],["可以强制转换为其他的任意指针类型",{"2":{"20":1}}],["可以在线执行",{"2":{"297":1}}],["可以在此处",{"2":{"198":1}}],["可以在如此多环境",{"2":{"25":1}}],["可以在",{"2":{"13":1,"164":1}}],["可以使用的动态链接库",{"2":{"293":1}}],["可以使用将",{"2":{"250":1}}],["可以使用函数来初始化数组",{"2":{"65":1}}],["可以使用转义",{"2":{"61":1}}],["可以使用",{"2":{"9":1,"28":1,"36":1,"37":2,"59":1,"63":1,"102":2,"173":2,"178":2,"192":1,"197":1,"201":1,"202":1,"245":1,"270":2}}],["可以查看该",{"2":{"5":1}}],["可以查看我的这篇文章",{"2":{"4":1}}],["dropfn",{"2":{"245":5}}],["draw",{"2":{"202":2}}],["dnf",{"2":{"218":1}}],["down",{"2":{"202":1}}],["don",{"2":{"202":1}}],["doptimize=releasesafe",{"2":{"208":1}}],["doptimize=debug",{"2":{"190":1}}],["doptimize",{"2":{"190":1}}],["dosomethingwithfoo",{"2":{"145":2}}],["dosomethingwithnumber",{"2":{"141":2}}],["doadifferentthing",{"2":{"141":1}}],["doathing",{"2":{"140":1,"141":3,"145":2}}],["do",{"2":{"140":1,"145":7,"156":1,"157":1,"158":1,"202":2}}],["double",{"2":{"126":1}}],["dothetest",{"2":{"99":3}}],["document>",{"2":{"265":2}}],["document",{"2":{"265":1}}],["documentation",{"2":{"4":2}}],["docs",{"2":{"196":9}}],["docgen",{"2":{"42":1,"124":2,"267":1}}],["data",{"2":{"87":2,"92":1,"201":2,"253":3}}],["dir",{"2":{"196":2,"265":2}}],["dis",{"2":{"193":1}}],["digit",{"2":{"139":4}}],["divexact",{"2":{"125":1,"272":2,"275":1}}],["divtrunc",{"2":{"125":1,"272":2}}],["divfloor",{"2":{"102":1,"125":1,"272":2}}],["divided",{"2":{"99":7}}],["division",{"2":{"42":1,"124":10}}],["diamonds",{"2":{"69":1}}],["duckdb",{"2":{"53":2}}],["dt",{"2":{"53":1}}],["decrement",{"2":{"245":2}}],["decremented",{"2":{"245":1}}],["decls",{"2":{"262":1}}],["decl",{"2":{"185":1}}],["declared",{"2":{"185":1}}],["declarations",{"2":{"185":2}}],["declaration",{"2":{"185":1,"262":1}}],["decltest",{"2":{"184":3}}],["dev",{"2":{"213":1,"218":2}}],["demo",{"2":{"185":3}}],["deallocatetmpbuffer",{"2":{"142":1}}],["deallocatefoo",{"2":{"142":1}}],["derp",{"2":{"74":2,"82":2}}],["dependon",{"2":{"192":2,"196":1,"197":1,"199":2,"200":2,"201":2,"202":2}}],["dependency",{"2":{"35":1,"37":7}}],["dependencies",{"2":{"35":2}}],["dep",{"2":{"35":2}}],["destroy",{"2":{"32":1}}],["deinit",{"2":{"26":3,"28":5,"29":1,"32":1,"90":3}}],["default",{"2":{"201":2,"262":1}}],["defaultoutput",{"2":{"100":1}}],["defaultmore",{"2":{"89":1,"90":1,"94":1,"149":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1}}],["defaultthread",{"2":{"27":1}}],["defererror",{"2":{"142":1}}],["defererrorcaptureexample",{"2":{"142":1}}],["defer",{"0":{"153":1},"2":{"21":1,"26":3,"27":2,"28":4,"29":2,"30":1,"31":1,"32":1,"90":7,"142":6,"153":9}}],["define",{"2":{"19":1}}],["debug",{"2":{"3":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"77":1,"78":2,"85":1,"86":1,"87":1,"89":1,"90":4,"94":1,"100":3,"102":1,"108":2,"124":1,"126":1,"129":1,"131":1,"132":2,"136":1,"138":1,"141":1,"142":1,"145":1,"148":1,"149":1,"153":1,"162":2,"167":2,"168":2,"170":1,"173":1,"176":1,"178":1,"190":9,"194":1,"199":1,"200":1,"231":1,"232":1,"233":1,"250":2,"254":2,"255":1,"256":4,"257":4,"258":2,"259":1,"260":1,"262":1,"272":1}}],["d",{"2":{"15":2,"17":3,"24":1,"37":1,"41":2,"61":4,"68":1,"74":1,"89":1,"105":1,"152":2,"171":2,"173":4,"202":2,"232":1,"262":2}}],["就会发生非法越界",{"2":{"283":1}}],["就会将rax寄存器的值通过",{"2":{"4":1}}],["就很方便",{"2":{"216":1}}],["就只是和其他编程语言中",{"2":{"134":1}}],["就行了",{"2":{"112":1}}],["就像",{"2":{"41":1}}],["就是一个零位类型",{"2":{"291":1}}],["就是一个函数指针类型",{"2":{"111":1}}],["就是零位类型",{"2":{"289":1}}],["就是以",{"2":{"190":1}}],["就是标记",{"2":{"160":1,"165":1}}],["就是可选类型",{"2":{"152":1}}],["就是推断错误集",{"2":{"143":1}}],["就是代表这个类型变成错误联合类型",{"2":{"139":1}}],["就是文档注释",{"2":{"134":1}}],["就是普通的注释",{"2":{"134":1}}],["就是匿名结构体要如何实现自引用呢",{"2":{"90":1}}],["就是这个语法表示数组的长度索引处的元素应该是",{"2":{"57":1}}],["就是",{"2":{"42":2,"151":1}}],["就是获取变量",{"2":{"76":1}}],["就是获取",{"2":{"35":1}}],["就是分支名",{"2":{"35":1}}],["就是对应的仓库名",{"2":{"35":1}}],["就是组织名或者用户名",{"2":{"35":1}}],["就是全局汇编",{"2":{"3":1}}],["就支持",{"2":{"35":1}}],["就可以在本机实现完善的交叉编译",{"2":{"24":1}}],["就可以实现在没有",{"2":{"23":1}}],["其目标是更小",{"2":{"294":1}}],["其还支持九种操作符",{"2":{"240":1}}],["其次你可能注意到路径前面还有一个",{"2":{"215":1}}],["其发布周期约为",{"2":{"211":1}}],["其参数为",{"2":{"191":1}}],["其内部可以是一个语句或者是一个作用域",{"2":{"163":1}}],["其实更好的解决办法就是显示声明一个错误集",{"2":{"143":1}}],["其中有一个字段是",{"2":{"255":1}}],["其中目前最为激进的应该是",{"2":{"145":1}}],["其中包含是否存在溢出",{"2":{"125":1}}],["其中包含着许多的",{"2":{"120":1}}],["其中你可以选择指明数组的大小或者使用",{"2":{"55":1}}],["其中",{"2":{"37":1,"87":1,"157":1}}],["其中的每个节点",{"2":{"191":1}}],["其中的",{"2":{"35":1,"111":1}}],["其他情况",{"2":{"265":5}}],["其他情况下",{"2":{"100":1,"265":1}}],["其他情况下建议使用",{"2":{"98":1}}],["其他的包管理器",{"0":{"214":1}}],["其他的文件import该文件后",{"2":{"111":1}}],["其他仅支持动态链接",{"2":{"24":1}}],["其他平台仍使用",{"2":{"23":1}}],["其后的",{"2":{"4":1}}],["其对",{"2":{"2":1}}],["寄存器中的值",{"2":{"4":1}}],["寄存器就是",{"2":{"4":1}}],["之后是一个输出位置",{"2":{"4":1}}],["vcpkg",{"2":{"293":1}}],["vim",{"0":{"208":1},"2":{"208":7,"209":1}}],["visual",{"2":{"205":1,"206":1}}],["visualstudio",{"2":{"205":1,"206":1}}],["v",{"2":{"104":3,"185":1,"202":2}}],["vec2",{"2":{"102":3}}],["vec",{"2":{"102":3}}],["vectors",{"2":{"105":1}}],["vector",{"2":{"101":1,"102":7,"103":1,"104":1,"105":11,"106":6}}],["version=",{"2":{"265":1}}],["versions",{"2":{"213":2}}],["version",{"2":{"35":3,"213":1,"215":2}}],["verbose",{"2":{"17":2}}],["vs是一个基本完整的开发工具集",{"2":{"206":1}}],["vs",{"0":{"16":1,"205":1,"206":1}}],["val",{"2":{"56":3}}],["value|",{"2":{"151":1,"152":4,"155":1,"179":1}}],["values",{"2":{"96":3}}],["value3",{"2":{"68":1}}],["value2",{"2":{"51":2,"68":1}}],["value1",{"2":{"51":2}}],["value",{"2":{"4":1,"8":14,"66":3,"68":2,"104":3,"124":1,"129":1,"151":1,"152":8,"155":4,"157":1,"159":2,"167":2,"168":2,"175":1,"179":2,"202":1,"239":1,"241":2,"242":2,"245":3,"262":1,"287":1}}],["va",{"2":{"21":3}}],["variable",{"2":{"82":2,"100":1,"129":5,"132":4,"276":1}}],["var",{"2":{"8":5,"10":2,"19":2,"21":3,"26":1,"27":5,"28":2,"29":2,"30":1,"32":1,"43":3,"47":1,"65":1,"66":2,"77":1,"78":5,"82":2,"83":2,"84":1,"85":4,"86":3,"87":2,"89":2,"90":6,"91":1,"99":4,"102":1,"108":3,"124":4,"129":3,"132":1,"133":1,"139":2,"146":1,"148":1,"155":1,"161":2,"162":1,"163":1,"164":1,"166":4,"167":2,"168":2,"170":1,"173":2,"178":4,"179":1,"233":8,"245":1,"253":1,"256":1,"257":1,"258":2,"259":1,"265":3,"282":1}}],["volatile",{"0":{"81":1},"2":{"4":4,"40":1,"81":4,"124":1,"267":1}}],["void`",{"2":{"239":1}}],["void",{"0":{"287":1},"2":{"3":1,"12":1,"13":1,"17":1,"19":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"47":4,"51":2,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"70":1,"71":1,"74":2,"75":1,"77":1,"78":2,"79":1,"82":4,"85":1,"86":1,"87":1,"89":1,"90":6,"94":1,"95":1,"99":1,"100":1,"102":1,"108":2,"111":1,"116":1,"118":1,"124":1,"126":1,"129":1,"130":1,"131":1,"132":1,"136":1,"140":1,"141":4,"142":1,"145":4,"148":1,"149":1,"153":1,"161":2,"162":1,"166":2,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":4,"184":1,"185":1,"191":2,"192":1,"193":1,"194":2,"195":2,"196":1,"197":1,"199":2,"200":2,"201":3,"202":7,"218":1,"231":1,"233":3,"243":1,"245":4,"250":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"262":1,"265":2,"272":1,"287":2}}],["占位符",{"2":{"4":2}}],["硬件",{"2":{"4":1}}],["例如字符串就是",{"2":{"232":1}}],["例如依赖中的包",{"2":{"197":1}}],["例如某些",{"2":{"192":1}}],["例如我们可以让",{"2":{"200":1}}],["例如我们可以以此实现让程序打印构建时的时间戳",{"2":{"194":1}}],["例如我们可以在",{"2":{"192":1}}],["例如我们在这里使用的就是函数名字",{"2":{"184":1}}],["例如要构建的二进制程序",{"2":{"192":1}}],["例如以上示例中的",{"2":{"191":1}}],["例如以下代码是非法的",{"2":{"133":1}}],["例如内存结构不同",{"2":{"190":1}}],["例如获取函数指针或者在不同构建目标之间保持相同的错误集合",{"2":{"143":1}}],["例如panic",{"2":{"140":1}}],["例如与外部库的链接",{"2":{"130":1}}],["例如有些分数无法用小数表示",{"2":{"126":1}}],["例如可以把一个源文件看作是一个匿名的结构体",{"2":{"100":1}}],["例如非",{"2":{"40":1}}],["例如链接库",{"2":{"37":1}}],["例如动态链接库和静态链接库",{"2":{"36":1}}],["例如web",{"2":{"28":1}}],["例如对齐",{"2":{"20":1}}],["例如",{"2":{"9":1,"16":1,"19":1,"35":2,"36":1,"42":1,"82":1,"90":2,"91":1,"96":1,"102":1,"108":1,"117":1,"122":1,"127":1,"190":1,"192":1,"195":1,"200":1,"250":1,"271":1,"283":1,"287":1,"291":1}}],["例如上方的示例中",{"2":{"4":1}}],["例如使用示例",{"2":{"246":1}}],["例如使用内存映射输入输出",{"2":{"81":1}}],["例如使用",{"2":{"4":1}}],["例如操作系统",{"2":{"4":1}}],["例如工业控制的程序",{"2":{"2":1}}],["关于原子顺序六个级别的具体说明",{"2":{"237":1}}],["关于流这个概念可能不好解释",{"2":{"233":1}}],["关于头文件的引入",{"2":{"201":1,"202":1}}],["关于所有的",{"2":{"198":1}}],["关于为什么",{"2":{"190":1}}],["关于可以使用的调用约定格式",{"2":{"119":1}}],["关于函数指针",{"2":{"111":1}}],["关于函数命名",{"2":{"111":1}}],["关于零指针的使用",{"2":{"83":1}}],["关于指针运算",{"2":{"76":1}}],["关于循环我们放在后面再聊",{"2":{"56":1}}],["关于越界问题",{"2":{"55":1}}],["关于二进制构建结果",{"2":{"36":1}}],["关于这个我们会在",{"2":{"66":1}}],["关于这个模型的更多信息",{"2":{"29":1}}],["关于这个结构体的名字",{"2":{"10":1}}],["关于更多的细节",{"2":{"23":1}}],["关于更多的内联汇编约束信息",{"2":{"4":1}}],["关于",{"2":{"19":1,"108":1,"142":1,"190":1,"202":1,"224":1}}],["关于本站",{"0":{"0":1},"1":{"1":1}}],["关键字进行修饰",{"2":{"250":1}}],["关键字会将",{"2":{"161":1,"166":1}}],["关键字会通知编译器",{"2":{"4":1}}],["关键字保证解构了可选类型",{"2":{"145":1}}],["关键字保证函数可以在生成的",{"2":{"117":1}}],["关键字定义了两个错误类型",{"2":{"136":1}}],["关键字告诉函数的调用约定",{"2":{"119":1}}],["关键字后面带引号的标识符指定具有该函数的库",{"2":{"117":1}}],["关键字意味着该参数必须在编译期已知",{"2":{"113":1}}],["关键字修饰结构体",{"2":{"99":1}}],["关键字用于修饰结构体",{"2":{"98":1}}],["关键字来修饰",{"2":{"81":1}}],["关键字来很轻松地声明并使用枚举",{"2":{"68":1}}],["关键字",{"2":{"6":1,"73":1,"184":1,"250":1}}],["关键字开头的一个表达式",{"2":{"4":1}}],[">=",{"2":{"127":1,"139":1}}],[">>=",{"2":{"127":1}}],[">>",{"2":{"127":1,"202":1}}],[">",{"2":{"4":3,"7":2,"104":1,"111":1,"127":1,"142":1,"192":2,"202":5,"265":1}}],["u0",{"2":{"288":1}}],["ubuntu",{"2":{"218":1}}],["update",{"2":{"202":4}}],["updating",{"2":{"23":1,"245":1}}],["utc",{"2":{"134":1}}],["utf8",{"2":{"61":2}}],["utf",{"2":{"61":5,"62":1,"212":2,"265":1}}],["u3",{"2":{"99":2}}],["u32",{"2":{"9":2,"32":1,"41":1,"68":1,"96":1,"99":3,"103":2,"119":2,"122":1,"124":2,"134":1,"149":4,"151":3,"152":6,"167":3,"168":3,"171":2,"173":4,"175":2,"258":3,"259":1,"262":1,"265":1,"282":1}}],["u4",{"2":{"68":1,"99":2}}],["u2",{"2":{"47":4,"68":2,"70":1,"99":1}}],["u",{"2":{"47":14,"61":2,"62":1,"122":1,"175":4,"185":5}}],["u1",{"2":{"70":1,"125":1}}],["u128",{"2":{"41":1,"122":1}}],["u16",{"2":{"41":3,"51":1,"99":1,"122":1,"129":1,"131":1,"132":1,"136":2,"271":1}}],["u64",{"2":{"41":2,"46":1,"122":1,"139":6,"140":1,"171":3}}],["url",{"2":{"35":3}}],["ulonglong",{"2":{"12":1}}],["ulong",{"2":{"12":1}}],["uintptr",{"2":{"122":1}}],["uint64",{"2":{"122":1}}],["uint32",{"2":{"122":1}}],["uint16",{"2":{"122":1}}],["uint8",{"2":{"122":1}}],["uint",{"2":{"12":1,"116":1}}],["usingnamespace",{"0":{"250":1},"2":{"250":5}}],["usize",{"2":{"4":13,"9":3,"10":1,"21":1,"47":1,"50":2,"51":5,"66":1,"82":1,"83":1,"85":1,"86":1,"87":1,"90":1,"92":1,"122":2,"145":1,"158":2,"160":2,"161":4,"162":2,"163":3,"164":3,"165":1,"166":4,"175":2,"245":2,"265":2}}],["use",{"2":{"245":1}}],["user",{"2":{"90":11,"172":4,"201":1,"215":3}}],["username",{"2":{"17":3,"35":2,"90":18}}],["usr",{"2":{"220":6}}],["usleep",{"2":{"202":1}}],["usable",{"2":{"30":1}}],["us",{"2":{"29":1,"185":3}}],["ushort",{"2":{"12":1}}],["unreachabel",{"2":{"268":1}}],["unreachable",{"0":{"176":1},"2":{"4":1,"116":1,"141":4,"144":1,"151":1,"152":4,"161":2,"166":2,"176":4,"179":2,"267":3}}],["unrefs",{"2":{"245":1}}],["unref",{"2":{"201":1,"245":3}}],["unsigned",{"2":{"122":1}}],["unaligned",{"2":{"82":2}}],["unable",{"2":{"19":1}}],["unistd",{"2":{"202":1}}],["unit",{"2":{"183":1,"197":7}}],["unicode",{"2":{"61":4,"62":1,"212":1,"294":1}}],["unixepoch",{"2":{"134":1}}],["unix",{"2":{"53":1,"134":1}}],["unioninit",{"2":{"178":4}}],["union",{"0":{"173":1,"181":1,"182":1},"2":{"47":2,"173":2,"175":2,"177":1,"178":7,"179":3,"180":1,"181":1,"182":1,"185":2,"282":1}}],["unexpected",{"2":{"19":1}}],["undefined",{"0":{"48":1,"132":1},"2":{"10":1,"27":2,"48":1,"66":1,"105":7,"124":1,"132":3,"167":1,"168":1,"265":1,"267":2}}],["u8",{"2":{"8":2,"21":1,"26":1,"27":4,"28":3,"29":1,"30":1,"31":1,"36":1,"37":2,"41":6,"43":22,"46":2,"49":3,"51":21,"55":2,"57":1,"61":4,"70":2,"72":1,"79":1,"81":2,"82":6,"87":2,"89":5,"90":17,"96":2,"99":2,"105":6,"108":6,"111":6,"122":1,"127":1,"139":5,"140":1,"141":4,"145":1,"148":1,"170":2,"173":2,"178":1,"179":4,"201":1,"255":2,"265":1,"271":2,"272":1}}],["615744",{"2":{"202":1}}],["615696",{"2":{"202":1}}],["614928",{"2":{"202":1}}],["610832",{"2":{"202":1}}],["67",{"2":{"91":1}}],["666",{"2":{"77":1,"129":2,"131":1,"132":1,"178":1,"262":1}}],["6f35761b17b87ee4c9f26e643a06e289",{"2":{"17":2}}],["6",{"2":{"8":2,"49":1,"60":2,"99":1,"102":2,"105":2,"106":2,"124":1,"158":1,"160":3,"161":4,"173":2,"211":1}}],["60",{"2":{"4":1}}],["64",{"2":{"2":1,"4":3,"23":1,"24":4,"82":2,"122":1,"198":1,"215":3,"219":1}}],["00",{"2":{"134":3}}],["0000",{"2":{"122":3}}],["000",{"2":{"122":3}}],["0o755",{"2":{"123":1}}],["0o7",{"2":{"122":1}}],["0b11110000",{"2":{"123":1}}],["0b1",{"2":{"122":1}}],["0xaa",{"2":{"132":1}}],["0x0",{"2":{"124":1,"267":1}}],["0xff",{"2":{"123":1,"130":1}}],["0xff80",{"2":{"122":1}}],["0x12",{"2":{"99":2}}],["0x1234",{"2":{"99":1}}],["0x12345678",{"2":{"81":1}}],["0x123456780",{"2":{"51":2}}],["0x1",{"2":{"99":1,"281":2}}],["0x222cf1",{"2":{"267":1}}],["0x222c65",{"2":{"267":1}}],["0x22319c",{"2":{"267":1}}],["0x223c8a",{"2":{"267":1}}],["0x22da7d",{"2":{"267":1}}],["0x21dbd1",{"2":{"124":1}}],["0x21e082",{"2":{"124":1}}],["0x21e83e",{"2":{"124":1}}],["0x2",{"2":{"99":1}}],["0x34",{"2":{"99":3}}],["0x",{"2":{"61":2}}],["0",{"2":{"4":1,"8":4,"10":1,"20":3,"21":3,"34":1,"35":3,"42":5,"50":1,"51":9,"55":2,"56":29,"57":2,"61":3,"63":1,"66":1,"78":3,"79":1,"82":1,"83":2,"85":3,"86":3,"87":5,"90":6,"94":1,"99":6,"104":1,"105":5,"107":1,"124":2,"126":6,"134":2,"136":2,"139":7,"143":4,"147":1,"152":4,"155":3,"156":1,"157":2,"159":1,"160":2,"161":2,"162":2,"163":1,"165":1,"166":6,"167":2,"168":2,"171":1,"175":1,"179":1,"202":25,"207":2,"208":1,"211":1,"245":1,"246":1,"253":2,"258":2,"259":2,"265":2,"272":3,"284":3,"286":2,"288":1,"289":1,"291":1}}],["0版本",{"2":{"0":1}}],["whether",{"2":{"193":2}}],["while",{"0":{"162":1},"1":{"163":1,"164":1,"165":1,"166":1,"167":1,"168":1},"2":{"8":2,"9":1,"21":1,"51":1,"116":1,"118":1,"154":1,"159":1,"160":1,"162":3,"163":3,"164":4,"165":5,"166":4,"167":4,"168":4,"202":3}}],["won",{"2":{"185":1,"202":1}}],["work",{"2":{"124":3,"267":6}}],["world",{"0":{"231":1},"1":{"232":1,"233":1,"234":1,"235":1},"2":{"4":2,"63":3,"79":1,"90":1,"105":1,"199":1,"201":3,"231":2,"232":1,"233":1,"235":1,"250":1}}],["wrapping",{"2":{"104":1,"272":1}}],["writer",{"2":{"90":2,"233":11}}],["write",{"2":{"4":2}}],["we",{"2":{"90":1,"172":2,"245":1}}],["webui",{"2":{"53":2}}],["wasm",{"0":{"285":1}}],["wasd",{"2":{"202":1}}],["wat",{"2":{"74":2}}],["warning",{"2":{"4":1,"7":1,"14":1,"36":1,"111":1,"142":1,"152":1,"201":1,"202":1,"224":1,"225":1,"229":1,"231":1,"255":1,"262":1}}],["widnows",{"2":{"212":1}}],["widget",{"2":{"201":1}}],["will",{"2":{"153":1,"202":1}}],["wingetchocolatey",{"2":{"214":1}}],["winget",{"2":{"214":1}}],["window",{"2":{"201":15}}],["windows",{"0":{"212":1},"1":{"213":1,"214":1,"215":1},"2":{"29":3,"206":1,"212":2,"215":3}}],["winapi",{"2":{"116":1}}],["win32",{"2":{"29":1}}],["withswitch",{"2":{"175":1}}],["with",{"2":{"4":1,"23":1,"89":1,"130":1,"145":1,"201":1,"202":1}}],["w",{"2":{"8":2,"74":2,"105":2,"202":2}}],["save=limine",{"2":{"229":1}}],["save",{"2":{"229":2}}],["safety",{"2":{"267":3}}],["safe",{"2":{"27":6}}],["snap",{"2":{"218":2}}],["srand",{"2":{"202":1}}],["src",{"2":{"37":1,"191":1,"193":1,"194":1,"195":2,"197":2,"198":1,"199":2,"200":1,"201":1,"202":1,"224":2,"225":2,"231":1,"232":1}}],["slowly",{"2":{"202":1}}],["slice类型",{"2":{"87":2}}],["slice4",{"2":{"82":1}}],["slice",{"2":{"51":4,"78":5,"82":4,"85":11,"86":6,"87":4,"175":1}}],["skip",{"2":{"197":2}}],["skipzigtest",{"2":{"186":1}}],["something",{"2":{"145":1,"156":1,"157":1,"158":1}}],["some",{"2":{"145":4}}],["so",{"2":{"117":1,"202":1}}],["source",{"2":{"13":1,"17":1,"24":1,"36":3,"37":1,"191":2,"192":1,"193":1,"194":1,"195":3,"196":1,"197":2,"198":1,"199":3,"200":3,"201":1,"202":1,"208":2}}],["scoop",{"0":{"213":1},"2":{"213":5}}],["score++",{"2":{"202":1}}],["score",{"2":{"202":4}}],["scopedloggingallocator",{"2":{"25":1}}],["scalar",{"2":{"103":4}}],["spinloophint",{"0":{"246":1},"2":{"246":3}}],["specific",{"2":{"193":1}}],["spartan",{"2":{"271":2}}],["spaces",{"2":{"130":1}}],["spades",{"2":{"69":1}}],["splat",{"0":{"103":1},"2":{"102":1,"103":2,"104":1}}],["sqrt",{"2":{"102":1}}],["sqlite",{"2":{"53":2}}],["side",{"2":{"253":1}}],["silverblue",{"2":{"218":1}}],["signal",{"2":{"124":1,"201":2}}],["simd",{"2":{"101":1,"102":5}}],["single",{"2":{"76":1}}],["sizeof",{"2":{"82":1,"94":1,"99":2}}],["size",{"2":{"30":1,"122":1,"145":3,"201":1,"265":2}}],["success",{"2":{"241":1,"242":1}}],["su",{"2":{"218":1}}],["support",{"2":{"207":1}}],["sublime",{"0":{"210":1},"2":{"210":1}}],["subdir",{"2":{"196":1}}],["subwithoverflow",{"2":{"125":1,"272":1}}],["sub",{"2":{"117":1,"272":1}}],["suit",{"2":{"69":3}}],["sum1",{"2":{"168":3}}],["sum2",{"2":{"167":3}}],["sum",{"2":{"21":3,"155":2,"161":6,"166":6}}],["small2",{"2":{"179":2}}],["small",{"2":{"59":2,"70":5}}],["s",{"2":{"55":2,"63":1,"90":6,"99":3,"100":3,"134":1,"142":1,"185":5,"199":1,"200":1,"202":2,"218":1,"220":1,"232":1,"233":4,"245":2,"254":2,"255":1,"258":2}}],["swarkland",{"2":{"53":1}}],["switch",{"0":{"169":1,"175":1},"1":{"170":1,"171":1,"172":1,"173":1,"174":1,"175":1},"2":{"7":1,"9":1,"47":1,"51":1,"72":2,"99":1,"124":1,"139":1,"141":2,"143":1,"161":2,"166":2,"169":1,"170":3,"171":2,"172":2,"173":3,"174":2,"175":4,"179":2,"267":1}}],["se",{"2":{"185":1}}],["second",{"2":{"153":1}}],["seconds",{"2":{"134":2}}],["sequential",{"2":{"104":1}}],["select",{"0":{"106":1},"2":{"102":1,"106":2}}],["self",{"2":{"47":2,"69":2,"89":6,"90":16,"192":1}}],["setruntimesafety",{"2":{"267":1}}],["setenvironmentvariable",{"2":{"215":2}}],["setevalbranchquota",{"2":{"9":1}}],["set",{"2":{"201":3,"202":7,"287":1}}],["setfloatmode",{"2":{"126":2}}],["setcold",{"0":{"118":1},"2":{"118":2}}],["setybasedonx",{"2":{"95":1}}],["sentinel",{"2":{"57":1}}],["semantic",{"2":{"35":1}}],["server",{"2":{"28":1,"53":1,"205":1,"208":1}}],["sbrkallocator",{"2":{"25":1}}],["shl",{"2":{"272":1}}],["shlwithoverflow",{"2":{"125":1,"272":1}}],["shexport",{"2":{"221":1}}],["shell$",{"2":{"42":1,"184":1}}],["shtar",{"2":{"220":1}}],["shport",{"2":{"216":1}}],["shproject",{"2":{"193":1}}],["shbrew",{"2":{"216":1}}],["shchoco",{"2":{"214":1}}],["shcc=",{"2":{"24":2}}],["shwinget",{"2":{"214":1}}],["shscoop",{"2":{"213":2}}],["share",{"2":{"208":1}}],["sh",{"2":{"200":2,"208":2,"221":1,"224":1,"225":1}}],["shiftleftone",{"2":{"119":1}}],["ships",{"2":{"23":1}}],["shuffle",{"0":{"105":1},"2":{"102":1,"105":4}}],["shvariable",{"2":{"100":1}}],["sh第1个元素为",{"2":{"85":1}}],["should",{"2":{"202":1}}],["show",{"2":{"52":1}}],["shortlist",{"2":{"265":1}}],["short",{"2":{"12":1}}],["sh$",{"2":{"17":1,"124":2,"229":1,"254":1,"267":1}}],["stb",{"2":{"250":1}}],["stbi",{"2":{"250":2}}],["studio是微软公司的开发工具包系列产品",{"2":{"206":1}}],["studio",{"2":{"205":1}}],["stuff",{"2":{"145":4}}],["stick",{"2":{"202":1}}],["step",{"0":{"192":1},"2":{"191":5,"192":16,"193":1,"194":1,"195":1,"196":7,"197":8,"199":8,"200":8,"201":7,"202":7}}],["string",{"2":{"202":1,"265":1}}],["strip=",{"2":{"193":1}}],["strip",{"2":{"193":7}}],["strict",{"2":{"126":1}}],["str",{"2":{"87":3,"140":3,"141":8}}],["structalias",{"2":{"265":1}}],["structname",{"2":{"265":2}}],["structfield",{"2":{"255":1}}],["structs",{"2":{"99":1}}],["struct",{"2":{"8":1,"10":1,"20":4,"49":1,"69":1,"89":3,"90":4,"91":1,"92":2,"93":1,"94":2,"95":1,"96":1,"99":5,"100":8,"134":2,"145":3,"173":1,"175":1,"181":1,"182":1,"185":4,"245":1,"250":1,"254":2,"255":6,"256":1,"257":1,"258":1,"259":1,"262":1,"265":4,"291":1}}],["stamp",{"2":{"194":4}}],["standardoptimizeoption",{"2":{"37":1,"190":1,"191":2,"193":1,"194":1,"195":1,"197":1,"199":1,"200":1,"201":1,"202":1}}],["standardtargetoptions",{"2":{"37":1,"191":2,"193":1,"194":1,"195":1,"197":1,"198":1,"199":1,"200":1,"201":1,"202":1}}],["stat",{"2":{"130":1}}],["status",{"2":{"26":2,"28":2,"90":2,"201":3}}],["static",{"2":{"24":1,"201":2}}],["stackfallbackallocator",{"2":{"25":1}}],["start",{"2":{"8":8,"21":1,"78":1,"87":1,"124":3,"202":2,"267":3}}],["stderr",{"2":{"233":4}}],["stdscr",{"2":{"202":1}}],["stdlib",{"2":{"202":1}}],["stdin",{"2":{"197":2}}],["stdio",{"2":{"13":2,"17":2,"63":1,"250":1}}],["stdout",{"2":{"4":2,"197":1,"233":3}}],["std",{"0":{"244":1},"1":{"245":1,"246":1},"2":{"3":3,"8":1,"9":1,"21":2,"25":7,"26":3,"27":7,"28":4,"29":3,"30":3,"31":3,"32":4,"33":3,"36":5,"37":7,"47":3,"51":4,"55":1,"56":1,"57":1,"59":1,"60":1,"61":3,"63":1,"65":1,"66":1,"70":4,"77":1,"78":2,"79":3,"81":1,"82":4,"83":3,"84":1,"85":1,"86":1,"87":1,"89":3,"90":12,"94":3,"99":9,"100":5,"102":3,"104":1,"108":2,"124":5,"125":1,"126":8,"129":3,"130":1,"131":3,"132":3,"136":3,"139":3,"142":1,"146":1,"148":1,"149":1,"153":3,"161":3,"162":4,"166":3,"167":4,"168":4,"170":3,"173":3,"178":1,"179":7,"184":4,"185":8,"187":1,"191":6,"192":3,"193":3,"194":7,"195":6,"196":3,"197":3,"198":1,"199":6,"200":6,"201":3,"202":3,"231":3,"232":1,"233":10,"234":1,"236":1,"245":1,"246":1,"250":2,"253":3,"254":4,"255":5,"256":6,"257":6,"258":4,"259":3,"260":3,"262":4,"267":2,"270":1,"272":8,"287":3}}],["system",{"2":{"215":1}}],["systemuser",{"2":{"215":1}}],["syscall",{"2":{"4":2}}],["syscall1",{"2":{"4":2}}],["syscall3",{"2":{"4":2}}],["sys",{"2":{"4":4,"200":3}}],["ln",{"2":{"220":1}}],["lspconfig",{"2":{"208":1}}],["lsp",{"2":{"208":1,"209":1}}],["lua",{"2":{"208":1}}],["lt",{"2":{"82":2,"102":3,"127":6}}],["lang",{"2":{"218":1}}],["language这个插件即可",{"2":{"205":1}}],["language",{"2":{"53":1,"138":1,"205":1,"208":1,"210":1}}],["landed",{"2":{"202":1}}],["layout",{"2":{"202":1,"262":1}}],["label",{"2":{"201":1}}],["last",{"2":{"92":1}}],["largefile64",{"2":{"24":1}}],["ld",{"2":{"53":1}}],["ldfalgs",{"2":{"24":1}}],["ldflags=",{"2":{"24":1}}],["l",{"2":{"41":2,"43":8,"55":4,"105":1}}],["lc",{"2":{"13":1,"17":1}}],["loris",{"2":{"235":1}}],["local",{"2":{"208":1,"221":5,"267":1}}],["loop",{"2":{"202":1}}],["lola",{"2":{"53":1}}],["log",{"2":{"102":1,"233":1}}],["logtowriterallocator",{"2":{"25":1}}],["loggingallocator",{"2":{"25":1}}],["longdouble",{"2":{"12":1,"126":1}}],["longlong",{"2":{"12":1}}],["long",{"2":{"12":1,"126":1}}],["low",{"2":{"4":1,"76":1,"293":2,"295":1}}],["limit",{"2":{"136":1}}],["limine",{"2":{"35":3,"229":4}}],["little",{"2":{"99":1}}],["libstdc++",{"2":{"202":1}}],["libz",{"2":{"195":2}}],["library",{"2":{"37":3}}],["lib",{"0":{"225":1},"2":{"36":4,"124":2,"184":1,"195":10,"196":2,"220":4,"224":1,"225":1,"231":1,"267":4}}],["libc++",{"2":{"202":2}}],["libc",{"0":{"24":1},"2":{"11":1,"13":1,"23":5,"24":1,"79":1,"117":1,"195":1,"295":1,"296":1}}],["line",{"2":{"202":4}}],["linksystemlibrary",{"2":{"195":2,"201":2,"202":1}}],["linkedlist",{"2":{"92":1}}],["linklibrary",{"2":{"37":1,"195":1}}],["linklibcpp",{"2":{"202":1}}],["linklibc",{"2":{"13":1,"30":1,"79":1,"195":1,"201":2}}],["link",{"2":{"35":1,"36":1}}],["linkmode=external",{"2":{"24":1}}],["linux安装的话",{"2":{"217":1}}],["linux",{"0":{"217":1},"1":{"218":1,"219":1,"220":1,"221":1},"2":{"4":1,"23":2,"24":5,"172":6,"202":1,"218":2,"219":1,"220":1,"221":1}}],["listtemplatefunction",{"2":{"265":1}}],["list",{"2":{"10":6,"90":7,"100":3,"265":1}}],["llvm",{"2":{"4":1,"23":2,"198":2,"202":1,"211":1,"237":1}}],["let",{"2":{"208":1}}],["left",{"2":{"167":5,"168":5}}],["leftover",{"2":{"141":1}}],["legend",{"2":{"53":1}}],["lemm",{"2":{"52":1}}],["length",{"2":{"87":2,"90":2}}],["len",{"2":{"4":1,"8":1,"10":2,"51":2,"57":3,"61":1,"70":1,"78":4,"85":5,"86":3,"87":1,"90":5,"92":1,"96":1,"105":4,"106":4,"161":2,"166":2,"175":2}}],["level",{"2":{"4":1,"76":1,"138":1,"185":1,"293":2,"295":1}}],["learn",{"2":{"29":1}}],["leak",{"2":{"26":1,"28":1,"90":1}}],["lea",{"2":{"3":1}}],["的平台",{"2":{"297":1}}],["的高级语言",{"2":{"295":1}}],["的社区需要更多的人来构建",{"2":{"293":1}}],["的特性也的确在这个方向发展",{"2":{"293":1}}],["的特性实现中断处理的文章",{"2":{"4":1}}],["的替代",{"2":{"293":1}}],["的替代品了",{"2":{"293":1}}],["的替代品",{"2":{"53":1,"293":1}}],["的的确确比",{"2":{"293":1}}],["的代替品的",{"2":{"293":1}}],["的代码",{"2":{"14":1}}],["的代码翻译为",{"2":{"14":1}}],["的未来也可能是这样子",{"2":{"293":1}}],["的超集",{"2":{"293":1}}],["的长度为",{"2":{"289":1}}],["的长度决定返回的向量的长度",{"2":{"105":1}}],["的安全检查",{"2":{"267":1}}],["的习惯",{"2":{"264":1}}],["的反函数",{"2":{"262":1}}],["的字段或者容器类型的声明",{"2":{"258":1}}],["的信息",{"2":{"255":1}}],["的世界打一声招呼",{"2":{"231":1}}],["的发行版和对应命令",{"2":{"218":1}}],["的发布往往要间隔很久",{"2":{"211":1}}],["的发布",{"2":{"34":1}}],["的编码修改为utf",{"2":{"212":1}}],["的编译器并且支持将",{"2":{"11":1}}],["的编译器",{"2":{"11":1,"23":1}}],["的新版本关联",{"2":{"211":1}}],["的插件",{"2":{"209":1}}],["的内置",{"2":{"208":1}}],["的内存地址",{"2":{"76":1}}],["的保存自动格式化功能",{"2":{"208":1}}],["的开发ide",{"2":{"207":1}}],["的开发手册所述",{"2":{"51":1}}],["的工具链使用的是",{"2":{"202":1}}],["的问题",{"2":{"202":1}}],["的指南",{"2":{"201":1}}],["的指针转换为地址不可能为",{"2":{"284":1}}],["的指针略有不同",{"2":{"76":1}}],["的指针和",{"2":{"76":1}}],["的指针特性",{"2":{"20":1}}],["的指针",{"2":{"20":1,"284":1}}],["的指针可以同时作为单项指针和多项指针使用",{"2":{"20":1}}],["的依赖",{"2":{"201":1}}],["的官方示例",{"2":{"201":1}}],["的存在",{"2":{"198":1}}],["的方法",{"2":{"217":1}}],["的方式如下",{"2":{"195":1}}],["的方案",{"2":{"25":1}}],["的构建系统",{"2":{"224":1}}],["的构建系统还允许我们执行一些额外的命令",{"2":{"200":1}}],["的构建系统提供了另外一种方式来处理当项目变得复杂时的测试",{"2":{"197":1}}],["的构建依赖于",{"2":{"192":1}}],["的构建目标三元组",{"2":{"15":1}}],["的有向无环图",{"2":{"191":1}}],["的文档并未给出具体说明",{"2":{"190":1}}],["的文档中出现过",{"2":{"51":1}}],["的标准库",{"2":{"202":1,"232":1}}],["的标准库还为我们提供了一个函数",{"2":{"185":1}}],["的标准构建器会以此为入口点",{"2":{"191":1}}],["的标准构建器位置",{"2":{"189":1}}],["的实现如下",{"2":{"185":1}}],["的规则",{"2":{"178":1}}],["的分支可以标记为",{"2":{"175":1}}],["的范围选择符",{"2":{"171":1}}],["的匹配必须要要穷尽所有",{"2":{"170":1}}],["的效果并不会真正生效",{"2":{"253":1}}],["的效果就是在标记处的",{"2":{"160":1,"165":1}}],["的效果类似于",{"2":{"160":1,"165":1}}],["的效果类似",{"2":{"3":1}}],["的还有",{"2":{"153":1}}],["的这个块中保证了",{"2":{"145":1}}],["的目标则是",{"2":{"293":1}}],["的目标是",{"2":{"293":1}}],["的目标代码",{"2":{"198":1}}],["的目标",{"2":{"145":1}}],["的变量",{"2":{"145":1}}],["的变体来创建",{"2":{"87":1}}],["的一个特殊变体",{"2":{"142":1}}],["的一等公民",{"2":{"92":1}}],["的语句",{"2":{"140":1}}],["的语言",{"2":{"11":1,"293":1}}],["的负担",{"2":{"138":1,"145":1}}],["的基本定义和使用",{"2":{"136":1}}],["的基本类型",{"2":{"12":1}}],["的错误处理方案笔者认为是比较简陋的",{"2":{"135":1}}],["的大小",{"2":{"127":1}}],["的精度和运算",{"2":{"126":1}}],["的操作指令",{"2":{"120":1}}],["的关键语法",{"2":{"111":1}}],["的函数明显",{"2":{"111":1}}],["的原因见",{"2":{"108":1}}],["的逻辑基本相同",{"2":{"108":1}}],["的向量",{"2":{"105":1}}],["的名字也可以使用标识符",{"2":{"184":1}}],["的名字",{"2":{"100":1}}],["的朋友对这个可能很熟悉",{"2":{"94":1}}],["的索引",{"2":{"86":1}}],["的索引处的值应该是",{"2":{"57":1}}],["的幂",{"2":{"82":1}}],["的值赋值给一个不能是",{"2":{"145":1}}],["的值是相同的",{"2":{"136":1}}],["的值是",{"2":{"105":1}}],["的值的方法",{"2":{"101":1}}],["的值就是",{"2":{"96":1}}],["的值",{"2":{"81":1,"105":1,"136":1,"140":1,"155":1}}],["的值进行操作",{"2":{"81":1}}],["的性质",{"2":{"66":1}}],["的源代码编码格式是",{"2":{"212":1}}],["的源文件本身就是",{"2":{"61":1}}],["的源码分支打包返回的",{"2":{"35":1}}],["的哨兵数组",{"2":{"61":1}}],["的包裹",{"2":{"53":1}}],["的游戏生态库",{"2":{"53":1}}],["的游戏引擎和图形套件",{"2":{"53":1}}],["的解析器",{"2":{"53":1}}],["的强大的",{"2":{"53":1}}],["的数组类型",{"2":{"61":1}}],["的数组",{"2":{"57":1}}],["的数组的指针",{"2":{"51":1}}],["的数组指针",{"2":{"43":2}}],["的表达式",{"2":{"51":4}}],["的类型将会是",{"2":{"152":1}}],["的类型",{"2":{"42":2,"122":1}}],["的类型是",{"2":{"7":1,"51":1}}],["的匿名结构和数组初始化语法",{"2":{"35":1}}],["的静态链接的二进制可执行文件",{"2":{"24":1}}],["的使用经验",{"2":{"111":1}}],["的使用",{"2":{"24":1,"232":1,"255":1}}],["的交叉编译",{"2":{"24":1}}],["的情况下仍然正确地进行动态链接",{"2":{"23":1}}],["的东西",{"2":{"23":1}}],["的宏",{"2":{"21":3}}],["的声明",{"2":{"21":1}}],["的全部语法",{"2":{"20":1}}],["的结构体的指针设置内存对齐来访问对应的字段",{"2":{"99":1}}],["的结构体",{"2":{"18":1}}],["的结构",{"2":{"18":1}}],["的后续构建将使用缓存",{"2":{"17":1}}],["的",{"2":{"13":1,"14":1,"15":2,"23":1,"24":1,"30":1,"35":1,"39":1,"53":4,"75":1,"129":1,"135":1,"175":1,"179":2,"193":1,"196":1,"202":1,"207":2,"213":1,"232":1,"287":1,"292":1,"296":2}}],["的库",{"2":{"11":1,"195":1,"225":1}}],["的寄存器",{"2":{"4":1}}],["的汇编代码和高级语言相组合",{"2":{"4":1}}],["的资料",{"2":{"3":1}}],["cd",{"2":{"208":2,"220":1,"221":1}}],["cdefine",{"2":{"13":2,"17":2,"250":2}}],["cmpxchgstrong",{"0":{"242":1},"2":{"242":1}}],["cmpxchgweak",{"0":{"241":1},"2":{"241":1}}],["cmake",{"2":{"207":1,"293":1}}],["cmd",{"2":{"8":4,"199":4,"200":7,"201":4,"202":4}}],["cmdfn",{"2":{"8":5}}],["ctime>",{"2":{"202":1}}],["curs",{"2":{"202":1}}],["curses",{"2":{"202":3}}],["cundef",{"2":{"13":1,"17":1}}],["c++",{"0":{"202":1},"2":{"200":1,"202":2,"207":2,"222":1,"293":1}}],["cp",{"2":{"208":1,"220":1,"221":1}}],["cpp",{"2":{"189":1,"202":1}}],["cpu运算器",{"2":{"120":1}}],["cpu",{"2":{"82":2,"99":1,"122":2,"198":1}}],["cvoid",{"2":{"145":1}}],["cvacopy",{"2":{"21":1}}],["cvaarg",{"2":{"21":2}}],["cvaend",{"2":{"21":2}}],["cvastart",{"2":{"21":2}}],["czig",{"2":{"145":1}}],["ceil",{"2":{"102":1}}],["cyber",{"2":{"53":1}}],["c指针",{"2":{"39":1}}],["chocolatey",{"2":{"214":1}}],["checking",{"2":{"202":1}}],["check",{"0":{"226":1},"2":{"202":7,"267":3}}],["checks",{"2":{"197":2}}],["chan",{"2":{"94":1}}],["chartodigit",{"2":{"139":2}}],["char",{"2":{"8":2,"12":1,"63":1,"108":13,"145":1,"201":1}}],["childtype",{"2":{"265":2}}],["child",{"2":{"27":1,"146":1,"201":1}}],["cxx=",{"2":{"24":2}}],["cc",{"2":{"24":4,"202":2}}],["cgo",{"2":{"24":5}}],["capturestdout",{"2":{"200":1}}],["capturestderr",{"2":{"200":1}}],["capy",{"2":{"53":1}}],["causes",{"2":{"124":1}}],["catch",{"0":{"140":1},"2":{"90":1,"127":1,"140":4,"141":2,"144":1}}],["can",{"2":{"90":1}}],["cast",{"2":{"42":1,"83":1}}],["call",{"0":{"260":1},"2":{"245":1,"252":1,"260":3}}],["called",{"2":{"245":1}}],["callback",{"2":{"201":2}}],["call2op",{"2":{"77":1}}],["callconv",{"0":{"119":1},"2":{"21":2,"74":1,"116":1,"117":1,"119":2}}],["callingconvention",{"2":{"119":1}}],["calling",{"2":{"3":1}}],["cache",{"2":{"17":3,"191":1,"267":1}}],["cflags=",{"2":{"24":1}}],["cflags",{"2":{"15":2,"17":1,"24":1}}],["classic",{"2":{"218":1}}],["clang",{"2":{"13":1,"15":3,"23":1}}],["clone",{"2":{"208":1}}],["clobbers",{"2":{"4":1}}],["clubs",{"2":{"69":2}}],["clion",{"0":{"207":1},"2":{"207":3}}],["clicked",{"2":{"201":1}}],["cli",{"0":{"14":1,"193":1},"1":{"15":1,"16":1}}],["ci",{"2":{"124":3,"267":6}}],["circle",{"2":{"89":13}}],["cinclude",{"2":{"13":2,"17":2,"250":3}}],["cimport",{"0":{"16":1},"2":{"13":4,"16":1,"17":11,"250":1}}],["crashed",{"2":{"267":1}}],["cro",{"2":{"235":1}}],["crosstarget",{"2":{"198":3}}],["createfoo",{"2":{"142":1}}],["createmodule",{"2":{"36":1}}],["createmoduleoptions",{"2":{"36":1}}],["create",{"2":{"32":4,"202":1}}],["crt",{"2":{"13":1,"17":1}}],["cr3",{"2":{"4":2}}],["c",{"0":{"11":1,"12":1,"13":1,"14":1,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"23":1,"30":1,"201":1},"1":{"12":1,"13":1,"14":1,"15":2,"16":2,"17":1,"18":1,"19":1,"20":1,"21":1,"22":1,"23":1,"24":1},"2":{"9":1,"11":8,"12":12,"13":6,"14":3,"15":1,"16":3,"17":7,"18":2,"19":7,"20":5,"21":12,"23":1,"24":2,"25":4,"30":10,"41":2,"51":4,"53":2,"54":1,"61":1,"63":2,"68":2,"73":3,"74":2,"75":2,"76":1,"79":4,"98":1,"99":3,"102":5,"106":2,"108":10,"111":1,"112":1,"116":1,"117":3,"124":6,"126":1,"130":7,"139":6,"145":5,"151":2,"152":2,"171":2,"173":6,"178":1,"179":7,"181":1,"189":1,"192":3,"200":2,"201":8,"202":18,"207":2,"215":2,"222":1,"232":1,"250":1,"284":1,"293":11,"295":1,"296":2}}],["coc",{"2":{"208":1}}],["coords",{"2":{"202":1}}],["cool",{"2":{"32":1}}],["colours",{"2":{"202":1}}],["color1",{"2":{"71":2}}],["color",{"2":{"71":2,"130":3,"174":4,"202":1}}],["collision",{"2":{"202":1}}],["cold",{"2":{"118":1}}],["could",{"2":{"245":1}}],["course",{"2":{"90":2}}],["counter",{"2":{"245":1}}],["count",{"2":{"21":2,"160":4,"245":11,"271":2}}],["coercion",{"2":{"42":3}}],["command",{"2":{"267":1}}],["combining",{"2":{"105":1}}],["comrak",{"2":{"53":1}}],["com",{"2":{"29":1,"35":2,"90":1,"205":1,"206":1,"208":3,"229":2}}],["complextype",{"2":{"179":5}}],["complextypetag",{"2":{"179":11}}],["compilation",{"2":{"17":3}}],["compileerror",{"2":{"18":2,"19":2}}],["compile",{"2":{"9":1,"191":1,"192":1,"197":2}}],["comptime",{"2":{"3":2,"6":2,"7":2,"8":3,"9":9,"10":2,"37":1,"42":5,"51":2,"61":1,"84":2,"90":1,"92":1,"99":2,"100":1,"104":1,"105":2,"106":1,"111":2,"113":1,"118":1,"122":1,"124":2,"126":1,"143":2,"146":1,"161":2,"166":4,"175":2,"178":2,"179":1,"185":2,"238":2,"239":2,"240":3,"241":1,"242":1,"253":3,"255":1,"262":2,"265":4}}],["code",{"0":{"205":1},"2":{"4":1,"116":1,"176":1,"205":2,"245":2,"267":1}}],["connect",{"2":{"201":2}}],["continue",{"0":{"163":1},"2":{"116":1,"155":2,"160":2,"162":2,"163":1,"165":2,"202":1}}],["conversion",{"2":{"38":1}}],["convention",{"2":{"3":1}}],["constant",{"2":{"131":3}}],["const",{"2":{"4":4,"8":3,"17":1,"19":1,"21":1,"26":3,"27":5,"28":3,"29":1,"30":1,"31":2,"32":4,"36":2,"37":8,"40":2,"41":11,"42":2,"43":25,"44":1,"46":1,"47":10,"49":2,"51":16,"55":2,"56":1,"57":1,"59":2,"60":3,"61":4,"63":1,"68":3,"70":3,"71":1,"72":3,"74":1,"77":3,"78":3,"79":1,"81":2,"82":7,"83":1,"84":1,"87":3,"89":3,"90":14,"92":1,"93":1,"94":3,"95":1,"96":3,"99":10,"100":1,"102":7,"103":1,"104":3,"105":5,"106":4,"111":1,"122":4,"124":4,"126":3,"130":4,"131":2,"133":1,"134":2,"136":3,"139":3,"140":2,"141":2,"142":2,"143":3,"145":3,"149":5,"153":1,"158":1,"159":1,"161":5,"163":1,"166":3,"170":1,"171":5,"172":1,"173":4,"174":2,"175":1,"176":1,"178":3,"179":8,"180":1,"185":5,"191":3,"192":3,"193":4,"194":6,"195":5,"196":2,"197":6,"198":1,"199":7,"200":8,"201":6,"202":5,"238":1,"245":2,"253":2,"254":2,"255":3,"256":2,"257":2,"258":1,"259":2,"262":2,"265":11,"271":1,"272":2,"281":1,"283":1,"291":1}}],["以允许使用反射访问有关这些类型的信息",{"2":{"294":1}}],["以至于",{"2":{"293":1}}],["以目前的开发速度",{"2":{"211":1}}],["以便同时运行多个测试",{"2":{"197":1}}],["以便两个索引都可以从",{"2":{"105":1}}],["以数组索引的语法来访问向量的元素",{"2":{"102":1}}],["以及一小组新的编译器指令",{"2":{"294":1}}],["以及相较",{"2":{"293":1}}],["以及操作中可能溢出的位",{"2":{"125":1}}],["以及内联",{"2":{"96":1}}],["以及",{"2":{"90":1}}],["以避免没有触发",{"2":{"81":1}}],["以此来抵消运行时的开销",{"2":{"66":1}}],["以下说明各种未定义行为",{"2":{"267":1}}],["以下示例为我们构建一个新的结构体",{"2":{"262":1}}],["以下示例代码不应用于生产环境中",{"2":{"233":1}}],["以下示例中",{"2":{"70":1,"160":1,"165":1}}],["以下仅列出常用的命令",{"2":{"222":1}}],["以下讲述两种两种方法安装",{"2":{"219":1}}],["以下讲述四种构建模式的区别",{"2":{"190":1}}],["以下列出了",{"2":{"297":1}}],["以下列出了支持通过包管理器安装",{"2":{"218":1}}],["以下列出了一些",{"2":{"52":1}}],["以下内容涉及到了联合类型和可选类型",{"2":{"150":1}}],["以下展示了",{"2":{"136":1}}],["以下有一部分运算符你么见过不要紧",{"2":{"127":1}}],["以下特性如果你连名字都没有听说过",{"2":{"97":1}}],["以下两句均为true",{"2":{"51":1}}],["以下是演示",{"2":{"171":1}}],["以下是示例",{"2":{"156":1}}],["以下是类型表格",{"2":{"122":1}}],["以下是一个简单的示例",{"2":{"255":1}}],["以下是一个简短的结构体声明",{"2":{"89":1}}],["以下是一个将英文字符串解析为数字的示例",{"2":{"139":1}}],["以下是一个示例",{"2":{"129":1,"265":1}}],["以下是一个链表的类型实现",{"2":{"92":1}}],["以下是一些示例",{"2":{"51":1}}],["以下是经过实践和总结出来的额外信息",{"2":{"22":1}}],["以下的是指针的额外特性",{"2":{"80":1}}],["以下的变量",{"2":{"8":1}}],["以下的示例仅仅是示范作用",{"2":{"8":1}}],["以上程序中",{"2":{"232":1}}],["以上构建中我们先使用了",{"2":{"201":1}}],["以上构建的其他说明",{"2":{"191":1}}],["以上的约束是在一般情况下",{"2":{"265":1}}],["以上的示例中",{"2":{"255":1}}],["以上的",{"2":{"191":1,"215":1}}],["以上的语法很啰嗦",{"2":{"96":1}}],["以上所说的错误类型实际上用的大概不多",{"2":{"139":1}}],["以上这些内建函数会返回一个元组",{"2":{"272":1}}],["以上这段测试完全可以运行通过",{"2":{"253":1}}],["以上这段函数中",{"2":{"3":1}}],["以上这行代码相当于",{"2":{"137":1}}],["以上几个特性就有很多有意思的点值得我们使用和注意",{"2":{"99":1}}],["以上我们对数组取切片",{"2":{"85":1}}],["以上字段含义为",{"2":{"35":1}}],["以上代码定义了一个名为",{"2":{"196":1}}],["以上代码中的value是一个指针",{"2":{"155":1}}],["以上代码中的",{"2":{"152":1,"155":1}}],["以上代码中",{"2":{"152":2,"157":1,"197":1}}],["以上代码的",{"2":{"151":1}}],["以上代码使用",{"2":{"136":1}}],["以上代码编译需要额外连接",{"2":{"79":1}}],["以上代码展示了定义一个字面量数组的方式",{"2":{"55":1}}],["以上代码翻译完成后",{"2":{"19":1}}],["以上代码",{"2":{"10":1}}],["以上函数实现了斐波那契数列",{"2":{"9":1}}],["以上",{"2":{"7":1,"193":1}}],["以",{"2":{"4":1}}],["以实现加法功能",{"2":{"3":1}}],["575",{"2":{"267":1}}],["595540",{"2":{"202":1}}],["598336",{"2":{"202":1}}],["598356",{"2":{"202":1}}],["599636",{"2":{"202":1}}],["5678",{"2":{"145":1}}],["564",{"2":{"124":1}}],["54",{"2":{"42":5}}],["5",{"2":{"3":1,"42":5,"43":9,"47":2,"49":1,"55":1,"60":2,"61":3,"89":1,"90":2,"93":1,"102":3,"103":1,"105":2,"106":1,"122":2,"124":1,"149":2,"155":1,"156":1,"157":1,"158":1,"159":2,"162":2,"170":8,"171":3,"253":2,"258":1,"267":2}}],["28",{"2":{"267":2}}],["21",{"2":{"202":1}}],["262176",{"2":{"202":2}}],["247872",{"2":{"202":1}}],["243",{"2":{"124":1}}],["2456131",{"2":{"124":1}}],["22",{"2":{"124":1,"202":2,"267":1}}],["2^20",{"2":{"102":1}}],["2^32",{"2":{"102":1}}],["200",{"2":{"201":2}}],["2000",{"2":{"163":2}}],["20",{"2":{"90":3,"202":2}}],["29",{"2":{"82":1}}],["253",{"2":{"267":1}}],["255",{"2":{"46":1,"127":2,"272":1}}],["25",{"2":{"42":1}}],["250",{"2":{"41":2}}],["2",{"2":{"3":1,"8":1,"9":3,"19":2,"43":2,"47":4,"49":1,"57":1,"59":4,"60":2,"62":1,"78":2,"82":2,"85":5,"86":1,"87":2,"89":1,"90":1,"99":5,"102":4,"105":2,"106":1,"126":2,"148":2,"151":1,"155":1,"158":1,"161":4,"163":1,"166":2,"171":2,"173":2,"176":1,"184":4,"202":9,"253":3,"260":1,"264":1,"265":1,"267":1,"293":1}}],["nix",{"2":{"218":1}}],["nixos",{"2":{"218":1}}],["nightly",{"2":{"35":3,"36":1,"129":1,"208":1,"211":1,"213":1,"216":1,"224":1,"225":1,"229":1,"231":1}}],["nvim",{"2":{"208":6}}],["nvim作为",{"2":{"208":1}}],["ncurses",{"2":{"202":2}}],["necessary",{"2":{"245":1}}],["neovim",{"0":{"208":1},"2":{"208":6}}],["new",{"2":{"201":3,"202":6,"241":1,"242":1}}],["news",{"2":{"23":1,"52":1}}],["nested",{"2":{"185":1}}],["negative",{"2":{"126":1}}],["next",{"2":{"92":1}}],["n是数组的长度",{"2":{"78":1}}],["nnnnnn",{"2":{"62":1}}],["nums",{"2":{"161":4}}],["num",{"2":{"108":2,"136":1,"148":6,"170":4,"175":3,"202":10}}],["numbers",{"2":{"167":5,"168":5}}],["number",{"2":{"4":8,"72":5,"99":2,"140":5,"141":7,"164":2,"180":2,"184":2,"202":1}}],["null",{"0":{"276":1,"284":1},"2":{"20":1,"44":3,"51":1,"61":1,"83":2,"145":11,"146":1,"147":1,"151":1,"159":1,"167":6,"201":2,"262":1,"276":1,"294":1,"296":1}}],["nope1234",{"2":{"256":2,"257":2}}],["nope",{"2":{"256":3,"257":3}}],["nostdlib++",{"2":{"202":1}}],["nostdinc++",{"2":{"202":1}}],["noecho",{"2":{"202":1}}],["normal",{"2":{"145":1}}],["noreturn",{"0":{"116":1},"2":{"4":1,"116":2,"118":1,"140":1}}],["node",{"2":{"92":5}}],["noop",{"2":{"245":2}}],["noop4",{"2":{"82":3}}],["noop1",{"2":{"82":3}}],["not",{"2":{"68":1,"153":1,"170":2,"172":2,"179":6}}],["none",{"2":{"198":1}}],["nonnull",{"2":{"145":1}}],["non",{"2":{"42":1,"99":1}}],["no",{"2":{"13":1,"17":1,"245":1,"250":1,"253":1}}],["nanos",{"2":{"134":2}}],["nan",{"2":{"126":3}}],["native",{"2":{"99":2,"124":1,"267":1}}],["namespace",{"2":{"265":1}}],["named",{"2":{"140":1}}],["name",{"2":{"8":5,"19":2,"35":7,"36":1,"37":11,"70":2,"90":3,"100":3,"178":1,"179":1,"185":1,"191":2,"192":1,"193":1,"194":1,"195":3,"197":1,"198":1,"199":1,"200":1,"201":1,"202":1,"229":3,"255":2,"262":1,"265":7}}],["nasm",{"2":{"2":1}}],["n",{"2":{"3":1,"4":1,"13":1,"29":2,"30":2,"55":2,"56":1,"57":6,"59":1,"61":12,"62":1,"63":2,"65":1,"66":1,"77":1,"78":6,"79":1,"85":3,"86":2,"87":2,"89":1,"90":2,"94":1,"100":3,"102":4,"108":3,"124":1,"129":1,"131":1,"132":1,"136":1,"142":1,"148":3,"149":1,"162":2,"167":2,"168":2,"170":4,"173":1,"178":2,"194":1,"201":1,"231":1,"233":4,"250":1,"254":2,"255":1,"256":4,"257":4,"258":2,"259":1,"260":1,"262":1,"265":2,"272":2}}],["play",{"2":{"297":1}}],["playground",{"2":{"297":1}}],["placing",{"2":{"202":1}}],["png",{"2":{"250":1}}],["p",{"2":{"202":9,"258":6,"259":3}}],["py",{"2":{"202":8}}],["px",{"2":{"202":9}}],["ps",{"2":{"134":1}}],["piece",{"2":{"202":18}}],["pi",{"2":{"89":5,"94":2}}],["pipe",{"2":{"53":1}}],["possibly",{"2":{"245":1}}],["position",{"2":{"202":2}}],["posixcallmainandexit",{"2":{"124":1,"267":1}}],["powershell",{"2":{"215":2}}],["point",{"2":{"91":2,"95":4,"173":5,"258":5,"259":3}}],["pointers",{"2":{"84":1}}],["pointer",{"2":{"82":4,"83":1,"99":2}}],["pool",{"2":{"32":8}}],["pt",{"2":{"66":2,"91":1}}],["ptr",{"2":{"77":4,"78":13,"81":4,"83":2,"84":3,"85":1,"86":4,"99":4,"145":5,"238":1,"239":1,"240":1,"241":1,"242":1,"253":3,"281":2}}],["ptrcast",{"2":{"50":1,"99":1}}],["ptrfromint",{"2":{"50":1,"51":2,"81":1,"83":1,"281":1}}],["permissions",{"2":{"122":1}}],["perform",{"2":{"8":1}}],["performfn",{"2":{"8":10}}],["peertypeemptyarrayandsliceanderror",{"2":{"51":1}}],["peertypeemptyarrayandslice",{"2":{"51":3}}],["peertypetandoptionalt",{"2":{"51":2}}],["peer",{"2":{"38":1,"51":1}}],["p4",{"2":{"32":2}}],["p3",{"2":{"32":2}}],["p2",{"2":{"32":2}}],["p1",{"2":{"32":2}}],["pair",{"2":{"202":1}}],["param",{"2":{"142":2,"265":1}}],["parseu64",{"2":{"139":1,"140":2,"141":5}}],["particular",{"2":{"202":1}}],["part",{"2":{"60":4}}],["passed",{"2":{"184":1}}],["passwd",{"2":{"90":3}}],["password",{"2":{"90":17}}],["pasting",{"2":{"18":1}}],["packed",{"0":{"99":1,"182":1},"2":{"98":1,"99":10,"178":1,"182":1,"282":1}}],["packages",{"2":{"208":1}}],["package",{"2":{"35":1,"36":1,"37":4}}],["pacman",{"2":{"53":1,"218":1}}],["payload",{"2":{"44":1,"45":1,"135":1,"178":15}}],["path=",{"2":{"221":1}}],["path",{"2":{"36":1,"37":1,"191":1,"192":1,"193":1,"194":1,"195":3,"197":2,"198":1,"199":2,"200":1,"201":3,"202":3,"215":6,"245":1}}],["paths",{"2":{"35":3}}],["patterns",{"2":{"32":1}}],["panic",{"2":{"26":1,"28":1,"90":1,"124":1,"141":1,"176":1,"197":1,"267":1}}],["page",{"0":{"31":1},"2":{"25":1,"31":1}}],["primitive",{"2":{"265":1}}],["printw",{"2":{"202":2}}],["printf",{"2":{"13":2,"21":2,"63":1,"79":3,"232":1}}],["print",{"2":{"3":1,"55":4,"56":3,"57":5,"59":3,"60":2,"61":14,"63":3,"65":3,"66":3,"77":3,"78":9,"85":5,"86":4,"87":4,"89":1,"90":9,"94":1,"100":3,"102":6,"108":7,"124":1,"129":1,"131":1,"132":1,"136":1,"142":1,"148":5,"149":3,"153":6,"162":2,"167":2,"168":2,"170":6,"173":1,"178":4,"194":1,"199":1,"200":1,"201":3,"231":1,"232":2,"233":6,"250":1,"254":2,"255":1,"256":4,"257":4,"258":2,"259":1,"260":1,"262":1,"272":4}}],["pr",{"2":{"202":7}}],["present",{"2":{"201":1}}],["pred",{"2":{"106":5}}],["previous",{"2":{"245":1}}],["prev",{"2":{"92":1}}],["prefix",{"2":{"8":2,"191":1,"196":1}}],["process",{"2":{"23":1,"124":1}}],["purpose",{"2":{"26":1,"28":1}}],["pub",{"2":{"3":1,"4":5,"13":1,"17":1,"19":1,"21":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"47":1,"51":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":1,"66":1,"69":1,"70":1,"71":1,"77":1,"78":2,"79":2,"85":1,"86":1,"87":1,"89":3,"90":10,"92":1,"94":1,"100":1,"102":1,"108":2,"111":2,"124":1,"126":1,"129":1,"130":2,"131":1,"132":1,"134":1,"136":1,"139":1,"143":2,"148":1,"149":1,"153":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":2,"185":1,"191":1,"192":1,"193":1,"194":2,"195":2,"196":1,"197":1,"199":2,"200":2,"201":1,"202":1,"231":1,"233":2,"250":3,"254":1,"255":1,"256":2,"257":2,"258":2,"259":1,"260":1,"262":1,"272":1}}],["pull",{"2":{"1":1}}],["mkdir",{"2":{"208":1,"221":2}}],["monotonic",{"2":{"245":1}}],["move",{"2":{"202":3}}],["modula",{"2":{"293":1}}],["module",{"2":{"36":3,"37":7}}],["mode",{"2":{"190":1,"209":2}}],["mutex",{"2":{"234":1}}],["mulwithoverflow",{"2":{"125":1,"139":1,"272":1}}],["mul",{"2":{"104":2,"272":1}}],["musl",{"2":{"24":3}}],["methodname",{"2":{"265":1}}],["meta",{"2":{"179":2,"185":2}}],["meet",{"2":{"167":2,"168":2}}],["message",{"2":{"55":4}}],["memcpy",{"2":{"90":3,"202":1}}],["memset",{"2":{"90":3,"202":1}}],["mem",{"2":{"33":1,"51":9,"61":4,"70":4}}],["member",{"2":{"20":2}}],["memorypool",{"0":{"32":1},"2":{"25":1,"32":1}}],["memory",{"2":{"4":1,"27":4,"31":2,"81":1}}],["min",{"2":{"104":1}}],["minisign",{"2":{"53":2}}],["million",{"2":{"68":1}}],["microsoft",{"2":{"29":1,"206":2}}],["m",{"2":{"23":1}}],["map",{"2":{"287":1}}],["mapped",{"2":{"81":1}}],["mason",{"2":{"208":4}}],["mask2",{"2":{"105":2}}],["mask1",{"2":{"105":2}}],["mask",{"2":{"105":7,"122":1}}],["math",{"2":{"125":1,"126":3,"139":1,"270":1,"272":7}}],["matrix",{"2":{"56":2}}],["mail",{"2":{"90":3}}],["mainterminal",{"2":{"267":2}}],["main",{"2":{"3":2,"4":1,"13":1,"17":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"37":1,"47":1,"51":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":2,"65":1,"66":1,"70":1,"71":1,"77":1,"78":2,"79":1,"85":1,"86":1,"87":1,"89":1,"90":3,"94":1,"100":3,"102":1,"108":2,"124":3,"126":1,"129":1,"131":1,"132":1,"136":1,"144":1,"148":1,"149":1,"153":1,"161":2,"162":1,"166":2,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":2,"191":1,"193":1,"194":3,"195":2,"197":2,"198":1,"199":3,"200":3,"201":3,"202":3,"213":3,"224":2,"225":4,"231":2,"232":2,"233":3,"250":2,"254":3,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"262":1,"267":2,"272":1}}],["many",{"2":{"76":1}}],["make",{"2":{"65":2}}],["makelocal",{"2":{"19":5}}],["markdown",{"2":{"53":1}}],["mac安装",{"2":{"216":1}}],["mac",{"0":{"216":1}}],["machine",{"2":{"215":2}}],["mach",{"2":{"53":1}}],["macro",{"0":{"19":1}}],["malloc",{"2":{"25":1,"30":4,"145":5}}],["magic",{"2":{"23":1}}],["maxint",{"2":{"139":3,"270":1}}],["max",{"2":{"7":5,"104":1,"111":1}}],["mmio",{"2":{"4":1,"81":4}}],["msg",{"2":{"4":3,"172":3}}],["my",{"2":{"3":5,"35":1,"37":1,"163":2}}],["effects",{"2":{"253":1}}],["epoxy",{"2":{"250":1}}],["each",{"2":{"202":1}}],["eax",{"2":{"3":1}}],["echo",{"2":{"200":1}}],["eventuallyerrorsequence",{"2":{"168":3}}],["eventuallynullsequence",{"2":{"167":3}}],["emerge",{"2":{"218":1}}],["emacs",{"0":{"209":1},"2":{"209":2}}],["email",{"2":{"90":17}}],["embedfile",{"0":{"199":1},"2":{"199":3,"200":2}}],["emit",{"2":{"196":1}}],["empty",{"2":{"94":3}}],["element",{"2":{"102":1}}],["ele",{"2":{"85":1,"102":3,"106":3}}],["else",{"2":{"7":3,"51":4,"72":1,"111":1,"139":1,"141":4,"148":4,"149":3,"151":2,"152":6,"159":1,"161":2,"164":3,"166":2,"167":3,"168":5,"170":3,"171":2,"172":2,"175":6,"202":1,"267":1,"272":1}}],["eql",{"2":{"51":7,"61":2,"70":2}}],["equal",{"2":{"19":1}}],["errdefer结合使用",{"2":{"142":1}}],["errdefer",{"0":{"142":1},"2":{"142":7,"153":2}}],["err|",{"2":{"141":1}}],["err",{"2":{"136":4,"137":2,"141":3,"142":1,"152":4,"168":4,"233":12}}],["errsetcast",{"2":{"50":1}}],["errorcast转换两个不相关的错误集",{"2":{"280":1}}],["errorfromint",{"2":{"278":1}}],["errorreturntrace",{"2":{"144":1}}],["errorsettwo",{"2":{"143":1}}],["errorsetone",{"2":{"143":1}}],["errorname",{"2":{"142":1}}],["error",{"0":{"277":1},"2":{"42":1,"45":1,"124":1,"130":1,"135":1,"136":7,"137":2,"139":6,"141":2,"142":4,"143":5,"152":1,"168":1,"175":1,"186":1,"267":1,"277":1}}],["e",{"2":{"41":2,"43":4,"47":9,"55":2,"61":2,"68":1,"104":1,"105":5,"171":2,"173":4,"214":1}}],["encoding=",{"2":{"265":1}}],["ensures",{"2":{"245":2}}],["env",{"2":{"218":1}}],["environment",{"2":{"215":4}}],["entry",{"2":{"202":1}}],["enumfromint",{"2":{"50":1,"72":1,"279":1}}],["enum",{"2":{"47":2,"68":5,"69":1,"70":4,"71":1,"72":1,"73":1,"130":1,"135":1,"173":2,"174":1,"175":1,"179":3,"185":1}}],["en",{"2":{"29":1}}],["endwin",{"2":{"202":1}}],["endian",{"2":{"99":3}}],["end",{"2":{"21":1,"78":1,"87":1,"164":2}}],["example",{"2":{"195":1,"201":1}}],["extra",{"2":{"245":1}}],["extract",{"2":{"202":1}}],["extldflags",{"2":{"24":1}}],["extern",{"0":{"73":1,"98":1,"117":1,"181":1},"2":{"3":1,"18":2,"21":2,"73":1,"74":1,"79":1,"98":1,"112":1,"117":2,"130":2,"178":1,"181":2,"182":1,"282":1}}],["explicit",{"2":{"143":1}}],["expr",{"2":{"19":1,"178":1}}],["export",{"2":{"19":1}}],["expected",{"2":{"241":1,"242":1}}],["expect",{"2":{"8":8,"9":4,"47":7,"51":8,"70":6,"81":3,"82":13,"83":3,"84":3,"90":1,"99":22,"146":3,"151":1,"152":3,"161":4,"163":1,"166":4,"171":1,"179":8,"184":6,"185":6,"253":4}}],["exec",{"2":{"153":4}}],["executed",{"2":{"90":1}}],["executableoptions",{"2":{"191":1}}],["executable",{"2":{"36":1,"193":2}}],["exe",{"0":{"224":1},"2":{"13":3,"17":1,"37":3,"79":1,"124":1,"191":3,"192":8,"193":4,"194":4,"195":9,"197":7,"198":1,"199":5,"200":5,"201":8,"202":8,"224":1,"225":2,"231":2}}],["exitprocess",{"2":{"116":1}}],["exit",{"2":{"4":2,"116":2}}],["181",{"2":{"267":1}}],["18",{"2":{"202":2}}],["16",{"2":{"202":3}}],["1月1日",{"2":{"134":1}}],["1smallstep4man",{"2":{"130":1}}],["15",{"2":{"124":1}}],["1970年",{"2":{"134":1}}],["19",{"2":{"124":1,"202":1}}],["14",{"2":{"89":2,"94":2}}],["1f4a9",{"2":{"61":1}}],["12202809180bab2c7ae3382781b2fc65395e74b49d99ff2595f3fea9f7cf66cfa963",{"2":{"229":1}}],["12200f41f9804eb9abff259c5d0d84f27caa0a25e0f72451a0243a806c8f94fdc433",{"2":{"35":1}}],["123",{"2":{"133":1}}],["123456",{"2":{"90":2}}],["1234",{"2":{"43":1,"82":3,"93":1,"96":1,"141":1,"145":3,"146":1,"178":4}}],["128175",{"2":{"61":1}}],["128169",{"2":{"61":1}}],["12",{"2":{"41":1,"47":1,"51":1,"96":1,"282":1}}],["112358",{"2":{"130":1}}],["1111",{"2":{"122":2}}],["111",{"2":{"43":4}}],["11",{"2":{"34":1,"35":1,"136":1,"207":1}}],["107",{"2":{"171":1}}],["101",{"2":{"171":1}}],["103",{"2":{"171":1}}],["104",{"2":{"108":2}}],["100",{"2":{"26":1,"27":2,"28":1,"31":1,"68":1,"82":2,"171":2}}],["10000",{"2":{"202":1}}],["1000000",{"2":{"68":1}}],["1000",{"2":{"9":1,"27":2,"68":1}}],["10",{"2":{"10":1,"28":1,"42":2,"65":1,"66":1,"139":2,"140":2,"141":5,"162":2,"163":1,"165":1,"171":1,"202":5,"246":1,"272":1}}],["1337",{"2":{"142":1}}],["13",{"2":{"9":2,"91":1,"140":3}}],["1",{"2":{"3":1,"4":2,"8":6,"9":2,"13":1,"17":1,"19":2,"21":1,"28":1,"29":1,"30":1,"35":1,"43":4,"47":2,"50":1,"51":3,"56":5,"57":2,"59":4,"60":2,"61":3,"62":1,"65":1,"70":1,"77":1,"78":4,"82":4,"84":3,"85":3,"86":1,"87":2,"90":1,"99":3,"102":5,"104":4,"105":6,"106":2,"107":1,"119":1,"122":1,"124":2,"126":2,"127":1,"133":3,"139":2,"143":2,"148":3,"155":1,"158":1,"160":6,"162":2,"163":3,"164":1,"165":1,"166":4,"167":1,"168":1,"171":4,"173":4,"175":1,"176":1,"178":2,"179":1,"184":2,"202":17,"211":1,"245":3,"253":1,"256":1,"257":1,"258":3,"260":1,"265":1,"267":2,"272":1,"281":1}}],["rc",{"2":{"245":9}}],["rcx",{"2":{"4":3}}],["rpm",{"2":{"218":1}}],["row++",{"2":{"202":1}}],["row",{"2":{"202":4}}],["root",{"2":{"36":1,"37":2,"124":1,"191":2,"192":1,"193":1,"194":1,"195":3,"197":2,"198":1,"199":1,"200":1,"201":1,"202":1,"232":2,"267":1}}],["rust",{"2":{"145":1,"190":1,"200":1,"293":4,"296":1}}],["runloop",{"2":{"202":3}}],["runner",{"2":{"124":3,"184":1,"267":8}}],["run",{"2":{"9":1,"185":1,"192":10,"197":5,"199":10,"200":13,"201":9,"202":8,"254":1}}],["runtime",{"2":{"6":1,"87":2,"124":6,"251":1,"253":1}}],["r",{"2":{"62":1,"105":1,"202":24,"220":1,"221":1}}],["river",{"2":{"53":1}}],["rand",{"2":{"202":3}}],["rangehasnumber",{"2":{"164":1}}],["radix",{"2":{"139":4}}],["radius",{"2":{"89":17}}],["raw",{"2":{"30":2}}],["rax",{"2":{"4":8}}],["rdx",{"2":{"4":2}}],["rdi",{"2":{"3":1,"4":3}}],["r11",{"2":{"4":3}}],["rsi",{"2":{"3":1,"4":2}}],["re",{"2":{"202":1}}],["reflection",{"2":{"251":1}}],["ref",{"2":{"245":5}}],["refcount",{"2":{"245":8}}],["refresh",{"2":{"202":1}}],["refalldecls",{"2":{"185":4}}],["remove",{"2":{"202":5}}],["remainder",{"2":{"42":1}}],["reached",{"2":{"267":1}}],["reachedzero",{"2":{"168":1}}],["readu32be",{"2":{"265":1}}],["real",{"2":{"151":1}}],["really",{"2":{"130":2}}],["red",{"2":{"130":3}}],["reduction",{"2":{"104":1}}],["reduceop",{"2":{"104":1}}],["reduce",{"0":{"104":1},"2":{"102":1,"104":2}}],["releasenightly",{"2":{"213":1}}],["release",{"2":{"213":1,"245":2,"293":1}}],["releasefast",{"2":{"141":1,"176":1,"190":2}}],["releasesafe",{"2":{"141":1,"176":1,"190":2,"267":1}}],["releasesmall",{"2":{"124":1,"141":1,"176":1,"190":2}}],["relative",{"2":{"37":1}}],["repo",{"2":{"35":2}}],["res",{"2":{"259":2}}],["resizeterm",{"2":{"202":1}}],["resizefn",{"2":{"33":1}}],["res2",{"2":{"105":2}}],["res的值是",{"2":{"105":1}}],["res1",{"2":{"105":1}}],["resolution",{"2":{"38":1,"51":1}}],["result",{"2":{"8":17,"72":2,"103":1,"104":3,"149":4,"159":1,"174":1,"260":1,"272":2}}],["ret",{"2":{"4":6}}],["return",{"2":{"4":2,"7":5,"8":7,"9":4,"10":1,"19":2,"21":1,"47":2,"51":7,"63":1,"65":1,"69":1,"82":1,"89":4,"90":5,"92":1,"100":2,"111":2,"115":1,"116":1,"117":1,"119":1,"134":1,"136":1,"139":5,"141":2,"142":4,"143":4,"145":2,"161":2,"164":1,"166":2,"167":1,"168":1,"175":5,"184":1,"185":1,"201":1,"202":6,"253":1,"260":1,"265":2,"267":1}}],["retq",{"2":{"3":1}}],["review",{"2":{"1":1}}],["request",{"2":{"1":1}}],["fence",{"0":{"243":1},"2":{"243":1,"245":1}}],["fedora",{"2":{"218":2}}],["fetchsub",{"2":{"245":2}}],["fetchadd",{"2":{"245":1}}],["fetch",{"0":{"229":1},"2":{"35":1,"229":2}}],["fmt",{"0":{"227":1},"2":{"208":2}}],["frame",{"2":{"202":2}}],["from",{"2":{"202":3}}],["free",{"2":{"26":1,"27":2,"28":1,"29":2,"30":1,"31":1,"90":3}}],["freestanding",{"2":{"20":1,"83":1,"198":1}}],["fd",{"2":{"130":2}}],["fstat$inode64",{"2":{"130":1}}],["f80",{"2":{"126":1}}],["full",{"2":{"99":6,"202":1}}],["funcname",{"2":{"100":1}}],["functionalias",{"2":{"265":1}}],["functionpointer",{"2":{"265":4}}],["functionname",{"2":{"265":3}}],["function",{"2":{"3":1,"82":1,"100":2,"260":1}}],["func",{"2":{"3":5,"8":5,"267":1}}],["flush",{"2":{"233":2}}],["floatfromint",{"2":{"50":1,"89":2}}],["floatcast",{"2":{"50":1}}],["float",{"2":{"42":2,"126":1,"178":3,"180":1,"253":2,"282":2,"283":2}}],["flags",{"2":{"15":1,"201":3,"202":2}}],["f128",{"2":{"41":1,"126":3}}],["f16",{"2":{"41":1,"89":6,"126":1}}],["f64",{"2":{"41":1,"96":1,"117":3,"126":2,"178":3,"180":1}}],["f32",{"2":{"41":1,"42":4,"43":2,"47":3,"56":5,"95":4,"102":4,"126":2,"161":2,"166":2,"175":1,"265":1,"282":1,"283":1}}],["f",{"2":{"41":2,"42":5,"282":2}}],["falls",{"2":{"202":1}}],["false",{"2":{"50":1,"51":7,"72":3,"90":1,"104":3,"106":2,"109":1,"153":1,"164":1,"174":2,"185":1,"193":1,"208":1,"256":2,"257":3,"262":2}}],["fancy",{"2":{"66":2}}],["fast",{"2":{"32":1}}],["failure",{"2":{"45":1}}],["fail",{"2":{"26":1,"28":1,"90":2,"241":1,"242":1}}],["failingallocator",{"2":{"25":1}}],["fba",{"2":{"27":6}}],["following",{"2":{"267":1}}],["fo",{"2":{"202":1}}],["found",{"2":{"172":2}}],["four",{"2":{"70":1}}],["foo",{"2":{"19":3,"73":1,"74":1,"82":4,"93":2,"99":2,"100":3,"136":3,"142":4,"145":16,"146":3,"253":3,"256":5,"257":5,"282":3}}],["foreign",{"2":{"197":2}}],["format",{"2":{"21":1,"79":1}}],["for",{"0":{"155":1},"1":{"156":1,"157":1,"158":1,"159":1,"160":1,"161":1},"2":{"9":1,"51":1,"56":3,"66":1,"85":1,"96":1,"139":1,"142":2,"154":1,"155":3,"157":1,"158":1,"159":2,"160":4,"161":4,"185":2,"202":9,"208":2,"246":1,"255":5}}],["fork",{"2":{"1":1}}],["ffi",{"2":{"11":1,"296":1}}],["fixed",{"2":{"265":2}}],["fixedbufferallocator",{"0":{"27":1},"2":{"25":1,"27":2}}],["filter",{"2":{"186":2}}],["file`",{"2":{"199":2,"200":2}}],["fileopenerror",{"2":{"136":5}}],["filename",{"2":{"100":1}}],["filenotfound",{"2":{"136":1,"137":3}}],["fileno",{"2":{"4":2}}],["file",{"2":{"17":1,"36":3,"37":1,"191":2,"192":1,"193":1,"194":1,"195":3,"197":2,"198":1,"199":2,"200":2,"201":2,"202":2,"265":1}}],["field",{"0":{"258":1},"2":{"99":1,"175":2,"178":1,"185":1,"252":1,"255":4,"258":6,"265":3}}],["fieldparentptr",{"0":{"259":1},"2":{"95":2,"252":1,"259":2}}],["fields",{"2":{"70":2,"175":4,"255":1,"262":1}}],["first",{"2":{"92":1,"153":1}}],["fibonacci",{"2":{"9":8}}],["fns",{"2":{"8":4}}],["fn",{"2":{"3":2,"4":3,"8":9,"9":2,"13":1,"17":1,"19":1,"21":2,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"47":2,"51":2,"55":1,"56":1,"57":1,"59":1,"60":1,"61":1,"63":1,"65":2,"66":1,"69":1,"70":1,"71":1,"74":2,"77":2,"78":2,"79":2,"82":5,"85":1,"86":1,"87":1,"89":5,"90":10,"94":1,"95":1,"99":1,"100":2,"102":1,"108":2,"111":3,"116":1,"117":2,"119":1,"124":1,"126":1,"129":1,"130":2,"131":1,"132":1,"134":1,"136":2,"139":2,"140":1,"143":2,"145":4,"148":1,"149":1,"153":1,"161":4,"162":1,"166":4,"167":2,"168":2,"170":1,"172":1,"173":1,"175":2,"178":1,"179":2,"184":1,"185":1,"191":2,"192":1,"193":1,"194":2,"195":2,"196":1,"197":1,"199":2,"200":2,"201":1,"202":1,"231":1,"233":2,"245":4,"250":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":2,"262":1,"265":5,"267":1,"272":1}}],["gc",{"2":{"294":1}}],["gcc",{"2":{"4":1,"145":1}}],["git",{"2":{"208":2}}],["github",{"2":{"1":1,"35":3,"53":1,"189":1,"208":3,"229":2}}],["game",{"2":{"202":1}}],["gamedev",{"2":{"53":1}}],["gpointer",{"2":{"201":2}}],["gpa",{"2":{"26":3,"28":3,"90":3}}],["gentoo",{"2":{"218":1}}],["generalpurposeallocator",{"0":{"26":1},"2":{"25":1,"26":1,"28":1,"33":1,"90":1}}],["getstderr",{"2":{"233":2}}],["getstdout",{"2":{"233":2}}],["getenvironmentvariable",{"2":{"215":2}}],["getemitteddocs",{"2":{"196":1}}],["getch",{"2":{"202":1}}],["getinstallstep",{"2":{"192":1,"199":1,"200":1,"201":1,"202":1}}],["getnum",{"2":{"175":1}}],["gui",{"2":{"53":1}}],["g",{"2":{"41":2,"201":9,"208":2}}],["gz",{"2":{"35":4,"229":2}}],["gnu",{"2":{"24":2,"202":1}}],["gotta",{"2":{"32":1}}],["goto",{"2":{"18":1,"160":2,"165":2}}],["go",{"2":{"24":6,"94":2,"293":1}}],["glfw3",{"2":{"250":1}}],["glfw",{"2":{"250":1}}],["gl",{"2":{"250":1}}],["glibc",{"2":{"23":2}}],["global",{"2":{"3":1,"82":1,"213":1,"265":1}}],["gtkapplication",{"2":{"201":2}}],["gtkwidget",{"2":{"201":3}}],["gtk",{"2":{"201":16,"202":1}}],["gtk4",{"2":{"53":1,"201":3}}],["gt",{"2":{"4":2,"40":1,"102":3,"117":1,"127":4}}],["i0",{"2":{"288":1}}],["image",{"2":{"250":1}}],["implicit",{"2":{"42":1}}],["import",{"2":{"3":1,"8":1,"9":1,"17":3,"21":1,"26":1,"27":2,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":2,"47":1,"51":1,"55":1,"56":1,"57":1,"59":1,"60":1,"61":2,"63":1,"65":1,"66":1,"70":1,"77":1,"78":2,"79":1,"81":1,"82":3,"83":1,"84":1,"85":1,"86":1,"87":1,"89":1,"90":3,"94":1,"99":4,"100":1,"102":1,"108":2,"124":1,"125":1,"126":2,"129":1,"130":1,"131":1,"132":1,"136":1,"139":1,"146":1,"148":1,"149":1,"153":1,"161":1,"162":1,"166":1,"167":1,"168":1,"170":1,"172":1,"173":1,"178":1,"179":2,"184":1,"185":1,"188":1,"191":1,"192":1,"193":1,"194":5,"195":2,"196":1,"197":1,"199":3,"200":2,"201":1,"202":1,"231":1,"232":2,"233":2,"250":2,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"262":1,"265":2,"272":8}}],["io",{"2":{"233":7}}],["i++",{"2":{"202":3}}],["ij",{"2":{"163":2}}],["i7",{"2":{"122":1}}],["i128",{"2":{"122":1}}],["i16",{"2":{"41":3,"51":1,"77":1,"122":1}}],["i64",{"2":{"122":1,"134":1,"178":3,"194":1}}],["ide",{"2":{"206":1,"207":2,"266":1}}],["identifier",{"2":{"130":1}}],["idx",{"2":{"175":1}}],["id",{"2":{"100":1,"214":1}}],["isfieldoptional",{"2":{"175":1}}],["isize",{"2":{"122":2}}],["is",{"2":{"72":2,"89":1,"90":2,"102":4,"104":2,"118":1,"136":1,"142":1,"148":3,"149":1,"162":2,"170":4,"185":3,"188":1,"193":3,"194":1,"202":1,"245":2,"255":2,"258":6,"259":2,"260":1,"262":2}}],["isclubs",{"2":{"69":1}}],["issue",{"2":{"4":1,"5":1,"9":1,"14":1,"202":1,"262":1}}],["i|",{"2":{"66":1,"157":1}}],["item|",{"2":{"173":2}}],["item",{"2":{"76":2,"173":16}}],["items2",{"2":{"158":2}}],["items",{"2":{"10":2,"90":3,"155":4,"157":2,"158":2,"159":2}}],["it",{"2":{"60":2,"130":1,"202":1,"245":1}}],["i8",{"2":{"51":1,"59":3,"77":3,"111":3,"117":3,"122":1,"161":2,"166":2}}],["i",{"2":{"8":6,"15":3,"21":3,"41":3,"66":1,"78":1,"106":3,"122":1,"157":1,"161":2,"162":12,"163":7,"164":4,"165":3,"166":8,"180":1,"202":28,"218":1}}],["if",{"2":{"7":4,"8":1,"9":2,"26":1,"28":1,"51":8,"82":1,"90":1,"111":1,"136":1,"139":3,"141":3,"142":1,"143":2,"145":3,"148":6,"149":3,"151":2,"152":8,"153":1,"155":1,"159":1,"162":2,"164":1,"167":2,"168":1,"175":1,"176":1,"185":1,"192":1,"199":1,"200":1,"201":1,"202":14,"245":1,"272":1,"276":1,"277":1}}],["inside",{"2":{"185":1}}],["installartifact",{"2":{"191":2,"192":5,"193":1,"194":1,"195":3,"197":1,"199":1,"200":1,"201":1,"202":1}}],["install",{"2":{"36":1,"191":2,"192":3,"193":1,"194":1,"195":2,"196":4,"197":1,"199":1,"200":1,"201":1,"202":1,"213":2,"214":2,"216":2,"218":4}}],["inferred",{"2":{"143":1}}],["inf",{"2":{"126":4}}],["info",{"2":{"17":3,"255":4,"262":1}}],["input",{"2":{"81":1,"202":1,"233":1}}],["inputoperands",{"2":{"4":1}}],["in",{"2":{"63":2,"90":1,"124":4,"130":1,"202":1,"235":1,"245":1,"267":6}}],["invalidparam",{"2":{"142":1}}],["invalidchar",{"2":{"139":1,"141":1}}],["invalid",{"2":{"61":2,"83":1}}],["ini",{"2":{"53":2,"192":1}}],["initscr",{"2":{"202":1}}],["initial",{"2":{"66":3}}],["init",{"0":{"224":1,"225":1},"2":{"19":2,"27":2,"28":1,"29":1,"32":1,"66":2,"89":4,"90":3,"178":1,"202":2,"224":3,"225":4,"231":4,"245":1,"287":1}}],["include",{"2":{"15":1,"63":1,"201":1,"202":5}}],["indexed",{"2":{"202":1}}],["indexoutofbounds",{"2":{"175":1}}],["index|",{"2":{"56":2,"85":1}}],["index",{"2":{"9":5,"20":1,"56":2,"85":1,"175":2}}],["inline",{"0":{"161":1,"166":1},"2":{"8":2,"13":1,"17":1,"119":1,"161":3,"166":3,"175":6,"185":1,"255":5}}],["introduction",{"2":{"184":2}}],["intptr",{"2":{"122":1}}],["int128",{"2":{"122":2}}],["int16",{"2":{"122":1}}],["int64",{"2":{"122":1}}],["int32",{"2":{"122":1}}],["int8",{"2":{"122":1}}],["intfromfloat",{"2":{"50":1,"175":1,"283":1}}],["intfromerror",{"2":{"50":1}}],["intfromenum",{"2":{"50":1}}],["intfrombool",{"2":{"50":1}}],["intfromptr",{"2":{"4":1,"50":1,"83":1}}],["intcast",{"2":{"50":1,"72":1,"271":1}}],["int",{"2":{"12":1,"19":5,"21":5,"42":3,"61":1,"63":2,"73":1,"79":1,"90":2,"122":1,"130":1,"145":2,"178":10,"180":2,"201":3,"202":22,"255":1,"282":2,"283":1}}],["integer",{"2":{"76":2,"77":3}}],["interrupt",{"2":{"4":1}}],["intellij",{"2":{"207":1}}],["intel",{"2":{"2":2}}],["i32的可选类型",{"2":{"145":1}}],["i32",{"2":{"3":3,"8":20,"10":4,"43":3,"44":2,"45":1,"47":1,"60":3,"65":3,"78":5,"82":10,"83":1,"84":1,"85":3,"86":1,"91":2,"93":2,"100":2,"102":1,"104":1,"105":4,"106":2,"122":1,"124":2,"133":2,"142":1,"145":3,"146":2,"155":3,"157":1,"159":1,"161":2,"179":1,"180":1,"184":2,"253":3,"256":1,"257":1,"260":3,"265":3,"281":2,"283":1,"287":2}}],["=>",{"2":{"47":2,"72":5,"99":2,"139":4,"141":3,"161":8,"166":8,"170":4,"171":6,"172":4,"173":6,"174":3,"175":4,"179":4}}],["==",{"2":{"7":1,"8":7,"9":2,"26":1,"28":1,"47":5,"51":4,"61":1,"69":1,"70":2,"81":1,"82":10,"83":1,"84":1,"90":1,"99":16,"102":1,"126":1,"127":2,"136":1,"146":1,"148":2,"152":3,"155":1,"159":1,"161":2,"162":2,"164":1,"166":2,"167":1,"168":1,"171":1,"175":2,"179":4,"184":2,"202":5,"245":1,"253":2,"259":1}}],["=",{"2":{"3":1,"4":11,"8":19,"9":2,"10":4,"13":2,"17":2,"19":6,"21":4,"26":5,"27":12,"28":9,"29":4,"30":3,"31":3,"32":9,"35":7,"36":5,"37":12,"41":12,"42":3,"43":23,"44":2,"45":1,"46":2,"47":13,"49":3,"51":10,"55":3,"56":2,"57":2,"59":3,"60":5,"61":4,"63":2,"65":2,"66":4,"68":10,"69":1,"70":4,"71":3,"72":4,"73":1,"74":2,"77":5,"78":8,"79":2,"81":2,"82":10,"83":4,"84":3,"85":5,"86":4,"87":5,"89":9,"90":34,"91":4,"92":1,"93":4,"94":5,"95":3,"96":3,"99":20,"100":2,"102":9,"103":2,"104":4,"105":6,"106":5,"108":5,"122":4,"124":10,"126":5,"127":15,"129":3,"130":5,"131":2,"132":3,"133":4,"134":4,"136":4,"137":2,"139":10,"140":3,"141":5,"142":2,"143":5,"145":7,"146":3,"148":2,"149":9,"151":3,"152":8,"153":2,"155":3,"157":1,"158":2,"159":2,"160":2,"161":8,"162":3,"163":6,"164":1,"165":1,"166":8,"167":5,"168":5,"170":4,"171":6,"172":4,"173":14,"174":3,"175":2,"176":3,"178":13,"179":13,"180":3,"184":1,"185":11,"191":9,"192":7,"193":11,"194":13,"195":20,"196":6,"197":17,"198":10,"199":16,"200":16,"201":17,"202":50,"208":2,"231":1,"233":10,"245":7,"250":1,"253":6,"254":3,"255":4,"256":4,"257":4,"258":8,"259":6,"260":1,"262":14,"265":13,"271":2,"272":4,"281":2,"282":5,"283":2,"287":1,"291":1}}],["不足以容纳数据的值",{"2":{"271":1}}],["不得不说",{"2":{"262":1}}],["不检查字段",{"2":{"256":1}}],["不要认为这是一个简单的问题",{"2":{"233":1}}],["不只是",{"2":{"200":1}}],["不会出现只完成部分操作的情况",{"2":{"236":1}}],["不会将错误混到一起",{"2":{"197":1}}],["不会发生内存对齐",{"2":{"99":1}}],["不是吗",{"2":{"231":1}}],["不是由项目决定",{"2":{"191":1}}],["不是一个可选类型的指针",{"2":{"145":1}}],["不可达代码",{"0":{"268":1}}],["不可复现的原因",{"2":{"190":1}}],["不可直接对其指针进行更改",{"2":{"76":1}}],["不仅仅是以上两种方式",{"2":{"199":1}}],["不仅仅是",{"2":{"189":1}}],["不保证普通联合类型在内存中的表现形式",{"2":{"178":1}}],["不保证枚举和",{"2":{"73":1}}],["不处理错误",{"2":{"141":1}}],["不等于",{"2":{"127":1}}],["不过我们可以通过借引用指针来操作数组",{"2":{"155":1}}],["不过在",{"2":{"145":1}}],["不过可以使用",{"2":{"143":1}}],["不过",{"2":{"85":1,"192":1}}],["不能是常量",{"2":{"26":1,"28":1}}],["不支持声明极大地降低了",{"2":{"262":1}}],["不支持",{"2":{"20":1}}],["不允许取消引用地址为",{"2":{"20":1}}],["不兼容问题",{"2":{"15":1}}],["不依赖",{"2":{"11":1}}],["不同构建目标之间可能存在着专属于架构的错误定义",{"2":{"143":1}}],["不同进制",{"0":{"123":1}}],["不同类型的整数间",{"2":{"50":1}}],["不同的指针类型之间进行显式强制转换",{"2":{"50":1}}],["不同",{"2":{"3":1,"249":1}}],["不透明",{"2":{"3":1,"249":1}}],["你有没有想过",{"2":{"233":1}}],["你暂时就当作像水流一样的数据的就行",{"2":{"233":1}}],["你是不是觉得自己被耍了",{"2":{"232":1}}],["你确定展开后会代码效率会更高",{"2":{"166":1}}],["你大概是这样处理的",{"2":{"145":1}}],["你也可以指定包的",{"2":{"229":1}}],["你也可以同时迭代多个目标",{"2":{"158":1}}],["你也可以在这里做点额外的事情",{"2":{"141":1}}],["你也可以这样理解",{"2":{"3":1,"249":1}}],["你只能通过",{"2":{"135":1}}],["你只需要保证符合变量声明的",{"2":{"111":1}}],["你只需要在你的",{"2":{"79":1}}],["你现在只需要知道加法结果最多只是该类型的极限即可",{"2":{"127":1}}],["你一定以为这个可以通过断言",{"2":{"126":1}}],["你如果自行看了",{"2":{"108":1}}],["你还可以使用空结构体",{"2":{"94":1}}],["你还可以自己尝试实现一个内存模型",{"2":{"25":1}}],["你在函数中也可以使用",{"2":{"92":1}}],["你需要设置使用的内存分配器",{"2":{"27":1}}],["你可实现很多花哨的操作",{"2":{"296":1}}],["你可能很陌生",{"2":{"111":1}}],["你可能注意到了有的函数定义是这样子的",{"2":{"111":1}}],["你可能会注意到",{"2":{"293":1}}],["你可能会疑惑",{"2":{"293":1}}],["你可能会想要使用切片",{"2":{"85":1}}],["你可能会一脸懵逼",{"2":{"6":1}}],["你可能需要查看官方文档",{"2":{"81":1}}],["你可能对上面的多种内存模型感到很迷惑",{"2":{"25":1}}],["你可能对于容器这个概念比较疑惑",{"2":{"3":1}}],["你可以暂时跳过这里",{"2":{"232":1}}],["你可以把它看作是一个匿名结构体",{"2":{"232":1}}],["你可以附加",{"2":{"229":1}}],["你可以在阅读完这两章节后再回来学习",{"2":{"150":1}}],["你可以将它放在类型的前面",{"2":{"145":1}}],["你可以将所有的错误强制转换到",{"2":{"138":1}}],["你可以通过使用",{"2":{"143":1}}],["你可以使用",{"2":{"179":1,"234":1}}],["你可以使用以下方式书写字面量",{"2":{"123":1}}],["你可以使用以下的方法",{"2":{"55":1}}],["你可以使用它来代替",{"2":{"116":1}}],["你可以一眼就看出来它的组成",{"2":{"111":1}}],["你可以对数组",{"2":{"85":1}}],["你可以看作是一类",{"2":{"69":1}}],["你可以进行参考和学习",{"2":{"53":1}}],["你可以参考以下链接",{"2":{"23":1}}],["你可以阅读这里",{"2":{"4":1}}],["你可以继续查询有关调用约定",{"2":{"3":1}}],["语句可以进行匹配",{"2":{"169":1}}],["语句",{"2":{"51":1}}],["语句是描述程序运行操作的一个单位",{"2":{"3":1,"249":1}}],["语言简单性的改进与流控制",{"2":{"294":1}}],["语言和区域",{"2":{"212":1}}],["语言",{"2":{"76":1,"293":1}}],["语言中不就是",{"2":{"25":1}}],["语言共享类型通常是通过引入头文件实现",{"2":{"13":1}}],["语法捕获指针类型",{"2":{"179":1}}],["语法出现在",{"2":{"167":1}}],["语法访问元组中的元素",{"2":{"96":1}}],["语法来解开可选类型",{"2":{"276":1,"277":1}}],["语法来解开可选",{"2":{"276":1}}],["语法来捕获对应的指针进行修改操作",{"2":{"173":2}}],["语法来访问",{"2":{"96":1}}],["语法来使用外",{"2":{"89":1}}],["语法兼容",{"2":{"2":1}}],["语法的支持存在",{"2":{"2":1}}],["语法",{"2":{"2":2,"87":1,"90":1,"130":1,"171":1}}],["但不依赖它",{"2":{"296":1}}],["但不排除当前因为",{"2":{"19":1}}],["但改善旧问题并提供了完善的工具链",{"2":{"295":1}}],["但就现在来看",{"2":{"293":1}}],["但由于历史原因",{"2":{"293":1}}],["但由于宏是在词法分析的级别上生效",{"2":{"19":1}}],["但普通指针是不允许的",{"2":{"284":1}}],["但作用于字段",{"2":{"257":1}}],["但作为开发者",{"2":{"112":1}}],["但我更推荐你结合标准库的源码来了解它",{"2":{"234":1}}],["但我们可以以此为基础在编译期构建新的类型",{"2":{"255":1}}],["但我们可以捕获它们并有效地报告给用户",{"2":{"135":1}}],["但我们可以使用",{"2":{"24":1}}],["但我们仍需要汇编语言的帮助",{"2":{"2":1}}],["但这样子实现效果内存占用会更少",{"2":{"287":1}}],["但这导致了无法在单元测试中写入",{"2":{"197":1}}],["但这些指针并不是普通指针",{"2":{"99":1}}],["但实际开发中这样很不方便",{"2":{"197":1}}],["但实际上在运行时会直接奔溃",{"2":{"126":1}}],["但其实这是不必要的",{"2":{"195":1}}],["但更加的现代化",{"2":{"189":1}}],["但同一时间只能存储一个类型",{"2":{"177":1}}],["但好处大大是减少了你在运行时",{"2":{"145":1}}],["但好处是线程安全并且无锁",{"2":{"31":1}}],["但错误联合类型大概是你经常用的",{"2":{"139":1}}],["但可以使用",{"2":{"267":1}}],["但可以增加一个修饰符",{"2":{"96":1}}],["但可通过将其分配给",{"2":{"129":1}}],["但在安装插件后可以作为",{"2":{"207":1}}],["但在执行某些操作时会变得有些棘手",{"2":{"143":1}}],["但在编译时如果传入参数",{"2":{"136":1}}],["但在",{"2":{"99":1}}],["但在实践中",{"2":{"85":1}}],["但保证它是",{"2":{"97":1}}],["但插入了安全检查",{"2":{"82":1}}],["但知道它实际上具有较大的对齐方式",{"2":{"82":1}}],["但反之则不然",{"2":{"82":1}}],["但始终是",{"2":{"82":1}}],["但非零",{"2":{"74":1}}],["但是使用可选类型代替",{"2":{"294":1}}],["但是在未来谁说的准呢",{"2":{"293":1}}],["但是在开发版中",{"2":{"136":1}}],["但是不同的编译器却有着不同的",{"2":{"293":1}}],["但是这就面临着性能问题",{"2":{"233":1}}],["但是请记住",{"2":{"233":1}}],["但是如果要使用",{"2":{"216":1}}],["但是注意我们获得的捕获是只读的",{"2":{"151":1}}],["但是可以使用",{"2":{"126":1}}],["但是它是否有符号取决于",{"2":{"108":1}}],["但是它无法通过正常的",{"2":{"96":1}}],["但是需要注意",{"2":{"108":1}}],["但是",{"2":{"95":1,"132":1,"234":1}}],["但是对切片指针做操作则不会有边界检查",{"2":{"86":1}}],["但是当我们给指针增加上",{"2":{"83":1}}],["但是我们可以通过指定序列类型来达到这一效果",{"2":{"73":1}}],["但是存在着变体",{"2":{"27":1}}],["但需明确指出枚举大小并且不能已经将整个大小空间消耗干净",{"2":{"72":1}}],["但需要手动",{"2":{"36":1}}],["但需要注意的是",{"2":{"185":1}}],["但需要注意需要注意不要超出枚举的大小空间",{"2":{"72":1}}],["但需要注意",{"2":{"6":1}}],["但用处颇多的类型",{"2":{"67":1}}],["但有时也会给我们带来困扰",{"2":{"143":1}}],["但有一个例外",{"2":{"39":1}}],["但有一点需要注意",{"2":{"29":1,"76":1}}],["但有些系统还支持2m和1g的页",{"2":{"31":1}}],["但仅仅是少量的保护",{"2":{"25":1}}],["但通常它没有这样做",{"2":{"20":1}}],["但得益于",{"2":{"18":1}}],["但",{"2":{"11":1,"142":1}}],["但它不止这一种用法",{"2":{"287":1}}],["但它只携带每个版本的符号库",{"2":{"23":1}}],["但它可以存在多个输入",{"2":{"4":1}}],["但它和普通的内联语句不同",{"2":{"4":1}}],["但容器并不能包含语句",{"2":{"3":1,"249":1}}],["甚至你可以用它来部署你的项目",{"2":{"222":1}}],["甚至被指责为计算机科学中最严重的错误",{"2":{"145":1}}],["甚至",{"2":{"3":1,"249":1}}],["联合起来",{"2":{"141":1}}],["联合类型字段访问错误",{"0":{"282":1}}],["联合类型可以在定义时使用枚举进行标记",{"2":{"179":1}}],["联合类型的基本使用",{"2":{"178":1}}],["联合类型",{"0":{"177":1,"292":1},"1":{"178":1,"179":1,"180":1,"181":1,"182":1},"2":{"177":1,"255":1,"257":1,"292":1}}],["联合类型只使用其最大位宽",{"2":{"99":1}}],["联合类型和枚举",{"0":{"47":1}}],["联合和枚举相同的声明",{"2":{"74":1}}],["联合错误可选类型也有效",{"2":{"43":1}}],["联合错误类型也有效",{"2":{"43":1}}],["联合",{"2":{"3":1,"112":1,"249":1,"255":1}}],["枚举类型",{"2":{"257":1}}],["枚举类型只使用其整数标志位的位宽",{"2":{"99":1}}],["枚举和不透明的类型信息都有声明",{"2":{"255":1}}],["枚举和错误集的类型信息具有保证与源文件中出现的顺序相同的字段",{"2":{"255":1}}],["枚举也支持让",{"2":{"71":1}}],["枚举也可以拥有方法",{"2":{"69":1}}],["枚举推断",{"0":{"71":1}}],["枚举的大小是会经过",{"2":{"70":1}}],["枚举大小",{"0":{"70":1}}],["枚举方法",{"0":{"69":1}}],["枚举是一种相对简单",{"2":{"67":1}}],["枚举",{"0":{"67":1,"290":1},"1":{"68":1,"69":1,"70":1,"71":1,"72":1,"73":1},"2":{"3":1,"249":1,"290":1}}],["容器类型",{"2":{"258":1}}],["容器",{"0":{"249":1},"2":{"249":1}}],["容器和块",{"2":{"3":1,"249":1}}],["容器是一个只包含变量或常量定义以及函数定义的命名空间",{"2":{"3":1,"249":1}}],["容器是充当保存变量和函数声明的命名空间的任何语法结构",{"2":{"3":1}}],["容器也是可以实例化的类型定义",{"2":{"3":1,"249":1}}],["当将浮点数转换为整数时",{"2":{"283":1}}],["当出现安全检查失败时",{"2":{"267":1}}],["当包提供",{"2":{"229":1}}],["当测试失败时",{"2":{"184":1}}],["当测试名字是一个标识符时",{"2":{"184":1}}],["当使用",{"2":{"175":1,"279":1}}],["当错误发生时",{"2":{"168":1}}],["当函数使用推导错误集时",{"2":{"143":1}}],["当发生错误时",{"2":{"140":1}}],["当它有标签时",{"2":{"133":1}}],["当它编译为机器码时",{"2":{"120":1}}],["当一个变量未定义时",{"2":{"132":1}}],["当一个函数不会返回时",{"2":{"116":1}}],["当编译器无法完成推断时",{"2":{"92":1}}],["当我们使用自动推导时",{"2":{"143":1}}],["当我们对切片元素取地址",{"2":{"86":1}}],["当我们在处理复杂数据时很有用",{"2":{"9":1}}],["当从内存加载或存储该类型的值时",{"2":{"82":1}}],["当元组中的所有值均为同一个类型时",{"2":{"49":1}}],["当需要一种类型时却提供了另一种类型",{"2":{"39":1}}],["当你需要动态内存时",{"2":{"26":1}}],["当",{"2":{"20":2,"167":1,"168":1,"232":1}}],["当被转换为非可选指针时",{"2":{"20":1}}],["当顶层空间",{"2":{"18":1}}],["当宿主机器并没有提供足够大的堆栈时",{"2":{"9":1}}],["当看到一只鸟走起来像鸭子",{"2":{"7":1}}],["当然如果你想将包直接添加到",{"2":{"229":1}}],["当然在",{"2":{"145":1}}],["当然进阶点我们还可以和命名",{"2":{"140":1}}],["当然这两个迭代的目标要长度一致防止出现未定义的行为",{"2":{"158":1}}],["当然这在",{"2":{"145":1}}],["当然这种操作不局限于声明变量",{"2":{"92":1}}],["当然这里如果是一个变量",{"2":{"4":1}}],["当然还涉及到一点点的汇编知识",{"2":{"25":1}}],["当然不仅仅如此",{"2":{"23":1}}],["当然也包括可选指针类型",{"2":{"20":1}}],["当然我们这里可以直接赋值为",{"2":{"9":1}}],["当然",{"2":{"3":1,"96":1,"145":1,"158":1,"159":1,"160":1,"165":1,"229":1,"249":1,"274":1,"293":1}}],["当汇编表达式出现在容器级",{"2":{"3":1}}],["当前可用的类型信息",{"2":{"255":1}}],["当前是将参数传递给运行构建结果",{"2":{"192":1}}],["当前包的参数并不会向包传递",{"2":{"37":1}}],["当前仅",{"2":{"35":1}}],["当前你所开发的包的名字",{"2":{"35":1}}],["当前你可以通过实现",{"2":{"33":1}}],["当前并没有一个中心化存储库",{"2":{"34":1}}],["当前的包管理模式为",{"2":{"34":1}}],["当前的自托管编译期设计存在某些缺陷",{"2":{"9":1}}],["当前的异步处于冻结状态",{"2":{"5":1}}],["当前汇编语法为",{"2":{"2":1}}],["当前",{"2":{"0":1,"14":1,"35":1,"129":1,"189":1,"211":1,"224":1,"225":1,"231":1,"262":1}}],["一切都是强制显示声明式",{"2":{"295":1}}],["一切都是自动完成的",{"2":{"49":1}}],["一些额外知识的补充",{"2":{"248":1}}],["一些二元操作符",{"2":{"51":1}}],["一样",{"2":{"167":1}}],["一样难以把控",{"2":{"160":1,"165":1}}],["一样纯粹",{"2":{"30":1}}],["一模一样",{"2":{"159":1}}],["一定不会失败",{"2":{"233":1}}],["一定是一个错误",{"2":{"233":1}}],["一定是一个可用的指针",{"2":{"145":1}}],["一定要是变量",{"2":{"26":1,"28":1}}],["一眼就可以看出来各自的作用",{"2":{"111":1}}],["一种是采取通用的linux安装方式",{"2":{"219":1}}],["一种是",{"2":{"154":2}}],["一种是环绕操作符",{"2":{"125":1}}],["一种是使用内置的溢出处理函数",{"2":{"125":1}}],["一种是多项",{"2":{"76":1}}],["一种是在个人目录下安装",{"2":{"219":1}}],["一种是在",{"2":{"3":1}}],["一种单项",{"2":{"76":1}}],["一个元组作为参数",{"2":{"260":1}}],["一个元素全为布尔类型的向量",{"2":{"106":1}}],["一个函数",{"2":{"260":1}}],["一个函数只能返回一个值",{"2":{"111":1}}],["一个是",{"2":{"191":2}}],["一个最简单的",{"2":{"191":1}}],["一个普通的i32整数",{"2":{"145":1}}],["一个向量",{"2":{"105":1}}],["一个声明",{"2":{"89":1}}],["一个简单的",{"2":{"53":1}}],["一个快速高效且并发的脚本语言",{"2":{"53":1}}],["一个小型轻量的静态类型脚本语言",{"2":{"53":1}}],["一个轻量强类型嵌入式语言",{"2":{"53":1}}],["一个实现",{"2":{"7":1}}],["一块内存区域",{"2":{"27":2}}],["一旦使用了它",{"2":{"24":1}}],["一般是出现问题的",{"2":{"202":1}}],["一般是在以下场景下",{"2":{"2":1}}],["一般填测试的用途",{"2":{"184":1}}],["一般用于使用",{"2":{"16":1}}],["一起使用",{"2":{"8":1}}],["外部汇编",{"0":{"3":1}}],["而构建系统则被很多",{"2":{"296":1}}],["而作用于类型时只能访问声明",{"2":{"258":1}}],["而gnu的则是",{"2":{"202":1}}],["而链接库的构建结果会输出在",{"2":{"195":1}}],["而在",{"2":{"145":1}}],["而无需尝试确保覆盖每个退出路径的冗长和认知开销",{"2":{"142":1}}],["而函数指针可能是运行时已知的",{"2":{"111":1}}],["而比目标机器",{"2":{"102":1}}],["而是一个标准",{"2":{"293":1}}],["而是一个指针",{"2":{"145":1}}],["而是由用户决定",{"2":{"191":1}}],["而是为了安全",{"2":{"26":1}}],["而是近乎原生的调用",{"2":{"11":1}}],["而且目前",{"2":{"293":1}}],["而且均有上手难度",{"2":{"293":1}}],["而且纠正起来很简单",{"2":{"145":1}}],["而且是哨兵字符为",{"2":{"61":1}}],["而且不仅仅是这些",{"2":{"25":1}}],["而且它们之间有一部分还可以叠加使用",{"2":{"25":1}}],["而不是语言语义",{"2":{"132":1}}],["而不是",{"2":{"30":1}}],["而不是重复翻译相同的代码",{"2":{"17":1}}],["而不是更流行的",{"2":{"2":1}}],["而",{"2":{"16":1,"30":1,"41":1,"157":1,"164":1,"175":1,"192":1}}],["而汇编语言完全由程序员控制",{"2":{"2":1}}],["txthello",{"2":{"199":1}}],["txt",{"2":{"199":2}}],["txtbuild",{"2":{"199":1}}],["tt",{"2":{"90":3}}],["t是所指向内存区域的类型",{"2":{"77":1,"78":1}}],["thing",{"2":{"145":2}}],["things",{"2":{"140":1}}],["third",{"2":{"102":1,"153":1}}],["this",{"2":{"90":2,"170":4,"185":2,"245":1}}],["then",{"2":{"245":1}}],["their",{"2":{"202":1}}],["they",{"2":{"202":1}}],["the",{"2":{"89":1,"102":1,"142":1,"185":2,"192":1,"199":1,"200":1,"201":1,"202":9,"245":2,"260":1,"267":1}}],["thousand",{"2":{"68":1}}],["thread",{"2":{"27":4,"124":1,"234":1,"267":1}}],["threadsafeallocator",{"2":{"27":4}}],["three",{"2":{"8":4,"47":9,"70":3,"72":2}}],["text",{"0":{"210":1},"2":{"186":2}}],["terminated",{"2":{"57":1,"124":1}}],["tetris",{"2":{"53":1}}],["tests",{"2":{"184":1,"197":7}}],["testpeerresolvearrayconstslice",{"2":{"51":2}}],["test",{"0":{"197":1,"228":1},"2":{"8":1,"9":3,"17":1,"26":1,"28":1,"42":3,"81":1,"82":3,"83":1,"84":1,"90":2,"99":3,"124":3,"146":1,"184":9,"185":13,"186":3,"188":1,"197":5,"253":1,"259":2,"267":15}}],["testing",{"2":{"8":1,"9":1,"25":2,"32":1,"47":1,"51":1,"70":1,"81":1,"82":2,"83":1,"84":1,"90":1,"99":3,"146":1,"161":1,"166":1,"179":2,"183":1,"184":5,"185":4,"187":1,"253":1,"287":1}}],["tick",{"2":{"202":5}}],["tinytetris",{"2":{"202":1}}],["titlecase",{"2":{"265":10}}],["title",{"2":{"201":1}}],["tigerbeetle",{"2":{"53":1}}],["timeout",{"2":{"202":1}}],["timestamp",{"2":{"134":4,"194":7}}],["time",{"2":{"9":2,"194":4,"202":1}}],["ts",{"2":{"53":1}}],["tuple",{"2":{"49":4,"96":1,"232":1,"262":1}}],["tab",{"2":{"62":1}}],["tag|",{"2":{"175":1}}],["tag形式的分配匹配",{"2":{"171":1}}],["tagname",{"2":{"70":2,"135":1,"136":2,"179":2}}],["tag",{"0":{"173":1},"2":{"47":3,"70":2,"171":1,"172":2,"175":4,"179":2,"198":1}}],["tar",{"2":{"35":5,"220":1,"221":2,"229":2}}],["target",{"2":{"15":2,"24":4,"37":3,"82":1,"99":1,"108":1,"172":2,"191":4,"193":3,"194":3,"195":5,"197":5,"198":8,"199":3,"200":3,"201":3,"202":3}}],["tmp",{"2":{"42":1,"90":2,"124":2,"142":2,"267":1}}],["top",{"2":{"185":1}}],["todo",{"2":{"37":1,"75":1,"203":1,"230":1,"246":1,"247":1,"255":1,"285":1}}],["tool",{"2":{"23":2}}],["to",{"2":{"19":1,"20":2,"35":1,"42":1,"82":2,"99":4,"184":2,"202":1,"245":1}}],["token",{"2":{"18":1,"19":1}}],["truncate",{"2":{"50":1,"271":1}}],["trunk",{"2":{"35":1,"229":2}}],["true",{"2":{"50":1,"51":10,"61":3,"72":3,"90":1,"96":1,"104":4,"106":3,"109":1,"116":1,"118":2,"151":1,"164":1,"165":3,"174":1,"184":1,"185":3,"197":1,"253":1,"256":2,"257":1,"259":1}}],["translation",{"0":{"14":1},"1":{"15":1,"16":1}}],["translate",{"0":{"16":1},"2":{"13":1,"14":2,"16":1,"17":1,"19":1}}],["trytoallocatefoo",{"2":{"142":1}}],["trycatch",{"2":{"141":1}}],["try",{"0":{"141":1},"2":{"8":3,"9":3,"26":1,"27":2,"28":3,"29":1,"31":1,"32":4,"37":1,"47":5,"51":6,"70":4,"81":1,"82":9,"83":1,"84":1,"90":4,"99":18,"141":3,"142":1,"144":1,"146":1,"151":1,"152":3,"161":2,"163":1,"166":2,"171":1,"179":4,"184":3,"185":4,"233":6,"253":2}}],["two",{"2":{"8":4,"47":4,"60":2,"68":1,"70":2,"72":2,"105":1,"202":1}}],["typenamelength",{"2":{"161":4,"166":4}}],["typename",{"0":{"254":1},"2":{"100":3,"161":2,"166":2,"252":1,"254":3,"265":3}}],["typeinfo",{"0":{"255":1},"2":{"70":4,"82":2,"115":1,"146":1,"175":2,"252":1,"255":5,"262":1}}],["typeof",{"0":{"253":1},"2":{"61":1,"81":1,"82":6,"85":2,"86":2,"87":2,"115":2,"146":1,"252":1,"253":6}}],["type",{"0":{"262":1},"2":{"3":1,"7":3,"10":2,"37":1,"38":2,"51":1,"68":2,"70":2,"90":2,"92":2,"100":2,"105":1,"106":1,"111":2,"129":1,"143":4,"146":1,"161":2,"166":2,"175":2,"178":1,"185":1,"238":1,"239":1,"240":1,"241":1,"242":1,"253":2,"255":6,"261":1,"262":5,"265":5,"286":1}}],["t",{"2":{"2":1,"7":14,"8":2,"10":2,"16":3,"20":4,"51":4,"57":2,"62":1,"76":1,"77":1,"78":4,"79":1,"85":1,"87":1,"90":3,"92":2,"100":2,"106":4,"111":5,"122":11,"130":1,"143":9,"145":1,"161":8,"166":8,"175":2,"185":4,"202":2,"238":3,"239":3,"240":4,"241":5,"242":5,"250":4,"253":5,"254":5,"255":3,"262":2,"265":2}}],["ada",{"2":{"293":1}}],["advanced",{"2":{"235":1}}],["addincludepath",{"2":{"201":1,"202":1}}],["addinstalldirectory",{"2":{"196":2}}],["addinstallartifact",{"2":{"192":2}}],["addcsourcefiles",{"2":{"201":1,"202":2}}],["addcsourcefile",{"2":{"201":2,"202":1}}],["addtest",{"2":{"197":2}}],["addoption",{"2":{"194":1}}],["addoptions",{"2":{"194":3}}],["addone",{"2":{"184":9}}],["addarg",{"2":{"200":1}}],["addargs",{"2":{"192":1,"199":1,"200":2,"201":1,"202":1}}],["addanonymousmodule",{"2":{"199":1,"200":1}}],["addassemblyfile",{"2":{"3":2}}],["addrunartifact",{"2":{"192":1,"197":1,"199":1,"200":1,"201":1,"202":1}}],["address",{"2":{"122":1}}],["addsystemcommand",{"2":{"200":1}}],["addstaticlibrary",{"2":{"195":1,"198":1}}],["adds",{"2":{"184":2}}],["addwithoverflow",{"2":{"125":1,"139":1,"143":2,"272":2}}],["addfortytwo",{"2":{"115":1}}],["addexecutable",{"2":{"37":1,"191":3,"192":1,"193":1,"194":1,"195":2,"197":1,"198":2,"199":1,"200":1,"201":1,"202":1}}],["addmodule",{"2":{"36":5,"37":1}}],["add",{"2":{"9":3,"21":1,"104":2,"111":2,"143":2,"213":2,"260":3,"272":1}}],["av",{"2":{"218":1}}],["aur",{"2":{"218":1}}],["autohashmap",{"2":{"287":2}}],["autosave",{"2":{"208":2}}],["auto",{"2":{"71":2,"174":2,"260":1,"262":1}}],["acqrel",{"2":{"245":1}}],["acquire",{"2":{"245":2}}],["accessdenied",{"2":{"136":1}}],["activate",{"2":{"201":3}}],["active",{"2":{"90":12,"178":1}}],["actions",{"2":{"124":3,"267":6}}],["action",{"2":{"1":1}}],["abort",{"2":{"118":1}}],["abi等等",{"2":{"195":1}}],["abi的",{"2":{"126":1}}],["abilist",{"2":{"23":1}}],["abi",{"0":{"12":1},"2":{"11":1,"12":1,"15":1,"23":1,"73":1,"97":1,"98":1,"99":2,"112":1,"117":1,"181":1,"198":1,"202":1,"293":1}}],["after",{"2":{"90":1}}],["amp",{"2":{"76":2,"86":1,"102":1,"127":1}}],["ambiguous",{"2":{"42":3}}],["aoeu",{"2":{"51":3}}],["a2",{"2":{"43":1}}],["a1",{"2":{"43":1}}],["another",{"2":{"245":1}}],["anonymous",{"2":{"100":2}}],["anonymousdependency",{"2":{"37":3,"199":1}}],["andrew",{"2":{"294":1}}],["and",{"2":{"42":1,"104":2,"127":2,"202":3,"233":1,"245":1}}],["anyslice",{"2":{"175":1}}],["any",{"2":{"59":1,"65":1,"66":1,"102":3,"173":1,"175":2}}],["anyerror",{"2":{"43":6,"44":1,"45":1,"51":2,"79":1,"138":4,"139":1,"152":5,"168":1,"184":1}}],["anytype",{"0":{"115":1},"2":{"16":1,"37":2,"103":2,"104":1,"115":2}}],["anyopaque",{"0":{"75":1},"2":{"12":1,"75":1,"78":1}}],["alias",{"2":{"265":2}}],["alignment",{"2":{"82":5,"262":1}}],["alignof",{"2":{"82":2}}],["aligncast",{"2":{"50":1,"82":2,"281":1}}],["aligned",{"2":{"30":1,"99":1,"281":1}}],["align",{"2":{"20":1,"82":13,"99":2,"281":2}}],["alternative",{"2":{"245":1}}],["allowzero",{"2":{"83":3,"284":1}}],["allocatetmpbuffer",{"2":{"142":1}}],["allocationerror",{"2":{"136":5}}],["allocator=thread",{"2":{"27":1}}],["allocator善后工作",{"2":{"26":1,"28":1}}],["allocator",{"0":{"30":1,"31":1},"2":{"25":3,"26":4,"27":11,"28":8,"29":4,"30":7,"31":4,"32":1,"33":1,"90":8,"187":1,"287":1}}],["allocfn",{"2":{"33":1}}],["alloc",{"2":{"26":1,"27":2,"28":3,"29":1,"30":2,"31":1,"32":1,"90":3}}],["all",{"2":{"60":2,"104":2,"184":1}}],["app",{"2":{"199":1,"200":1,"201":8,"202":1}}],["application",{"2":{"192":1,"201":5}}],["api包装库",{"2":{"53":1}}],["api",{"0":{"196":1},"2":{"29":1,"53":1,"250":1}}],["ap",{"2":{"21":3}}],["area",{"2":{"89":5}}],["arena",{"2":{"28":7}}],["arenaallocator",{"0":{"28":1},"2":{"25":1,"28":1}}],["arch",{"2":{"82":1,"99":1,"124":1,"198":1,"218":1,"267":1}}],["archive",{"2":{"35":2,"220":1,"221":1,"229":2}}],["arr1",{"2":{"102":3}}],["arr",{"2":{"56":3,"78":3,"90":2}}],["arrays",{"2":{"57":1}}],["array",{"2":{"20":1,"49":1,"57":6,"65":2,"66":2,"78":6,"82":2,"85":4,"86":2,"87":2}}],["arocc",{"2":{"53":1}}],["artifact",{"2":{"37":2,"192":1}}],["argv",{"2":{"63":1,"201":2}}],["argc",{"2":{"63":1,"201":2}}],["args",{"2":{"37":3,"192":2,"199":2,"200":2,"201":2,"202":2}}],["arg",{"2":{"21":1}}],["arg3",{"2":{"4":5}}],["arg2",{"2":{"4":5,"192":1}}],["arg1",{"2":{"4":8,"192":1}}],["ast",{"0":{"226":1}}],["assert",{"2":{"126":1,"138":1}}],["assert用于断言",{"2":{"126":1}}],["assemblertemplate",{"2":{"4":1}}],["assembly",{"2":{"4":1}}],["ascii",{"2":{"61":1,"107":1,"108":2}}],["as",{"2":{"51":4,"82":7,"89":2,"90":1,"96":2,"102":1,"104":1,"105":1,"179":2,"245":1}}],["asm",{"2":{"3":1,"4":4,"124":1,"267":1}}],["a",{"2":{"3":1,"7":9,"9":2,"19":5,"41":3,"47":4,"51":8,"68":1,"73":1,"77":1,"89":1,"93":1,"99":5,"102":2,"105":10,"106":5,"111":8,"117":3,"119":2,"124":6,"127":1,"139":4,"143":4,"145":2,"149":4,"152":4,"167":2,"168":2,"171":2,"172":4,"173":8,"175":1,"179":3,"185":2,"192":3,"202":7,"245":1,"255":1,"260":2}}],["atomicrmwop",{"2":{"240":1}}],["atomicrmw",{"0":{"240":1},"2":{"240":1}}],["atomicstore",{"0":{"239":1},"2":{"239":1}}],["atomicorder",{"2":{"238":1,"239":1,"240":1,"241":2,"242":2,"243":1}}],["atomicload",{"0":{"238":1},"2":{"238":1}}],["atomic",{"0":{"244":1},"1":{"245":1,"246":1},"2":{"236":1,"245":1,"246":1}}],["attroff",{"2":{"202":1}}],["attron",{"2":{"202":1}}],["attribute",{"2":{"145":1}}],["atan2",{"2":{"117":1}}],["at",{"2":{"2":1,"9":2,"202":1}}],["和普通的函数调用方式相同",{"2":{"260":1}}],["和通过",{"2":{"225":1}}],["和对应的",{"2":{"175":1}}],["和上面类似",{"2":{"168":1}}],["和上面一样",{"2":{"127":1}}],["和乘的倍数",{"2":{"127":1}}],["和数组索引语法以从向量转换为标量",{"2":{"102":1}}],["和向量的混合使用数学运算符",{"2":{"102":1}}],["和指针转换",{"2":{"99":1}}],["和其他的函数没有任何区别",{"2":{"89":1}}],["和其他任意不透明类型",{"2":{"78":1}}],["和变量定义一样的结构体名字",{"2":{"89":1}}],["和长度",{"2":{"85":1}}],["和包管理",{"2":{"53":1}}],["和传递的",{"2":{"15":1}}],["和分析具有不同预处理定义的代码时才出现多个",{"2":{"13":1}}],["和相关的约束",{"2":{"4":1}}],["和",{"2":{"2":1,"9":2,"17":1,"20":1,"21":1,"24":1,"33":2,"35":1,"36":1,"37":2,"41":3,"43":1,"51":1,"61":1,"66":1,"68":1,"70":1,"78":1,"82":1,"85":1,"89":1,"96":1,"99":1,"102":1,"104":1,"107":1,"108":1,"109":1,"111":1,"112":1,"115":1,"122":1,"124":1,"136":1,"141":3,"142":3,"143":1,"155":1,"164":1,"176":2,"197":1,"198":1,"201":1,"207":1,"208":1,"213":1,"224":2,"225":2,"231":1,"232":1,"233":3,"253":1,"257":1,"282":1,"288":1,"289":1,"293":1}}],["内部直接使用混入的声明",{"2":{"250":1}}],["内部返回值",{"2":{"164":1}}],["内部是一连串的匿名结构体",{"2":{"35":1}}],["内联",{"0":{"161":1,"166":1,"175":1},"2":{"161":1}}],["内联汇编特性在未来可能会发生更改以支持新的特性",{"2":{"4":1}}],["内联汇编的表达式会被某些编译器未知的因素更改",{"2":{"4":1}}],["内联汇编是以",{"2":{"4":1}}],["内联汇编给予了我们可以将",{"2":{"4":1}}],["内联汇编",{"0":{"4":1}}],["内联汇编大概是使用最多的情况",{"2":{"2":1}}],["内置溢出处理函数",{"2":{"125":1}}],["内建函数由编译器提供",{"2":{"113":1}}],["内建函数",{"0":{"113":1,"237":1,"247":1},"1":{"238":1,"239":1,"240":1,"241":1,"242":1,"243":1}}],["内建函数来轻松从标量转换为向量",{"2":{"102":1}}],["内存对齐大小取决于",{"2":{"82":1}}],["内存地址必须能被该数字整除",{"2":{"82":1}}],["内存池还支持预分配和指针对齐设置等",{"2":{"32":1}}],["内存池",{"2":{"32":1}}],["内存",{"2":{"29":1}}],["内存管理",{"0":{"25":1},"1":{"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1,"33":1}}],["内核上利用",{"2":{"4":1}}],["内核的开发",{"2":{"2":1}}],["优化",{"2":{"2":1}}],["它和",{"2":{"295":1}}],["它和输出位置类似",{"2":{"4":1}}],["它不提供垃圾回收",{"2":{"294":1}}],["它旨在替代c编程语言",{"2":{"294":1}}],["它本身有着一套自己的标准",{"2":{"293":1}}],["它本质是一个胖指针",{"2":{"85":1}}],["它非常成功",{"2":{"293":1}}],["它需要保证被除数可以整除除数",{"2":{"275":1}}],["它将类型信息具体化为一个类型",{"2":{"262":1}}],["它将以父结构体和前面的规则推断出的名称命名",{"2":{"100":1}}],["它接收一个调用修饰符",{"2":{"260":1}}],["它接受任意个表达式作为参数",{"2":{"253":1}}],["它还没有多线程支持",{"2":{"234":1}}],["它还有一个变体",{"2":{"30":1}}],["它可能会出现错误导致写入失败",{"2":{"233":1}}],["它可以作为任何语言的构建系统",{"2":{"189":1}}],["它可以是你设置的任何名字",{"2":{"133":1}}],["它可以赋值给所有类型",{"2":{"48":1}}],["它可以提供更加完善的工具链",{"2":{"24":1}}],["它可以将",{"2":{"14":1}}],["它可以使用",{"2":{"4":1}}],["它囊括了项目建立",{"2":{"222":1}}],["它包括了整个软件生命周期中所需要的大部分工具",{"2":{"206":1}}],["它包含编译单元中的所有错误集",{"2":{"138":1}}],["它包含一个方法",{"2":{"36":1,"37":1}}],["它包含一个编译期参数",{"2":{"7":1}}],["它所使用的",{"2":{"185":1}}],["它默认会使用标准库提供的",{"2":{"184":1}}],["它实际上用户定义的一种特殊的类型",{"2":{"177":1}}],["它支持搜索查询",{"2":{"196":1}}],["它支持",{"2":{"155":1}}],["它支持线程安全",{"2":{"26":1}}],["它真的是非常的激进",{"2":{"145":1}}],["它兼顾了代码的可读性和效率问题",{"2":{"145":1}}],["它用于处理错误",{"2":{"142":1}}],["它用于显式声明包含的源文件",{"2":{"35":1}}],["它无法再被更改",{"2":{"131":1}}],["它代表以下内容",{"2":{"116":1}}],["它使用的是小驼峰命名法",{"2":{"111":1}}],["它对应",{"2":{"108":1}}],["它尽可能使用",{"2":{"101":1}}],["它保证了内存布局",{"2":{"99":1}}],["它具有运行时已知的长度",{"2":{"87":1}}],["它就以该变量命名",{"2":{"100":1}}],["它就变成合法的行为了",{"2":{"83":1}}],["它就是",{"2":{"61":1}}],["它相当于一个胖指针",{"2":{"78":1}}],["它相当于一个指向数组的单项指针",{"2":{"78":1}}],["它存储了一个地址",{"2":{"76":1}}],["它大小等效于",{"2":{"70":1}}],["它发生在以下情况",{"2":{"51":1}}],["它看起来与前面提到的普通类型解析很像",{"2":{"51":1}}],["它返回一个",{"2":{"37":1,"198":1}}],["它都会向操作系统申请整个内存页面",{"2":{"31":1}}],["它仅仅是实现了不同系统的分页申请系统调用",{"2":{"31":1}}],["它会返回一个结构体类型",{"2":{"257":1}}],["它会返回一个新的",{"2":{"192":1}}],["它会允许读取命令行输入来决定构建目标",{"2":{"198":1}}],["它会使用具有表示所有错误值所需的最少位数的整数类型",{"2":{"136":1}}],["它会根据给定字段指针",{"2":{"95":1}}],["它会给出一个完整的堆栈跟踪",{"2":{"92":1}}],["它会报告如下的错误",{"2":{"42":1}}],["它会直接尝试调用",{"2":{"30":1}}],["它会通知编译器内联汇编会写入任意为声明的内存位置",{"2":{"4":1}}],["它的大小为",{"2":{"291":1}}],["它的文档在这里",{"2":{"234":1}}],["它的引入规则与",{"2":{"199":1}}],["它的行为和",{"2":{"159":1}}],["它的内存大小为",{"2":{"94":1}}],["它的内部可以包含与结构",{"2":{"74":1}}],["它的指针",{"2":{"85":1}}],["它的长度有标记值",{"2":{"79":1}}],["它的原型为",{"2":{"37":1,"192":1}}],["它的原型如下",{"2":{"36":1,"37":1}}],["它的实现很巧妙",{"2":{"32":1}}],["它的实际作用就和使用",{"2":{"3":1}}],["它的速度很慢",{"2":{"31":1}}],["它的确分发",{"2":{"23":1}}],["它是以",{"2":{"207":1}}],["它是用来实现鸭子类型",{"2":{"111":1}}],["它是一个元组",{"2":{"232":1}}],["它是一个多项指针",{"2":{"86":1}}],["它是一个结构体的示例",{"2":{"10":1}}],["它是",{"2":{"35":1}}],["它是由编译器决定的",{"2":{"10":1}}],["它有以下特性",{"2":{"9":1}}],["它有时会做出反而使程序变慢的",{"2":{"2":1}}],["它们按照强度顺序排列",{"2":{"237":1}}],["它们作为一个整体来执行",{"2":{"236":1}}],["它们都是依靠系统调用来实现输出效果",{"2":{"233":1}}],["它们都以",{"2":{"232":1}}],["它们均是抽象的io",{"2":{"233":1}}],["它们均会分配一个大于",{"2":{"136":1}}],["它们可以很方便地帮助开发者找出错误",{"2":{"267":1}}],["它们可以构成一个有向无环图",{"2":{"192":1}}],["它们可以分配给变量",{"2":{"6":1}}],["它们只会增加你的代码复杂性",{"2":{"160":1,"165":1}}],["它们只能用于编译期已知的语句或函数中",{"2":{"6":1}}],["它们将会按照出栈方式执行",{"2":{"153":1}}],["它们会取计算后溢出的值",{"2":{"125":1,"272":1}}],["它们会在编译时进行解析并转换为",{"2":{"13":1}}],["它们的大小也是",{"2":{"288":1}}],["它们的大小是",{"2":{"286":1}}],["它们的特点是",{"2":{"286":1}}],["它们的原因",{"2":{"194":1}}],["它们的类型均是",{"2":{"111":1}}],["它们的解引用的方式也略有不同",{"2":{"76":1}}],["它们在内存中占用的大小为1个字节",{"2":{"109":1}}],["它们也有对应的指针类型",{"2":{"78":1}}],["它们就可以串联",{"2":{"60":1}}],["它表示你需要将值输出到哪里",{"2":{"4":1}}],["它允许我们对硬件直接进行操作",{"2":{"2":1}}],["中间不会被任何其他的操作打断",{"2":{"236":1}}],["中作为依赖",{"2":{"191":1,"192":1,"193":1,"194":1,"195":1,"197":1,"199":1,"200":1,"201":1,"202":1}}],["中等的运行效率",{"2":{"190":2}}],["中你可以使用",{"2":{"145":1}}],["中不存在",{"2":{"145":1}}],["中只是略微加工后的",{"2":{"135":1}}],["中如何正确的书写注释",{"2":{"134":1}}],["中独具特色的小玩意",{"2":{"127":1}}],["中字符就是",{"2":{"108":1}}],["中按元素选择值",{"2":{"106":1}}],["中很多结构是匿名的",{"2":{"100":1}}],["中传递",{"2":{"94":1}}],["中经常用空结构体做实体在",{"2":{"94":1}}],["中实现了相关的函数来处理它们",{"2":{"61":1}}],["中实现了调用",{"2":{"3":1}}],["中文语言社区",{"2":{"52":1}}],["中文社区",{"2":{"1":1}}],["中对外暴露出多个模块",{"2":{"36":1}}],["中引入包",{"2":{"34":1}}],["中的三元表达式是通过",{"2":{"149":1}}],["中的函数可能导致溢出发生",{"2":{"125":1}}],["中的",{"2":{"108":1,"194":1}}],["中的元素索引越界会产生编译错误",{"2":{"105":1}}],["中的选出的值是",{"2":{"105":1}}],["中的索引使用",{"2":{"105":1}}],["中的值",{"2":{"105":1}}],["中的是索引的边界值",{"2":{"85":1}}],["中的包名字",{"2":{"37":1}}],["中的文档注释",{"2":{"33":1}}],["中的宏",{"2":{"19":1}}],["中无缝工作的原因",{"2":{"25":1}}],["中添加一个运行程序的步骤",{"2":{"192":1}}],["中添加上",{"2":{"30":1}}],["中添加",{"2":{"13":1,"79":1,"194":1}}],["中可以无缝做到",{"2":{"13":1}}],["中均是只读的",{"2":{"7":1}}],["中",{"2":{"3":1,"6":1,"35":1,"54":1,"55":1,"61":1,"82":1,"88":1,"109":1,"111":1,"122":1,"125":1,"126":1,"129":1,"130":1,"136":1,"145":2,"148":1,"154":1,"184":2,"192":1,"229":1,"231":1,"249":1,"286":1}}],["中使用在标准库",{"2":{"232":1}}],["中使用了",{"2":{"190":1}}],["中使用",{"2":{"3":1}}],["中使用汇编有两种方式",{"2":{"2":1}}],["中断处理等",{"2":{"2":1}}],["bashrc",{"2":{"221":1}}],["badvalue",{"2":{"152":1}}],["barrier",{"2":{"245":1}}],["bar",{"2":{"74":2}}],["b|",{"2":{"151":1}}],["blah",{"2":{"256":3,"257":3}}],["blk",{"2":{"133":3,"140":2,"167":2,"168":2,"171":4,"173":4}}],["blocks",{"2":{"66":1,"140":1}}],["block",{"2":{"3":1,"133":1,"202":5,"249":1}}],["below",{"2":{"245":1}}],["before",{"2":{"245":4}}],["beta",{"2":{"218":1}}],["between",{"2":{"99":1}}],["be",{"2":{"202":1,"245":1}}],["begin",{"2":{"164":2}}],["behavior",{"2":{"124":1,"267":2}}],["byte",{"2":{"271":1,"272":2}}],["bytes",{"2":{"26":2,"61":5}}],["by",{"2":{"124":11,"202":1,"245":1}}],["b选出值",{"2":{"105":1}}],["box",{"2":{"202":2}}],["board",{"2":{"202":13}}],["bog",{"2":{"53":1}}],["bootstrap",{"2":{"124":3,"267":6}}],["bootloader",{"2":{"2":1,"35":1,"229":2}}],["boolean",{"2":{"178":3}}],["booltostr",{"2":{"51":5}}],["bool",{"2":{"7":5,"51":6,"69":1,"90":4,"99":1,"106":2,"118":1,"161":2,"164":1,"166":2,"175":1,"178":3,"179":1,"193":2,"253":1}}],["break",{"2":{"51":1,"66":2,"116":1,"133":2,"140":1,"155":1,"159":1,"160":3,"164":4,"165":3,"167":1,"168":1,"171":2,"173":2}}],["branch",{"2":{"35":2}}],["billion",{"2":{"122":1}}],["big",{"2":{"59":2,"99":1,"122":1}}],["bit不占任何空间",{"2":{"286":1}}],["bits",{"2":{"202":1}}],["bit",{"2":{"99":1,"202":1,"286":1,"288":1}}],["bitfield",{"2":{"99":7}}],["bitfields",{"2":{"18":1}}],["bitoffsetof",{"2":{"99":4}}],["bitcast",{"2":{"50":1,"99":4,"270":1}}],["bin",{"2":{"192":1,"195":1,"200":1,"208":2,"218":1,"220":2,"221":5}}],["binary",{"2":{"37":1,"122":1}}],["bindings",{"2":{"11":1,"296":1}}],["b",{"2":{"3":1,"7":9,"9":2,"19":5,"36":4,"37":9,"41":2,"47":4,"51":11,"68":1,"73":1,"77":1,"93":2,"99":8,"102":2,"105":9,"106":5,"111":7,"117":3,"124":6,"127":1,"143":4,"149":4,"151":3,"152":1,"171":2,"173":3,"175":2,"179":1,"191":9,"192":14,"193":8,"194":7,"195":10,"196":3,"197":9,"198":2,"199":10,"200":10,"201":9,"202":9,"255":1,"260":2,"262":3}}],["but",{"2":{"245":1}}],["button",{"2":{"201":5}}],["bucket",{"2":{"213":2}}],["builtin",{"2":{"82":3,"99":1,"104":1,"119":1,"172":4,"185":1,"188":1,"232":1,"238":1,"239":1,"240":2,"255":2,"262":1}}],["build",{"0":{"223":1},"2":{"3":1,"13":2,"17":1,"24":2,"30":1,"34":2,"35":1,"36":7,"37":13,"79":1,"124":1,"190":3,"191":10,"192":5,"193":3,"194":4,"195":4,"196":2,"197":2,"199":3,"200":2,"201":3,"202":3,"208":1,"223":1,"224":3,"225":4,"254":1}}],["buzz",{"2":{"53":1}}],["bun",{"2":{"53":1}}],["bunjs",{"2":{"1":1}}],["buf这个临时资源",{"2":{"142":1}}],["buf4",{"2":{"43":2}}],["buf3",{"2":{"43":2}}],["buf2",{"2":{"43":4}}],["buf",{"2":{"43":4,"130":1,"139":2,"142":2}}],["bufferedwriter",{"2":{"233":2}}],["buffer中",{"2":{"27":2}}],["buffer",{"2":{"10":2,"27":4,"233":6}}],["bug",{"2":{"2":1,"14":1,"19":1,"25":1}}],["如加",{"2":{"272":1}}],["如uml工具",{"2":{"206":1}}],["如golang",{"2":{"200":1}}],["如以上的枚举类型",{"2":{"70":1}}],["如何打印东西",{"2":{"233":1}}],["如何将模块对外暴露呢",{"2":{"36":1}}],["如何直接使用指定分支的源码",{"2":{"35":1}}],["如多个返回值",{"2":{"4":1}}],["如果它们的元素类型是零位类型",{"2":{"289":1}}],["如果它从",{"2":{"105":1}}],["如果浮点数的值超出了整数类型的范围",{"2":{"283":1}}],["如果访问的联合类型字段并非是它当前的有效字段",{"2":{"282":1}}],["如果强制使用",{"2":{"280":1}}],["如果直接使用",{"2":{"276":1}}],["如果仅仅是想要将负数当作无符号整数看待",{"2":{"270":1}}],["如果程序执行到它",{"2":{"268":1}}],["如果已经有了内部约定",{"2":{"265":1}}],["如果文件具有字段",{"2":{"265":1}}],["如果目标指针是给定值",{"2":{"241":1,"242":1}}],["如果是个人电脑",{"2":{"215":1}}],["如果是错误从当前函数向上返回",{"2":{"141":1}}],["如果说",{"2":{"209":1}}],["如果使用其他的shell",{"2":{"221":1}}],["如果使用",{"2":{"208":1}}],["如果使用coc",{"2":{"208":1}}],["如果我们想要重新创建一个全新的",{"2":{"192":1}}],["如果我们想操纵值的内容",{"2":{"151":1}}],["如果应用程序运行依赖于其他已存在的文件",{"2":{"192":1}}],["如果在编译期就检测到了未定义的行为",{"2":{"267":1}}],["如果在",{"2":{"190":1}}],["如果想要获取到无符号整数的最大值",{"2":{"270":1}}],["如果想要跳过外部来自于其他包的单元测试",{"2":{"197":1}}],["如果想执行非顶级的测试块",{"2":{"185":1}}],["如果想表示",{"2":{"83":1}}],["如果有需要",{"2":{"178":1}}],["如果有一个指针或切片的对齐方式较小",{"2":{"82":1}}],["如果存在多个",{"2":{"153":1}}],["如果存在副作用",{"2":{"81":1}}],["如果函数可以执行到这里",{"2":{"142":1}}],["如果函数执行成功就正常返回它",{"2":{"142":1}}],["如果函数执行到了这里",{"2":{"141":1}}],["如果一个变量",{"2":{"264":1}}],["如果一个变量是未定义的",{"2":{"132":1}}],["如果一个结构体位于",{"2":{"100":1}}],["如果一个结构体位于变量的初始化表达式中",{"2":{"100":1}}],["如果一定要使用不符合这些规定的名称",{"2":{"130":1}}],["如果未被使用编译器会报告错误",{"2":{"129":1}}],["如果没有对应整数的枚举",{"2":{"279":1}}],["如果没有对应整数的错误",{"2":{"278":1}}],["如果没有分母会被转换为",{"2":{"126":1}}],["如果没有返回值",{"2":{"111":1}}],["如果两个向量均是",{"2":{"105":1}}],["如果两个边界值均是编译期可知的话",{"2":{"85":1}}],["如果给定的目标体系架构上不支持",{"2":{"102":1}}],["如果该结构体在另一个结构体中声明",{"2":{"100":1}}],["如果该值等于基础类型的对齐方式",{"2":{"82":1}}],["如果该函数尝试执行具有全局运行时副作用的操作",{"2":{"9":1}}],["如果不通过则报告错误",{"2":{"184":1}}],["如果不想处理错误怎么办呢",{"2":{"141":1}}],["如果不是这种情况",{"2":{"87":1}}],["如果不知道什么是指针操作的",{"2":{"81":1}}],["如果不可能",{"2":{"9":1}}],["如果要连接到系统的库",{"2":{"195":1}}],["如果要修改实际的载荷",{"2":{"179":1}}],["如果要初始化一个在编译期已知的字段名的联合类型",{"2":{"178":1}}],["如果要了解更多",{"2":{"81":1}}],["如果要使用多行字符串",{"2":{"63":1}}],["如果要设置这些",{"2":{"20":1}}],["如果另外一个类型可以表示它",{"2":{"46":1}}],["如果",{"2":{"43":1,"105":1,"106":1,"265":2}}],["如果此时这种转换是安全",{"2":{"39":1}}],["如果需要",{"2":{"208":1}}],["如果需要手动指定一个",{"2":{"198":1}}],["如果需要忽略可将返回值分配给",{"2":{"111":1}}],["如果需要重新排列元素",{"2":{"102":1}}],["如果需要引入一个本地包",{"2":{"37":1}}],["如果需要使用它们",{"2":{"126":1}}],["如果需要使用私有的模块",{"2":{"36":1}}],["如果需要使用寄存器",{"2":{"4":1}}],["如果代码托管平台提供分支源码打包直接返回功能",{"2":{"35":1}}],["如果包含全部则指定为空",{"2":{"35":1}}],["如果你是嵌入式开发",{"2":{"295":1}}],["如果你是中文简体用户",{"2":{"212":1}}],["如果你已经对计算机有了基础的了解",{"2":{"293":1}}],["如果你想写一个",{"2":{"225":1}}],["如果你想在迭代数组",{"2":{"157":1}}],["如果你想了解更多内容",{"2":{"235":1}}],["如果你想了解更多信息",{"2":{"5":1}}],["如果你想了解更多这些相关的内容",{"2":{"3":1}}],["如果你打算定义一个只有一个值的错误集",{"2":{"137":1}}],["如果你需要一个命名的推荐规则的话",{"2":{"111":1}}],["如果你有使用复数的需求",{"2":{"127":1}}],["如果你有",{"2":{"111":1}}],["如果你不知道内存对齐的含义是什么",{"2":{"82":1}}],["如果你的程序是一个命令行程序或者没有什么特别的循环模式",{"2":{"28":1}}],["如果地址为",{"2":{"20":1}}],["如果超过了这个值",{"2":{"9":1}}],["如果无法完成计算",{"2":{"9":1}}],["如",{"2":{"2":1,"18":1,"76":1,"198":1,"199":1,"221":1,"252":1,"281":1}}],["这避免了空指针的出现",{"2":{"294":1}}],["这门语言并不适合计算机初学者",{"2":{"293":1}}],["这本身就是非法行为",{"2":{"270":1}}],["这将忽略构建模式",{"2":{"267":1}}],["这将使汇编能够更加无缝地集成到语言中",{"2":{"2":1}}],["这有助于",{"2":{"266":1}}],["这有助于格式化",{"2":{"264":1}}],["这有助于加快下次构建",{"2":{"191":1}}],["这常用于组织",{"2":{"250":1}}],["这很棒",{"2":{"234":1}}],["这段代码将会分别输出",{"2":{"233":1}}],["这段函数用来判断一个结构体的字段是否是",{"2":{"175":1}}],["这单单一个命令可神了",{"2":{"222":1}}],["这代替原本的",{"2":{"195":1}}],["这代表着函数是公共可访问的",{"2":{"111":1}}],["这一切都是得益于",{"2":{"222":1}}],["这一",{"2":{"192":1}}],["这可以确保它们正确的运行",{"2":{"192":1}}],["这几个字段",{"2":{"191":1}}],["这并不会影响程序正常运行",{"2":{"190":1}}],["这便于我们在",{"2":{"190":1}}],["这使得代码阅读很轻松",{"2":{"295":1}}],["这使得测试构建仅包含名称包含提供的过滤器文本的测试",{"2":{"186":1}}],["这使得在任何地方使用",{"2":{"144":1}}],["这使得在不同架构上构建出来的代码的实际错误集并不相同",{"2":{"143":1}}],["这允许代码执行一些一些仅在编译时有效的操作",{"2":{"161":1,"166":1}}],["这增加了程序员在写代码时的心智负担",{"2":{"145":1}}],["这对于在清理期间打印错误信息很有用",{"2":{"142":1}}],["这时我们可以将",{"2":{"141":1}}],["这意味函数返回的是一个",{"2":{"139":1}}],["这意味着原子操作要么全部完成",{"2":{"236":1}}],["这意味着多行注释的最佳实践形式就是多行的",{"2":{"134":1}}],["这意味着你可以在任何你用普通函数的地方使用结构体的方法",{"2":{"89":1}}],["这意味着我们可以通过语法",{"2":{"86":1}}],["这意味着我们可以使用函数来初始化复杂的静态数据",{"2":{"9":1}}],["这意味着它不能是",{"2":{"78":1}}],["这意味着参数类型与返回值类型是一致的",{"2":{"7":1}}],["这种方式才可以",{"2":{"250":1}}],["这种方案是采取配置path来实现",{"2":{"221":1}}],["这种函数",{"2":{"233":1}}],["这种语法看起来并不好看",{"2":{"185":1}}],["这种信息",{"2":{"184":1}}],["这种多行注释",{"2":{"134":1}}],["这种编译期变量的实现",{"2":{"8":1}}],["这涉及到计算机相当底层的涉及哲学",{"2":{"233":1}}],["这涉及到",{"2":{"127":1}}],["这无疑大大增加了程序员在编程时的心智负担",{"2":{"112":1}}],["这和",{"2":{"108":1,"296":1}}],["这容易破坏切片的内部结构",{"2":{"85":1}}],["这样的概念解释可能比较模糊",{"2":{"294":1}}],["这样就会获得一个",{"2":{"287":1}}],["这样在编译时可以检查分支是否均能被正确地处理",{"2":{"175":1}}],["这样做的好处是",{"2":{"142":1,"175":1}}],["这样做的好处就是提供了针对缓冲区溢出和过度读取的保护",{"2":{"79":1}}],["这样",{"2":{"82":1,"213":1}}],["这样编译器就不会额外优化这段内联汇编",{"2":{"4":1}}],["这通常用于保证与不公开结构详细信息的",{"2":{"74":1}}],["这在对外暴漏函数或者裸汇编时会很有用",{"2":{"119":1}}],["这在运行时无操作",{"2":{"82":1}}],["这在嵌入式开发和内核开发时很常用",{"2":{"50":2}}],["这在处理字符串时很有用",{"2":{"43":1}}],["这往往是由于编译器推断类型出现歧义导致的",{"2":{"42":1}}],["这句话看起来可能有点绕",{"2":{"41":1}}],["这两个类型实现了几种错误的定义",{"2":{"136":1}}],["这两个东西的底层实现是一样的",{"2":{"16":1}}],["这两种类型的的大小取决于",{"2":{"122":1}}],["这两种情况",{"2":{"112":1}}],["这两者的区别仅仅是",{"2":{"30":1}}],["这些都是允许地址为",{"2":{"284":1}}],["这些print函数是如何实现的",{"2":{"233":1}}],["这些操作符保证了环绕语义",{"2":{"125":1}}],["这些操作是按元素执行",{"2":{"102":1}}],["这些内建函数返回一个元组",{"2":{"125":1}}],["这些传递均是由编译器来决定究竟是使用",{"2":{"112":1}}],["这些转换实际上在运行时没有任何操作",{"2":{"40":1}}],["这些特性均可手动配置是否开启",{"2":{"26":1}}],["这些模型均有着不同的特点",{"2":{"25":1}}],["这些额外未使用的分支在编译时会被",{"2":{"7":1}}],["这就是",{"2":{"267":1}}],["这就是它们的区别",{"2":{"233":1}}],["这就是我们为何能够像普通包一样",{"2":{"194":1}}],["这就是一个最基本的包暴露实现",{"2":{"36":1}}],["这就是一个占位符",{"2":{"4":1}}],["这就使得在递归上出现了不兼容",{"2":{"143":1}}],["这就涉及到计算机组成原理和操作系统的理论知识了",{"2":{"25":1}}],["这就要求程序员在需要明白数据在内存中真实存在的模样",{"2":{"25":1}}],["这也可用于依赖于当前包的其他包",{"2":{"193":1}}],["这也是精度问题导致的",{"2":{"126":1}}],["这也是为什么",{"2":{"25":1}}],["这也适用于",{"2":{"7":1}}],["这导致他们之间可以互相访问",{"2":{"256":1}}],["这导致错误类型无法携带有效的",{"2":{"135":1}}],["这导致",{"2":{"23":1}}],["这会触发非法行为",{"2":{"284":1}}],["这会导致混用可能出现问题",{"2":{"202":1}}],["这会导致歧义",{"2":{"20":1}}],["这会扰乱测试器的正常工作",{"2":{"197":1}}],["这会链接一个名为",{"2":{"195":1}}],["这会允许我们通过",{"2":{"194":1}}],["这会使运行是从构建输出目录",{"2":{"192":1}}],["这会使切片长度直接等于数组",{"2":{"43":1}}],["这会明确告诉编译器返回的错误种类都有什么",{"2":{"143":1}}],["这会告诉编译器此次函数执行不会返回错误",{"2":{"141":1}}],["这会破坏切片的内部结构",{"2":{"76":1}}],["这会牵扯到",{"2":{"72":1}}],["这会通知编译器",{"2":{"8":1}}],["这点在",{"2":{"13":1}}],["这归功于",{"2":{"11":1}}],["这表示变量是编译期已知的",{"2":{"8":1}}],["这个数",{"2":{"271":1}}],["这个容器中",{"2":{"250":1}}],["这个句柄实现流print函数",{"2":{"233":1}}],["这个是操作系统负责保证的",{"2":{"233":1}}],["这个内建函数",{"2":{"232":1}}],["这个内存分配器来检测内存泄漏",{"2":{"187":1}}],["这个文件的内容涉及到了",{"2":{"224":1}}],["这个文件存储了包的信息",{"2":{"35":1}}],["这个命令用于初始化项目",{"2":{"224":1}}],["这个命令来执行单个文件的",{"2":{"184":1}}],["这个步骤不是必要的",{"2":{"192":1}}],["这个返回值将会是",{"2":{"179":1}}],["这个语法的作用可就大了",{"2":{"148":1}}],["这个函数相对来说会变得更加的通用",{"2":{"143":1}}],["这个大小固定使用",{"2":{"136":1}}],["这个类型其实平常使用不算多",{"2":{"108":1}}],["这个情况可以使用",{"2":{"99":1}}],["这个关键字适合使用于嵌入式或者裸机器上",{"2":{"98":1}}],["这个关键字表示",{"2":{"6":1}}],["这个指针标记了边界的值",{"2":{"79":1}}],["这个枚举类型之中任意切换了",{"2":{"68":1}}],["这个示例中",{"2":{"66":1}}],["这个表达式的值为",{"2":{"51":1}}],["这个词汇仅仅在",{"2":{"51":1}}],["这个包的主分支源码打包",{"2":{"35":1}}],["这个善后工作只有在你指定",{"2":{"29":1}}],["这个分配器的特点是你可以多次申请内存",{"2":{"28":1}}],["这个分配器的目的不是为了性能",{"2":{"26":1}}],["这个分配器是固定大小的内存缓冲区",{"2":{"27":1}}],["这个",{"2":{"7":1}}],["这里我需要向你讲述一下",{"2":{"233":1}}],["这里我们需要说的是",{"2":{"232":1}}],["这里我们就是将子集",{"2":{"136":1}}],["这里每次都是不同的值",{"2":{"175":1}}],["这里最后一个联合类型",{"2":{"173":2}}],["这里你只需要知道一下就行",{"2":{"232":1}}],["这里你也可以使用",{"2":{"141":1}}],["这里你看起来可能会感到迷惑",{"2":{"81":1}}],["这里",{"2":{"113":1,"175":1}}],["这里命名规则没什么强制性的要求",{"2":{"111":1}}],["这里有两个参数",{"2":{"111":1}}],["这里有一篇关于最初这个内存池是如何实现的文章",{"2":{"32":1}}],["这里说明可能有些不清楚",{"2":{"99":1}}],["这里说的是边界值有一个是变量",{"2":{"85":1}}],["这里获取目标架构是字节排序方式",{"2":{"99":1}}],["这里使用了内建函数",{"2":{"95":1}}],["这里保证每次都使用",{"2":{"81":1}}],["这里列出一些仍在积极维护的",{"2":{"53":1}}],["这里包括",{"2":{"47":1}}],["这里的名字是根据官方的文档直接翻译过来的",{"2":{"57":1}}],["这里的",{"2":{"35":1,"124":1,"164":1}}],["这里仅仅作为示例",{"2":{"9":1}}],["这里是改动的寄存器",{"2":{"4":1}}],["这里讲述全局汇编功能",{"2":{"3":1}}],["这说明它可以返回值",{"2":{"4":1}}],["这是联合错误类型",{"2":{"233":1}}],["这是规定",{"2":{"232":1}}],["这是编译期可知的",{"2":{"175":1}}],["这是编译期参数",{"2":{"111":1}}],["这是由我们之前显式声明的",{"2":{"152":1}}],["这是由于",{"2":{"61":1,"255":1}}],["这是由于技术限制",{"2":{"2":1}}],["这是为了尽早发现错误",{"2":{"132":1}}],["这是",{"2":{"90":1,"190":1}}],["这是传给对应的包构建的参数",{"2":{"37":1}}],["这是最基本的分配器",{"2":{"31":1}}],["这是纯粹的",{"2":{"30":1}}],["这是一个很好的特性",{"2":{"143":1}}],["这是一个依赖",{"2":{"29":1}}],["这是一个通用的分配器",{"2":{"26":1}}],["这是一个收集每个版本的",{"2":{"23":1}}],["这是一篇关于如何在",{"2":{"4":1}}],["这是对应",{"2":{"21":1}}],["这是因为",{"2":{"19":1,"255":1}}],["这是因为汇编语言更加接近硬件",{"2":{"2":1}}],["这是防止编译器重复调用",{"2":{"13":1}}],["这是输入操作数",{"2":{"4":1}}],["这需要直接操控硬件",{"2":{"2":1}}],["驱动程序",{"2":{"2":1}}],["在裸机器上也可以",{"2":{"296":1}}],["在我看来",{"2":{"293":1}}],["在讲述下列的内建函数前",{"2":{"237":1}}],["在zig中有很多的内置函数",{"2":{"232":1}}],["在当前路径下创建",{"2":{"224":1,"225":1}}],["在当前作用域的末尾执行语句",{"2":{"90":1}}],["在新打开的窗口中点击",{"2":{"212":1}}],["在初次初始化时会推荐安装",{"2":{"205":1}}],["在进行本部分教程前请先安装好",{"2":{"201":1}}],["在构建时调用系统的",{"2":{"200":1}}],["在构建时自动构建",{"2":{"195":1}}],["在测试中",{"2":{"187":1}}],["在其内部引用你需要执行测试的容器即可",{"2":{"185":1}}],["在迭代时操作数组",{"2":{"155":1}}],["在错误联合可选类型上也可以使用指针捕获",{"2":{"152":1}}],["在接下来的代码中",{"2":{"145":1}}],["在解决空指针上采取的方式比较保守",{"2":{"145":1}}],["在不损害效率和可读性的前提下提高代码安全性的一个方案就是可选类型",{"2":{"145":1}}],["在不同字段之间不会存在位填充",{"2":{"99":1}}],["在不同的整数类型中显式强制转换",{"2":{"50":1}}],["在最新的稳定版",{"2":{"136":1}}],["在高级语言的角度来看",{"2":{"112":1}}],["在表中对应的值是",{"2":{"108":1}}],["在计算机学中",{"2":{"251":1}}],["在计算机编程中",{"2":{"183":1}}],["在计算机中定义的",{"2":{"107":1}}],["在计算机科学",{"2":{"38":1}}],["在计算机科学中代表一个计算机程序从开始执行到终止执行的运作",{"2":{"6":1}}],["在整型上的操作是",{"2":{"104":1}}],["在使用",{"2":{"174":1,"213":1}}],["在使用该特性时需要谨慎对待",{"2":{"142":1}}],["在使用结构体的时候还支持省略结构体类型",{"2":{"91":1}}],["在使用翻译功能时",{"2":{"15":1}}],["在实际使用时",{"2":{"85":1}}],["在编译时",{"2":{"136":1}}],["在编译代码时",{"2":{"81":1}}],["在编译期和运行时也分别有类似",{"2":{"125":1}}],["在编译期和运行时均有完整的越界保护和完善的堆栈错误跟踪",{"2":{"55":1}}],["在编译期",{"2":{"9":1}}],["在编译期它们会被提取出来作为单独的汇编文件进行编译和链接",{"2":{"3":1}}],["在以上的代码中",{"2":{"90":1}}],["在以上的示例中",{"2":{"56":1}}],["在以下代码中",{"2":{"81":1}}],["在此基础上",{"2":{"68":1}}],["在此基础上给我们提供了少量的保护",{"2":{"25":1}}],["在它对应",{"2":{"57":1}}],["在内存管理方面采取了类似",{"2":{"25":1}}],["在非",{"2":{"20":1}}],["在容器级别",{"2":{"9":1}}],["在函数定义中",{"2":{"6":1}}],["在这里我们也不例外",{"2":{"231":1}}],["在这里我们使用",{"2":{"201":1}}],["在这里我们使用了单元测试功能",{"2":{"81":1}}],["在这里",{"2":{"145":1}}],["在这种情况下",{"2":{"115":1}}],["在这方面的处理则是",{"2":{"112":1}}],["在这方面提供了更多的选择",{"2":{"25":1}}],["在这个调用点",{"2":{"6":1}}],["在这其中我用了内联汇编",{"2":{"4":1}}],["在开始之前",{"2":{"6":1}}],["在未来可用时将会更新此部分内容",{"2":{"5":1}}],["在未来的某一天",{"2":{"2":1}}],["在",{"2":{"2":1,"3":1,"6":1,"25":1,"54":1,"55":1,"61":1,"82":1,"88":1,"94":1,"108":1,"109":1,"111":1,"122":1,"126":1,"129":1,"130":1,"132":1,"141":2,"145":1,"148":1,"154":1,"176":2,"184":1,"194":1,"199":1,"249":1,"286":1}}],["在某些特殊的场景下",{"2":{"2":1}}],["在提交时请勿将其他nodejs的包管理工具的额外配置文件添加到仓库中",{"2":{"1":1}}],["汇编解析由llvm提供",{"2":{"2":1}}],["汇编语言可以发挥出比高级语言更好的性能",{"2":{"2":1}}],["汇编",{"0":{"2":1},"1":{"3":1,"4":1}}],["🅿️",{"2":{"1":1,"2":1,"3":1,"4":1,"6":1,"7":1,"8":1,"9":2,"10":1,"11":1,"13":2,"15":1,"19":1,"23":1,"25":1,"30":1,"35":2,"36":2,"37":1,"57":1,"72":1,"77":1,"78":1,"82":1,"85":1,"89":1,"92":1,"94":1,"96":1,"102":1,"104":1,"105":1,"108":1,"111":1,"112":1,"117":1,"122":1,"126":1,"127":1,"129":1,"135":1,"136":1,"140":1,"141":1,"142":1,"143":1,"166":1,"170":1,"178":1,"184":1,"185":1,"189":1,"191":1,"192":1,"194":1,"201":1,"202":1,"208":1,"211":1,"213":1,"215":1,"225":1,"232":2,"233":1,"258":1,"263":1,"282":1}}],["并养成在最后一个元素后添加",{"2":{"264":1}}],["并允许我们通过该类型观察并获取指定类型的具体信息",{"2":{"255":1}}],["并根据已有类型的信息来创造新的类型",{"2":{"251":1}}],["并没有真正地执行函数体的内容",{"2":{"253":1}}],["并没有内置类似与",{"2":{"233":1}}],["并没有一个内置的打印功能",{"2":{"233":1}}],["并没有对应的类型",{"2":{"47":1}}],["并导入它",{"2":{"232":1}}],["并设置环境变量",{"2":{"217":1}}],["并链接",{"2":{"202":1}}],["并使用",{"2":{"200":1}}],["并将",{"2":{"196":1}}],["并将其转换为指针来完成",{"2":{"173":1}}],["并将其输出到标准输出",{"2":{"14":1}}],["并返回它们的公共可转换类型",{"2":{"253":1}}],["并返回null",{"2":{"241":1,"242":1}}],["并返回对应的指针",{"2":{"191":1}}],["并返回与输入向量长度相同的向量",{"2":{"102":1}}],["并通知测试运行器测试结果未通过",{"2":{"184":1}}],["并显示消息达到",{"2":{"176":1}}],["并退出",{"2":{"168":1}}],["并帮助检测调试器中未定义内存的使用",{"2":{"132":1}}],["并指定值为",{"2":{"129":1}}],["并未像其他语言那样默认提供了",{"2":{"126":1}}],["并未提供",{"2":{"22":1}}],["并以",{"2":{"113":1}}],["并用点分隔",{"2":{"100":1}}],["并序列化参数",{"2":{"100":1}}],["并保证了代码执行的顺序",{"2":{"81":1}}],["并写入到",{"2":{"35":1}}],["并无需每次用完时进行",{"2":{"28":1}}],["并不支持构建的类型包含声明",{"2":{"262":1}}],["并不相同",{"2":{"225":1}}],["并不会递归",{"2":{"185":1}}],["并不推荐使用",{"2":{"160":1,"165":1}}],["并不是一个赛道上的东西",{"2":{"293":1}}],["并不是全等的",{"2":{"108":1}}],["并不是通过",{"2":{"11":1}}],["并不保证结构体字段的顺序和结构体大小",{"2":{"97":1}}],["并不准确",{"2":{"23":1}}],["并不知道如何处理指针",{"2":{"20":1}}],["并非所有宏均可以转为函数",{"2":{"19":1}}],["并远超其他语言",{"2":{"11":1}}],["并从函数返回",{"2":{"6":1}}],["并且编译时就会跟踪你的内存是否发生泄漏",{"2":{"296":1}}],["并且能够较为熟练的掌握一门高级编程语言",{"2":{"293":1}}],["并且返回非类型",{"2":{"265":1}}],["并且返回值就是",{"2":{"4":1}}],["并且包含其父容器的名字",{"2":{"254":1}}],["并且不会产生任何副作用",{"2":{"253":1}}],["并且不得与关键字重叠",{"2":{"130":1}}],["并且修改自己的行为",{"2":{"251":1}}],["并且提供了",{"2":{"236":1}}],["并且遵循",{"2":{"232":1}}],["并且内置了命令行工具和git",{"2":{"205":1}}],["并且可以有效地报告错误",{"2":{"197":1}}],["并且向其中添加了",{"2":{"194":1}}],["并且默认测试运行程序将认为该测试被跳过",{"2":{"186":1}}],["并且us在此处被引用",{"2":{"185":1}}],["并且测试在正常构建时会被忽略",{"2":{"184":1}}],["并且switch匹配不能出现遗漏匹配的情况",{"2":{"169":1}}],["并且如果控制流不经过",{"2":{"153":1}}],["并且如果错误最终从应用程序中一直冒出来",{"2":{"144":1}}],["并且申请一块内存",{"2":{"145":1}}],["并且保证你不会将一个可能为",{"2":{"145":1}}],["并且保证与",{"2":{"53":1}}],["并且这种检测不是很深奥",{"2":{"145":1}}],["并且使用默认的",{"2":{"191":1}}],["并且使用",{"2":{"117":1}}],["并且使用了切片和多行字符串",{"2":{"90":1}}],["并且需要是",{"2":{"108":1}}],["并且逐个根据",{"2":{"105":1}}],["并且它可选支持",{"2":{"295":1}}],["并且它返回一个类型",{"2":{"265":1}}],["并且它支持",{"2":{"102":1}}],["并且它也支持",{"2":{"4":1}}],["并且支持",{"2":{"96":1}}],["并且还保证由该长度索引的元素的标记值",{"2":{"87":1}}],["并且还不知道自己应该用什么分配器模型",{"2":{"26":1}}],["并且小于",{"2":{"82":1}}],["并且在编译期可以确定联合类型的某一个字段仅有一个可能值",{"2":{"47":1}}],["并且避免内联函数被重复",{"2":{"13":1}}],["并且",{"2":{"11":1,"36":1}}],["并且会删掉未使用的分支",{"2":{"7":1}}],["并在所有测试运行后将报告失败数目",{"2":{"184":1}}],["并在遇到",{"2":{"167":1}}],["并在转换时增加一个语言级断言",{"2":{"138":1}}],["并在",{"2":{"3":1}}],["并与流行的",{"2":{"2":1}}],["并由",{"2":{"1":1}}],["并一起壮大",{"2":{"1":1}}],["本风格指南并不是强制性的",{"2":{"263":1}}],["本部分是关于",{"2":{"248":1}}],["本质就是",{"2":{"108":1}}],["本身没有一个属于自己的包管理器",{"2":{"293":1}}],["本身有许多未定义行为",{"2":{"267":1}}],["本身有着良好的错误堆栈跟踪",{"2":{"144":1}}],["本身提供了一个实验性的文档生成器",{"2":{"196":1}}],["本身就是一套完整的工具链",{"2":{"189":1}}],["本身并未提供类似",{"2":{"134":1}}],["本身支持三种注释方式",{"2":{"134":1}}],["本身支持指针运算",{"2":{"76":1}}],["本身的编译期",{"2":{"222":1}}],["本身的标准库为我们提供了多种内存分配模型",{"2":{"25":1}}],["本身的全局汇编功能",{"2":{"3":1}}],["本身所谓的",{"2":{"23":1}}],["本身实现了一个",{"2":{"23":1}}],["本文档所使用的构建工具为",{"2":{"1":1}}],["本文档仓库",{"2":{"1":1}}],["本网站仅仅用于帮助用户快速学习和了解",{"2":{"0":1}}],["贡献方法",{"2":{"1":1}}],["道友",{"2":{"1":1}}],["欢迎各位志同道合的",{"2":{"1":1}}],["敬请谅解",{"2":{"0":1}}]],"serializationVersion":2}';export{e as default};
diff --git a/assets/chunks/VPLocalSearchBox.h_vxVhNN.js b/assets/chunks/VPLocalSearchBox.NRnZ9XZ2.js
similarity index 99%
rename from assets/chunks/VPLocalSearchBox.h_vxVhNN.js
rename to assets/chunks/VPLocalSearchBox.NRnZ9XZ2.js
index 1a4b2a01..8047bb4a 100644
--- a/assets/chunks/VPLocalSearchBox.h_vxVhNN.js
+++ b/assets/chunks/VPLocalSearchBox.NRnZ9XZ2.js
@@ -1,4 +1,4 @@
-var kt=Object.defineProperty;var It=(o,e,t)=>e in o?kt(o,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):o[e]=t;var Oe=(o,e,t)=>(It(o,typeof e!="symbol"?e+"":e,t),t);import{X as mt,h as oe,y as $e,ah as Dt,ai as Ot,d as Rt,G as xe,aj as tt,k as Fe,ak as _t,al as Mt,z as Lt,am as zt,l as Re,R as de,P as Ee,an as Pt,ao as Bt,Y as Vt,j as $t,ap as Wt,o as ee,b as jt,m as E,a1 as Kt,p as U,aq as Jt,ar as Ut,as as Ht,c as re,n as rt,e as Se,E as at,F as nt,a as ve,t as pe,at as Gt,q as qt,s as Qt,au as it,av as Yt,a7 as Zt,ad as Xt,aw as er,_ as tr}from"./framework.iEE2KsGo.js";import{u as rr,c as ar}from"./theme.eHXeYJL0.js";const nr={root:()=>mt(()=>import("./@localSearchIndexroot.HClziMeA.js"),__vite__mapDeps([]))};/*!
+var kt=Object.defineProperty;var It=(o,e,t)=>e in o?kt(o,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):o[e]=t;var Oe=(o,e,t)=>(It(o,typeof e!="symbol"?e+"":e,t),t);import{X as mt,h as oe,y as $e,ah as Dt,ai as Ot,d as Rt,G as xe,aj as tt,k as Fe,ak as _t,al as Mt,z as Lt,am as zt,l as Re,R as de,P as Ee,an as Pt,ao as Bt,Y as Vt,j as $t,ap as Wt,o as ee,b as jt,m as E,a1 as Kt,p as U,aq as Jt,ar as Ut,as as Ht,c as re,n as rt,e as Se,E as at,F as nt,a as ve,t as pe,at as Gt,q as qt,s as Qt,au as it,av as Yt,a7 as Zt,ad as Xt,aw as er,_ as tr}from"./framework.iEE2KsGo.js";import{u as rr,c as ar}from"./theme.fbFORVJM.js";const nr={root:()=>mt(()=>import("./@localSearchIndexroot.92CUtxnc.js"),__vite__mapDeps([]))};/*!
 * tabbable 6.2.0
 * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
 */var yt=["input:not([inert])","select:not([inert])","textarea:not([inert])","a[href]:not([inert])","button:not([inert])","[tabindex]:not(slot):not([inert])","audio[controls]:not([inert])","video[controls]:not([inert])",'[contenteditable]:not([contenteditable="false"]):not([inert])',"details>summary:first-of-type:not([inert])","details:not([inert])"],Ce=yt.join(","),gt=typeof Element>"u",ue=gt?function(){}:Element.prototype.matches||Element.prototype.msMatchesSelector||Element.prototype.webkitMatchesSelector,Ne=!gt&&Element.prototype.getRootNode?function(o){var e;return o==null||(e=o.getRootNode)===null||e===void 0?void 0:e.call(o)}:function(o){return o==null?void 0:o.ownerDocument},ke=function o(e,t){var r;t===void 0&&(t=!0);var n=e==null||(r=e.getAttribute)===null||r===void 0?void 0:r.call(e,"inert"),a=n===""||n==="true",i=a||t&&e&&o(e.parentNode);return i},ir=function(e){var t,r=e==null||(t=e.getAttribute)===null||t===void 0?void 0:t.call(e,"contenteditable");return r===""||r==="true"},bt=function(e,t,r){if(ke(e))return[];var n=Array.prototype.slice.apply(e.querySelectorAll(Ce));return t&&ue.call(e,Ce)&&n.unshift(e),n=n.filter(r),n},wt=function o(e,t,r){for(var n=[],a=Array.from(e);a.length;){var i=a.shift();if(!ke(i,!1))if(i.tagName==="SLOT"){var s=i.assignedElements(),u=s.length?s:i.children,l=o(u,!0,r);r.flatten?n.push.apply(n,l):n.push({scopeParent:i,candidates:l})}else{var h=ue.call(i,Ce);h&&r.filter(i)&&(t||!e.includes(i))&&n.push(i);var d=i.shadowRoot||typeof r.getShadowRoot=="function"&&r.getShadowRoot(i),v=!ke(d,!1)&&(!r.shadowRootFilter||r.shadowRootFilter(i));if(d&&v){var m=o(d===!0?i.children:d.children,!0,r);r.flatten?n.push.apply(n,m):n.push({scopeParent:i,candidates:m})}else a.unshift.apply(a,i.children)}}return n},xt=function(e){return!isNaN(parseInt(e.getAttribute("tabindex"),10))},se=function(e){if(!e)throw new Error("No node provided");return e.tabIndex<0&&(/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName)||ir(e))&&!xt(e)?0:e.tabIndex},or=function(e,t){var r=se(e);return r<0&&t&&!xt(e)?0:r},sr=function(e,t){return e.tabIndex===t.tabIndex?e.documentOrder-t.documentOrder:e.tabIndex-t.tabIndex},Ft=function(e){return e.tagName==="INPUT"},ur=function(e){return Ft(e)&&e.type==="hidden"},lr=function(e){var t=e.tagName==="DETAILS"&&Array.prototype.slice.apply(e.children).some(function(r){return r.tagName==="SUMMARY"});return t},cr=function(e,t){for(var r=0;rsummary:first-of-type"),i=a?e.parentElement:e;if(ue.call(i,"details:not([open]) *"))return!0;if(!r||r==="full"||r==="legacy-full"){if(typeof n=="function"){for(var s=e;e;){var u=e.parentElement,l=Ne(e);if(u&&!u.shadowRoot&&n(u)===!0)return ot(e);e.assignedSlot?e=e.assignedSlot:!u&&l!==e.ownerDocument?e=l.host:e=u}e=s}if(vr(e))return!e.getClientRects().length;if(r!=="legacy-full")return!0}else if(r==="non-zero-area")return ot(e);return!1},mr=function(e){if(/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))for(var t=e.parentElement;t;){if(t.tagName==="FIELDSET"&&t.disabled){for(var r=0;r=0)},gr=function o(e){var t=[],r=[];return e.forEach(function(n,a){var i=!!n.scopeParent,s=i?n.scopeParent:n,u=or(s,i),l=i?o(n.candidates):s;u===0?i?t.push.apply(t,l):t.push(s):r.push({documentOrder:a,tabIndex:u,item:n,isScope:i,content:l})}),r.sort(sr).reduce(function(n,a){return a.isScope?n.push.apply(n,a.content):n.push(a.content),n},[]).concat(t)},br=function(e,t){t=t||{};var r;return t.getShadowRoot?r=wt([e],t.includeContainer,{filter:We.bind(null,t),flatten:!1,getShadowRoot:t.getShadowRoot,shadowRootFilter:yr}):r=bt(e,t.includeContainer,We.bind(null,t)),gr(r)},wr=function(e,t){t=t||{};var r;return t.getShadowRoot?r=wt([e],t.includeContainer,{filter:Ie.bind(null,t),flatten:!0,getShadowRoot:t.getShadowRoot}):r=bt(e,t.includeContainer,Ie.bind(null,t)),r},le=function(e,t){if(t=t||{},!e)throw new Error("No node provided");return ue.call(e,Ce)===!1?!1:We(t,e)},xr=yt.concat("iframe").join(","),_e=function(e,t){if(t=t||{},!e)throw new Error("No node provided");return ue.call(e,xr)===!1?!1:Ie(t,e)};/*!
diff --git a/assets/chunks/theme.eHXeYJL0.js b/assets/chunks/theme.fbFORVJM.js
similarity index 99%
rename from assets/chunks/theme.eHXeYJL0.js
rename to assets/chunks/theme.fbFORVJM.js
index 3c41cd3e..38c98cfd 100644
--- a/assets/chunks/theme.eHXeYJL0.js
+++ b/assets/chunks/theme.fbFORVJM.js
@@ -1,4 +1,4 @@
-import{d as w,o as r,c as f,r as m,n as F,a as K,t as D,b as L,w as g,T as dt,e as y,_ as k,u as ni,i as Vi,f as Pi,g as ht,h as z,j as Te,k as V,l as le,m as p,p as u,q as se,s as ae,v as pe,x as it,y as ue,z as Xe,A as ft,B as si,C as Ii,D as me,F as H,E as j,G as ai,H as Ge,I as b,J as fe,K as oi,L as Ve,M as Be,N as Ke,O as Ci,P as nt,Q as Ni,R as ri,S as li,U as Ai,V as Mi,W as Di,X as ci,Y as ui,Z as di,$ as zi,a0 as xi,a1 as Oi,a2 as Hi,a3 as Ue}from"./framework.iEE2KsGo.js";const Bi=w({__name:"VPBadge",props:{text:{},type:{default:"tip"}},setup(n){return(e,t)=>(r(),f("span",{class:F(["VPBadge",e.type])},[m(e.$slots,"default",{},()=>[K(D(e.text),1)])],2))}}),Fi={key:0,class:"VPBackdrop"},Ri=w({__name:"VPBackdrop",props:{show:{type:Boolean}},setup(n){return(e,t)=>(r(),L(dt,{name:"fade"},{default:g(()=>[e.show?(r(),f("div",Fi)):y("",!0)]),_:1}))}}),Wi=k(Ri,[["__scopeId","data-v-c79a1216"]]),N=ni;function Yi(n,e){let t,i=!1;return()=>{t&&clearTimeout(t),i?t=setTimeout(n,e):(n(),(i=!0)&&setTimeout(()=>i=!1,e))}}function st(n){return/^\//.test(n)?n:`/${n}`}function vt(n){const{pathname:e,search:t,hash:i,protocol:s}=new URL(n,"http://a.com");if(Vi(n)||n.startsWith("#")||!s.startsWith("http")||!Pi(e))return n;const{site:a}=N(),o=e.endsWith("/")||e.endsWith(".html")?n:n.replace(/(?:(^\.+)\/)?.*$/,`$1${e.replace(/(\.md)?$/,a.value.cleanUrls?"":".html")}${t}${i}`);return ht(o)}const pt=z(Te?location.hash:"");Te&&window.addEventListener("hashchange",()=>{pt.value=location.hash});function De({removeCurrent:n=!0,correspondingLink:e=!1}={}){const{site:t,localeIndex:i,page:s,theme:a}=N(),o=V(()=>{var c,d;return{label:(c=t.value.locales[i.value])==null?void 0:c.label,link:((d=t.value.locales[i.value])==null?void 0:d.link)||(i.value==="root"?"/":`/${i.value}/`)}});return{localeLinks:V(()=>Object.entries(t.value.locales).flatMap(([c,d])=>n&&o.value.label===d.label?[]:{text:d.label,link:Ui(d.link||(c==="root"?"/":`/${c}/`),a.value.i18nRouting!==!1&&e,s.value.relativePath.slice(o.value.link.length-1),!t.value.cleanUrls)+pt.value})),currentLang:o}}function Ui(n,e,t,i){return e?n.replace(/\/$/,"")+st(t.replace(/(^|\/)index\.md$/,"$1").replace(/\.md$/,i?".html":"")):n}const qi=n=>(se("data-v-f87ff6e4"),n=n(),ae(),n),ji={class:"NotFound"},Xi={class:"code"},Gi={class:"title"},Ki=qi(()=>p("div",{class:"divider"},null,-1)),Zi={class:"quote"},Ji={class:"action"},Qi=["href","aria-label"],en=w({__name:"NotFound",setup(n){const{site:e,theme:t}=N(),{localeLinks:i}=De({removeCurrent:!1}),s=z("/");return le(()=>{var o;const a=window.location.pathname.replace(e.value.base,"").replace(/(^.*?\/).*$/,"/$1");i.value.length&&(s.value=((o=i.value.find(({link:l})=>l.startsWith(a)))==null?void 0:o.link)||i.value[0].link)}),(a,o)=>{var l,c,d,h,v;return r(),f("div",ji,[p("p",Xi,D(((l=u(t).notFound)==null?void 0:l.code)??"404"),1),p("h1",Gi,D(((c=u(t).notFound)==null?void 0:c.title)??"PAGE NOT FOUND"),1),Ki,p("blockquote",Zi,D(((d=u(t).notFound)==null?void 0:d.quote)??"But if you don't change your direction, and if you keep looking, you may end up where you are heading."),1),p("div",Ji,[p("a",{class:"link",href:u(ht)(s.value),"aria-label":((h=u(t).notFound)==null?void 0:h.linkLabel)??"go to home"},D(((v=u(t).notFound)==null?void 0:v.linkText)??"Take me home"),9,Qi)])])}}}),tn=k(en,[["__scopeId","data-v-f87ff6e4"]]);function hi(n,e){if(Array.isArray(n))return Fe(n);if(n==null)return[];e=st(e);const t=Object.keys(n).sort((s,a)=>a.split("/").length-s.split("/").length).find(s=>e.startsWith(st(s))),i=t?n[t]:[];return Array.isArray(i)?Fe(i):Fe(i.items,i.base)}function nn(n){const e=[];let t=0;for(const i in n){const s=n[i];if(s.items){t=e.push(s);continue}e[t]||e.push({items:[]}),e[t].items.push(s)}return e}function sn(n){const e=[];function t(i){for(const s of i)s.text&&s.link&&e.push({text:s.text,link:s.link,docFooterText:s.docFooterText}),s.items&&t(s.items)}return t(n),e}function at(n,e){return Array.isArray(e)?e.some(t=>at(n,t)):pe(n,e.link)?!0:e.items?at(n,e.items):!1}function Fe(n,e){return[...n].map(t=>{const i={...t},s=i.base||e;return s&&i.link&&(i.link=s+i.link),i.items&&(i.items=Fe(i.items,s)),i})}function ce(){const{frontmatter:n,page:e,theme:t}=N(),i=it("(min-width: 960px)"),s=z(!1),a=V(()=>{const $=t.value.sidebar,P=e.value.relativePath;return $?hi($,P):[]}),o=z(a.value);ue(a,($,P)=>{JSON.stringify($)!==JSON.stringify(P)&&(o.value=a.value)});const l=V(()=>n.value.sidebar!==!1&&o.value.length>0&&n.value.layout!=="home"),c=V(()=>d?n.value.aside==null?t.value.aside==="left":n.value.aside==="left":!1),d=V(()=>n.value.layout==="home"?!1:n.value.aside!=null?!!n.value.aside:t.value.aside!==!1),h=V(()=>l.value&&i.value),v=V(()=>l.value?nn(o.value):[]);function _(){s.value=!0}function E(){s.value=!1}function S(){s.value?E():_()}return{isOpen:s,sidebar:o,sidebarGroups:v,hasSidebar:l,hasAside:d,leftAside:c,isSidebarEnabled:h,open:_,close:E,toggle:S}}function an(n,e){let t;Xe(()=>{t=n.value?document.activeElement:void 0}),le(()=>{window.addEventListener("keyup",i)}),ft(()=>{window.removeEventListener("keyup",i)});function i(s){s.key==="Escape"&&n.value&&(e(),t==null||t.focus())}}function on(n){const{page:e}=N(),t=z(!1),i=V(()=>n.value.collapsed!=null),s=V(()=>!!n.value.link),a=z(!1),o=()=>{a.value=pe(e.value.relativePath,n.value.link)};ue([e,n,pt],o),le(o);const l=V(()=>a.value?!0:n.value.items?at(e.value.relativePath,n.value.items):!1),c=V(()=>!!(n.value.items&&n.value.items.length));Xe(()=>{t.value=!!(i.value&&n.value.collapsed)}),si(()=>{(a.value||l.value)&&(t.value=!1)});function d(){i.value&&(t.value=!t.value)}return{collapsed:t,collapsible:i,isLink:s,isActiveLink:a,hasActiveLink:l,hasChildren:c,toggle:d}}function rn(){const{hasSidebar:n}=ce(),e=it("(min-width: 960px)"),t=it("(min-width: 1280px)");return{isAsideEnabled:V(()=>!t.value&&!e.value?!1:n.value?t.value:e.value)}}const ot=[];function fi(n){return typeof n.outline=="object"&&!Array.isArray(n.outline)&&n.outline.label||n.outlineTitle||"On this page"}function mt(n){const e=[...document.querySelectorAll(".VPDoc :where(h1,h2,h3,h4,h5,h6)")].filter(t=>t.id&&t.hasChildNodes()).map(t=>{const i=Number(t.tagName[1]);return{element:t,title:ln(t),link:"#"+t.id,level:i}});return cn(e,n)}function ln(n){let e="";for(const t of n.childNodes)if(t.nodeType===1){if(t.classList.contains("VPBadge")||t.classList.contains("header-anchor")||t.classList.contains("ignore-header"))continue;e+=t.textContent}else t.nodeType===3&&(e+=t.textContent);return e.trim()}function cn(n,e){if(e===!1)return[];const t=(typeof e=="object"&&!Array.isArray(e)?e.level:e)||2,[i,s]=typeof t=="number"?[t,t]:t==="deep"?[2,6]:t;n=n.filter(o=>o.level>=i&&o.level<=s),ot.length=0;for(const{element:o,link:l}of n)ot.push({element:o,link:l});const a=[];e:for(let o=0;o=0;c--){const d=n[c];if(d.level{requestAnimationFrame(a),window.addEventListener("scroll",i)}),Ii(()=>{o(location.hash)}),ft(()=>{window.removeEventListener("scroll",i)});function a(){if(!t.value)return;const l=(()=>{var $;const S=($=document.querySelector("#VPContent .VPDoc"))==null?void 0:$.firstElementChild;return S?Lt(S):78})(),c=window.scrollY,d=window.innerHeight,h=document.body.offsetHeight,v=Math.abs(c+d-h)<1,_=ot.map(({element:S,link:$})=>({link:$,top:Lt(S)})).filter(({top:S})=>!Number.isNaN(S)).sort((S,$)=>S.top-$.top);if(!_.length){o(null);return}if(c<1){o(null);return}if(v){o(_[_.length-1].link);return}let E=null;for(const{link:S,top:$}of _){if($>c+l)break;E=S}o(E)}function o(l){s&&s.classList.remove("active"),l==null?s=null:s=n.value.querySelector(`a[href="${decodeURIComponent(l)}"]`);const c=s;c?(c.classList.add("active"),e.value.style.top=c.offsetTop+39+"px",e.value.style.opacity="1"):(e.value.style.top="33px",e.value.style.opacity="0")}}function Lt(n){let e=0;for(;n!==document.body;){if(n===null)return NaN;e+=n.offsetTop,n=n.offsetParent}return e}const dn=["href","title"],hn=w({__name:"VPDocOutlineItem",props:{headers:{},root:{type:Boolean}},setup(n){function e({target:t}){const i=t.href.split("#")[1],s=document.getElementById(decodeURIComponent(i));s==null||s.focus({preventScroll:!0})}return(t,i)=>{const s=me("VPDocOutlineItem",!0);return r(),f("ul",{class:F(["VPDocOutlineItem",t.root?"root":"nested"])},[(r(!0),f(H,null,j(t.headers,({children:a,link:o,title:l})=>(r(),f("li",null,[p("a",{class:"outline-link",href:o,onClick:e,title:l},D(l),9,dn),a!=null&&a.length?(r(),L(s,{key:0,headers:a},null,8,["headers"])):y("",!0)]))),256))],2)}}}),vi=k(hn,[["__scopeId","data-v-b933a997"]]),fn=n=>(se("data-v-935f8a84"),n=n(),ae(),n),vn={class:"content"},pn={class:"outline-title",role:"heading","aria-level":"2"},mn={"aria-labelledby":"doc-outline-aria-label"},gn=fn(()=>p("span",{class:"visually-hidden",id:"doc-outline-aria-label"}," Table of Contents for current page ",-1)),_n=w({__name:"VPDocAsideOutline",setup(n){const{frontmatter:e,theme:t}=N(),i=ai([]);Ge(()=>{i.value=mt(e.value.outline??t.value.outline)});const s=z(),a=z();return un(s,a),(o,l)=>(r(),f("div",{class:F(["VPDocAsideOutline",{"has-outline":i.value.length>0}]),ref_key:"container",ref:s,role:"navigation"},[p("div",vn,[p("div",{class:"outline-marker",ref_key:"marker",ref:a},null,512),p("div",pn,D(u(fi)(u(t))),1),p("nav",mn,[gn,b(vi,{headers:i.value,root:!0},null,8,["headers"])])])],2))}}),bn=k(_n,[["__scopeId","data-v-935f8a84"]]),yn={class:"VPDocAsideCarbonAds"},wn=w({__name:"VPDocAsideCarbonAds",props:{carbonAds:{}},setup(n){const e=()=>null;return(t,i)=>(r(),f("div",yn,[b(u(e),{"carbon-ads":t.carbonAds},null,8,["carbon-ads"])]))}}),kn=n=>(se("data-v-3f215769"),n=n(),ae(),n),$n={class:"VPDocAside"},Sn=kn(()=>p("div",{class:"spacer"},null,-1)),Ln=w({__name:"VPDocAside",setup(n){const{theme:e}=N();return(t,i)=>(r(),f("div",$n,[m(t.$slots,"aside-top",{},void 0,!0),m(t.$slots,"aside-outline-before",{},void 0,!0),b(bn),m(t.$slots,"aside-outline-after",{},void 0,!0),Sn,m(t.$slots,"aside-ads-before",{},void 0,!0),u(e).carbonAds?(r(),L(wn,{key:0,"carbon-ads":u(e).carbonAds},null,8,["carbon-ads"])):y("",!0),m(t.$slots,"aside-ads-after",{},void 0,!0),m(t.$slots,"aside-bottom",{},void 0,!0)]))}}),En=k(Ln,[["__scopeId","data-v-3f215769"]]);function Tn(){const{theme:n,page:e}=N();return V(()=>{const{text:t="Edit this page",pattern:i=""}=n.value.editLink||{};let s;return typeof i=="function"?s=i(e.value):s=i.replace(/:path/g,e.value.filePath),{url:s,text:t}})}function Vn(){const{page:n,theme:e,frontmatter:t}=N();return V(()=>{var c,d,h,v,_,E,S,$;const i=hi(e.value.sidebar,n.value.relativePath),s=sn(i),a=s.findIndex(P=>pe(n.value.relativePath,P.link)),o=((c=e.value.docFooter)==null?void 0:c.prev)===!1&&!t.value.prev||t.value.prev===!1,l=((d=e.value.docFooter)==null?void 0:d.next)===!1&&!t.value.next||t.value.next===!1;return{prev:o?void 0:{text:(typeof t.value.prev=="string"?t.value.prev:typeof t.value.prev=="object"?t.value.prev.text:void 0)??((h=s[a-1])==null?void 0:h.docFooterText)??((v=s[a-1])==null?void 0:v.text),link:(typeof t.value.prev=="object"?t.value.prev.link:void 0)??((_=s[a-1])==null?void 0:_.link)},next:l?void 0:{text:(typeof t.value.next=="string"?t.value.next:typeof t.value.next=="object"?t.value.next.text:void 0)??((E=s[a+1])==null?void 0:E.docFooterText)??((S=s[a+1])==null?void 0:S.text),link:(typeof t.value.next=="object"?t.value.next.link:void 0)??(($=s[a+1])==null?void 0:$.link)}}})}const Pn={},In={xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24"},Cn=p("path",{d:"M18,23H4c-1.7,0-3-1.3-3-3V6c0-1.7,1.3-3,3-3h7c0.6,0,1,0.4,1,1s-0.4,1-1,1H4C3.4,5,3,5.4,3,6v14c0,0.6,0.4,1,1,1h14c0.6,0,1-0.4,1-1v-7c0-0.6,0.4-1,1-1s1,0.4,1,1v7C21,21.7,19.7,23,18,23z"},null,-1),Nn=p("path",{d:"M8,17c-0.3,0-0.5-0.1-0.7-0.3C7,16.5,6.9,16.1,7,15.8l1-4c0-0.2,0.1-0.3,0.3-0.5l9.5-9.5c1.2-1.2,3.2-1.2,4.4,0c1.2,1.2,1.2,3.2,0,4.4l-9.5,9.5c-0.1,0.1-0.3,0.2-0.5,0.3l-4,1C8.2,17,8.1,17,8,17zM9.9,12.5l-0.5,2.1l2.1-0.5l9.3-9.3c0.4-0.4,0.4-1.1,0-1.6c-0.4-0.4-1.2-0.4-1.6,0l0,0L9.9,12.5z M18.5,2.5L18.5,2.5L18.5,2.5z"},null,-1),An=[Cn,Nn];function Mn(n,e){return r(),f("svg",In,An)}const Dn=k(Pn,[["render",Mn]]),ne=w({__name:"VPLink",props:{tag:{},href:{},noIcon:{type:Boolean},target:{},rel:{}},setup(n){const e=n,t=V(()=>e.tag??(e.href?"a":"span")),i=V(()=>e.href&&oi.test(e.href));return(s,a)=>(r(),L(fe(t.value),{class:F(["VPLink",{link:s.href,"vp-external-link-icon":i.value,"no-icon":s.noIcon}]),href:s.href?u(vt)(s.href):void 0,target:s.target??(i.value?"_blank":void 0),rel:s.rel??(i.value?"noreferrer":void 0)},{default:g(()=>[m(s.$slots,"default")]),_:3},8,["class","href","target","rel"]))}}),zn={class:"VPLastUpdated"},xn=["datetime"],On=w({__name:"VPDocFooterLastUpdated",setup(n){const{theme:e,page:t,frontmatter:i,lang:s}=N(),a=V(()=>new Date(i.value.lastUpdated??t.value.lastUpdated)),o=V(()=>a.value.toISOString()),l=z("");return le(()=>{Xe(()=>{var c,d,h;l.value=new Intl.DateTimeFormat((d=(c=e.value.lastUpdated)==null?void 0:c.formatOptions)!=null&&d.forceLocale?s.value:void 0,((h=e.value.lastUpdated)==null?void 0:h.formatOptions)??{dateStyle:"short",timeStyle:"short"}).format(a.value)})}),(c,d)=>{var h;return r(),f("p",zn,[K(D(((h=u(e).lastUpdated)==null?void 0:h.text)||u(e).lastUpdatedText||"Last updated")+": ",1),p("time",{datetime:o.value},D(l.value),9,xn)])}}}),Hn=k(On,[["__scopeId","data-v-7e05ebdb"]]),Bn={key:0,class:"VPDocFooter"},Fn={key:0,class:"edit-info"},Rn={key:0,class:"edit-link"},Wn={key:1,class:"last-updated"},Yn={key:1,class:"prev-next"},Un={class:"pager"},qn=["innerHTML"],jn=["innerHTML"],Xn={class:"pager"},Gn=["innerHTML"],Kn=["innerHTML"],Zn=w({__name:"VPDocFooter",setup(n){const{theme:e,page:t,frontmatter:i}=N(),s=Tn(),a=Vn(),o=V(()=>e.value.editLink&&i.value.editLink!==!1),l=V(()=>t.value.lastUpdated&&i.value.lastUpdated!==!1),c=V(()=>o.value||l.value||a.value.prev||a.value.next);return(d,h)=>{var v,_,E,S;return c.value?(r(),f("footer",Bn,[m(d.$slots,"doc-footer-before",{},void 0,!0),o.value||l.value?(r(),f("div",Fn,[o.value?(r(),f("div",Rn,[b(ne,{class:"edit-link-button",href:u(s).url,"no-icon":!0},{default:g(()=>[b(Dn,{class:"edit-link-icon","aria-label":"edit icon"}),K(" "+D(u(s).text),1)]),_:1},8,["href"])])):y("",!0),l.value?(r(),f("div",Wn,[b(Hn)])):y("",!0)])):y("",!0),(v=u(a).prev)!=null&&v.link||(_=u(a).next)!=null&&_.link?(r(),f("nav",Yn,[p("div",Un,[(E=u(a).prev)!=null&&E.link?(r(),L(ne,{key:0,class:"pager-link prev",href:u(a).prev.link},{default:g(()=>{var $;return[p("span",{class:"desc",innerHTML:(($=u(e).docFooter)==null?void 0:$.prev)||"Previous page"},null,8,qn),p("span",{class:"title",innerHTML:u(a).prev.text},null,8,jn)]}),_:1},8,["href"])):y("",!0)]),p("div",Xn,[(S=u(a).next)!=null&&S.link?(r(),L(ne,{key:0,class:"pager-link next",href:u(a).next.link},{default:g(()=>{var $;return[p("span",{class:"desc",innerHTML:(($=u(e).docFooter)==null?void 0:$.next)||"Next page"},null,8,Gn),p("span",{class:"title",innerHTML:u(a).next.text},null,8,Kn)]}),_:1},8,["href"])):y("",!0)])])):y("",!0)])):y("",!0)}}}),Jn=k(Zn,[["__scopeId","data-v-48f9bb55"]]),Qn=n=>(se("data-v-39a288b8"),n=n(),ae(),n),es={class:"container"},ts=Qn(()=>p("div",{class:"aside-curtain"},null,-1)),is={class:"aside-container"},ns={class:"aside-content"},ss={class:"content"},as={class:"content-container"},os={class:"main"},rs=w({__name:"VPDoc",setup(n){const{theme:e}=N(),t=Ve(),{hasSidebar:i,hasAside:s,leftAside:a}=ce(),o=V(()=>t.path.replace(/[./]+/g,"_").replace(/_html$/,""));return(l,c)=>{const d=me("Content");return r(),f("div",{class:F(["VPDoc",{"has-sidebar":u(i),"has-aside":u(s)}])},[m(l.$slots,"doc-top",{},void 0,!0),p("div",es,[u(s)?(r(),f("div",{key:0,class:F(["aside",{"left-aside":u(a)}])},[ts,p("div",is,[p("div",ns,[b(En,null,{"aside-top":g(()=>[m(l.$slots,"aside-top",{},void 0,!0)]),"aside-bottom":g(()=>[m(l.$slots,"aside-bottom",{},void 0,!0)]),"aside-outline-before":g(()=>[m(l.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":g(()=>[m(l.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":g(()=>[m(l.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":g(()=>[m(l.$slots,"aside-ads-after",{},void 0,!0)]),_:3})])])],2)):y("",!0),p("div",ss,[p("div",as,[m(l.$slots,"doc-before",{},void 0,!0),p("main",os,[b(d,{class:F(["vp-doc",[o.value,u(e).externalLinkIcon&&"external-link-icon-enabled"]])},null,8,["class"])]),b(Jn,null,{"doc-footer-before":g(()=>[m(l.$slots,"doc-footer-before",{},void 0,!0)]),_:3}),m(l.$slots,"doc-after",{},void 0,!0)])])]),m(l.$slots,"doc-bottom",{},void 0,!0)],2)}}}),ls=k(rs,[["__scopeId","data-v-39a288b8"]]),cs=w({__name:"VPButton",props:{tag:{},size:{default:"medium"},theme:{default:"brand"},text:{},href:{}},setup(n){const e=n,t=V(()=>e.href&&oi.test(e.href)),i=V(()=>e.tag||e.href?"a":"button");return(s,a)=>(r(),L(fe(i.value),{class:F(["VPButton",[s.size,s.theme]]),href:s.href?u(vt)(s.href):void 0,target:t.value?"_blank":void 0,rel:t.value?"noreferrer":void 0},{default:g(()=>[K(D(s.text),1)]),_:1},8,["class","href","target","rel"]))}}),us=k(cs,[["__scopeId","data-v-c1c5efc1"]]),ds=["src","alt"],hs=w({inheritAttrs:!1,__name:"VPImage",props:{image:{},alt:{}},setup(n){return(e,t)=>{const i=me("VPImage",!0);return e.image?(r(),f(H,{key:0},[typeof e.image=="string"||"src"in e.image?(r(),f("img",Be({key:0,class:"VPImage"},typeof e.image=="string"?e.$attrs:{...e.image,...e.$attrs},{src:u(ht)(typeof e.image=="string"?e.image:e.image.src),alt:e.alt??(typeof e.image=="string"?"":e.image.alt||"")}),null,16,ds)):(r(),f(H,{key:1},[b(i,Be({class:"dark",image:e.image.dark,alt:e.image.alt},e.$attrs),null,16,["image","alt"]),b(i,Be({class:"light",image:e.image.light,alt:e.image.alt},e.$attrs),null,16,["image","alt"])],64))],64)):y("",!0)}}}),qe=k(hs,[["__scopeId","data-v-8426fc1a"]]),fs=n=>(se("data-v-da5d1713"),n=n(),ae(),n),vs={class:"container"},ps={class:"main"},ms={key:0,class:"name"},gs=["innerHTML"],_s=["innerHTML"],bs=["innerHTML"],ys={key:0,class:"actions"},ws={key:0,class:"image"},ks={class:"image-container"},$s=fs(()=>p("div",{class:"image-bg"},null,-1)),Ss=w({__name:"VPHero",props:{name:{},text:{},tagline:{},image:{},actions:{}},setup(n){const e=Ke("hero-image-slot-exists");return(t,i)=>(r(),f("div",{class:F(["VPHero",{"has-image":t.image||u(e)}])},[p("div",vs,[p("div",ps,[m(t.$slots,"home-hero-info",{},()=>[t.name?(r(),f("h1",ms,[p("span",{innerHTML:t.name,class:"clip"},null,8,gs)])):y("",!0),t.text?(r(),f("p",{key:1,innerHTML:t.text,class:"text"},null,8,_s)):y("",!0),t.tagline?(r(),f("p",{key:2,innerHTML:t.tagline,class:"tagline"},null,8,bs)):y("",!0)],!0),t.actions?(r(),f("div",ys,[(r(!0),f(H,null,j(t.actions,s=>(r(),f("div",{key:s.link,class:"action"},[b(us,{tag:"a",size:"medium",theme:s.theme,text:s.text,href:s.link},null,8,["theme","text","href"])]))),128))])):y("",!0)]),t.image||u(e)?(r(),f("div",ws,[p("div",ks,[$s,m(t.$slots,"home-hero-image",{},()=>[t.image?(r(),L(qe,{key:0,class:"image-src",image:t.image},null,8,["image"])):y("",!0)],!0)])])):y("",!0)])],2))}}),Ls=k(Ss,[["__scopeId","data-v-da5d1713"]]),Es=w({__name:"VPHomeHero",setup(n){const{frontmatter:e}=N();return(t,i)=>u(e).hero?(r(),L(Ls,{key:0,class:"VPHomeHero",name:u(e).hero.name,text:u(e).hero.text,tagline:u(e).hero.tagline,image:u(e).hero.image,actions:u(e).hero.actions},{"home-hero-info":g(()=>[m(t.$slots,"home-hero-info")]),"home-hero-image":g(()=>[m(t.$slots,"home-hero-image")]),_:3},8,["name","text","tagline","image","actions"])):y("",!0)}}),Ts={},Vs={xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24"},Ps=p("path",{d:"M19.9,12.4c0.1-0.2,0.1-0.5,0-0.8c-0.1-0.1-0.1-0.2-0.2-0.3l-7-7c-0.4-0.4-1-0.4-1.4,0s-0.4,1,0,1.4l5.3,5.3H5c-0.6,0-1,0.4-1,1s0.4,1,1,1h11.6l-5.3,5.3c-0.4,0.4-0.4,1,0,1.4c0.2,0.2,0.5,0.3,0.7,0.3s0.5-0.1,0.7-0.3l7-7C19.8,12.6,19.9,12.5,19.9,12.4z"},null,-1),Is=[Ps];function Cs(n,e){return r(),f("svg",Vs,Is)}const Ns=k(Ts,[["render",Cs]]),As={class:"box"},Ms={key:0,class:"icon"},Ds=["innerHTML"],zs=["innerHTML"],xs=["innerHTML"],Os={key:4,class:"link-text"},Hs={class:"link-text-value"},Bs=w({__name:"VPFeature",props:{icon:{},title:{},details:{},link:{},linkText:{},rel:{},target:{}},setup(n){return(e,t)=>(r(),L(ne,{class:"VPFeature",href:e.link,rel:e.rel,target:e.target,"no-icon":!0,tag:e.link?"a":"div"},{default:g(()=>[p("article",As,[typeof e.icon=="object"&&e.icon.wrap?(r(),f("div",Ms,[b(qe,{image:e.icon,alt:e.icon.alt,height:e.icon.height||48,width:e.icon.width||48},null,8,["image","alt","height","width"])])):typeof e.icon=="object"?(r(),L(qe,{key:1,image:e.icon,alt:e.icon.alt,height:e.icon.height||48,width:e.icon.width||48},null,8,["image","alt","height","width"])):e.icon?(r(),f("div",{key:2,class:"icon",innerHTML:e.icon},null,8,Ds)):y("",!0),p("h2",{class:"title",innerHTML:e.title},null,8,zs),e.details?(r(),f("p",{key:3,class:"details",innerHTML:e.details},null,8,xs)):y("",!0),e.linkText?(r(),f("div",Os,[p("p",Hs,[K(D(e.linkText)+" ",1),b(Ns,{class:"link-text-icon"})])])):y("",!0)])]),_:1},8,["href","rel","target","tag"]))}}),Fs=k(Bs,[["__scopeId","data-v-33204567"]]),Rs={key:0,class:"VPFeatures"},Ws={class:"container"},Ys={class:"items"},Us=w({__name:"VPFeatures",props:{features:{}},setup(n){const e=n,t=V(()=>{const i=e.features.length;if(i){if(i===2)return"grid-2";if(i===3)return"grid-3";if(i%3===0)return"grid-6";if(i>3)return"grid-4"}else return});return(i,s)=>i.features?(r(),f("div",Rs,[p("div",Ws,[p("div",Ys,[(r(!0),f(H,null,j(i.features,a=>(r(),f("div",{key:a.title,class:F(["item",[t.value]])},[b(Fs,{icon:a.icon,title:a.title,details:a.details,link:a.link,"link-text":a.linkText,rel:a.rel,target:a.target},null,8,["icon","title","details","link","link-text","rel","target"])],2))),128))])])])):y("",!0)}}),qs=k(Us,[["__scopeId","data-v-a6181336"]]),js=w({__name:"VPHomeFeatures",setup(n){const{frontmatter:e}=N();return(t,i)=>u(e).features?(r(),L(qs,{key:0,class:"VPHomeFeatures",features:u(e).features},null,8,["features"])):y("",!0)}}),Xs={class:"VPHome"},Gs=w({__name:"VPHome",setup(n){return(e,t)=>{const i=me("Content");return r(),f("div",Xs,[m(e.$slots,"home-hero-before",{},void 0,!0),b(Es,null,{"home-hero-info":g(()=>[m(e.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-image":g(()=>[m(e.$slots,"home-hero-image",{},void 0,!0)]),_:3}),m(e.$slots,"home-hero-after",{},void 0,!0),m(e.$slots,"home-features-before",{},void 0,!0),b(js),m(e.$slots,"home-features-after",{},void 0,!0),b(i)])}}}),Ks=k(Gs,[["__scopeId","data-v-d82743a8"]]),Zs={},Js={class:"VPPage"};function Qs(n,e){const t=me("Content");return r(),f("div",Js,[m(n.$slots,"page-top"),b(t),m(n.$slots,"page-bottom")])}const ea=k(Zs,[["render",Qs]]),ta=w({__name:"VPContent",setup(n){const{page:e,frontmatter:t}=N(),{hasSidebar:i}=ce();return(s,a)=>(r(),f("div",{class:F(["VPContent",{"has-sidebar":u(i),"is-home":u(t).layout==="home"}]),id:"VPContent"},[u(e).isNotFound?m(s.$slots,"not-found",{key:0},()=>[b(tn)],!0):u(t).layout==="page"?(r(),L(ea,{key:1},{"page-top":g(()=>[m(s.$slots,"page-top",{},void 0,!0)]),"page-bottom":g(()=>[m(s.$slots,"page-bottom",{},void 0,!0)]),_:3})):u(t).layout==="home"?(r(),L(Ks,{key:2},{"home-hero-before":g(()=>[m(s.$slots,"home-hero-before",{},void 0,!0)]),"home-hero-info":g(()=>[m(s.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-image":g(()=>[m(s.$slots,"home-hero-image",{},void 0,!0)]),"home-hero-after":g(()=>[m(s.$slots,"home-hero-after",{},void 0,!0)]),"home-features-before":g(()=>[m(s.$slots,"home-features-before",{},void 0,!0)]),"home-features-after":g(()=>[m(s.$slots,"home-features-after",{},void 0,!0)]),_:3})):u(t).layout&&u(t).layout!=="doc"?(r(),L(fe(u(t).layout),{key:3})):(r(),L(ls,{key:4},{"doc-top":g(()=>[m(s.$slots,"doc-top",{},void 0,!0)]),"doc-bottom":g(()=>[m(s.$slots,"doc-bottom",{},void 0,!0)]),"doc-footer-before":g(()=>[m(s.$slots,"doc-footer-before",{},void 0,!0)]),"doc-before":g(()=>[m(s.$slots,"doc-before",{},void 0,!0)]),"doc-after":g(()=>[m(s.$slots,"doc-after",{},void 0,!0)]),"aside-top":g(()=>[m(s.$slots,"aside-top",{},void 0,!0)]),"aside-outline-before":g(()=>[m(s.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":g(()=>[m(s.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":g(()=>[m(s.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":g(()=>[m(s.$slots,"aside-ads-after",{},void 0,!0)]),"aside-bottom":g(()=>[m(s.$slots,"aside-bottom",{},void 0,!0)]),_:3}))],2))}}),ia=k(ta,[["__scopeId","data-v-669faec9"]]),na={class:"container"},sa=["innerHTML"],aa=["innerHTML"],oa=w({__name:"VPFooter",setup(n){const{theme:e,frontmatter:t}=N(),{hasSidebar:i}=ce();return(s,a)=>u(e).footer&&u(t).footer!==!1?(r(),f("footer",{key:0,class:F(["VPFooter",{"has-sidebar":u(i)}])},[p("div",na,[u(e).footer.message?(r(),f("p",{key:0,class:"message",innerHTML:u(e).footer.message},null,8,sa)):y("",!0),u(e).footer.copyright?(r(),f("p",{key:1,class:"copyright",innerHTML:u(e).footer.copyright},null,8,aa)):y("",!0)])],2)):y("",!0)}}),ra=k(oa,[["__scopeId","data-v-e315a0ad"]]);function pi(){const{theme:n,frontmatter:e}=N(),t=ai([]),i=V(()=>t.value.length>0);return Ge(()=>{t.value=mt(e.value.outline??n.value.outline)}),{headers:t,hasLocalNav:i}}const la={},ca={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},ua=p("path",{d:"M9,19c-0.3,0-0.5-0.1-0.7-0.3c-0.4-0.4-0.4-1,0-1.4l5.3-5.3L8.3,6.7c-0.4-0.4-0.4-1,0-1.4s1-0.4,1.4,0l6,6c0.4,0.4,0.4,1,0,1.4l-6,6C9.5,18.9,9.3,19,9,19z"},null,-1),da=[ua];function ha(n,e){return r(),f("svg",ca,da)}const mi=k(la,[["render",ha]]),fa={class:"header"},va={class:"outline"},pa=w({__name:"VPLocalNavOutlineDropdown",props:{headers:{},navHeight:{}},setup(n){const e=n,{theme:t}=N(),i=z(!1),s=z(0),a=z(),o=z();Ci(a,()=>{i.value=!1}),nt("Escape",()=>{i.value=!1}),Ge(()=>{i.value=!1});function l(){i.value=!i.value,s.value=window.innerHeight+Math.min(window.scrollY-e.navHeight,0)}function c(h){h.target.classList.contains("outline-link")&&(o.value&&(o.value.style.transition="none"),ri(()=>{i.value=!1}))}function d(){i.value=!1,window.scrollTo({top:0,left:0,behavior:"smooth"})}return(h,v)=>(r(),f("div",{class:"VPLocalNavOutlineDropdown",style:Ni({"--vp-vh":s.value+"px"}),ref_key:"main",ref:a},[h.headers.length>0?(r(),f("button",{key:0,onClick:l,class:F({open:i.value})},[K(D(u(fi)(u(t)))+" ",1),b(mi,{class:"icon"})],2)):(r(),f("button",{key:1,onClick:d},D(u(t).returnToTopLabel||"Return to top"),1)),b(dt,{name:"flyout"},{default:g(()=>[i.value?(r(),f("div",{key:0,ref_key:"items",ref:o,class:"items",onClick:c},[p("div",fa,[p("a",{class:"top-link",href:"#",onClick:d},D(u(t).returnToTopLabel||"Return to top"),1)]),p("div",va,[b(vi,{headers:h.headers},null,8,["headers"])])],512)):y("",!0)]),_:1})],4))}}),ma=k(pa,[["__scopeId","data-v-af18c0d5"]]),ga={},_a={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},ba=p("path",{d:"M17,11H3c-0.6,0-1-0.4-1-1s0.4-1,1-1h14c0.6,0,1,0.4,1,1S17.6,11,17,11z"},null,-1),ya=p("path",{d:"M21,7H3C2.4,7,2,6.6,2,6s0.4-1,1-1h18c0.6,0,1,0.4,1,1S21.6,7,21,7z"},null,-1),wa=p("path",{d:"M21,15H3c-0.6,0-1-0.4-1-1s0.4-1,1-1h18c0.6,0,1,0.4,1,1S21.6,15,21,15z"},null,-1),ka=p("path",{d:"M17,19H3c-0.6,0-1-0.4-1-1s0.4-1,1-1h14c0.6,0,1,0.4,1,1S17.6,19,17,19z"},null,-1),$a=[ba,ya,wa,ka];function Sa(n,e){return r(),f("svg",_a,$a)}const La=k(ga,[["render",Sa]]),Ea={class:"container"},Ta=["aria-expanded"],Va={class:"menu-text"},Pa=w({__name:"VPLocalNav",props:{open:{type:Boolean}},emits:["open-menu"],setup(n){const{theme:e,frontmatter:t}=N(),{hasSidebar:i}=ce(),{headers:s}=pi(),{y:a}=li(),o=z(0);le(()=>{o.value=parseInt(getComputedStyle(document.documentElement).getPropertyValue("--vp-nav-height"))}),Ge(()=>{s.value=mt(t.value.outline??e.value.outline)});const l=V(()=>s.value.length===0),c=V(()=>l.value&&!i.value),d=V(()=>({VPLocalNav:!0,"has-sidebar":i.value,empty:l.value,fixed:c.value}));return(h,v)=>u(t).layout!=="home"&&(!c.value||u(a)>=o.value)?(r(),f("div",{key:0,class:F(d.value)},[p("div",Ea,[u(i)?(r(),f("button",{key:0,class:"menu","aria-expanded":h.open,"aria-controls":"VPSidebarNav",onClick:v[0]||(v[0]=_=>h.$emit("open-menu"))},[b(La,{class:"menu-icon"}),p("span",Va,D(u(e).sidebarMenuLabel||"Menu"),1)],8,Ta)):y("",!0),b(ma,{headers:u(s),navHeight:o.value},null,8,["headers","navHeight"])])],2)):y("",!0)}}),Ia=k(Pa,[["__scopeId","data-v-0282ae07"]]);function Ca(){const n=z(!1);function e(){n.value=!0,window.addEventListener("resize",s)}function t(){n.value=!1,window.removeEventListener("resize",s)}function i(){n.value?t():e()}function s(){window.outerWidth>=768&&t()}const a=Ve();return ue(()=>a.path,t),{isScreenOpen:n,openScreen:e,closeScreen:t,toggleScreen:i}}const Na={},Aa={class:"VPSwitch",type:"button",role:"switch"},Ma={class:"check"},Da={key:0,class:"icon"};function za(n,e){return r(),f("button",Aa,[p("span",Ma,[n.$slots.default?(r(),f("span",Da,[m(n.$slots,"default",{},void 0,!0)])):y("",!0)])])}const xa=k(Na,[["render",za],["__scopeId","data-v-b1685198"]]),Oa={},Ha={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},Ba=p("path",{d:"M12.1,22c-0.3,0-0.6,0-0.9,0c-5.5-0.5-9.5-5.4-9-10.9c0.4-4.8,4.2-8.6,9-9c0.4,0,0.8,0.2,1,0.5c0.2,0.3,0.2,0.8-0.1,1.1c-2,2.7-1.4,6.4,1.3,8.4c2.1,1.6,5,1.6,7.1,0c0.3-0.2,0.7-0.3,1.1-0.1c0.3,0.2,0.5,0.6,0.5,1c-0.2,2.7-1.5,5.1-3.6,6.8C16.6,21.2,14.4,22,12.1,22zM9.3,4.4c-2.9,1-5,3.6-5.2,6.8c-0.4,4.4,2.8,8.3,7.2,8.7c2.1,0.2,4.2-0.4,5.8-1.8c1.1-0.9,1.9-2.1,2.4-3.4c-2.5,0.9-5.3,0.5-7.5-1.1C9.2,11.4,8.1,7.7,9.3,4.4z"},null,-1),Fa=[Ba];function Ra(n,e){return r(),f("svg",Ha,Fa)}const Wa=k(Oa,[["render",Ra]]),Ya={},Ua={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},qa=Ai('',9),ja=[qa];function Xa(n,e){return r(),f("svg",Ua,ja)}const Ga=k(Ya,[["render",Xa]]),Ka=w({__name:"VPSwitchAppearance",setup(n){const{isDark:e,theme:t}=N(),i=Ke("toggle-appearance",()=>{e.value=!e.value}),s=V(()=>e.value?t.value.lightModeSwitchTitle||"Switch to light theme":t.value.darkModeSwitchTitle||"Switch to dark theme");return(a,o)=>(r(),L(xa,{title:s.value,class:"VPSwitchAppearance","aria-checked":u(e),onClick:u(i)},{default:g(()=>[b(Ga,{class:"sun"}),b(Wa,{class:"moon"})]),_:1},8,["title","aria-checked","onClick"]))}}),gt=k(Ka,[["__scopeId","data-v-1736f215"]]),Za={key:0,class:"VPNavBarAppearance"},Ja=w({__name:"VPNavBarAppearance",setup(n){const{site:e}=N();return(t,i)=>u(e).appearance&&u(e).appearance!=="force-dark"?(r(),f("div",Za,[b(gt)])):y("",!0)}}),Qa=k(Ja,[["__scopeId","data-v-e6aabb21"]]),_t=z();let gi=!1,Qe=0;function eo(n){const e=z(!1);if(Te){!gi&&to(),Qe++;const t=ue(_t,i=>{var s,a,o;i===n.el.value||(s=n.el.value)!=null&&s.contains(i)?(e.value=!0,(a=n.onFocus)==null||a.call(n)):(e.value=!1,(o=n.onBlur)==null||o.call(n))});ft(()=>{t(),Qe--,Qe||io()})}return Mi(e)}function to(){document.addEventListener("focusin",_i),gi=!0,_t.value=document.activeElement}function io(){document.removeEventListener("focusin",_i)}function _i(){_t.value=document.activeElement}const no={},so={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},ao=p("path",{d:"M12,16c-0.3,0-0.5-0.1-0.7-0.3l-6-6c-0.4-0.4-0.4-1,0-1.4s1-0.4,1.4,0l5.3,5.3l5.3-5.3c0.4-0.4,1-0.4,1.4,0s0.4,1,0,1.4l-6,6C12.5,15.9,12.3,16,12,16z"},null,-1),oo=[ao];function ro(n,e){return r(),f("svg",so,oo)}const bi=k(no,[["render",ro]]),lo={},co={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},uo=p("circle",{cx:"12",cy:"12",r:"2"},null,-1),ho=p("circle",{cx:"19",cy:"12",r:"2"},null,-1),fo=p("circle",{cx:"5",cy:"12",r:"2"},null,-1),vo=[uo,ho,fo];function po(n,e){return r(),f("svg",co,vo)}const mo=k(lo,[["render",po]]),go={class:"VPMenuLink"},_o=w({__name:"VPMenuLink",props:{item:{}},setup(n){const{page:e}=N();return(t,i)=>(r(),f("div",go,[b(ne,{class:F({active:u(pe)(u(e).relativePath,t.item.activeMatch||t.item.link,!!t.item.activeMatch)}),href:t.item.link,target:t.item.target,rel:t.item.rel},{default:g(()=>[K(D(t.item.text),1)]),_:1},8,["class","href","target","rel"])]))}}),Ze=k(_o,[["__scopeId","data-v-43f1e123"]]),bo={class:"VPMenuGroup"},yo={key:0,class:"title"},wo=w({__name:"VPMenuGroup",props:{text:{},items:{}},setup(n){return(e,t)=>(r(),f("div",bo,[e.text?(r(),f("p",yo,D(e.text),1)):y("",!0),(r(!0),f(H,null,j(e.items,i=>(r(),f(H,null,["link"in i?(r(),L(Ze,{key:0,item:i},null,8,["item"])):y("",!0)],64))),256))]))}}),ko=k(wo,[["__scopeId","data-v-69e747b5"]]),$o={class:"VPMenu"},So={key:0,class:"items"},Lo=w({__name:"VPMenu",props:{items:{}},setup(n){return(e,t)=>(r(),f("div",$o,[e.items?(r(),f("div",So,[(r(!0),f(H,null,j(e.items,i=>(r(),f(H,{key:i.text},["link"in i?(r(),L(Ze,{key:0,item:i},null,8,["item"])):(r(),L(ko,{key:1,text:i.text,items:i.items},null,8,["text","items"]))],64))),128))])):y("",!0),m(e.$slots,"default",{},void 0,!0)]))}}),Eo=k(Lo,[["__scopeId","data-v-e7ea1737"]]),To=["aria-expanded","aria-label"],Vo={key:0,class:"text"},Po=["innerHTML"],Io={class:"menu"},Co=w({__name:"VPFlyout",props:{icon:{},button:{},label:{},items:{}},setup(n){const e=z(!1),t=z();eo({el:t,onBlur:i});function i(){e.value=!1}return(s,a)=>(r(),f("div",{class:"VPFlyout",ref_key:"el",ref:t,onMouseenter:a[1]||(a[1]=o=>e.value=!0),onMouseleave:a[2]||(a[2]=o=>e.value=!1)},[p("button",{type:"button",class:"button","aria-haspopup":"true","aria-expanded":e.value,"aria-label":s.label,onClick:a[0]||(a[0]=o=>e.value=!e.value)},[s.button||s.icon?(r(),f("span",Vo,[s.icon?(r(),L(fe(s.icon),{key:0,class:"option-icon"})):y("",!0),s.button?(r(),f("span",{key:1,innerHTML:s.button},null,8,Po)):y("",!0),b(bi,{class:"text-icon"})])):(r(),L(mo,{key:1,class:"icon"}))],8,To),p("div",Io,[b(Eo,{items:s.items},{default:g(()=>[m(s.$slots,"default",{},void 0,!0)]),_:3},8,["items"])])],544))}}),bt=k(Co,[["__scopeId","data-v-9c007e85"]]),No={discord:'Discord',facebook:'Facebook',github:'GitHub',instagram:'Instagram',linkedin:'LinkedIn',mastodon:'Mastodon',slack:'Slack',twitter:'Twitter',x:'X',youtube:'YouTube'},Ao=["href","aria-label","innerHTML"],Mo=w({__name:"VPSocialLink",props:{icon:{},link:{},ariaLabel:{}},setup(n){const e=n,t=V(()=>typeof e.icon=="object"?e.icon.svg:No[e.icon]);return(i,s)=>(r(),f("a",{class:"VPSocialLink no-icon",href:i.link,"aria-label":i.ariaLabel??(typeof i.icon=="string"?i.icon:""),target:"_blank",rel:"noopener",innerHTML:t.value},null,8,Ao))}}),Do=k(Mo,[["__scopeId","data-v-f80f8133"]]),zo={class:"VPSocialLinks"},xo=w({__name:"VPSocialLinks",props:{links:{}},setup(n){return(e,t)=>(r(),f("div",zo,[(r(!0),f(H,null,j(e.links,({link:i,icon:s,ariaLabel:a})=>(r(),L(Do,{key:i,icon:s,link:i,ariaLabel:a},null,8,["icon","link","ariaLabel"]))),128))]))}}),yt=k(xo,[["__scopeId","data-v-7bc22406"]]),Oo={key:0,class:"group translations"},Ho={class:"trans-title"},Bo={key:1,class:"group"},Fo={class:"item appearance"},Ro={class:"label"},Wo={class:"appearance-action"},Yo={key:2,class:"group"},Uo={class:"item social-links"},qo=w({__name:"VPNavBarExtra",setup(n){const{site:e,theme:t}=N(),{localeLinks:i,currentLang:s}=De({correspondingLink:!0}),a=V(()=>i.value.length&&s.value.label||e.value.appearance||t.value.socialLinks);return(o,l)=>a.value?(r(),L(bt,{key:0,class:"VPNavBarExtra",label:"extra navigation"},{default:g(()=>[u(i).length&&u(s).label?(r(),f("div",Oo,[p("p",Ho,D(u(s).label),1),(r(!0),f(H,null,j(u(i),c=>(r(),L(Ze,{key:c.link,item:c},null,8,["item"]))),128))])):y("",!0),u(e).appearance&&u(e).appearance!=="force-dark"?(r(),f("div",Bo,[p("div",Fo,[p("p",Ro,D(u(t).darkModeSwitchLabel||"Appearance"),1),p("div",Wo,[b(gt)])])])):y("",!0),u(t).socialLinks?(r(),f("div",Yo,[p("div",Uo,[b(yt,{class:"social-links-list",links:u(t).socialLinks},null,8,["links"])])])):y("",!0)]),_:1})):y("",!0)}}),jo=k(qo,[["__scopeId","data-v-d0bd9dde"]]),Xo=n=>(se("data-v-e5dd9c1c"),n=n(),ae(),n),Go=["aria-expanded"],Ko=Xo(()=>p("span",{class:"container"},[p("span",{class:"top"}),p("span",{class:"middle"}),p("span",{class:"bottom"})],-1)),Zo=[Ko],Jo=w({__name:"VPNavBarHamburger",props:{active:{type:Boolean}},emits:["click"],setup(n){return(e,t)=>(r(),f("button",{type:"button",class:F(["VPNavBarHamburger",{active:e.active}]),"aria-label":"mobile navigation","aria-expanded":e.active,"aria-controls":"VPNavScreen",onClick:t[0]||(t[0]=i=>e.$emit("click"))},Zo,10,Go))}}),Qo=k(Jo,[["__scopeId","data-v-e5dd9c1c"]]),er=["innerHTML"],tr=w({__name:"VPNavBarMenuLink",props:{item:{}},setup(n){const{page:e}=N();return(t,i)=>(r(),L(ne,{class:F({VPNavBarMenuLink:!0,active:u(pe)(u(e).relativePath,t.item.activeMatch||t.item.link,!!t.item.activeMatch)}),href:t.item.link,target:t.item.target,rel:t.item.rel,tabindex:"0"},{default:g(()=>[p("span",{innerHTML:t.item.text},null,8,er)]),_:1},8,["class","href","target","rel"]))}}),ir=k(tr,[["__scopeId","data-v-42ef59de"]]),nr=w({__name:"VPNavBarMenuGroup",props:{item:{}},setup(n){const e=n,{page:t}=N(),i=a=>"link"in a?pe(t.value.relativePath,a.link,!!e.item.activeMatch):a.items.some(i),s=V(()=>i(e.item));return(a,o)=>(r(),L(bt,{class:F({VPNavBarMenuGroup:!0,active:u(pe)(u(t).relativePath,a.item.activeMatch,!!a.item.activeMatch)||s.value}),button:a.item.text,items:a.item.items},null,8,["class","button","items"]))}}),sr=n=>(se("data-v-7f418b0f"),n=n(),ae(),n),ar={key:0,"aria-labelledby":"main-nav-aria-label",class:"VPNavBarMenu"},or=sr(()=>p("span",{id:"main-nav-aria-label",class:"visually-hidden"},"Main Navigation",-1)),rr=w({__name:"VPNavBarMenu",setup(n){const{theme:e}=N();return(t,i)=>u(e).nav?(r(),f("nav",ar,[or,(r(!0),f(H,null,j(u(e).nav,s=>(r(),f(H,{key:s.text},["link"in s?(r(),L(ir,{key:0,item:s},null,8,["item"])):(r(),L(nr,{key:1,item:s},null,8,["item"]))],64))),128))])):y("",!0)}}),lr=k(rr,[["__scopeId","data-v-7f418b0f"]]);function cr(n){const{localeIndex:e,theme:t}=N();function i(s){var S,$,P;const a=s.split("."),o=(S=t.value.search)==null?void 0:S.options,l=o&&typeof o=="object",c=l&&((P=($=o.locales)==null?void 0:$[e.value])==null?void 0:P.translations)||null,d=l&&o.translations||null;let h=c,v=d,_=n;const E=a.pop();for(const q of a){let R=null;const A=_==null?void 0:_[q];A&&(R=_=A);const X=v==null?void 0:v[q];X&&(R=v=X);const Q=h==null?void 0:h[q];Q&&(R=h=Q),A||(_=R),X||(v=R),Q||(h=R)}return(h==null?void 0:h[E])??(v==null?void 0:v[E])??(_==null?void 0:_[E])??""}return i}const ur=["aria-label"],dr={class:"DocSearch-Button-Container"},hr=p("svg",{class:"DocSearch-Search-Icon",width:"20",height:"20",viewBox:"0 0 20 20","aria-label":"search icon"},[p("path",{d:"M14.386 14.386l4.0877 4.0877-4.0877-4.0877c-2.9418 2.9419-7.7115 2.9419-10.6533 0-2.9419-2.9418-2.9419-7.7115 0-10.6533 2.9418-2.9419 7.7115-2.9419 10.6533 0 2.9419 2.9418 2.9419 7.7115 0 10.6533z",stroke:"currentColor",fill:"none","fill-rule":"evenodd","stroke-linecap":"round","stroke-linejoin":"round"})],-1),fr={class:"DocSearch-Button-Placeholder"},vr=p("span",{class:"DocSearch-Button-Keys"},[p("kbd",{class:"DocSearch-Button-Key"}),p("kbd",{class:"DocSearch-Button-Key"},"K")],-1),Et=w({__name:"VPNavBarSearchButton",setup(n){const t=cr({button:{buttonText:"Search",buttonAriaLabel:"Search"}});return(i,s)=>(r(),f("button",{type:"button",class:"DocSearch DocSearch-Button","aria-label":u(t)("button.buttonAriaLabel")},[p("span",dr,[hr,p("span",fr,D(u(t)("button.buttonText")),1)]),vr],8,ur))}}),pr={class:"VPNavBarSearch"},mr={id:"local-search"},gr={key:1,id:"docsearch"},_r=w({__name:"VPNavBarSearch",setup(n){const e=Di(()=>ci(()=>import("./VPLocalSearchBox.h_vxVhNN.js"),__vite__mapDeps([0,1]))),t=()=>null,{theme:i}=N(),s=z(!1),a=z(!1);le(()=>{});function o(){s.value||(s.value=!0,setTimeout(l,16))}function l(){const v=new Event("keydown");v.key="k",v.metaKey=!0,window.dispatchEvent(v),setTimeout(()=>{document.querySelector(".DocSearch-Modal")||l()},16)}function c(v){const _=v.target,E=_.tagName;return _.isContentEditable||E==="INPUT"||E==="SELECT"||E==="TEXTAREA"}const d=z(!1);nt("k",v=>{(v.ctrlKey||v.metaKey)&&(v.preventDefault(),d.value=!0)}),nt("/",v=>{c(v)||(v.preventDefault(),d.value=!0)});const h="local";return(v,_)=>{var E;return r(),f("div",pr,[u(h)==="local"?(r(),f(H,{key:0},[d.value?(r(),L(u(e),{key:0,onClose:_[0]||(_[0]=S=>d.value=!1)})):y("",!0),p("div",mr,[b(Et,{onClick:_[1]||(_[1]=S=>d.value=!0)})])],64)):u(h)==="algolia"?(r(),f(H,{key:1},[s.value?(r(),L(u(t),{key:0,algolia:((E=u(i).search)==null?void 0:E.options)??u(i).algolia,onVnodeBeforeMount:_[2]||(_[2]=S=>a.value=!0)},null,8,["algolia"])):y("",!0),a.value?y("",!0):(r(),f("div",gr,[b(Et,{onClick:o})]))],64)):y("",!0)])}}}),br=w({__name:"VPNavBarSocialLinks",setup(n){const{theme:e}=N();return(t,i)=>u(e).socialLinks?(r(),L(yt,{key:0,class:"VPNavBarSocialLinks",links:u(e).socialLinks},null,8,["links"])):y("",!0)}}),yr=k(br,[["__scopeId","data-v-0394ad82"]]),wr=["href","rel","target"],kr=w({__name:"VPNavBarTitle",setup(n){const{site:e,theme:t}=N(),{hasSidebar:i}=ce(),{currentLang:s}=De(),a=V(()=>{var c;return typeof t.value.logoLink=="string"?t.value.logoLink:(c=t.value.logoLink)==null?void 0:c.link}),o=V(()=>{var c;return typeof t.value.logoLink=="string"||(c=t.value.logoLink)==null?void 0:c.rel}),l=V(()=>{var c;return typeof t.value.logoLink=="string"||(c=t.value.logoLink)==null?void 0:c.target});return(c,d)=>(r(),f("div",{class:F(["VPNavBarTitle",{"has-sidebar":u(i)}])},[p("a",{class:"title",href:a.value??u(vt)(u(s).link),rel:o.value,target:l.value},[m(c.$slots,"nav-bar-title-before",{},void 0,!0),u(t).logo?(r(),L(qe,{key:0,class:"logo",image:u(t).logo},null,8,["image"])):y("",!0),u(t).siteTitle?(r(),f(H,{key:1},[K(D(u(t).siteTitle),1)],64)):u(t).siteTitle===void 0?(r(),f(H,{key:2},[K(D(u(e).title),1)],64)):y("",!0),m(c.$slots,"nav-bar-title-after",{},void 0,!0)],8,wr)],2))}}),$r=k(kr,[["__scopeId","data-v-8460f0a8"]]),Sr={},Lr={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},Er=p("path",{d:"M0 0h24v24H0z",fill:"none"},null,-1),Tr=p("path",{d:" M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z ",class:"css-c4d79v"},null,-1),Vr=[Er,Tr];function Pr(n,e){return r(),f("svg",Lr,Vr)}const yi=k(Sr,[["render",Pr]]),Ir={class:"items"},Cr={class:"title"},Nr=w({__name:"VPNavBarTranslations",setup(n){const{theme:e}=N(),{localeLinks:t,currentLang:i}=De({correspondingLink:!0});return(s,a)=>u(t).length&&u(i).label?(r(),L(bt,{key:0,class:"VPNavBarTranslations",icon:yi,label:u(e).langMenuLabel||"Change language"},{default:g(()=>[p("div",Ir,[p("p",Cr,D(u(i).label),1),(r(!0),f(H,null,j(u(t),o=>(r(),L(Ze,{key:o.link,item:o},null,8,["item"]))),128))])]),_:1},8,["label"])):y("",!0)}}),Ar=k(Nr,[["__scopeId","data-v-74abcbb9"]]),Mr=n=>(se("data-v-19c990f1"),n=n(),ae(),n),Dr={class:"wrapper"},zr={class:"container"},xr={class:"title"},Or={class:"content"},Hr={class:"content-body"},Br=Mr(()=>p("div",{class:"divider"},[p("div",{class:"divider-line"})],-1)),Fr=w({__name:"VPNavBar",props:{isScreenOpen:{type:Boolean}},emits:["toggle-screen"],setup(n){const{y:e}=li(),{hasSidebar:t}=ce(),{hasLocalNav:i}=pi(),{frontmatter:s}=N(),a=z({});return si(()=>{a.value={"has-sidebar":t.value,"has-local-nav":i.value,top:s.value.layout==="home"&&e.value===0}}),(o,l)=>(r(),f("div",{class:F(["VPNavBar",a.value])},[p("div",Dr,[p("div",zr,[p("div",xr,[b($r,null,{"nav-bar-title-before":g(()=>[m(o.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":g(()=>[m(o.$slots,"nav-bar-title-after",{},void 0,!0)]),_:3})]),p("div",Or,[p("div",Hr,[m(o.$slots,"nav-bar-content-before",{},void 0,!0),b(_r,{class:"search"}),b(lr,{class:"menu"}),b(Ar,{class:"translations"}),b(Qa,{class:"appearance"}),b(yr,{class:"social-links"}),b(jo,{class:"extra"}),m(o.$slots,"nav-bar-content-after",{},void 0,!0),b(Qo,{class:"hamburger",active:o.isScreenOpen,onClick:l[0]||(l[0]=c=>o.$emit("toggle-screen"))},null,8,["active"])])])])]),Br],2))}}),Rr=k(Fr,[["__scopeId","data-v-19c990f1"]]),Wr={key:0,class:"VPNavScreenAppearance"},Yr={class:"text"},Ur=w({__name:"VPNavScreenAppearance",setup(n){const{site:e,theme:t}=N();return(i,s)=>u(e).appearance&&u(e).appearance!=="force-dark"?(r(),f("div",Wr,[p("p",Yr,D(u(t).darkModeSwitchLabel||"Appearance"),1),b(gt)])):y("",!0)}}),qr=k(Ur,[["__scopeId","data-v-2d7af913"]]),jr=w({__name:"VPNavScreenMenuLink",props:{item:{}},setup(n){const e=Ke("close-screen");return(t,i)=>(r(),L(ne,{class:"VPNavScreenMenuLink",href:t.item.link,target:t.item.target,rel:t.item.rel,onClick:u(e)},{default:g(()=>[K(D(t.item.text),1)]),_:1},8,["href","target","rel","onClick"]))}}),Xr=k(jr,[["__scopeId","data-v-05f27b2a"]]),Gr={},Kr={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},Zr=p("path",{d:"M18.9,10.9h-6v-6c0-0.6-0.4-1-1-1s-1,0.4-1,1v6h-6c-0.6,0-1,0.4-1,1s0.4,1,1,1h6v6c0,0.6,0.4,1,1,1s1-0.4,1-1v-6h6c0.6,0,1-0.4,1-1S19.5,10.9,18.9,10.9z"},null,-1),Jr=[Zr];function Qr(n,e){return r(),f("svg",Kr,Jr)}const el=k(Gr,[["render",Qr]]),tl=w({__name:"VPNavScreenMenuGroupLink",props:{item:{}},setup(n){const e=Ke("close-screen");return(t,i)=>(r(),L(ne,{class:"VPNavScreenMenuGroupLink",href:t.item.link,target:t.item.target,rel:t.item.rel,onClick:u(e)},{default:g(()=>[K(D(t.item.text),1)]),_:1},8,["href","target","rel","onClick"]))}}),wi=k(tl,[["__scopeId","data-v-19976ae1"]]),il={class:"VPNavScreenMenuGroupSection"},nl={key:0,class:"title"},sl=w({__name:"VPNavScreenMenuGroupSection",props:{text:{},items:{}},setup(n){return(e,t)=>(r(),f("div",il,[e.text?(r(),f("p",nl,D(e.text),1)):y("",!0),(r(!0),f(H,null,j(e.items,i=>(r(),L(wi,{key:i.text,item:i},null,8,["item"]))),128))]))}}),al=k(sl,[["__scopeId","data-v-8133b170"]]),ol=["aria-controls","aria-expanded"],rl=["innerHTML"],ll=["id"],cl={key:1,class:"group"},ul=w({__name:"VPNavScreenMenuGroup",props:{text:{},items:{}},setup(n){const e=n,t=z(!1),i=V(()=>`NavScreenGroup-${e.text.replace(" ","-").toLowerCase()}`);function s(){t.value=!t.value}return(a,o)=>(r(),f("div",{class:F(["VPNavScreenMenuGroup",{open:t.value}])},[p("button",{class:"button","aria-controls":i.value,"aria-expanded":t.value,onClick:s},[p("span",{class:"button-text",innerHTML:a.text},null,8,rl),b(el,{class:"button-icon"})],8,ol),p("div",{id:i.value,class:"items"},[(r(!0),f(H,null,j(a.items,l=>(r(),f(H,{key:l.text},["link"in l?(r(),f("div",{key:l.text,class:"item"},[b(wi,{item:l},null,8,["item"])])):(r(),f("div",cl,[b(al,{text:l.text,items:l.items},null,8,["text","items"])]))],64))),128))],8,ll)],2))}}),dl=k(ul,[["__scopeId","data-v-65ef89ca"]]),hl={key:0,class:"VPNavScreenMenu"},fl=w({__name:"VPNavScreenMenu",setup(n){const{theme:e}=N();return(t,i)=>u(e).nav?(r(),f("nav",hl,[(r(!0),f(H,null,j(u(e).nav,s=>(r(),f(H,{key:s.text},["link"in s?(r(),L(Xr,{key:0,item:s},null,8,["item"])):(r(),L(dl,{key:1,text:s.text||"",items:s.items},null,8,["text","items"]))],64))),128))])):y("",!0)}}),vl=w({__name:"VPNavScreenSocialLinks",setup(n){const{theme:e}=N();return(t,i)=>u(e).socialLinks?(r(),L(yt,{key:0,class:"VPNavScreenSocialLinks",links:u(e).socialLinks},null,8,["links"])):y("",!0)}}),pl={class:"list"},ml=w({__name:"VPNavScreenTranslations",setup(n){const{localeLinks:e,currentLang:t}=De({correspondingLink:!0}),i=z(!1);function s(){i.value=!i.value}return(a,o)=>u(e).length&&u(t).label?(r(),f("div",{key:0,class:F(["VPNavScreenTranslations",{open:i.value}])},[p("button",{class:"title",onClick:s},[b(yi,{class:"icon lang"}),K(" "+D(u(t).label)+" ",1),b(bi,{class:"icon chevron"})]),p("ul",pl,[(r(!0),f(H,null,j(u(e),l=>(r(),f("li",{key:l.link,class:"item"},[b(ne,{class:"link",href:l.link},{default:g(()=>[K(D(l.text),1)]),_:2},1032,["href"])]))),128))])],2)):y("",!0)}}),gl=k(ml,[["__scopeId","data-v-d72aa483"]]),_l={class:"container"},bl=w({__name:"VPNavScreen",props:{open:{type:Boolean}},setup(n){const e=z(null),t=ui(Te?document.body:null);return(i,s)=>(r(),L(dt,{name:"fade",onEnter:s[0]||(s[0]=a=>t.value=!0),onAfterLeave:s[1]||(s[1]=a=>t.value=!1)},{default:g(()=>[i.open?(r(),f("div",{key:0,class:"VPNavScreen",ref_key:"screen",ref:e,id:"VPNavScreen"},[p("div",_l,[m(i.$slots,"nav-screen-content-before",{},void 0,!0),b(fl,{class:"menu"}),b(gl,{class:"translations"}),b(qr,{class:"appearance"}),b(vl,{class:"social-links"}),m(i.$slots,"nav-screen-content-after",{},void 0,!0)])],512)):y("",!0)]),_:3}))}}),yl=k(bl,[["__scopeId","data-v-cc5739dd"]]),wl={key:0,class:"VPNav"},kl=w({__name:"VPNav",setup(n){const{isScreenOpen:e,closeScreen:t,toggleScreen:i}=Ca(),{frontmatter:s}=N(),a=V(()=>s.value.navbar!==!1);return di("close-screen",t),Xe(()=>{Te&&document.documentElement.classList.toggle("hide-nav",!a.value)}),(o,l)=>a.value?(r(),f("header",wl,[b(Rr,{"is-screen-open":u(e),onToggleScreen:u(i)},{"nav-bar-title-before":g(()=>[m(o.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":g(()=>[m(o.$slots,"nav-bar-title-after",{},void 0,!0)]),"nav-bar-content-before":g(()=>[m(o.$slots,"nav-bar-content-before",{},void 0,!0)]),"nav-bar-content-after":g(()=>[m(o.$slots,"nav-bar-content-after",{},void 0,!0)]),_:3},8,["is-screen-open","onToggleScreen"]),b(yl,{open:u(e)},{"nav-screen-content-before":g(()=>[m(o.$slots,"nav-screen-content-before",{},void 0,!0)]),"nav-screen-content-after":g(()=>[m(o.$slots,"nav-screen-content-after",{},void 0,!0)]),_:3},8,["open"])])):y("",!0)}}),$l=k(kl,[["__scopeId","data-v-ae24b3ad"]]),Sl=n=>(se("data-v-e31bd47b"),n=n(),ae(),n),Ll=["role","tabindex"],El=Sl(()=>p("div",{class:"indicator"},null,-1)),Tl={key:1,class:"items"},Vl=w({__name:"VPSidebarItem",props:{item:{},depth:{}},setup(n){const e=n,{collapsed:t,collapsible:i,isLink:s,isActiveLink:a,hasActiveLink:o,hasChildren:l,toggle:c}=on(V(()=>e.item)),d=V(()=>l.value?"section":"div"),h=V(()=>s.value?"a":"div"),v=V(()=>l.value?e.depth+2===7?"p":`h${e.depth+2}`:"p"),_=V(()=>s.value?void 0:"button"),E=V(()=>[[`level-${e.depth}`],{collapsible:i.value},{collapsed:t.value},{"is-link":s.value},{"is-active":a.value},{"has-active":o.value}]);function S(P){"key"in P&&P.key!=="Enter"||!e.item.link&&c()}function $(){e.item.link&&c()}return(P,q)=>{const R=me("VPSidebarItem",!0);return r(),L(fe(d.value),{class:F(["VPSidebarItem",E.value])},{default:g(()=>[P.item.text?(r(),f("div",Be({key:0,class:"item",role:_.value},xi(P.item.items?{click:S,keydown:S}:{},!0),{tabindex:P.item.items&&0}),[El,P.item.link?(r(),L(ne,{key:0,tag:h.value,class:"link",href:P.item.link,rel:P.item.rel,target:P.item.target},{default:g(()=>[(r(),L(fe(v.value),{class:"text",innerHTML:P.item.text},null,8,["innerHTML"]))]),_:1},8,["tag","href","rel","target"])):(r(),L(fe(v.value),{key:1,class:"text",innerHTML:P.item.text},null,8,["innerHTML"])),P.item.collapsed!=null?(r(),f("div",{key:2,class:"caret",role:"button","aria-label":"toggle section",onClick:$,onKeydown:zi($,["enter"]),tabindex:"0"},[b(mi,{class:"caret-icon"})],32)):y("",!0)],16,Ll)):y("",!0),P.item.items&&P.item.items.length?(r(),f("div",Tl,[P.depth<5?(r(!0),f(H,{key:0},j(P.item.items,A=>(r(),L(R,{key:A.text,item:A,depth:P.depth+1},null,8,["item","depth"]))),128)):y("",!0)])):y("",!0)]),_:1},8,["class"])}}}),Pl=k(Vl,[["__scopeId","data-v-e31bd47b"]]),ki=n=>(se("data-v-575e6a36"),n=n(),ae(),n),Il=ki(()=>p("div",{class:"curtain"},null,-1)),Cl={class:"nav",id:"VPSidebarNav","aria-labelledby":"sidebar-aria-label",tabindex:"-1"},Nl=ki(()=>p("span",{class:"visually-hidden",id:"sidebar-aria-label"}," Sidebar Navigation ",-1)),Al=w({__name:"VPSidebar",props:{open:{type:Boolean}},setup(n){const{sidebarGroups:e,hasSidebar:t}=ce(),i=n,s=z(null),a=ui(Te?document.body:null);return ue([i,s],()=>{var o;i.open?(a.value=!0,(o=s.value)==null||o.focus()):a.value=!1},{immediate:!0,flush:"post"}),(o,l)=>u(t)?(r(),f("aside",{key:0,class:F(["VPSidebar",{open:o.open}]),ref_key:"navEl",ref:s,onClick:l[0]||(l[0]=Oi(()=>{},["stop"]))},[Il,p("nav",Cl,[Nl,m(o.$slots,"sidebar-nav-before",{},void 0,!0),(r(!0),f(H,null,j(u(e),c=>(r(),f("div",{key:c.text,class:"group"},[b(Pl,{item:c,depth:0},null,8,["item"])]))),128)),m(o.$slots,"sidebar-nav-after",{},void 0,!0)])],2)):y("",!0)}}),Ml=k(Al,[["__scopeId","data-v-575e6a36"]]),Dl=w({__name:"VPSkipLink",setup(n){const e=Ve(),t=z();ue(()=>e.path,()=>t.value.focus());function i({target:s}){const a=document.getElementById(decodeURIComponent(s.hash).slice(1));if(a){const o=()=>{a.removeAttribute("tabindex"),a.removeEventListener("blur",o)};a.setAttribute("tabindex","-1"),a.addEventListener("blur",o),a.focus(),window.scrollTo(0,0)}}return(s,a)=>(r(),f(H,null,[p("span",{ref_key:"backToTop",ref:t,tabindex:"-1"},null,512),p("a",{href:"#VPContent",class:"VPSkipLink visually-hidden",onClick:i}," Skip to content ")],64))}}),zl=k(Dl,[["__scopeId","data-v-0f60ec36"]]),xl=w({__name:"Layout",setup(n){const{isOpen:e,open:t,close:i}=ce(),s=Ve();ue(()=>s.path,i),an(e,i);const{frontmatter:a}=N(),o=Hi(),l=V(()=>!!o["home-hero-image"]);return di("hero-image-slot-exists",l),(c,d)=>{const h=me("Content");return u(a).layout!==!1?(r(),f("div",{key:0,class:F(["Layout",u(a).pageClass])},[m(c.$slots,"layout-top",{},void 0,!0),b(zl),b(Wi,{class:"backdrop",show:u(e),onClick:u(i)},null,8,["show","onClick"]),b($l,null,{"nav-bar-title-before":g(()=>[m(c.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":g(()=>[m(c.$slots,"nav-bar-title-after",{},void 0,!0)]),"nav-bar-content-before":g(()=>[m(c.$slots,"nav-bar-content-before",{},void 0,!0)]),"nav-bar-content-after":g(()=>[m(c.$slots,"nav-bar-content-after",{},void 0,!0)]),"nav-screen-content-before":g(()=>[m(c.$slots,"nav-screen-content-before",{},void 0,!0)]),"nav-screen-content-after":g(()=>[m(c.$slots,"nav-screen-content-after",{},void 0,!0)]),_:3}),b(Ia,{open:u(e),onOpenMenu:u(t)},null,8,["open","onOpenMenu"]),b(Ml,{open:u(e)},{"sidebar-nav-before":g(()=>[m(c.$slots,"sidebar-nav-before",{},void 0,!0)]),"sidebar-nav-after":g(()=>[m(c.$slots,"sidebar-nav-after",{},void 0,!0)]),_:3},8,["open"]),b(ia,null,{"page-top":g(()=>[m(c.$slots,"page-top",{},void 0,!0)]),"page-bottom":g(()=>[m(c.$slots,"page-bottom",{},void 0,!0)]),"not-found":g(()=>[m(c.$slots,"not-found",{},void 0,!0)]),"home-hero-before":g(()=>[m(c.$slots,"home-hero-before",{},void 0,!0)]),"home-hero-info":g(()=>[m(c.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-image":g(()=>[m(c.$slots,"home-hero-image",{},void 0,!0)]),"home-hero-after":g(()=>[m(c.$slots,"home-hero-after",{},void 0,!0)]),"home-features-before":g(()=>[m(c.$slots,"home-features-before",{},void 0,!0)]),"home-features-after":g(()=>[m(c.$slots,"home-features-after",{},void 0,!0)]),"doc-footer-before":g(()=>[m(c.$slots,"doc-footer-before",{},void 0,!0)]),"doc-before":g(()=>[m(c.$slots,"doc-before",{},void 0,!0)]),"doc-after":g(()=>[m(c.$slots,"doc-after",{},void 0,!0)]),"doc-top":g(()=>[m(c.$slots,"doc-top",{},void 0,!0)]),"doc-bottom":g(()=>[m(c.$slots,"doc-bottom",{},void 0,!0)]),"aside-top":g(()=>[m(c.$slots,"aside-top",{},void 0,!0)]),"aside-bottom":g(()=>[m(c.$slots,"aside-bottom",{},void 0,!0)]),"aside-outline-before":g(()=>[m(c.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":g(()=>[m(c.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":g(()=>[m(c.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":g(()=>[m(c.$slots,"aside-ads-after",{},void 0,!0)]),_:3}),b(ra),m(c.$slots,"layout-bottom",{},void 0,!0)],2)):(r(),L(h,{key:1}))}}}),Ol=k(xl,[["__scopeId","data-v-5a346dfe"]]),et={Layout:Ol,enhanceApp:({app:n})=>{n.component("Badge",Bi)}};/*!
+import{d as w,o as r,c as f,r as m,n as F,a as K,t as D,b as L,w as g,T as dt,e as y,_ as k,u as ni,i as Vi,f as Pi,g as ht,h as z,j as Te,k as V,l as le,m as p,p as u,q as se,s as ae,v as pe,x as it,y as ue,z as Xe,A as ft,B as si,C as Ii,D as me,F as H,E as j,G as ai,H as Ge,I as b,J as fe,K as oi,L as Ve,M as Be,N as Ke,O as Ci,P as nt,Q as Ni,R as ri,S as li,U as Ai,V as Mi,W as Di,X as ci,Y as ui,Z as di,$ as zi,a0 as xi,a1 as Oi,a2 as Hi,a3 as Ue}from"./framework.iEE2KsGo.js";const Bi=w({__name:"VPBadge",props:{text:{},type:{default:"tip"}},setup(n){return(e,t)=>(r(),f("span",{class:F(["VPBadge",e.type])},[m(e.$slots,"default",{},()=>[K(D(e.text),1)])],2))}}),Fi={key:0,class:"VPBackdrop"},Ri=w({__name:"VPBackdrop",props:{show:{type:Boolean}},setup(n){return(e,t)=>(r(),L(dt,{name:"fade"},{default:g(()=>[e.show?(r(),f("div",Fi)):y("",!0)]),_:1}))}}),Wi=k(Ri,[["__scopeId","data-v-c79a1216"]]),N=ni;function Yi(n,e){let t,i=!1;return()=>{t&&clearTimeout(t),i?t=setTimeout(n,e):(n(),(i=!0)&&setTimeout(()=>i=!1,e))}}function st(n){return/^\//.test(n)?n:`/${n}`}function vt(n){const{pathname:e,search:t,hash:i,protocol:s}=new URL(n,"http://a.com");if(Vi(n)||n.startsWith("#")||!s.startsWith("http")||!Pi(e))return n;const{site:a}=N(),o=e.endsWith("/")||e.endsWith(".html")?n:n.replace(/(?:(^\.+)\/)?.*$/,`$1${e.replace(/(\.md)?$/,a.value.cleanUrls?"":".html")}${t}${i}`);return ht(o)}const pt=z(Te?location.hash:"");Te&&window.addEventListener("hashchange",()=>{pt.value=location.hash});function De({removeCurrent:n=!0,correspondingLink:e=!1}={}){const{site:t,localeIndex:i,page:s,theme:a}=N(),o=V(()=>{var c,d;return{label:(c=t.value.locales[i.value])==null?void 0:c.label,link:((d=t.value.locales[i.value])==null?void 0:d.link)||(i.value==="root"?"/":`/${i.value}/`)}});return{localeLinks:V(()=>Object.entries(t.value.locales).flatMap(([c,d])=>n&&o.value.label===d.label?[]:{text:d.label,link:Ui(d.link||(c==="root"?"/":`/${c}/`),a.value.i18nRouting!==!1&&e,s.value.relativePath.slice(o.value.link.length-1),!t.value.cleanUrls)+pt.value})),currentLang:o}}function Ui(n,e,t,i){return e?n.replace(/\/$/,"")+st(t.replace(/(^|\/)index\.md$/,"$1").replace(/\.md$/,i?".html":"")):n}const qi=n=>(se("data-v-f87ff6e4"),n=n(),ae(),n),ji={class:"NotFound"},Xi={class:"code"},Gi={class:"title"},Ki=qi(()=>p("div",{class:"divider"},null,-1)),Zi={class:"quote"},Ji={class:"action"},Qi=["href","aria-label"],en=w({__name:"NotFound",setup(n){const{site:e,theme:t}=N(),{localeLinks:i}=De({removeCurrent:!1}),s=z("/");return le(()=>{var o;const a=window.location.pathname.replace(e.value.base,"").replace(/(^.*?\/).*$/,"/$1");i.value.length&&(s.value=((o=i.value.find(({link:l})=>l.startsWith(a)))==null?void 0:o.link)||i.value[0].link)}),(a,o)=>{var l,c,d,h,v;return r(),f("div",ji,[p("p",Xi,D(((l=u(t).notFound)==null?void 0:l.code)??"404"),1),p("h1",Gi,D(((c=u(t).notFound)==null?void 0:c.title)??"PAGE NOT FOUND"),1),Ki,p("blockquote",Zi,D(((d=u(t).notFound)==null?void 0:d.quote)??"But if you don't change your direction, and if you keep looking, you may end up where you are heading."),1),p("div",Ji,[p("a",{class:"link",href:u(ht)(s.value),"aria-label":((h=u(t).notFound)==null?void 0:h.linkLabel)??"go to home"},D(((v=u(t).notFound)==null?void 0:v.linkText)??"Take me home"),9,Qi)])])}}}),tn=k(en,[["__scopeId","data-v-f87ff6e4"]]);function hi(n,e){if(Array.isArray(n))return Fe(n);if(n==null)return[];e=st(e);const t=Object.keys(n).sort((s,a)=>a.split("/").length-s.split("/").length).find(s=>e.startsWith(st(s))),i=t?n[t]:[];return Array.isArray(i)?Fe(i):Fe(i.items,i.base)}function nn(n){const e=[];let t=0;for(const i in n){const s=n[i];if(s.items){t=e.push(s);continue}e[t]||e.push({items:[]}),e[t].items.push(s)}return e}function sn(n){const e=[];function t(i){for(const s of i)s.text&&s.link&&e.push({text:s.text,link:s.link,docFooterText:s.docFooterText}),s.items&&t(s.items)}return t(n),e}function at(n,e){return Array.isArray(e)?e.some(t=>at(n,t)):pe(n,e.link)?!0:e.items?at(n,e.items):!1}function Fe(n,e){return[...n].map(t=>{const i={...t},s=i.base||e;return s&&i.link&&(i.link=s+i.link),i.items&&(i.items=Fe(i.items,s)),i})}function ce(){const{frontmatter:n,page:e,theme:t}=N(),i=it("(min-width: 960px)"),s=z(!1),a=V(()=>{const $=t.value.sidebar,P=e.value.relativePath;return $?hi($,P):[]}),o=z(a.value);ue(a,($,P)=>{JSON.stringify($)!==JSON.stringify(P)&&(o.value=a.value)});const l=V(()=>n.value.sidebar!==!1&&o.value.length>0&&n.value.layout!=="home"),c=V(()=>d?n.value.aside==null?t.value.aside==="left":n.value.aside==="left":!1),d=V(()=>n.value.layout==="home"?!1:n.value.aside!=null?!!n.value.aside:t.value.aside!==!1),h=V(()=>l.value&&i.value),v=V(()=>l.value?nn(o.value):[]);function _(){s.value=!0}function E(){s.value=!1}function S(){s.value?E():_()}return{isOpen:s,sidebar:o,sidebarGroups:v,hasSidebar:l,hasAside:d,leftAside:c,isSidebarEnabled:h,open:_,close:E,toggle:S}}function an(n,e){let t;Xe(()=>{t=n.value?document.activeElement:void 0}),le(()=>{window.addEventListener("keyup",i)}),ft(()=>{window.removeEventListener("keyup",i)});function i(s){s.key==="Escape"&&n.value&&(e(),t==null||t.focus())}}function on(n){const{page:e}=N(),t=z(!1),i=V(()=>n.value.collapsed!=null),s=V(()=>!!n.value.link),a=z(!1),o=()=>{a.value=pe(e.value.relativePath,n.value.link)};ue([e,n,pt],o),le(o);const l=V(()=>a.value?!0:n.value.items?at(e.value.relativePath,n.value.items):!1),c=V(()=>!!(n.value.items&&n.value.items.length));Xe(()=>{t.value=!!(i.value&&n.value.collapsed)}),si(()=>{(a.value||l.value)&&(t.value=!1)});function d(){i.value&&(t.value=!t.value)}return{collapsed:t,collapsible:i,isLink:s,isActiveLink:a,hasActiveLink:l,hasChildren:c,toggle:d}}function rn(){const{hasSidebar:n}=ce(),e=it("(min-width: 960px)"),t=it("(min-width: 1280px)");return{isAsideEnabled:V(()=>!t.value&&!e.value?!1:n.value?t.value:e.value)}}const ot=[];function fi(n){return typeof n.outline=="object"&&!Array.isArray(n.outline)&&n.outline.label||n.outlineTitle||"On this page"}function mt(n){const e=[...document.querySelectorAll(".VPDoc :where(h1,h2,h3,h4,h5,h6)")].filter(t=>t.id&&t.hasChildNodes()).map(t=>{const i=Number(t.tagName[1]);return{element:t,title:ln(t),link:"#"+t.id,level:i}});return cn(e,n)}function ln(n){let e="";for(const t of n.childNodes)if(t.nodeType===1){if(t.classList.contains("VPBadge")||t.classList.contains("header-anchor")||t.classList.contains("ignore-header"))continue;e+=t.textContent}else t.nodeType===3&&(e+=t.textContent);return e.trim()}function cn(n,e){if(e===!1)return[];const t=(typeof e=="object"&&!Array.isArray(e)?e.level:e)||2,[i,s]=typeof t=="number"?[t,t]:t==="deep"?[2,6]:t;n=n.filter(o=>o.level>=i&&o.level<=s),ot.length=0;for(const{element:o,link:l}of n)ot.push({element:o,link:l});const a=[];e:for(let o=0;o=0;c--){const d=n[c];if(d.level{requestAnimationFrame(a),window.addEventListener("scroll",i)}),Ii(()=>{o(location.hash)}),ft(()=>{window.removeEventListener("scroll",i)});function a(){if(!t.value)return;const l=(()=>{var $;const S=($=document.querySelector("#VPContent .VPDoc"))==null?void 0:$.firstElementChild;return S?Lt(S):78})(),c=window.scrollY,d=window.innerHeight,h=document.body.offsetHeight,v=Math.abs(c+d-h)<1,_=ot.map(({element:S,link:$})=>({link:$,top:Lt(S)})).filter(({top:S})=>!Number.isNaN(S)).sort((S,$)=>S.top-$.top);if(!_.length){o(null);return}if(c<1){o(null);return}if(v){o(_[_.length-1].link);return}let E=null;for(const{link:S,top:$}of _){if($>c+l)break;E=S}o(E)}function o(l){s&&s.classList.remove("active"),l==null?s=null:s=n.value.querySelector(`a[href="${decodeURIComponent(l)}"]`);const c=s;c?(c.classList.add("active"),e.value.style.top=c.offsetTop+39+"px",e.value.style.opacity="1"):(e.value.style.top="33px",e.value.style.opacity="0")}}function Lt(n){let e=0;for(;n!==document.body;){if(n===null)return NaN;e+=n.offsetTop,n=n.offsetParent}return e}const dn=["href","title"],hn=w({__name:"VPDocOutlineItem",props:{headers:{},root:{type:Boolean}},setup(n){function e({target:t}){const i=t.href.split("#")[1],s=document.getElementById(decodeURIComponent(i));s==null||s.focus({preventScroll:!0})}return(t,i)=>{const s=me("VPDocOutlineItem",!0);return r(),f("ul",{class:F(["VPDocOutlineItem",t.root?"root":"nested"])},[(r(!0),f(H,null,j(t.headers,({children:a,link:o,title:l})=>(r(),f("li",null,[p("a",{class:"outline-link",href:o,onClick:e,title:l},D(l),9,dn),a!=null&&a.length?(r(),L(s,{key:0,headers:a},null,8,["headers"])):y("",!0)]))),256))],2)}}}),vi=k(hn,[["__scopeId","data-v-b933a997"]]),fn=n=>(se("data-v-935f8a84"),n=n(),ae(),n),vn={class:"content"},pn={class:"outline-title",role:"heading","aria-level":"2"},mn={"aria-labelledby":"doc-outline-aria-label"},gn=fn(()=>p("span",{class:"visually-hidden",id:"doc-outline-aria-label"}," Table of Contents for current page ",-1)),_n=w({__name:"VPDocAsideOutline",setup(n){const{frontmatter:e,theme:t}=N(),i=ai([]);Ge(()=>{i.value=mt(e.value.outline??t.value.outline)});const s=z(),a=z();return un(s,a),(o,l)=>(r(),f("div",{class:F(["VPDocAsideOutline",{"has-outline":i.value.length>0}]),ref_key:"container",ref:s,role:"navigation"},[p("div",vn,[p("div",{class:"outline-marker",ref_key:"marker",ref:a},null,512),p("div",pn,D(u(fi)(u(t))),1),p("nav",mn,[gn,b(vi,{headers:i.value,root:!0},null,8,["headers"])])])],2))}}),bn=k(_n,[["__scopeId","data-v-935f8a84"]]),yn={class:"VPDocAsideCarbonAds"},wn=w({__name:"VPDocAsideCarbonAds",props:{carbonAds:{}},setup(n){const e=()=>null;return(t,i)=>(r(),f("div",yn,[b(u(e),{"carbon-ads":t.carbonAds},null,8,["carbon-ads"])]))}}),kn=n=>(se("data-v-3f215769"),n=n(),ae(),n),$n={class:"VPDocAside"},Sn=kn(()=>p("div",{class:"spacer"},null,-1)),Ln=w({__name:"VPDocAside",setup(n){const{theme:e}=N();return(t,i)=>(r(),f("div",$n,[m(t.$slots,"aside-top",{},void 0,!0),m(t.$slots,"aside-outline-before",{},void 0,!0),b(bn),m(t.$slots,"aside-outline-after",{},void 0,!0),Sn,m(t.$slots,"aside-ads-before",{},void 0,!0),u(e).carbonAds?(r(),L(wn,{key:0,"carbon-ads":u(e).carbonAds},null,8,["carbon-ads"])):y("",!0),m(t.$slots,"aside-ads-after",{},void 0,!0),m(t.$slots,"aside-bottom",{},void 0,!0)]))}}),En=k(Ln,[["__scopeId","data-v-3f215769"]]);function Tn(){const{theme:n,page:e}=N();return V(()=>{const{text:t="Edit this page",pattern:i=""}=n.value.editLink||{};let s;return typeof i=="function"?s=i(e.value):s=i.replace(/:path/g,e.value.filePath),{url:s,text:t}})}function Vn(){const{page:n,theme:e,frontmatter:t}=N();return V(()=>{var c,d,h,v,_,E,S,$;const i=hi(e.value.sidebar,n.value.relativePath),s=sn(i),a=s.findIndex(P=>pe(n.value.relativePath,P.link)),o=((c=e.value.docFooter)==null?void 0:c.prev)===!1&&!t.value.prev||t.value.prev===!1,l=((d=e.value.docFooter)==null?void 0:d.next)===!1&&!t.value.next||t.value.next===!1;return{prev:o?void 0:{text:(typeof t.value.prev=="string"?t.value.prev:typeof t.value.prev=="object"?t.value.prev.text:void 0)??((h=s[a-1])==null?void 0:h.docFooterText)??((v=s[a-1])==null?void 0:v.text),link:(typeof t.value.prev=="object"?t.value.prev.link:void 0)??((_=s[a-1])==null?void 0:_.link)},next:l?void 0:{text:(typeof t.value.next=="string"?t.value.next:typeof t.value.next=="object"?t.value.next.text:void 0)??((E=s[a+1])==null?void 0:E.docFooterText)??((S=s[a+1])==null?void 0:S.text),link:(typeof t.value.next=="object"?t.value.next.link:void 0)??(($=s[a+1])==null?void 0:$.link)}}})}const Pn={},In={xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24"},Cn=p("path",{d:"M18,23H4c-1.7,0-3-1.3-3-3V6c0-1.7,1.3-3,3-3h7c0.6,0,1,0.4,1,1s-0.4,1-1,1H4C3.4,5,3,5.4,3,6v14c0,0.6,0.4,1,1,1h14c0.6,0,1-0.4,1-1v-7c0-0.6,0.4-1,1-1s1,0.4,1,1v7C21,21.7,19.7,23,18,23z"},null,-1),Nn=p("path",{d:"M8,17c-0.3,0-0.5-0.1-0.7-0.3C7,16.5,6.9,16.1,7,15.8l1-4c0-0.2,0.1-0.3,0.3-0.5l9.5-9.5c1.2-1.2,3.2-1.2,4.4,0c1.2,1.2,1.2,3.2,0,4.4l-9.5,9.5c-0.1,0.1-0.3,0.2-0.5,0.3l-4,1C8.2,17,8.1,17,8,17zM9.9,12.5l-0.5,2.1l2.1-0.5l9.3-9.3c0.4-0.4,0.4-1.1,0-1.6c-0.4-0.4-1.2-0.4-1.6,0l0,0L9.9,12.5z M18.5,2.5L18.5,2.5L18.5,2.5z"},null,-1),An=[Cn,Nn];function Mn(n,e){return r(),f("svg",In,An)}const Dn=k(Pn,[["render",Mn]]),ne=w({__name:"VPLink",props:{tag:{},href:{},noIcon:{type:Boolean},target:{},rel:{}},setup(n){const e=n,t=V(()=>e.tag??(e.href?"a":"span")),i=V(()=>e.href&&oi.test(e.href));return(s,a)=>(r(),L(fe(t.value),{class:F(["VPLink",{link:s.href,"vp-external-link-icon":i.value,"no-icon":s.noIcon}]),href:s.href?u(vt)(s.href):void 0,target:s.target??(i.value?"_blank":void 0),rel:s.rel??(i.value?"noreferrer":void 0)},{default:g(()=>[m(s.$slots,"default")]),_:3},8,["class","href","target","rel"]))}}),zn={class:"VPLastUpdated"},xn=["datetime"],On=w({__name:"VPDocFooterLastUpdated",setup(n){const{theme:e,page:t,frontmatter:i,lang:s}=N(),a=V(()=>new Date(i.value.lastUpdated??t.value.lastUpdated)),o=V(()=>a.value.toISOString()),l=z("");return le(()=>{Xe(()=>{var c,d,h;l.value=new Intl.DateTimeFormat((d=(c=e.value.lastUpdated)==null?void 0:c.formatOptions)!=null&&d.forceLocale?s.value:void 0,((h=e.value.lastUpdated)==null?void 0:h.formatOptions)??{dateStyle:"short",timeStyle:"short"}).format(a.value)})}),(c,d)=>{var h;return r(),f("p",zn,[K(D(((h=u(e).lastUpdated)==null?void 0:h.text)||u(e).lastUpdatedText||"Last updated")+": ",1),p("time",{datetime:o.value},D(l.value),9,xn)])}}}),Hn=k(On,[["__scopeId","data-v-7e05ebdb"]]),Bn={key:0,class:"VPDocFooter"},Fn={key:0,class:"edit-info"},Rn={key:0,class:"edit-link"},Wn={key:1,class:"last-updated"},Yn={key:1,class:"prev-next"},Un={class:"pager"},qn=["innerHTML"],jn=["innerHTML"],Xn={class:"pager"},Gn=["innerHTML"],Kn=["innerHTML"],Zn=w({__name:"VPDocFooter",setup(n){const{theme:e,page:t,frontmatter:i}=N(),s=Tn(),a=Vn(),o=V(()=>e.value.editLink&&i.value.editLink!==!1),l=V(()=>t.value.lastUpdated&&i.value.lastUpdated!==!1),c=V(()=>o.value||l.value||a.value.prev||a.value.next);return(d,h)=>{var v,_,E,S;return c.value?(r(),f("footer",Bn,[m(d.$slots,"doc-footer-before",{},void 0,!0),o.value||l.value?(r(),f("div",Fn,[o.value?(r(),f("div",Rn,[b(ne,{class:"edit-link-button",href:u(s).url,"no-icon":!0},{default:g(()=>[b(Dn,{class:"edit-link-icon","aria-label":"edit icon"}),K(" "+D(u(s).text),1)]),_:1},8,["href"])])):y("",!0),l.value?(r(),f("div",Wn,[b(Hn)])):y("",!0)])):y("",!0),(v=u(a).prev)!=null&&v.link||(_=u(a).next)!=null&&_.link?(r(),f("nav",Yn,[p("div",Un,[(E=u(a).prev)!=null&&E.link?(r(),L(ne,{key:0,class:"pager-link prev",href:u(a).prev.link},{default:g(()=>{var $;return[p("span",{class:"desc",innerHTML:(($=u(e).docFooter)==null?void 0:$.prev)||"Previous page"},null,8,qn),p("span",{class:"title",innerHTML:u(a).prev.text},null,8,jn)]}),_:1},8,["href"])):y("",!0)]),p("div",Xn,[(S=u(a).next)!=null&&S.link?(r(),L(ne,{key:0,class:"pager-link next",href:u(a).next.link},{default:g(()=>{var $;return[p("span",{class:"desc",innerHTML:(($=u(e).docFooter)==null?void 0:$.next)||"Next page"},null,8,Gn),p("span",{class:"title",innerHTML:u(a).next.text},null,8,Kn)]}),_:1},8,["href"])):y("",!0)])])):y("",!0)])):y("",!0)}}}),Jn=k(Zn,[["__scopeId","data-v-48f9bb55"]]),Qn=n=>(se("data-v-39a288b8"),n=n(),ae(),n),es={class:"container"},ts=Qn(()=>p("div",{class:"aside-curtain"},null,-1)),is={class:"aside-container"},ns={class:"aside-content"},ss={class:"content"},as={class:"content-container"},os={class:"main"},rs=w({__name:"VPDoc",setup(n){const{theme:e}=N(),t=Ve(),{hasSidebar:i,hasAside:s,leftAside:a}=ce(),o=V(()=>t.path.replace(/[./]+/g,"_").replace(/_html$/,""));return(l,c)=>{const d=me("Content");return r(),f("div",{class:F(["VPDoc",{"has-sidebar":u(i),"has-aside":u(s)}])},[m(l.$slots,"doc-top",{},void 0,!0),p("div",es,[u(s)?(r(),f("div",{key:0,class:F(["aside",{"left-aside":u(a)}])},[ts,p("div",is,[p("div",ns,[b(En,null,{"aside-top":g(()=>[m(l.$slots,"aside-top",{},void 0,!0)]),"aside-bottom":g(()=>[m(l.$slots,"aside-bottom",{},void 0,!0)]),"aside-outline-before":g(()=>[m(l.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":g(()=>[m(l.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":g(()=>[m(l.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":g(()=>[m(l.$slots,"aside-ads-after",{},void 0,!0)]),_:3})])])],2)):y("",!0),p("div",ss,[p("div",as,[m(l.$slots,"doc-before",{},void 0,!0),p("main",os,[b(d,{class:F(["vp-doc",[o.value,u(e).externalLinkIcon&&"external-link-icon-enabled"]])},null,8,["class"])]),b(Jn,null,{"doc-footer-before":g(()=>[m(l.$slots,"doc-footer-before",{},void 0,!0)]),_:3}),m(l.$slots,"doc-after",{},void 0,!0)])])]),m(l.$slots,"doc-bottom",{},void 0,!0)],2)}}}),ls=k(rs,[["__scopeId","data-v-39a288b8"]]),cs=w({__name:"VPButton",props:{tag:{},size:{default:"medium"},theme:{default:"brand"},text:{},href:{}},setup(n){const e=n,t=V(()=>e.href&&oi.test(e.href)),i=V(()=>e.tag||e.href?"a":"button");return(s,a)=>(r(),L(fe(i.value),{class:F(["VPButton",[s.size,s.theme]]),href:s.href?u(vt)(s.href):void 0,target:t.value?"_blank":void 0,rel:t.value?"noreferrer":void 0},{default:g(()=>[K(D(s.text),1)]),_:1},8,["class","href","target","rel"]))}}),us=k(cs,[["__scopeId","data-v-c1c5efc1"]]),ds=["src","alt"],hs=w({inheritAttrs:!1,__name:"VPImage",props:{image:{},alt:{}},setup(n){return(e,t)=>{const i=me("VPImage",!0);return e.image?(r(),f(H,{key:0},[typeof e.image=="string"||"src"in e.image?(r(),f("img",Be({key:0,class:"VPImage"},typeof e.image=="string"?e.$attrs:{...e.image,...e.$attrs},{src:u(ht)(typeof e.image=="string"?e.image:e.image.src),alt:e.alt??(typeof e.image=="string"?"":e.image.alt||"")}),null,16,ds)):(r(),f(H,{key:1},[b(i,Be({class:"dark",image:e.image.dark,alt:e.image.alt},e.$attrs),null,16,["image","alt"]),b(i,Be({class:"light",image:e.image.light,alt:e.image.alt},e.$attrs),null,16,["image","alt"])],64))],64)):y("",!0)}}}),qe=k(hs,[["__scopeId","data-v-8426fc1a"]]),fs=n=>(se("data-v-da5d1713"),n=n(),ae(),n),vs={class:"container"},ps={class:"main"},ms={key:0,class:"name"},gs=["innerHTML"],_s=["innerHTML"],bs=["innerHTML"],ys={key:0,class:"actions"},ws={key:0,class:"image"},ks={class:"image-container"},$s=fs(()=>p("div",{class:"image-bg"},null,-1)),Ss=w({__name:"VPHero",props:{name:{},text:{},tagline:{},image:{},actions:{}},setup(n){const e=Ke("hero-image-slot-exists");return(t,i)=>(r(),f("div",{class:F(["VPHero",{"has-image":t.image||u(e)}])},[p("div",vs,[p("div",ps,[m(t.$slots,"home-hero-info",{},()=>[t.name?(r(),f("h1",ms,[p("span",{innerHTML:t.name,class:"clip"},null,8,gs)])):y("",!0),t.text?(r(),f("p",{key:1,innerHTML:t.text,class:"text"},null,8,_s)):y("",!0),t.tagline?(r(),f("p",{key:2,innerHTML:t.tagline,class:"tagline"},null,8,bs)):y("",!0)],!0),t.actions?(r(),f("div",ys,[(r(!0),f(H,null,j(t.actions,s=>(r(),f("div",{key:s.link,class:"action"},[b(us,{tag:"a",size:"medium",theme:s.theme,text:s.text,href:s.link},null,8,["theme","text","href"])]))),128))])):y("",!0)]),t.image||u(e)?(r(),f("div",ws,[p("div",ks,[$s,m(t.$slots,"home-hero-image",{},()=>[t.image?(r(),L(qe,{key:0,class:"image-src",image:t.image},null,8,["image"])):y("",!0)],!0)])])):y("",!0)])],2))}}),Ls=k(Ss,[["__scopeId","data-v-da5d1713"]]),Es=w({__name:"VPHomeHero",setup(n){const{frontmatter:e}=N();return(t,i)=>u(e).hero?(r(),L(Ls,{key:0,class:"VPHomeHero",name:u(e).hero.name,text:u(e).hero.text,tagline:u(e).hero.tagline,image:u(e).hero.image,actions:u(e).hero.actions},{"home-hero-info":g(()=>[m(t.$slots,"home-hero-info")]),"home-hero-image":g(()=>[m(t.$slots,"home-hero-image")]),_:3},8,["name","text","tagline","image","actions"])):y("",!0)}}),Ts={},Vs={xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24"},Ps=p("path",{d:"M19.9,12.4c0.1-0.2,0.1-0.5,0-0.8c-0.1-0.1-0.1-0.2-0.2-0.3l-7-7c-0.4-0.4-1-0.4-1.4,0s-0.4,1,0,1.4l5.3,5.3H5c-0.6,0-1,0.4-1,1s0.4,1,1,1h11.6l-5.3,5.3c-0.4,0.4-0.4,1,0,1.4c0.2,0.2,0.5,0.3,0.7,0.3s0.5-0.1,0.7-0.3l7-7C19.8,12.6,19.9,12.5,19.9,12.4z"},null,-1),Is=[Ps];function Cs(n,e){return r(),f("svg",Vs,Is)}const Ns=k(Ts,[["render",Cs]]),As={class:"box"},Ms={key:0,class:"icon"},Ds=["innerHTML"],zs=["innerHTML"],xs=["innerHTML"],Os={key:4,class:"link-text"},Hs={class:"link-text-value"},Bs=w({__name:"VPFeature",props:{icon:{},title:{},details:{},link:{},linkText:{},rel:{},target:{}},setup(n){return(e,t)=>(r(),L(ne,{class:"VPFeature",href:e.link,rel:e.rel,target:e.target,"no-icon":!0,tag:e.link?"a":"div"},{default:g(()=>[p("article",As,[typeof e.icon=="object"&&e.icon.wrap?(r(),f("div",Ms,[b(qe,{image:e.icon,alt:e.icon.alt,height:e.icon.height||48,width:e.icon.width||48},null,8,["image","alt","height","width"])])):typeof e.icon=="object"?(r(),L(qe,{key:1,image:e.icon,alt:e.icon.alt,height:e.icon.height||48,width:e.icon.width||48},null,8,["image","alt","height","width"])):e.icon?(r(),f("div",{key:2,class:"icon",innerHTML:e.icon},null,8,Ds)):y("",!0),p("h2",{class:"title",innerHTML:e.title},null,8,zs),e.details?(r(),f("p",{key:3,class:"details",innerHTML:e.details},null,8,xs)):y("",!0),e.linkText?(r(),f("div",Os,[p("p",Hs,[K(D(e.linkText)+" ",1),b(Ns,{class:"link-text-icon"})])])):y("",!0)])]),_:1},8,["href","rel","target","tag"]))}}),Fs=k(Bs,[["__scopeId","data-v-33204567"]]),Rs={key:0,class:"VPFeatures"},Ws={class:"container"},Ys={class:"items"},Us=w({__name:"VPFeatures",props:{features:{}},setup(n){const e=n,t=V(()=>{const i=e.features.length;if(i){if(i===2)return"grid-2";if(i===3)return"grid-3";if(i%3===0)return"grid-6";if(i>3)return"grid-4"}else return});return(i,s)=>i.features?(r(),f("div",Rs,[p("div",Ws,[p("div",Ys,[(r(!0),f(H,null,j(i.features,a=>(r(),f("div",{key:a.title,class:F(["item",[t.value]])},[b(Fs,{icon:a.icon,title:a.title,details:a.details,link:a.link,"link-text":a.linkText,rel:a.rel,target:a.target},null,8,["icon","title","details","link","link-text","rel","target"])],2))),128))])])])):y("",!0)}}),qs=k(Us,[["__scopeId","data-v-a6181336"]]),js=w({__name:"VPHomeFeatures",setup(n){const{frontmatter:e}=N();return(t,i)=>u(e).features?(r(),L(qs,{key:0,class:"VPHomeFeatures",features:u(e).features},null,8,["features"])):y("",!0)}}),Xs={class:"VPHome"},Gs=w({__name:"VPHome",setup(n){return(e,t)=>{const i=me("Content");return r(),f("div",Xs,[m(e.$slots,"home-hero-before",{},void 0,!0),b(Es,null,{"home-hero-info":g(()=>[m(e.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-image":g(()=>[m(e.$slots,"home-hero-image",{},void 0,!0)]),_:3}),m(e.$slots,"home-hero-after",{},void 0,!0),m(e.$slots,"home-features-before",{},void 0,!0),b(js),m(e.$slots,"home-features-after",{},void 0,!0),b(i)])}}}),Ks=k(Gs,[["__scopeId","data-v-d82743a8"]]),Zs={},Js={class:"VPPage"};function Qs(n,e){const t=me("Content");return r(),f("div",Js,[m(n.$slots,"page-top"),b(t),m(n.$slots,"page-bottom")])}const ea=k(Zs,[["render",Qs]]),ta=w({__name:"VPContent",setup(n){const{page:e,frontmatter:t}=N(),{hasSidebar:i}=ce();return(s,a)=>(r(),f("div",{class:F(["VPContent",{"has-sidebar":u(i),"is-home":u(t).layout==="home"}]),id:"VPContent"},[u(e).isNotFound?m(s.$slots,"not-found",{key:0},()=>[b(tn)],!0):u(t).layout==="page"?(r(),L(ea,{key:1},{"page-top":g(()=>[m(s.$slots,"page-top",{},void 0,!0)]),"page-bottom":g(()=>[m(s.$slots,"page-bottom",{},void 0,!0)]),_:3})):u(t).layout==="home"?(r(),L(Ks,{key:2},{"home-hero-before":g(()=>[m(s.$slots,"home-hero-before",{},void 0,!0)]),"home-hero-info":g(()=>[m(s.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-image":g(()=>[m(s.$slots,"home-hero-image",{},void 0,!0)]),"home-hero-after":g(()=>[m(s.$slots,"home-hero-after",{},void 0,!0)]),"home-features-before":g(()=>[m(s.$slots,"home-features-before",{},void 0,!0)]),"home-features-after":g(()=>[m(s.$slots,"home-features-after",{},void 0,!0)]),_:3})):u(t).layout&&u(t).layout!=="doc"?(r(),L(fe(u(t).layout),{key:3})):(r(),L(ls,{key:4},{"doc-top":g(()=>[m(s.$slots,"doc-top",{},void 0,!0)]),"doc-bottom":g(()=>[m(s.$slots,"doc-bottom",{},void 0,!0)]),"doc-footer-before":g(()=>[m(s.$slots,"doc-footer-before",{},void 0,!0)]),"doc-before":g(()=>[m(s.$slots,"doc-before",{},void 0,!0)]),"doc-after":g(()=>[m(s.$slots,"doc-after",{},void 0,!0)]),"aside-top":g(()=>[m(s.$slots,"aside-top",{},void 0,!0)]),"aside-outline-before":g(()=>[m(s.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":g(()=>[m(s.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":g(()=>[m(s.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":g(()=>[m(s.$slots,"aside-ads-after",{},void 0,!0)]),"aside-bottom":g(()=>[m(s.$slots,"aside-bottom",{},void 0,!0)]),_:3}))],2))}}),ia=k(ta,[["__scopeId","data-v-669faec9"]]),na={class:"container"},sa=["innerHTML"],aa=["innerHTML"],oa=w({__name:"VPFooter",setup(n){const{theme:e,frontmatter:t}=N(),{hasSidebar:i}=ce();return(s,a)=>u(e).footer&&u(t).footer!==!1?(r(),f("footer",{key:0,class:F(["VPFooter",{"has-sidebar":u(i)}])},[p("div",na,[u(e).footer.message?(r(),f("p",{key:0,class:"message",innerHTML:u(e).footer.message},null,8,sa)):y("",!0),u(e).footer.copyright?(r(),f("p",{key:1,class:"copyright",innerHTML:u(e).footer.copyright},null,8,aa)):y("",!0)])],2)):y("",!0)}}),ra=k(oa,[["__scopeId","data-v-e315a0ad"]]);function pi(){const{theme:n,frontmatter:e}=N(),t=ai([]),i=V(()=>t.value.length>0);return Ge(()=>{t.value=mt(e.value.outline??n.value.outline)}),{headers:t,hasLocalNav:i}}const la={},ca={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},ua=p("path",{d:"M9,19c-0.3,0-0.5-0.1-0.7-0.3c-0.4-0.4-0.4-1,0-1.4l5.3-5.3L8.3,6.7c-0.4-0.4-0.4-1,0-1.4s1-0.4,1.4,0l6,6c0.4,0.4,0.4,1,0,1.4l-6,6C9.5,18.9,9.3,19,9,19z"},null,-1),da=[ua];function ha(n,e){return r(),f("svg",ca,da)}const mi=k(la,[["render",ha]]),fa={class:"header"},va={class:"outline"},pa=w({__name:"VPLocalNavOutlineDropdown",props:{headers:{},navHeight:{}},setup(n){const e=n,{theme:t}=N(),i=z(!1),s=z(0),a=z(),o=z();Ci(a,()=>{i.value=!1}),nt("Escape",()=>{i.value=!1}),Ge(()=>{i.value=!1});function l(){i.value=!i.value,s.value=window.innerHeight+Math.min(window.scrollY-e.navHeight,0)}function c(h){h.target.classList.contains("outline-link")&&(o.value&&(o.value.style.transition="none"),ri(()=>{i.value=!1}))}function d(){i.value=!1,window.scrollTo({top:0,left:0,behavior:"smooth"})}return(h,v)=>(r(),f("div",{class:"VPLocalNavOutlineDropdown",style:Ni({"--vp-vh":s.value+"px"}),ref_key:"main",ref:a},[h.headers.length>0?(r(),f("button",{key:0,onClick:l,class:F({open:i.value})},[K(D(u(fi)(u(t)))+" ",1),b(mi,{class:"icon"})],2)):(r(),f("button",{key:1,onClick:d},D(u(t).returnToTopLabel||"Return to top"),1)),b(dt,{name:"flyout"},{default:g(()=>[i.value?(r(),f("div",{key:0,ref_key:"items",ref:o,class:"items",onClick:c},[p("div",fa,[p("a",{class:"top-link",href:"#",onClick:d},D(u(t).returnToTopLabel||"Return to top"),1)]),p("div",va,[b(vi,{headers:h.headers},null,8,["headers"])])],512)):y("",!0)]),_:1})],4))}}),ma=k(pa,[["__scopeId","data-v-af18c0d5"]]),ga={},_a={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},ba=p("path",{d:"M17,11H3c-0.6,0-1-0.4-1-1s0.4-1,1-1h14c0.6,0,1,0.4,1,1S17.6,11,17,11z"},null,-1),ya=p("path",{d:"M21,7H3C2.4,7,2,6.6,2,6s0.4-1,1-1h18c0.6,0,1,0.4,1,1S21.6,7,21,7z"},null,-1),wa=p("path",{d:"M21,15H3c-0.6,0-1-0.4-1-1s0.4-1,1-1h18c0.6,0,1,0.4,1,1S21.6,15,21,15z"},null,-1),ka=p("path",{d:"M17,19H3c-0.6,0-1-0.4-1-1s0.4-1,1-1h14c0.6,0,1,0.4,1,1S17.6,19,17,19z"},null,-1),$a=[ba,ya,wa,ka];function Sa(n,e){return r(),f("svg",_a,$a)}const La=k(ga,[["render",Sa]]),Ea={class:"container"},Ta=["aria-expanded"],Va={class:"menu-text"},Pa=w({__name:"VPLocalNav",props:{open:{type:Boolean}},emits:["open-menu"],setup(n){const{theme:e,frontmatter:t}=N(),{hasSidebar:i}=ce(),{headers:s}=pi(),{y:a}=li(),o=z(0);le(()=>{o.value=parseInt(getComputedStyle(document.documentElement).getPropertyValue("--vp-nav-height"))}),Ge(()=>{s.value=mt(t.value.outline??e.value.outline)});const l=V(()=>s.value.length===0),c=V(()=>l.value&&!i.value),d=V(()=>({VPLocalNav:!0,"has-sidebar":i.value,empty:l.value,fixed:c.value}));return(h,v)=>u(t).layout!=="home"&&(!c.value||u(a)>=o.value)?(r(),f("div",{key:0,class:F(d.value)},[p("div",Ea,[u(i)?(r(),f("button",{key:0,class:"menu","aria-expanded":h.open,"aria-controls":"VPSidebarNav",onClick:v[0]||(v[0]=_=>h.$emit("open-menu"))},[b(La,{class:"menu-icon"}),p("span",Va,D(u(e).sidebarMenuLabel||"Menu"),1)],8,Ta)):y("",!0),b(ma,{headers:u(s),navHeight:o.value},null,8,["headers","navHeight"])])],2)):y("",!0)}}),Ia=k(Pa,[["__scopeId","data-v-0282ae07"]]);function Ca(){const n=z(!1);function e(){n.value=!0,window.addEventListener("resize",s)}function t(){n.value=!1,window.removeEventListener("resize",s)}function i(){n.value?t():e()}function s(){window.outerWidth>=768&&t()}const a=Ve();return ue(()=>a.path,t),{isScreenOpen:n,openScreen:e,closeScreen:t,toggleScreen:i}}const Na={},Aa={class:"VPSwitch",type:"button",role:"switch"},Ma={class:"check"},Da={key:0,class:"icon"};function za(n,e){return r(),f("button",Aa,[p("span",Ma,[n.$slots.default?(r(),f("span",Da,[m(n.$slots,"default",{},void 0,!0)])):y("",!0)])])}const xa=k(Na,[["render",za],["__scopeId","data-v-b1685198"]]),Oa={},Ha={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},Ba=p("path",{d:"M12.1,22c-0.3,0-0.6,0-0.9,0c-5.5-0.5-9.5-5.4-9-10.9c0.4-4.8,4.2-8.6,9-9c0.4,0,0.8,0.2,1,0.5c0.2,0.3,0.2,0.8-0.1,1.1c-2,2.7-1.4,6.4,1.3,8.4c2.1,1.6,5,1.6,7.1,0c0.3-0.2,0.7-0.3,1.1-0.1c0.3,0.2,0.5,0.6,0.5,1c-0.2,2.7-1.5,5.1-3.6,6.8C16.6,21.2,14.4,22,12.1,22zM9.3,4.4c-2.9,1-5,3.6-5.2,6.8c-0.4,4.4,2.8,8.3,7.2,8.7c2.1,0.2,4.2-0.4,5.8-1.8c1.1-0.9,1.9-2.1,2.4-3.4c-2.5,0.9-5.3,0.5-7.5-1.1C9.2,11.4,8.1,7.7,9.3,4.4z"},null,-1),Fa=[Ba];function Ra(n,e){return r(),f("svg",Ha,Fa)}const Wa=k(Oa,[["render",Ra]]),Ya={},Ua={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},qa=Ai('',9),ja=[qa];function Xa(n,e){return r(),f("svg",Ua,ja)}const Ga=k(Ya,[["render",Xa]]),Ka=w({__name:"VPSwitchAppearance",setup(n){const{isDark:e,theme:t}=N(),i=Ke("toggle-appearance",()=>{e.value=!e.value}),s=V(()=>e.value?t.value.lightModeSwitchTitle||"Switch to light theme":t.value.darkModeSwitchTitle||"Switch to dark theme");return(a,o)=>(r(),L(xa,{title:s.value,class:"VPSwitchAppearance","aria-checked":u(e),onClick:u(i)},{default:g(()=>[b(Ga,{class:"sun"}),b(Wa,{class:"moon"})]),_:1},8,["title","aria-checked","onClick"]))}}),gt=k(Ka,[["__scopeId","data-v-1736f215"]]),Za={key:0,class:"VPNavBarAppearance"},Ja=w({__name:"VPNavBarAppearance",setup(n){const{site:e}=N();return(t,i)=>u(e).appearance&&u(e).appearance!=="force-dark"?(r(),f("div",Za,[b(gt)])):y("",!0)}}),Qa=k(Ja,[["__scopeId","data-v-e6aabb21"]]),_t=z();let gi=!1,Qe=0;function eo(n){const e=z(!1);if(Te){!gi&&to(),Qe++;const t=ue(_t,i=>{var s,a,o;i===n.el.value||(s=n.el.value)!=null&&s.contains(i)?(e.value=!0,(a=n.onFocus)==null||a.call(n)):(e.value=!1,(o=n.onBlur)==null||o.call(n))});ft(()=>{t(),Qe--,Qe||io()})}return Mi(e)}function to(){document.addEventListener("focusin",_i),gi=!0,_t.value=document.activeElement}function io(){document.removeEventListener("focusin",_i)}function _i(){_t.value=document.activeElement}const no={},so={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},ao=p("path",{d:"M12,16c-0.3,0-0.5-0.1-0.7-0.3l-6-6c-0.4-0.4-0.4-1,0-1.4s1-0.4,1.4,0l5.3,5.3l5.3-5.3c0.4-0.4,1-0.4,1.4,0s0.4,1,0,1.4l-6,6C12.5,15.9,12.3,16,12,16z"},null,-1),oo=[ao];function ro(n,e){return r(),f("svg",so,oo)}const bi=k(no,[["render",ro]]),lo={},co={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},uo=p("circle",{cx:"12",cy:"12",r:"2"},null,-1),ho=p("circle",{cx:"19",cy:"12",r:"2"},null,-1),fo=p("circle",{cx:"5",cy:"12",r:"2"},null,-1),vo=[uo,ho,fo];function po(n,e){return r(),f("svg",co,vo)}const mo=k(lo,[["render",po]]),go={class:"VPMenuLink"},_o=w({__name:"VPMenuLink",props:{item:{}},setup(n){const{page:e}=N();return(t,i)=>(r(),f("div",go,[b(ne,{class:F({active:u(pe)(u(e).relativePath,t.item.activeMatch||t.item.link,!!t.item.activeMatch)}),href:t.item.link,target:t.item.target,rel:t.item.rel},{default:g(()=>[K(D(t.item.text),1)]),_:1},8,["class","href","target","rel"])]))}}),Ze=k(_o,[["__scopeId","data-v-43f1e123"]]),bo={class:"VPMenuGroup"},yo={key:0,class:"title"},wo=w({__name:"VPMenuGroup",props:{text:{},items:{}},setup(n){return(e,t)=>(r(),f("div",bo,[e.text?(r(),f("p",yo,D(e.text),1)):y("",!0),(r(!0),f(H,null,j(e.items,i=>(r(),f(H,null,["link"in i?(r(),L(Ze,{key:0,item:i},null,8,["item"])):y("",!0)],64))),256))]))}}),ko=k(wo,[["__scopeId","data-v-69e747b5"]]),$o={class:"VPMenu"},So={key:0,class:"items"},Lo=w({__name:"VPMenu",props:{items:{}},setup(n){return(e,t)=>(r(),f("div",$o,[e.items?(r(),f("div",So,[(r(!0),f(H,null,j(e.items,i=>(r(),f(H,{key:i.text},["link"in i?(r(),L(Ze,{key:0,item:i},null,8,["item"])):(r(),L(ko,{key:1,text:i.text,items:i.items},null,8,["text","items"]))],64))),128))])):y("",!0),m(e.$slots,"default",{},void 0,!0)]))}}),Eo=k(Lo,[["__scopeId","data-v-e7ea1737"]]),To=["aria-expanded","aria-label"],Vo={key:0,class:"text"},Po=["innerHTML"],Io={class:"menu"},Co=w({__name:"VPFlyout",props:{icon:{},button:{},label:{},items:{}},setup(n){const e=z(!1),t=z();eo({el:t,onBlur:i});function i(){e.value=!1}return(s,a)=>(r(),f("div",{class:"VPFlyout",ref_key:"el",ref:t,onMouseenter:a[1]||(a[1]=o=>e.value=!0),onMouseleave:a[2]||(a[2]=o=>e.value=!1)},[p("button",{type:"button",class:"button","aria-haspopup":"true","aria-expanded":e.value,"aria-label":s.label,onClick:a[0]||(a[0]=o=>e.value=!e.value)},[s.button||s.icon?(r(),f("span",Vo,[s.icon?(r(),L(fe(s.icon),{key:0,class:"option-icon"})):y("",!0),s.button?(r(),f("span",{key:1,innerHTML:s.button},null,8,Po)):y("",!0),b(bi,{class:"text-icon"})])):(r(),L(mo,{key:1,class:"icon"}))],8,To),p("div",Io,[b(Eo,{items:s.items},{default:g(()=>[m(s.$slots,"default",{},void 0,!0)]),_:3},8,["items"])])],544))}}),bt=k(Co,[["__scopeId","data-v-9c007e85"]]),No={discord:'Discord',facebook:'Facebook',github:'GitHub',instagram:'Instagram',linkedin:'LinkedIn',mastodon:'Mastodon',slack:'Slack',twitter:'Twitter',x:'X',youtube:'YouTube'},Ao=["href","aria-label","innerHTML"],Mo=w({__name:"VPSocialLink",props:{icon:{},link:{},ariaLabel:{}},setup(n){const e=n,t=V(()=>typeof e.icon=="object"?e.icon.svg:No[e.icon]);return(i,s)=>(r(),f("a",{class:"VPSocialLink no-icon",href:i.link,"aria-label":i.ariaLabel??(typeof i.icon=="string"?i.icon:""),target:"_blank",rel:"noopener",innerHTML:t.value},null,8,Ao))}}),Do=k(Mo,[["__scopeId","data-v-f80f8133"]]),zo={class:"VPSocialLinks"},xo=w({__name:"VPSocialLinks",props:{links:{}},setup(n){return(e,t)=>(r(),f("div",zo,[(r(!0),f(H,null,j(e.links,({link:i,icon:s,ariaLabel:a})=>(r(),L(Do,{key:i,icon:s,link:i,ariaLabel:a},null,8,["icon","link","ariaLabel"]))),128))]))}}),yt=k(xo,[["__scopeId","data-v-7bc22406"]]),Oo={key:0,class:"group translations"},Ho={class:"trans-title"},Bo={key:1,class:"group"},Fo={class:"item appearance"},Ro={class:"label"},Wo={class:"appearance-action"},Yo={key:2,class:"group"},Uo={class:"item social-links"},qo=w({__name:"VPNavBarExtra",setup(n){const{site:e,theme:t}=N(),{localeLinks:i,currentLang:s}=De({correspondingLink:!0}),a=V(()=>i.value.length&&s.value.label||e.value.appearance||t.value.socialLinks);return(o,l)=>a.value?(r(),L(bt,{key:0,class:"VPNavBarExtra",label:"extra navigation"},{default:g(()=>[u(i).length&&u(s).label?(r(),f("div",Oo,[p("p",Ho,D(u(s).label),1),(r(!0),f(H,null,j(u(i),c=>(r(),L(Ze,{key:c.link,item:c},null,8,["item"]))),128))])):y("",!0),u(e).appearance&&u(e).appearance!=="force-dark"?(r(),f("div",Bo,[p("div",Fo,[p("p",Ro,D(u(t).darkModeSwitchLabel||"Appearance"),1),p("div",Wo,[b(gt)])])])):y("",!0),u(t).socialLinks?(r(),f("div",Yo,[p("div",Uo,[b(yt,{class:"social-links-list",links:u(t).socialLinks},null,8,["links"])])])):y("",!0)]),_:1})):y("",!0)}}),jo=k(qo,[["__scopeId","data-v-d0bd9dde"]]),Xo=n=>(se("data-v-e5dd9c1c"),n=n(),ae(),n),Go=["aria-expanded"],Ko=Xo(()=>p("span",{class:"container"},[p("span",{class:"top"}),p("span",{class:"middle"}),p("span",{class:"bottom"})],-1)),Zo=[Ko],Jo=w({__name:"VPNavBarHamburger",props:{active:{type:Boolean}},emits:["click"],setup(n){return(e,t)=>(r(),f("button",{type:"button",class:F(["VPNavBarHamburger",{active:e.active}]),"aria-label":"mobile navigation","aria-expanded":e.active,"aria-controls":"VPNavScreen",onClick:t[0]||(t[0]=i=>e.$emit("click"))},Zo,10,Go))}}),Qo=k(Jo,[["__scopeId","data-v-e5dd9c1c"]]),er=["innerHTML"],tr=w({__name:"VPNavBarMenuLink",props:{item:{}},setup(n){const{page:e}=N();return(t,i)=>(r(),L(ne,{class:F({VPNavBarMenuLink:!0,active:u(pe)(u(e).relativePath,t.item.activeMatch||t.item.link,!!t.item.activeMatch)}),href:t.item.link,target:t.item.target,rel:t.item.rel,tabindex:"0"},{default:g(()=>[p("span",{innerHTML:t.item.text},null,8,er)]),_:1},8,["class","href","target","rel"]))}}),ir=k(tr,[["__scopeId","data-v-42ef59de"]]),nr=w({__name:"VPNavBarMenuGroup",props:{item:{}},setup(n){const e=n,{page:t}=N(),i=a=>"link"in a?pe(t.value.relativePath,a.link,!!e.item.activeMatch):a.items.some(i),s=V(()=>i(e.item));return(a,o)=>(r(),L(bt,{class:F({VPNavBarMenuGroup:!0,active:u(pe)(u(t).relativePath,a.item.activeMatch,!!a.item.activeMatch)||s.value}),button:a.item.text,items:a.item.items},null,8,["class","button","items"]))}}),sr=n=>(se("data-v-7f418b0f"),n=n(),ae(),n),ar={key:0,"aria-labelledby":"main-nav-aria-label",class:"VPNavBarMenu"},or=sr(()=>p("span",{id:"main-nav-aria-label",class:"visually-hidden"},"Main Navigation",-1)),rr=w({__name:"VPNavBarMenu",setup(n){const{theme:e}=N();return(t,i)=>u(e).nav?(r(),f("nav",ar,[or,(r(!0),f(H,null,j(u(e).nav,s=>(r(),f(H,{key:s.text},["link"in s?(r(),L(ir,{key:0,item:s},null,8,["item"])):(r(),L(nr,{key:1,item:s},null,8,["item"]))],64))),128))])):y("",!0)}}),lr=k(rr,[["__scopeId","data-v-7f418b0f"]]);function cr(n){const{localeIndex:e,theme:t}=N();function i(s){var S,$,P;const a=s.split("."),o=(S=t.value.search)==null?void 0:S.options,l=o&&typeof o=="object",c=l&&((P=($=o.locales)==null?void 0:$[e.value])==null?void 0:P.translations)||null,d=l&&o.translations||null;let h=c,v=d,_=n;const E=a.pop();for(const q of a){let R=null;const A=_==null?void 0:_[q];A&&(R=_=A);const X=v==null?void 0:v[q];X&&(R=v=X);const Q=h==null?void 0:h[q];Q&&(R=h=Q),A||(_=R),X||(v=R),Q||(h=R)}return(h==null?void 0:h[E])??(v==null?void 0:v[E])??(_==null?void 0:_[E])??""}return i}const ur=["aria-label"],dr={class:"DocSearch-Button-Container"},hr=p("svg",{class:"DocSearch-Search-Icon",width:"20",height:"20",viewBox:"0 0 20 20","aria-label":"search icon"},[p("path",{d:"M14.386 14.386l4.0877 4.0877-4.0877-4.0877c-2.9418 2.9419-7.7115 2.9419-10.6533 0-2.9419-2.9418-2.9419-7.7115 0-10.6533 2.9418-2.9419 7.7115-2.9419 10.6533 0 2.9419 2.9418 2.9419 7.7115 0 10.6533z",stroke:"currentColor",fill:"none","fill-rule":"evenodd","stroke-linecap":"round","stroke-linejoin":"round"})],-1),fr={class:"DocSearch-Button-Placeholder"},vr=p("span",{class:"DocSearch-Button-Keys"},[p("kbd",{class:"DocSearch-Button-Key"}),p("kbd",{class:"DocSearch-Button-Key"},"K")],-1),Et=w({__name:"VPNavBarSearchButton",setup(n){const t=cr({button:{buttonText:"Search",buttonAriaLabel:"Search"}});return(i,s)=>(r(),f("button",{type:"button",class:"DocSearch DocSearch-Button","aria-label":u(t)("button.buttonAriaLabel")},[p("span",dr,[hr,p("span",fr,D(u(t)("button.buttonText")),1)]),vr],8,ur))}}),pr={class:"VPNavBarSearch"},mr={id:"local-search"},gr={key:1,id:"docsearch"},_r=w({__name:"VPNavBarSearch",setup(n){const e=Di(()=>ci(()=>import("./VPLocalSearchBox.NRnZ9XZ2.js"),__vite__mapDeps([0,1]))),t=()=>null,{theme:i}=N(),s=z(!1),a=z(!1);le(()=>{});function o(){s.value||(s.value=!0,setTimeout(l,16))}function l(){const v=new Event("keydown");v.key="k",v.metaKey=!0,window.dispatchEvent(v),setTimeout(()=>{document.querySelector(".DocSearch-Modal")||l()},16)}function c(v){const _=v.target,E=_.tagName;return _.isContentEditable||E==="INPUT"||E==="SELECT"||E==="TEXTAREA"}const d=z(!1);nt("k",v=>{(v.ctrlKey||v.metaKey)&&(v.preventDefault(),d.value=!0)}),nt("/",v=>{c(v)||(v.preventDefault(),d.value=!0)});const h="local";return(v,_)=>{var E;return r(),f("div",pr,[u(h)==="local"?(r(),f(H,{key:0},[d.value?(r(),L(u(e),{key:0,onClose:_[0]||(_[0]=S=>d.value=!1)})):y("",!0),p("div",mr,[b(Et,{onClick:_[1]||(_[1]=S=>d.value=!0)})])],64)):u(h)==="algolia"?(r(),f(H,{key:1},[s.value?(r(),L(u(t),{key:0,algolia:((E=u(i).search)==null?void 0:E.options)??u(i).algolia,onVnodeBeforeMount:_[2]||(_[2]=S=>a.value=!0)},null,8,["algolia"])):y("",!0),a.value?y("",!0):(r(),f("div",gr,[b(Et,{onClick:o})]))],64)):y("",!0)])}}}),br=w({__name:"VPNavBarSocialLinks",setup(n){const{theme:e}=N();return(t,i)=>u(e).socialLinks?(r(),L(yt,{key:0,class:"VPNavBarSocialLinks",links:u(e).socialLinks},null,8,["links"])):y("",!0)}}),yr=k(br,[["__scopeId","data-v-0394ad82"]]),wr=["href","rel","target"],kr=w({__name:"VPNavBarTitle",setup(n){const{site:e,theme:t}=N(),{hasSidebar:i}=ce(),{currentLang:s}=De(),a=V(()=>{var c;return typeof t.value.logoLink=="string"?t.value.logoLink:(c=t.value.logoLink)==null?void 0:c.link}),o=V(()=>{var c;return typeof t.value.logoLink=="string"||(c=t.value.logoLink)==null?void 0:c.rel}),l=V(()=>{var c;return typeof t.value.logoLink=="string"||(c=t.value.logoLink)==null?void 0:c.target});return(c,d)=>(r(),f("div",{class:F(["VPNavBarTitle",{"has-sidebar":u(i)}])},[p("a",{class:"title",href:a.value??u(vt)(u(s).link),rel:o.value,target:l.value},[m(c.$slots,"nav-bar-title-before",{},void 0,!0),u(t).logo?(r(),L(qe,{key:0,class:"logo",image:u(t).logo},null,8,["image"])):y("",!0),u(t).siteTitle?(r(),f(H,{key:1},[K(D(u(t).siteTitle),1)],64)):u(t).siteTitle===void 0?(r(),f(H,{key:2},[K(D(u(e).title),1)],64)):y("",!0),m(c.$slots,"nav-bar-title-after",{},void 0,!0)],8,wr)],2))}}),$r=k(kr,[["__scopeId","data-v-8460f0a8"]]),Sr={},Lr={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},Er=p("path",{d:"M0 0h24v24H0z",fill:"none"},null,-1),Tr=p("path",{d:" M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z ",class:"css-c4d79v"},null,-1),Vr=[Er,Tr];function Pr(n,e){return r(),f("svg",Lr,Vr)}const yi=k(Sr,[["render",Pr]]),Ir={class:"items"},Cr={class:"title"},Nr=w({__name:"VPNavBarTranslations",setup(n){const{theme:e}=N(),{localeLinks:t,currentLang:i}=De({correspondingLink:!0});return(s,a)=>u(t).length&&u(i).label?(r(),L(bt,{key:0,class:"VPNavBarTranslations",icon:yi,label:u(e).langMenuLabel||"Change language"},{default:g(()=>[p("div",Ir,[p("p",Cr,D(u(i).label),1),(r(!0),f(H,null,j(u(t),o=>(r(),L(Ze,{key:o.link,item:o},null,8,["item"]))),128))])]),_:1},8,["label"])):y("",!0)}}),Ar=k(Nr,[["__scopeId","data-v-74abcbb9"]]),Mr=n=>(se("data-v-19c990f1"),n=n(),ae(),n),Dr={class:"wrapper"},zr={class:"container"},xr={class:"title"},Or={class:"content"},Hr={class:"content-body"},Br=Mr(()=>p("div",{class:"divider"},[p("div",{class:"divider-line"})],-1)),Fr=w({__name:"VPNavBar",props:{isScreenOpen:{type:Boolean}},emits:["toggle-screen"],setup(n){const{y:e}=li(),{hasSidebar:t}=ce(),{hasLocalNav:i}=pi(),{frontmatter:s}=N(),a=z({});return si(()=>{a.value={"has-sidebar":t.value,"has-local-nav":i.value,top:s.value.layout==="home"&&e.value===0}}),(o,l)=>(r(),f("div",{class:F(["VPNavBar",a.value])},[p("div",Dr,[p("div",zr,[p("div",xr,[b($r,null,{"nav-bar-title-before":g(()=>[m(o.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":g(()=>[m(o.$slots,"nav-bar-title-after",{},void 0,!0)]),_:3})]),p("div",Or,[p("div",Hr,[m(o.$slots,"nav-bar-content-before",{},void 0,!0),b(_r,{class:"search"}),b(lr,{class:"menu"}),b(Ar,{class:"translations"}),b(Qa,{class:"appearance"}),b(yr,{class:"social-links"}),b(jo,{class:"extra"}),m(o.$slots,"nav-bar-content-after",{},void 0,!0),b(Qo,{class:"hamburger",active:o.isScreenOpen,onClick:l[0]||(l[0]=c=>o.$emit("toggle-screen"))},null,8,["active"])])])])]),Br],2))}}),Rr=k(Fr,[["__scopeId","data-v-19c990f1"]]),Wr={key:0,class:"VPNavScreenAppearance"},Yr={class:"text"},Ur=w({__name:"VPNavScreenAppearance",setup(n){const{site:e,theme:t}=N();return(i,s)=>u(e).appearance&&u(e).appearance!=="force-dark"?(r(),f("div",Wr,[p("p",Yr,D(u(t).darkModeSwitchLabel||"Appearance"),1),b(gt)])):y("",!0)}}),qr=k(Ur,[["__scopeId","data-v-2d7af913"]]),jr=w({__name:"VPNavScreenMenuLink",props:{item:{}},setup(n){const e=Ke("close-screen");return(t,i)=>(r(),L(ne,{class:"VPNavScreenMenuLink",href:t.item.link,target:t.item.target,rel:t.item.rel,onClick:u(e)},{default:g(()=>[K(D(t.item.text),1)]),_:1},8,["href","target","rel","onClick"]))}}),Xr=k(jr,[["__scopeId","data-v-05f27b2a"]]),Gr={},Kr={xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",focusable:"false",viewBox:"0 0 24 24"},Zr=p("path",{d:"M18.9,10.9h-6v-6c0-0.6-0.4-1-1-1s-1,0.4-1,1v6h-6c-0.6,0-1,0.4-1,1s0.4,1,1,1h6v6c0,0.6,0.4,1,1,1s1-0.4,1-1v-6h6c0.6,0,1-0.4,1-1S19.5,10.9,18.9,10.9z"},null,-1),Jr=[Zr];function Qr(n,e){return r(),f("svg",Kr,Jr)}const el=k(Gr,[["render",Qr]]),tl=w({__name:"VPNavScreenMenuGroupLink",props:{item:{}},setup(n){const e=Ke("close-screen");return(t,i)=>(r(),L(ne,{class:"VPNavScreenMenuGroupLink",href:t.item.link,target:t.item.target,rel:t.item.rel,onClick:u(e)},{default:g(()=>[K(D(t.item.text),1)]),_:1},8,["href","target","rel","onClick"]))}}),wi=k(tl,[["__scopeId","data-v-19976ae1"]]),il={class:"VPNavScreenMenuGroupSection"},nl={key:0,class:"title"},sl=w({__name:"VPNavScreenMenuGroupSection",props:{text:{},items:{}},setup(n){return(e,t)=>(r(),f("div",il,[e.text?(r(),f("p",nl,D(e.text),1)):y("",!0),(r(!0),f(H,null,j(e.items,i=>(r(),L(wi,{key:i.text,item:i},null,8,["item"]))),128))]))}}),al=k(sl,[["__scopeId","data-v-8133b170"]]),ol=["aria-controls","aria-expanded"],rl=["innerHTML"],ll=["id"],cl={key:1,class:"group"},ul=w({__name:"VPNavScreenMenuGroup",props:{text:{},items:{}},setup(n){const e=n,t=z(!1),i=V(()=>`NavScreenGroup-${e.text.replace(" ","-").toLowerCase()}`);function s(){t.value=!t.value}return(a,o)=>(r(),f("div",{class:F(["VPNavScreenMenuGroup",{open:t.value}])},[p("button",{class:"button","aria-controls":i.value,"aria-expanded":t.value,onClick:s},[p("span",{class:"button-text",innerHTML:a.text},null,8,rl),b(el,{class:"button-icon"})],8,ol),p("div",{id:i.value,class:"items"},[(r(!0),f(H,null,j(a.items,l=>(r(),f(H,{key:l.text},["link"in l?(r(),f("div",{key:l.text,class:"item"},[b(wi,{item:l},null,8,["item"])])):(r(),f("div",cl,[b(al,{text:l.text,items:l.items},null,8,["text","items"])]))],64))),128))],8,ll)],2))}}),dl=k(ul,[["__scopeId","data-v-65ef89ca"]]),hl={key:0,class:"VPNavScreenMenu"},fl=w({__name:"VPNavScreenMenu",setup(n){const{theme:e}=N();return(t,i)=>u(e).nav?(r(),f("nav",hl,[(r(!0),f(H,null,j(u(e).nav,s=>(r(),f(H,{key:s.text},["link"in s?(r(),L(Xr,{key:0,item:s},null,8,["item"])):(r(),L(dl,{key:1,text:s.text||"",items:s.items},null,8,["text","items"]))],64))),128))])):y("",!0)}}),vl=w({__name:"VPNavScreenSocialLinks",setup(n){const{theme:e}=N();return(t,i)=>u(e).socialLinks?(r(),L(yt,{key:0,class:"VPNavScreenSocialLinks",links:u(e).socialLinks},null,8,["links"])):y("",!0)}}),pl={class:"list"},ml=w({__name:"VPNavScreenTranslations",setup(n){const{localeLinks:e,currentLang:t}=De({correspondingLink:!0}),i=z(!1);function s(){i.value=!i.value}return(a,o)=>u(e).length&&u(t).label?(r(),f("div",{key:0,class:F(["VPNavScreenTranslations",{open:i.value}])},[p("button",{class:"title",onClick:s},[b(yi,{class:"icon lang"}),K(" "+D(u(t).label)+" ",1),b(bi,{class:"icon chevron"})]),p("ul",pl,[(r(!0),f(H,null,j(u(e),l=>(r(),f("li",{key:l.link,class:"item"},[b(ne,{class:"link",href:l.link},{default:g(()=>[K(D(l.text),1)]),_:2},1032,["href"])]))),128))])],2)):y("",!0)}}),gl=k(ml,[["__scopeId","data-v-d72aa483"]]),_l={class:"container"},bl=w({__name:"VPNavScreen",props:{open:{type:Boolean}},setup(n){const e=z(null),t=ui(Te?document.body:null);return(i,s)=>(r(),L(dt,{name:"fade",onEnter:s[0]||(s[0]=a=>t.value=!0),onAfterLeave:s[1]||(s[1]=a=>t.value=!1)},{default:g(()=>[i.open?(r(),f("div",{key:0,class:"VPNavScreen",ref_key:"screen",ref:e,id:"VPNavScreen"},[p("div",_l,[m(i.$slots,"nav-screen-content-before",{},void 0,!0),b(fl,{class:"menu"}),b(gl,{class:"translations"}),b(qr,{class:"appearance"}),b(vl,{class:"social-links"}),m(i.$slots,"nav-screen-content-after",{},void 0,!0)])],512)):y("",!0)]),_:3}))}}),yl=k(bl,[["__scopeId","data-v-cc5739dd"]]),wl={key:0,class:"VPNav"},kl=w({__name:"VPNav",setup(n){const{isScreenOpen:e,closeScreen:t,toggleScreen:i}=Ca(),{frontmatter:s}=N(),a=V(()=>s.value.navbar!==!1);return di("close-screen",t),Xe(()=>{Te&&document.documentElement.classList.toggle("hide-nav",!a.value)}),(o,l)=>a.value?(r(),f("header",wl,[b(Rr,{"is-screen-open":u(e),onToggleScreen:u(i)},{"nav-bar-title-before":g(()=>[m(o.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":g(()=>[m(o.$slots,"nav-bar-title-after",{},void 0,!0)]),"nav-bar-content-before":g(()=>[m(o.$slots,"nav-bar-content-before",{},void 0,!0)]),"nav-bar-content-after":g(()=>[m(o.$slots,"nav-bar-content-after",{},void 0,!0)]),_:3},8,["is-screen-open","onToggleScreen"]),b(yl,{open:u(e)},{"nav-screen-content-before":g(()=>[m(o.$slots,"nav-screen-content-before",{},void 0,!0)]),"nav-screen-content-after":g(()=>[m(o.$slots,"nav-screen-content-after",{},void 0,!0)]),_:3},8,["open"])])):y("",!0)}}),$l=k(kl,[["__scopeId","data-v-ae24b3ad"]]),Sl=n=>(se("data-v-e31bd47b"),n=n(),ae(),n),Ll=["role","tabindex"],El=Sl(()=>p("div",{class:"indicator"},null,-1)),Tl={key:1,class:"items"},Vl=w({__name:"VPSidebarItem",props:{item:{},depth:{}},setup(n){const e=n,{collapsed:t,collapsible:i,isLink:s,isActiveLink:a,hasActiveLink:o,hasChildren:l,toggle:c}=on(V(()=>e.item)),d=V(()=>l.value?"section":"div"),h=V(()=>s.value?"a":"div"),v=V(()=>l.value?e.depth+2===7?"p":`h${e.depth+2}`:"p"),_=V(()=>s.value?void 0:"button"),E=V(()=>[[`level-${e.depth}`],{collapsible:i.value},{collapsed:t.value},{"is-link":s.value},{"is-active":a.value},{"has-active":o.value}]);function S(P){"key"in P&&P.key!=="Enter"||!e.item.link&&c()}function $(){e.item.link&&c()}return(P,q)=>{const R=me("VPSidebarItem",!0);return r(),L(fe(d.value),{class:F(["VPSidebarItem",E.value])},{default:g(()=>[P.item.text?(r(),f("div",Be({key:0,class:"item",role:_.value},xi(P.item.items?{click:S,keydown:S}:{},!0),{tabindex:P.item.items&&0}),[El,P.item.link?(r(),L(ne,{key:0,tag:h.value,class:"link",href:P.item.link,rel:P.item.rel,target:P.item.target},{default:g(()=>[(r(),L(fe(v.value),{class:"text",innerHTML:P.item.text},null,8,["innerHTML"]))]),_:1},8,["tag","href","rel","target"])):(r(),L(fe(v.value),{key:1,class:"text",innerHTML:P.item.text},null,8,["innerHTML"])),P.item.collapsed!=null?(r(),f("div",{key:2,class:"caret",role:"button","aria-label":"toggle section",onClick:$,onKeydown:zi($,["enter"]),tabindex:"0"},[b(mi,{class:"caret-icon"})],32)):y("",!0)],16,Ll)):y("",!0),P.item.items&&P.item.items.length?(r(),f("div",Tl,[P.depth<5?(r(!0),f(H,{key:0},j(P.item.items,A=>(r(),L(R,{key:A.text,item:A,depth:P.depth+1},null,8,["item","depth"]))),128)):y("",!0)])):y("",!0)]),_:1},8,["class"])}}}),Pl=k(Vl,[["__scopeId","data-v-e31bd47b"]]),ki=n=>(se("data-v-575e6a36"),n=n(),ae(),n),Il=ki(()=>p("div",{class:"curtain"},null,-1)),Cl={class:"nav",id:"VPSidebarNav","aria-labelledby":"sidebar-aria-label",tabindex:"-1"},Nl=ki(()=>p("span",{class:"visually-hidden",id:"sidebar-aria-label"}," Sidebar Navigation ",-1)),Al=w({__name:"VPSidebar",props:{open:{type:Boolean}},setup(n){const{sidebarGroups:e,hasSidebar:t}=ce(),i=n,s=z(null),a=ui(Te?document.body:null);return ue([i,s],()=>{var o;i.open?(a.value=!0,(o=s.value)==null||o.focus()):a.value=!1},{immediate:!0,flush:"post"}),(o,l)=>u(t)?(r(),f("aside",{key:0,class:F(["VPSidebar",{open:o.open}]),ref_key:"navEl",ref:s,onClick:l[0]||(l[0]=Oi(()=>{},["stop"]))},[Il,p("nav",Cl,[Nl,m(o.$slots,"sidebar-nav-before",{},void 0,!0),(r(!0),f(H,null,j(u(e),c=>(r(),f("div",{key:c.text,class:"group"},[b(Pl,{item:c,depth:0},null,8,["item"])]))),128)),m(o.$slots,"sidebar-nav-after",{},void 0,!0)])],2)):y("",!0)}}),Ml=k(Al,[["__scopeId","data-v-575e6a36"]]),Dl=w({__name:"VPSkipLink",setup(n){const e=Ve(),t=z();ue(()=>e.path,()=>t.value.focus());function i({target:s}){const a=document.getElementById(decodeURIComponent(s.hash).slice(1));if(a){const o=()=>{a.removeAttribute("tabindex"),a.removeEventListener("blur",o)};a.setAttribute("tabindex","-1"),a.addEventListener("blur",o),a.focus(),window.scrollTo(0,0)}}return(s,a)=>(r(),f(H,null,[p("span",{ref_key:"backToTop",ref:t,tabindex:"-1"},null,512),p("a",{href:"#VPContent",class:"VPSkipLink visually-hidden",onClick:i}," Skip to content ")],64))}}),zl=k(Dl,[["__scopeId","data-v-0f60ec36"]]),xl=w({__name:"Layout",setup(n){const{isOpen:e,open:t,close:i}=ce(),s=Ve();ue(()=>s.path,i),an(e,i);const{frontmatter:a}=N(),o=Hi(),l=V(()=>!!o["home-hero-image"]);return di("hero-image-slot-exists",l),(c,d)=>{const h=me("Content");return u(a).layout!==!1?(r(),f("div",{key:0,class:F(["Layout",u(a).pageClass])},[m(c.$slots,"layout-top",{},void 0,!0),b(zl),b(Wi,{class:"backdrop",show:u(e),onClick:u(i)},null,8,["show","onClick"]),b($l,null,{"nav-bar-title-before":g(()=>[m(c.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":g(()=>[m(c.$slots,"nav-bar-title-after",{},void 0,!0)]),"nav-bar-content-before":g(()=>[m(c.$slots,"nav-bar-content-before",{},void 0,!0)]),"nav-bar-content-after":g(()=>[m(c.$slots,"nav-bar-content-after",{},void 0,!0)]),"nav-screen-content-before":g(()=>[m(c.$slots,"nav-screen-content-before",{},void 0,!0)]),"nav-screen-content-after":g(()=>[m(c.$slots,"nav-screen-content-after",{},void 0,!0)]),_:3}),b(Ia,{open:u(e),onOpenMenu:u(t)},null,8,["open","onOpenMenu"]),b(Ml,{open:u(e)},{"sidebar-nav-before":g(()=>[m(c.$slots,"sidebar-nav-before",{},void 0,!0)]),"sidebar-nav-after":g(()=>[m(c.$slots,"sidebar-nav-after",{},void 0,!0)]),_:3},8,["open"]),b(ia,null,{"page-top":g(()=>[m(c.$slots,"page-top",{},void 0,!0)]),"page-bottom":g(()=>[m(c.$slots,"page-bottom",{},void 0,!0)]),"not-found":g(()=>[m(c.$slots,"not-found",{},void 0,!0)]),"home-hero-before":g(()=>[m(c.$slots,"home-hero-before",{},void 0,!0)]),"home-hero-info":g(()=>[m(c.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-image":g(()=>[m(c.$slots,"home-hero-image",{},void 0,!0)]),"home-hero-after":g(()=>[m(c.$slots,"home-hero-after",{},void 0,!0)]),"home-features-before":g(()=>[m(c.$slots,"home-features-before",{},void 0,!0)]),"home-features-after":g(()=>[m(c.$slots,"home-features-after",{},void 0,!0)]),"doc-footer-before":g(()=>[m(c.$slots,"doc-footer-before",{},void 0,!0)]),"doc-before":g(()=>[m(c.$slots,"doc-before",{},void 0,!0)]),"doc-after":g(()=>[m(c.$slots,"doc-after",{},void 0,!0)]),"doc-top":g(()=>[m(c.$slots,"doc-top",{},void 0,!0)]),"doc-bottom":g(()=>[m(c.$slots,"doc-bottom",{},void 0,!0)]),"aside-top":g(()=>[m(c.$slots,"aside-top",{},void 0,!0)]),"aside-bottom":g(()=>[m(c.$slots,"aside-bottom",{},void 0,!0)]),"aside-outline-before":g(()=>[m(c.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":g(()=>[m(c.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":g(()=>[m(c.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":g(()=>[m(c.$slots,"aside-ads-after",{},void 0,!0)]),_:3}),b(ra),m(c.$slots,"layout-bottom",{},void 0,!0)],2)):(r(),L(h,{key:1}))}}}),Ol=k(xl,[["__scopeId","data-v-5a346dfe"]]),et={Layout:Ol,enhanceApp:({app:n})=>{n.component("Badge",Bi)}};/*!
  * Viewer.js v1.11.6
  * https://fengyuanchen.github.io/viewerjs
  *
@@ -9,7 +9,7 @@ import{d as w,o as r,c as f,r as m,n as F,a as K,t as D,b as L,w as g,T as dt,e
  */function Tt(n,e){var t=Object.keys(n);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(n);e&&(i=i.filter(function(s){return Object.getOwnPropertyDescriptor(n,s).enumerable})),t.push.apply(t,i)}return t}function wt(n){for(var e=1;e
',Je=typeof window<"u"&&typeof window.document<"u",re=Je?window:{},$e=Je&&re.document.documentElement?"ontouchstart"in re.document.documentElement:!1,kt=Je?"PointerEvent"in re:!1,C="viewer",Re="move",Si="switch",Ie="zoom",ze="".concat(C,"-active"),Yl="".concat(C,"-close"),We="".concat(C,"-fade"),lt="".concat(C,"-fixed"),Ul="".concat(C,"-fullscreen"),It="".concat(C,"-fullscreen-exit"),he="".concat(C,"-hide"),ql="".concat(C,"-hide-md-down"),jl="".concat(C,"-hide-sm-down"),Xl="".concat(C,"-hide-xs-down"),Z="".concat(C,"-in"),Ce="".concat(C,"-invisible"),Se="".concat(C,"-loading"),Gl="".concat(C,"-move"),Ct="".concat(C,"-open"),_e="".concat(C,"-show"),Y="".concat(C,"-transition"),Le="click",ct="dblclick",Nt="dragstart",At="focusin",Mt="keydown",J="load",ve="error",Kl=$e?"touchend touchcancel":"mouseup",Zl=$e?"touchmove":"mousemove",Jl=$e?"touchstart":"mousedown",Dt=kt?"pointerdown":Jl,zt=kt?"pointermove":Zl,xt=kt?"pointerup pointercancel":Kl,Ot="resize",ee="transitionend",Ht="wheel",Bt="ready",Ft="show",Rt="shown",Wt="hide",Yt="hidden",Ut="view",Ne="viewed",qt="move",jt="moved",Xt="rotate",Gt="rotated",Kt="scale",Zt="scaled",Jt="zoom",Qt="zoomed",ei="play",ti="stop",je="".concat(C,"Action"),$t=/\s\s*/,xe=["zoom-in","zoom-out","one-to-one","reset","prev","play","next","rotate-left","rotate-right","flip-horizontal","flip-vertical"];function Ae(n){return typeof n=="string"}var Ql=Number.isNaN||re.isNaN;function W(n){return typeof n=="number"&&!Ql(n)}function ye(n){return typeof n>"u"}function Ee(n){return rt(n)==="object"&&n!==null}var ec=Object.prototype.hasOwnProperty;function we(n){if(!Ee(n))return!1;try{var e=n.constructor,t=e.prototype;return e&&t&&ec.call(t,"isPrototypeOf")}catch{return!1}}function x(n){return typeof n=="function"}function B(n,e){if(n&&x(e))if(Array.isArray(n)||W(n.length)){var t=n.length,i;for(i=0;i1?t-1:0),s=1;s0&&i.forEach(function(a){Ee(a)&&Object.keys(a).forEach(function(o){e[o]=a[o]})}),e},tc=/^(?:width|height|left|top|marginLeft|marginTop)$/;function te(n,e){var t=n.style;B(e,function(i,s){tc.test(s)&&W(i)&&(i+="px"),t[s]=i})}function ic(n){return Ae(n)?n.replace(/&(?!amp;|quot;|#39;|lt;|gt;)/g,"&").replace(/"/g,""").replace(/'/g,"'").replace(//g,">"):n}function be(n,e){return!n||!e?!1:n.classList?n.classList.contains(e):n.className.indexOf(e)>-1}function T(n,e){if(!(!n||!e)){if(W(n.length)){B(n,function(i){T(i,e)});return}if(n.classList){n.classList.add(e);return}var t=n.className.trim();t?t.indexOf(e)<0&&(n.className="".concat(t," ").concat(e)):n.className=e}}function M(n,e){if(!(!n||!e)){if(W(n.length)){B(n,function(t){M(t,e)});return}if(n.classList){n.classList.remove(e);return}n.className.indexOf(e)>=0&&(n.className=n.className.replace(e,""))}}function Me(n,e,t){if(e){if(W(n.length)){B(n,function(i){Me(i,e,t)});return}t?T(n,e):M(n,e)}}var nc=/([a-z\d])([A-Z])/g;function St(n){return n.replace(nc,"$1-$2").toLowerCase()}function ke(n,e){return Ee(n[e])?n[e]:n.dataset?n.dataset[e]:n.getAttribute("data-".concat(St(e)))}function ut(n,e,t){Ee(t)?n[e]=t:n.dataset?n.dataset[e]=t:n.setAttribute("data-".concat(St(e)),t)}var Li=function(){var n=!1;if(Je){var e=!1,t=function(){},i=Object.defineProperty({},"once",{get:function(){return n=!0,e},set:function(a){e=a}});re.addEventListener("test",t,i),re.removeEventListener("test",t,i)}return n}();function O(n,e,t){var i=arguments.length>3&&arguments[3]!==void 0?arguments[3]:{},s=t;e.trim().split($t).forEach(function(a){if(!Li){var o=n.listeners;o&&o[a]&&o[a][t]&&(s=o[a][t],delete o[a][t],Object.keys(o[a]).length===0&&delete o[a],Object.keys(o).length===0&&delete n.listeners)}n.removeEventListener(a,s,i)})}function I(n,e,t){var i=arguments.length>3&&arguments[3]!==void 0?arguments[3]:{},s=t;e.trim().split($t).forEach(function(a){if(i.once&&!Li){var o=n.listeners,l=o===void 0?{}:o;s=function(){delete l[a][t],n.removeEventListener(a,s,i);for(var d=arguments.length,h=new Array(d),v=0;vl?P=l/E:$=c*E,S=W(S)?S:.9,$=Math.min($*S,v),P=Math.min(P*S,_);var q=(l-$)/2,R=(c-P)/2,A={left:q,top:R,x:q,y:R,width:$,height:P,oldRatio:1,ratio:$/v,aspectRatio:E,naturalWidth:v,naturalHeight:_},X=G({},A);i.rotatable&&(A.rotate=d.rotate||0,X.rotate=0),i.scalable&&(A.scaleX=d.scaleX||1,A.scaleY=d.scaleY||1,X.scaleX=1,X.scaleY=1),t.imageData=A,t.initialImageData=X,e&&e()})},renderImage:function(e){var t=this,i=this.image,s=this.imageData;if(te(i,G({width:s.width,height:s.height,marginLeft:s.x,marginTop:s.y},Ye(s))),e)if((this.viewing||this.moving||this.rotating||this.scaling||this.zooming)&&this.options.transition&&be(i,Y)){var a=function(){t.imageRendering=!1,e()};this.imageRendering={abort:function(){O(i,ee,a)}},I(i,ee,a,{once:!0})}else e()},resetImage:function(){var e=this.image;e&&(this.viewing&&this.viewing.abort(),e.parentNode.removeChild(e),this.image=null,this.title.innerHTML="")}},cc={bind:function(){var e=this.options,t=this.viewer,i=this.canvas,s=this.element.ownerDocument;I(t,Le,this.onClick=this.click.bind(this)),I(t,Nt,this.onDragStart=this.dragstart.bind(this)),I(i,Dt,this.onPointerDown=this.pointerdown.bind(this)),I(s,zt,this.onPointerMove=this.pointermove.bind(this)),I(s,xt,this.onPointerUp=this.pointerup.bind(this)),I(s,Mt,this.onKeyDown=this.keydown.bind(this)),I(window,Ot,this.onResize=this.resize.bind(this)),e.zoomable&&e.zoomOnWheel&&I(t,Ht,this.onWheel=this.wheel.bind(this),{passive:!1,capture:!0}),e.toggleOnDblclick&&I(i,ct,this.onDblclick=this.dblclick.bind(this))},unbind:function(){var e=this.options,t=this.viewer,i=this.canvas,s=this.element.ownerDocument;O(t,Le,this.onClick),O(t,Nt,this.onDragStart),O(i,Dt,this.onPointerDown),O(s,zt,this.onPointerMove),O(s,xt,this.onPointerUp),O(s,Mt,this.onKeyDown),O(window,Ot,this.onResize),e.zoomable&&e.zoomOnWheel&&O(t,Ht,this.onWheel,{passive:!1,capture:!0}),e.toggleOnDblclick&&O(i,ct,this.onDblclick)}},uc={click:function(e){var t=this.options,i=this.imageData,s=e.target,a=ke(s,je);switch(!a&&s.localName==="img"&&s.parentElement.localName==="li"&&(s=s.parentElement,a=ke(s,je)),$e&&e.isTrusted&&s===this.canvas&&clearTimeout(this.clickCanvasTimeout),a){case"mix":this.played?this.stop():t.inline?this.fulled?this.exit():this.full():this.hide();break;case"hide":this.pointerMoved||this.hide();break;case"view":this.view(ke(s,"index"));break;case"zoom-in":this.zoom(.1,!0);break;case"zoom-out":this.zoom(-.1,!0);break;case"one-to-one":this.toggle();break;case"reset":this.reset();break;case"prev":this.prev(t.loop);break;case"play":this.play(t.fullscreen);break;case"next":this.next(t.loop);break;case"rotate-left":this.rotate(-90);break;case"rotate-right":this.rotate(90);break;case"flip-horizontal":this.scaleX(-i.scaleX||-1);break;case"flip-vertical":this.scaleY(-i.scaleY||-1);break;default:this.played&&this.stop()}},dblclick:function(e){e.preventDefault(),this.viewed&&e.target===this.image&&($e&&e.isTrusted&&clearTimeout(this.doubleClickImageTimeout),this.toggle(e.isTrusted?e:e.detail&&e.detail.originalEvent))},load:function(){var e=this;this.timeout&&(clearTimeout(this.timeout),this.timeout=!1);var t=this.element,i=this.options,s=this.image,a=this.index,o=this.viewerData;M(s,Ce),i.loading&&M(this.canvas,Se),s.style.cssText="height:0;"+"margin-left:".concat(o.width/2,"px;")+"margin-top:".concat(o.height/2,"px;")+"max-width:none!important;position:relative;width:0;",this.initImage(function(){Me(s,Gl,i.movable),Me(s,Y,i.transition),e.renderImage(function(){e.viewed=!0,e.viewing=!1,x(i.viewed)&&I(t,Ne,i.viewed,{once:!0}),U(t,Ne,{originalImage:e.images[a],index:a,image:s},{cancelable:!1})})})},loadImage:function(e){var t=e.target,i=t.parentNode,s=i.offsetWidth||30,a=i.offsetHeight||50,o=!!ke(t,"filled");Ei(t,this.options,function(l,c){var d=l/c,h=s,v=a;a*d>s?o?h=a*d:v=s/d:o?v=s/d:h=a*d,te(t,G({width:h,height:v},Ye({translateX:(s-h)/2,translateY:(a-v)/2})))})},keydown:function(e){var t=this.options;if(t.keyboard){var i=e.keyCode||e.which||e.charCode;switch(i){case 13:this.viewer.contains(e.target)&&this.click(e);break}if(this.fulled)switch(i){case 27:this.played?this.stop():t.inline?this.fulled&&this.exit():this.hide();break;case 32:this.played&&this.stop();break;case 37:this.played&&this.playing?this.playing.prev():this.prev(t.loop);break;case 38:e.preventDefault(),this.zoom(t.zoomRatio,!0);break;case 39:this.played&&this.playing?this.playing.next():this.next(t.loop);break;case 40:e.preventDefault(),this.zoom(-t.zoomRatio,!0);break;case 48:case 49:e.ctrlKey&&(e.preventDefault(),this.toggle());break}}},dragstart:function(e){e.target.localName==="img"&&e.preventDefault()},pointerdown:function(e){var t=this.options,i=this.pointers,s=e.buttons,a=e.button;if(this.pointerMoved=!1,!(!this.viewed||this.showing||this.viewing||this.hiding||(e.type==="mousedown"||e.type==="pointerdown"&&e.pointerType==="mouse")&&(W(s)&&s!==1||W(a)&&a!==0||e.ctrlKey))){e.preventDefault(),e.changedTouches?B(e.changedTouches,function(l){i[l.identifier]=He(l)}):i[e.pointerId||0]=He(e);var o=t.movable?Re:!1;t.zoomOnTouch&&t.zoomable&&Object.keys(i).length>1?o=Ie:t.slideOnTouch&&(e.pointerType==="touch"||e.type==="touchstart")&&this.isSwitchable()&&(o=Si),t.transition&&(o===Re||o===Ie)&&M(this.image,Y),this.action=o}},pointermove:function(e){var t=this.pointers,i=this.action;!this.viewed||!i||(e.preventDefault(),e.changedTouches?B(e.changedTouches,function(s){G(t[s.identifier]||{},He(s,!0))}):G(t[e.pointerId||0]||{},He(e,!0)),this.change(e))},pointerup:function(e){var t=this,i=this.options,s=this.action,a=this.pointers,o;e.changedTouches?B(e.changedTouches,function(l){o=a[l.identifier],delete a[l.identifier]}):(o=a[e.pointerId||0],delete a[e.pointerId||0]),s&&(e.preventDefault(),i.transition&&(s===Re||s===Ie)&&T(this.image,Y),this.action=!1,$e&&s!==Ie&&o&&Date.now()-o.timeStamp<500&&(clearTimeout(this.clickCanvasTimeout),clearTimeout(this.doubleClickImageTimeout),i.toggleOnDblclick&&this.viewed&&e.target===this.image?this.imageClicked?(this.imageClicked=!1,this.doubleClickImageTimeout=setTimeout(function(){U(t.image,ct,{originalEvent:e})},50)):(this.imageClicked=!0,this.doubleClickImageTimeout=setTimeout(function(){t.imageClicked=!1},500)):(this.imageClicked=!1,i.backdrop&&i.backdrop!=="static"&&e.target===this.canvas&&(this.clickCanvasTimeout=setTimeout(function(){U(t.canvas,Le,{originalEvent:e})},50)))))},resize:function(){var e=this;if(!(!this.isShown||this.hiding)&&(this.fulled&&(this.close(),this.initBody(),this.open()),this.initContainer(),this.initViewer(),this.renderViewer(),this.renderList(),this.viewed&&this.initImage(function(){e.renderImage()}),this.played)){if(this.options.fullscreen&&this.fulled&&!(document.fullscreenElement||document.webkitFullscreenElement||document.mozFullScreenElement||document.msFullscreenElement)){this.stop();return}B(this.player.getElementsByTagName("img"),function(t){I(t,J,e.loadImage.bind(e),{once:!0}),U(t,J)})}},wheel:function(e){var t=this;if(this.viewed&&(e.preventDefault(),!this.wheeling)){this.wheeling=!0,setTimeout(function(){t.wheeling=!1},50);var i=Number(this.options.zoomRatio)||.1,s=1;e.deltaY?s=e.deltaY>0?1:-1:e.wheelDelta?s=-e.wheelDelta/120:e.detail&&(s=e.detail>0?1:-1),this.zoom(-s*i,!0,null,e)}}},dc={show:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,t=this.element,i=this.options;if(i.inline||this.showing||this.isShown||this.showing)return this;if(!this.ready)return this.build(),this.ready&&this.show(e),this;if(x(i.show)&&I(t,Ft,i.show,{once:!0}),U(t,Ft)===!1||!this.ready)return this;this.hiding&&this.transitioning.abort(),this.showing=!0,this.open();var s=this.viewer;if(M(s,he),s.setAttribute("role","dialog"),s.setAttribute("aria-labelledby",this.title.id),s.setAttribute("aria-modal",!0),s.removeAttribute("aria-hidden"),i.transition&&!e){var a=this.shown.bind(this);this.transitioning={abort:function(){O(s,ee,a),M(s,Z)}},T(s,Y),s.initialOffsetWidth=s.offsetWidth,I(s,ee,a,{once:!0}),T(s,Z)}else T(s,Z),this.shown();return this},hide:function(){var e=this,t=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,i=this.element,s=this.options;if(s.inline||this.hiding||!(this.isShown||this.showing))return this;if(x(s.hide)&&I(i,Wt,s.hide,{once:!0}),U(i,Wt)===!1)return this;this.showing&&this.transitioning.abort(),this.hiding=!0,this.played?this.stop():this.viewing&&this.viewing.abort();var a=this.viewer,o=this.image,l=function(){M(a,Z),e.hidden()};if(s.transition&&!t){var c=function h(v){v&&v.target===a&&(O(a,ee,h),e.hidden())},d=function(){be(a,Y)?(I(a,ee,c),M(a,Z)):l()};this.transitioning={abort:function(){e.viewed&&be(o,Y)?O(o,ee,d):be(a,Y)&&O(a,ee,c)}},this.viewed&&be(o,Y)?(I(o,ee,d,{once:!0}),this.zoomTo(0,!1,null,null,!0)):d()}else l();return this},view:function(){var e=this,t=arguments.length>0&&arguments[0]!==void 0?arguments[0]:this.options.initialViewIndex;if(t=Number(t)||0,this.hiding||this.played||t<0||t>=this.length||this.viewed&&t===this.index)return this;if(!this.isShown)return this.index=t,this.show();this.viewing&&this.viewing.abort();var i=this.element,s=this.options,a=this.title,o=this.canvas,l=this.items[t],c=l.querySelector("img"),d=ke(c,"originalUrl"),h=c.getAttribute("alt"),v=document.createElement("img");if(B(s.inheritedAttributes,function(P){var q=c.getAttribute(P);q!==null&&v.setAttribute(P,q)}),v.src=d,v.alt=h,x(s.view)&&I(i,Ut,s.view,{once:!0}),U(i,Ut,{originalImage:this.images[t],index:t,image:v})===!1||!this.isShown||this.hiding||this.played)return this;var _=this.items[this.index];_&&(M(_,ze),_.removeAttribute("aria-selected")),T(l,ze),l.setAttribute("aria-selected",!0),s.focus&&l.focus(),this.image=v,this.viewed=!1,this.index=t,this.imageData={},T(v,Ce),s.loading&&T(o,Se),o.innerHTML="",o.appendChild(v),this.renderList(),a.innerHTML="";var E=function(){var q=e.imageData,R=Array.isArray(s.title)?s.title[1]:s.title;a.innerHTML=ic(x(R)?R.call(e,v,q):"".concat(h," (").concat(q.naturalWidth," × ").concat(q.naturalHeight,")"))},S,$;return I(i,Ne,E,{once:!0}),this.viewing={abort:function(){O(i,Ne,E),v.complete?e.imageRendering?e.imageRendering.abort():e.imageInitializing&&e.imageInitializing.abort():(v.src="",O(v,J,S),e.timeout&&clearTimeout(e.timeout))}},v.complete?this.load():(I(v,J,S=function(){O(v,ve,$),e.load()},{once:!0}),I(v,ve,$=function(){O(v,J,S),e.timeout&&(clearTimeout(e.timeout),e.timeout=!1),M(v,Ce),s.loading&&M(e.canvas,Se)},{once:!0}),this.timeout&&clearTimeout(this.timeout),this.timeout=setTimeout(function(){M(v,Ce),e.timeout=!1},1e3)),this},prev:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,t=this.index-1;return t<0&&(t=e?this.length-1:0),this.view(t),this},next:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,t=this.length-1,i=this.index+1;return i>t&&(i=e?0:t),this.view(i),this},move:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e,i=this.imageData;return this.moveTo(ye(e)?e:i.x+Number(e),ye(t)?t:i.y+Number(t)),this},moveTo:function(e){var t=this,i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e,s=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,a=this.element,o=this.options,l=this.imageData;if(e=Number(e),i=Number(i),this.viewed&&!this.played&&o.movable){var c=l.x,d=l.y,h=!1;if(W(e)?h=!0:e=c,W(i)?h=!0:i=d,h){if(x(o.move)&&I(a,qt,o.move,{once:!0}),U(a,qt,{x:e,y:i,oldX:c,oldY:d,originalEvent:s})===!1)return this;l.x=e,l.y=i,l.left=e,l.top=i,this.moving=!0,this.renderImage(function(){t.moving=!1,x(o.moved)&&I(a,jt,o.moved,{once:!0}),U(a,jt,{x:e,y:i,oldX:c,oldY:d,originalEvent:s},{cancelable:!1})})}}return this},rotate:function(e){return this.rotateTo((this.imageData.rotate||0)+Number(e)),this},rotateTo:function(e){var t=this,i=this.element,s=this.options,a=this.imageData;if(e=Number(e),W(e)&&this.viewed&&!this.played&&s.rotatable){var o=a.rotate;if(x(s.rotate)&&I(i,Xt,s.rotate,{once:!0}),U(i,Xt,{degree:e,oldDegree:o})===!1)return this;a.rotate=e,this.rotating=!0,this.renderImage(function(){t.rotating=!1,x(s.rotated)&&I(i,Gt,s.rotated,{once:!0}),U(i,Gt,{degree:e,oldDegree:o},{cancelable:!1})})}return this},scaleX:function(e){return this.scale(e,this.imageData.scaleY),this},scaleY:function(e){return this.scale(this.imageData.scaleX,e),this},scale:function(e){var t=this,i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e,s=this.element,a=this.options,o=this.imageData;if(e=Number(e),i=Number(i),this.viewed&&!this.played&&a.scalable){var l=o.scaleX,c=o.scaleY,d=!1;if(W(e)?d=!0:e=l,W(i)?d=!0:i=c,d){if(x(a.scale)&&I(s,Kt,a.scale,{once:!0}),U(s,Kt,{scaleX:e,scaleY:i,oldScaleX:l,oldScaleY:c})===!1)return this;o.scaleX=e,o.scaleY=i,this.scaling=!0,this.renderImage(function(){t.scaling=!1,x(a.scaled)&&I(s,Zt,a.scaled,{once:!0}),U(s,Zt,{scaleX:e,scaleY:i,oldScaleX:l,oldScaleY:c},{cancelable:!1})})}}return this},zoom:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,s=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,a=this.imageData;return e=Number(e),e<0?e=1/(1-e):e=1+e,this.zoomTo(a.width*e/a.naturalWidth,t,i,s),this},zoomTo:function(e){var t=this,i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,s=arguments.length>2&&arguments[2]!==void 0?arguments[2]:null,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:null,o=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1,l=this.element,c=this.options,d=this.pointers,h=this.imageData,v=h.x,_=h.y,E=h.width,S=h.height,$=h.naturalWidth,P=h.naturalHeight;if(e=Math.max(0,e),W(e)&&this.viewed&&!this.played&&(o||c.zoomable)){if(!o){var q=Math.max(.01,c.minZoomRatio),R=Math.min(100,c.maxZoomRatio);e=Math.min(Math.max(e,q),R)}if(a)switch(a.type){case"wheel":c.zoomRatio>=.055&&e>.95&&e<1.05&&(e=1);break;case"pointermove":case"touchmove":case"mousemove":e>.99&&e<1.01&&(e=1);break}var A=$*e,X=P*e,Q=A-E,ie=X-S,de=h.ratio;if(x(c.zoom)&&I(l,Jt,c.zoom,{once:!0}),U(l,Jt,{ratio:e,oldRatio:de,originalEvent:a})===!1)return this;if(this.zooming=!0,a){var Pe=sc(this.viewer),ge=d&&Object.keys(d).length>0?rc(d):{pageX:a.pageX,pageY:a.pageY};h.x-=Q*((ge.pageX-Pe.left-v)/E),h.y-=ie*((ge.pageY-Pe.top-_)/S)}else we(s)&&W(s.x)&&W(s.y)?(h.x-=Q*((s.x-v)/E),h.y-=ie*((s.y-_)/S)):(h.x-=Q/2,h.y-=ie/2);h.left=h.x,h.top=h.y,h.width=A,h.height=X,h.oldRatio=de,h.ratio=e,this.renderImage(function(){t.zooming=!1,x(c.zoomed)&&I(l,Qt,c.zoomed,{once:!0}),U(l,Qt,{ratio:e,oldRatio:de,originalEvent:a},{cancelable:!1})}),i&&this.tooltip()}return this},play:function(){var e=this,t=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;if(!this.isShown||this.played)return this;var i=this.element,s=this.options;if(x(s.play)&&I(i,ei,s.play,{once:!0}),U(i,ei)===!1)return this;var a=this.player,o=this.loadImage.bind(this),l=[],c=0,d=0;if(this.played=!0,this.onLoadWhenPlay=o,t&&this.requestFullscreen(t),T(a,_e),B(this.items,function(_,E){var S=_.querySelector("img"),$=document.createElement("img");$.src=ke(S,"originalUrl"),$.alt=S.getAttribute("alt"),$.referrerPolicy=S.referrerPolicy,c+=1,T($,We),Me($,Y,s.transition),be(_,ze)&&(T($,Z),d=E),l.push($),I($,J,o,{once:!0}),a.appendChild($)}),W(s.interval)&&s.interval>0){var h=function _(){clearTimeout(e.playing.timeout),M(l[d],Z),d-=1,d=d>=0?d:c-1,T(l[d],Z),e.playing.timeout=setTimeout(_,s.interval)},v=function _(){clearTimeout(e.playing.timeout),M(l[d],Z),d+=1,d=d1&&(this.playing={prev:h,next:v,timeout:setTimeout(v,s.interval)})}return this},stop:function(){var e=this;if(!this.played)return this;var t=this.element,i=this.options;if(x(i.stop)&&I(t,ti,i.stop,{once:!0}),U(t,ti)===!1)return this;var s=this.player;return clearTimeout(this.playing.timeout),this.playing=!1,this.played=!1,B(s.getElementsByTagName("img"),function(a){O(a,J,e.onLoadWhenPlay)}),M(s,_e),s.innerHTML="",this.exitFullscreen(),this},full:function(){var e=this,t=this.options,i=this.viewer,s=this.image,a=this.list;return!this.isShown||this.played||this.fulled||!t.inline?this:(this.fulled=!0,this.open(),T(this.button,It),t.transition&&(M(a,Y),this.viewed&&M(s,Y)),T(i,lt),i.setAttribute("role","dialog"),i.setAttribute("aria-labelledby",this.title.id),i.setAttribute("aria-modal",!0),i.removeAttribute("style"),te(i,{zIndex:t.zIndex}),t.focus&&this.enforceFocus(),this.initContainer(),this.viewerData=G({},this.containerData),this.renderList(),this.viewed&&this.initImage(function(){e.renderImage(function(){t.transition&&setTimeout(function(){T(s,Y),T(a,Y)},0)})}),this)},exit:function(){var e=this,t=this.options,i=this.viewer,s=this.image,a=this.list;return!this.isShown||this.played||!this.fulled||!t.inline?this:(this.fulled=!1,this.close(),M(this.button,It),t.transition&&(M(a,Y),this.viewed&&M(s,Y)),t.focus&&this.clearEnforceFocus(),i.removeAttribute("role"),i.removeAttribute("aria-labelledby"),i.removeAttribute("aria-modal"),M(i,lt),te(i,{zIndex:t.zIndexInline}),this.viewerData=G({},this.parentData),this.renderViewer(),this.renderList(),this.viewed&&this.initImage(function(){e.renderImage(function(){t.transition&&setTimeout(function(){T(s,Y),T(a,Y)},0)})}),this)},tooltip:function(){var e=this,t=this.options,i=this.tooltipBox,s=this.imageData;return!this.viewed||this.played||!t.tooltip?this:(i.textContent="".concat(Math.round(s.ratio*100),"%"),this.tooltipping?clearTimeout(this.tooltipping):t.transition?(this.fading&&U(i,ee),T(i,_e),T(i,We),T(i,Y),i.removeAttribute("aria-hidden"),i.initialOffsetWidth=i.offsetWidth,T(i,Z)):(T(i,_e),i.removeAttribute("aria-hidden")),this.tooltipping=setTimeout(function(){t.transition?(I(i,ee,function(){M(i,_e),M(i,We),M(i,Y),i.setAttribute("aria-hidden",!0),e.fading=!1},{once:!0}),M(i,Z),e.fading=!0):(M(i,_e),i.setAttribute("aria-hidden",!0)),e.tooltipping=!1},1e3),this)},toggle:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:null;return this.imageData.ratio===1?this.zoomTo(this.imageData.oldRatio,!0,null,e):this.zoomTo(1,!0,null,e),this},reset:function(){return this.viewed&&!this.played&&(this.imageData=G({},this.initialImageData),this.renderImage()),this},update:function(){var e=this,t=this.element,i=this.options,s=this.isImg;if(s&&!t.parentNode)return this.destroy();var a=[];if(B(s?[t]:t.querySelectorAll("img"),function(d){x(i.filter)?i.filter.call(e,d)&&a.push(d):e.getImageURL(d)&&a.push(d)}),!a.length)return this;if(this.images=a,this.length=a.length,this.ready){var o=[];if(B(this.items,function(d,h){var v=d.querySelector("img"),_=a[h];_&&v?(_.src!==v.src||_.alt!==v.alt)&&o.push(h):o.push(h)}),te(this.list,{width:"auto"}),this.initList(),this.isShown)if(this.length){if(this.viewed){var l=o.indexOf(this.index);if(l>=0)this.viewed=!1,this.view(Math.max(Math.min(this.index-l,this.length-1),0));else{var c=this.items[this.index];T(c,ze),c.setAttribute("aria-selected",!0)}}}else this.image=null,this.viewed=!1,this.index=0,this.imageData={},this.canvas.innerHTML="",this.title.innerHTML=""}else this.build();return this},destroy:function(){var e=this.element,t=this.options;return e[C]?(this.destroyed=!0,this.ready?(this.played&&this.stop(),t.inline?(this.fulled&&this.exit(),this.unbind()):this.isShown?(this.viewing&&(this.imageRendering?this.imageRendering.abort():this.imageInitializing&&this.imageInitializing.abort()),this.hiding&&this.transitioning.abort(),this.hidden()):this.showing&&(this.transitioning.abort(),this.hidden()),this.ready=!1,this.viewer.parentNode.removeChild(this.viewer)):t.inline&&(this.delaying?this.delaying.abort():this.initializing&&this.initializing.abort()),t.inline||O(e,Le,this.onStart),e[C]=void 0,this):this}},hc={getImageURL:function(e){var t=this.options.url;return Ae(t)?t=e.getAttribute(t):x(t)?t=t.call(this,e):t="",t},enforceFocus:function(){var e=this;this.clearEnforceFocus(),I(document,At,this.onFocusin=function(t){var i=e.viewer,s=t.target;if(!(s===document||s===i||i.contains(s))){for(;s;){if(s.getAttribute("tabindex")!==null||s.getAttribute("aria-modal")==="true")return;s=s.parentElement}i.focus()}})},clearEnforceFocus:function(){this.onFocusin&&(O(document,At,this.onFocusin),this.onFocusin=null)},open:function(){var e=this.body;T(e,Ct),this.scrollbarWidth>0&&(e.style.paddingRight="".concat(this.scrollbarWidth+(parseFloat(this.initialBodyComputedPaddingRight)||0),"px"))},close:function(){var e=this.body;M(e,Ct),this.scrollbarWidth>0&&(e.style.paddingRight=this.initialBodyPaddingRight)},shown:function(){var e=this.element,t=this.options,i=this.viewer;this.fulled=!0,this.isShown=!0,this.render(),this.bind(),this.showing=!1,t.focus&&(i.focus(),this.enforceFocus()),x(t.shown)&&I(e,Rt,t.shown,{once:!0}),U(e,Rt)!==!1&&this.ready&&this.isShown&&!this.hiding&&this.view(this.index)},hidden:function(){var e=this.element,t=this.options,i=this.viewer;t.fucus&&this.clearEnforceFocus(),this.close(),this.unbind(),T(i,he),i.removeAttribute("role"),i.removeAttribute("aria-labelledby"),i.removeAttribute("aria-modal"),i.setAttribute("aria-hidden",!0),this.resetList(),this.resetImage(),this.fulled=!1,this.viewed=!1,this.isShown=!1,this.hiding=!1,this.destroyed||(x(t.hidden)&&I(e,Yt,t.hidden,{once:!0}),U(e,Yt,null,{cancelable:!1}))},requestFullscreen:function(e){var t=this.element.ownerDocument;if(this.fulled&&!(t.fullscreenElement||t.webkitFullscreenElement||t.mozFullScreenElement||t.msFullscreenElement)){var i=t.documentElement;i.requestFullscreen?we(e)?i.requestFullscreen(e):i.requestFullscreen():i.webkitRequestFullscreen?i.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT):i.mozRequestFullScreen?i.mozRequestFullScreen():i.msRequestFullscreen&&i.msRequestFullscreen()}},exitFullscreen:function(){var e=this.element.ownerDocument;this.fulled&&(e.fullscreenElement||e.webkitFullscreenElement||e.mozFullScreenElement||e.msFullscreenElement)&&(e.exitFullscreen?e.exitFullscreen():e.webkitExitFullscreen?e.webkitExitFullscreen():e.mozCancelFullScreen?e.mozCancelFullScreen():e.msExitFullscreen&&e.msExitFullscreen())},change:function(e){var t=this.options,i=this.pointers,s=i[Object.keys(i)[0]];if(s){var a=s.endX-s.startX,o=s.endY-s.startY;switch(this.action){case Re:(a!==0||o!==0)&&(this.pointerMoved=!0,this.move(a,o,e));break;case Ie:this.zoom(oc(i),!1,null,e);break;case Si:{this.action="switched";var l=Math.abs(a);l>1&&l>Math.abs(o)&&(this.pointers={},a>1?this.prev(t.loop):a<-1&&this.next(t.loop));break}}B(i,function(c){c.startX=c.endX,c.startY=c.endY})}},isSwitchable:function(){var e=this.imageData,t=this.viewerData;return this.length>1&&e.x>=0&&e.y>=0&&e.width<=t.width&&e.height<=t.height}},fc=re.Viewer,vc=function(n){return function(){return n+=1,n}}(-1),Ti=function(){function n(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{};if(Hl(this,n),!e||e.nodeType!==1)throw new Error("The first argument is required and must be an element.");this.element=e,this.options=G({},Pt,we(t)&&t),this.action=!1,this.fading=!1,this.fulled=!1,this.hiding=!1,this.imageClicked=!1,this.imageData={},this.index=this.options.initialViewIndex,this.isImg=!1,this.isShown=!1,this.length=0,this.moving=!1,this.played=!1,this.playing=!1,this.pointers={},this.ready=!1,this.rotating=!1,this.scaling=!1,this.showing=!1,this.timeout=!1,this.tooltipping=!1,this.viewed=!1,this.viewing=!1,this.wheeling=!1,this.zooming=!1,this.pointerMoved=!1,this.id=vc(),this.init()}return Bl(n,[{key:"init",value:function(){var t=this,i=this.element,s=this.options;if(!i[C]){i[C]=this,s.focus&&!s.keyboard&&(s.focus=!1);var a=i.localName==="img",o=[];if(B(a?[i]:i.querySelectorAll("img"),function(d){x(s.filter)?s.filter.call(t,d)&&o.push(d):t.getImageURL(d)&&o.push(d)}),this.isImg=a,this.length=o.length,this.images=o,this.initBody(),ye(document.createElement(C).style.transition)&&(s.transition=!1),s.inline){var l=0,c=function(){if(l+=1,l===t.length){var h;t.initializing=!1,t.delaying={abort:function(){clearTimeout(h)}},h=setTimeout(function(){t.delaying=!1,t.build()},0)}};this.initializing={abort:function(){B(o,function(h){h.complete||(O(h,J,c),O(h,ve,c))})}},B(o,function(d){if(d.complete)c();else{var h,v;I(d,J,h=function(){O(d,ve,v),c()},{once:!0}),I(d,ve,v=function(){O(d,J,h),c()},{once:!0})}})}else I(i,Le,this.onStart=function(d){var h=d.target;h.localName==="img"&&(!x(s.filter)||s.filter.call(t,h))&&t.view(t.images.indexOf(h))})}}},{key:"build",value:function(){if(!this.ready){var t=this.element,i=this.options,s=t.parentNode,a=document.createElement("div");a.innerHTML=Wl;var o=a.querySelector(".".concat(C,"-container")),l=o.querySelector(".".concat(C,"-title")),c=o.querySelector(".".concat(C,"-toolbar")),d=o.querySelector(".".concat(C,"-navbar")),h=o.querySelector(".".concat(C,"-button")),v=o.querySelector(".".concat(C,"-canvas"));if(this.parent=s,this.viewer=o,this.title=l,this.toolbar=c,this.navbar=d,this.button=h,this.canvas=v,this.footer=o.querySelector(".".concat(C,"-footer")),this.tooltipBox=o.querySelector(".".concat(C,"-tooltip")),this.player=o.querySelector(".".concat(C,"-player")),this.list=o.querySelector(".".concat(C,"-list")),o.id="".concat(C).concat(this.id),l.id="".concat(C,"Title").concat(this.id),T(l,i.title?Oe(Array.isArray(i.title)?i.title[0]:i.title):he),T(d,i.navbar?Oe(i.navbar):he),Me(h,he,!i.button),i.keyboard&&h.setAttribute("tabindex",0),i.backdrop&&(T(o,"".concat(C,"-backdrop")),!i.inline&&i.backdrop!=="static"&&ut(v,je,"hide")),Ae(i.className)&&i.className&&i.className.split($t).forEach(function(A){T(o,A)}),i.toolbar){var _=document.createElement("ul"),E=we(i.toolbar),S=xe.slice(0,3),$=xe.slice(7,9),P=xe.slice(9);E||T(c,Oe(i.toolbar)),B(E?i.toolbar:xe,function(A,X){var Q=E&&we(A),ie=E?St(X):A,de=Q&&!ye(A.show)?A.show:A;if(!(!de||!i.zoomable&&S.indexOf(ie)!==-1||!i.rotatable&&$.indexOf(ie)!==-1||!i.scalable&&P.indexOf(ie)!==-1)){var Pe=Q&&!ye(A.size)?A.size:A,ge=Q&&!ye(A.click)?A.click:A,oe=document.createElement("li");i.keyboard&&oe.setAttribute("tabindex",0),oe.setAttribute("role","button"),T(oe,"".concat(C,"-").concat(ie)),x(ge)||ut(oe,je,ie),W(de)&&T(oe,Oe(de)),["small","large"].indexOf(Pe)!==-1?T(oe,"".concat(C,"-").concat(Pe)):ie==="play"&&T(oe,"".concat(C,"-large")),x(ge)&&I(oe,Le,ge),_.appendChild(oe)}}),c.appendChild(_)}else T(c,he);if(!i.rotatable){var q=c.querySelectorAll('li[class*="rotate"]');T(q,Ce),B(q,function(A){c.appendChild(A)})}if(i.inline)T(h,Ul),te(o,{zIndex:i.zIndexInline}),window.getComputedStyle(s).position==="static"&&te(s,{position:"relative"}),s.insertBefore(o,t.nextSibling);else{T(h,Yl),T(o,lt),T(o,We),T(o,he),te(o,{zIndex:i.zIndex});var R=i.container;Ae(R)&&(R=t.ownerDocument.querySelector(R)),R||(R=this.body),R.appendChild(o)}if(i.inline&&(this.render(),this.bind(),this.isShown=!0),this.ready=!0,x(i.ready)&&I(t,Bt,i.ready,{once:!0}),U(t,Bt)===!1){this.ready=!1;return}this.ready&&i.inline&&this.view(this.index)}}}],[{key:"noConflict",value:function(){return window.Viewer=fc,n}},{key:"setDefaults",value:function(t){G(Pt,we(t)&&t)}}]),n}();G(Ti.prototype,lc,cc,uc,dc,hc);const ii=(n=".vp-doc img",e)=>{const t={navbar:!1,title:!1,toolbar:{zoomIn:4,zoomOut:4,prev:4,next:4,reset:4,oneToOne:4}};document.querySelectorAll(n).forEach(i=>{i.onclick=()=>{const s=new Ti(i,{...t,...e,hide(a){s.destroy()}});s.show()},i.style.cursor="zoom-in"})},pc=(n,e,t)=>{le(()=>{ii(e,t)}),ue(()=>n.path,()=>ri(()=>{ii(e,t)}))},mc=["id","host","repo","repoid","category","categoryid","mapping","term","strict","reactionsenabled","emitmetadata","inputposition","theme","lang","loading"],gc=w({__name:"Giscus",props:{id:{},host:{},repo:{},repoId:{},category:{},categoryId:{},mapping:{},term:{},theme:{},strict:{},reactionsEnabled:{},emitMetadata:{},inputPosition:{},lang:{},loading:{}},setup(n){const e=z(!1);return le(()=>{e.value=!0,ci(()=>import("./giscus-aTimukGI.jKnbteiG.js"),__vite__mapDeps([]))}),(t,i)=>e.value?(r(),f("giscus-widget",{key:0,id:t.id,host:t.host,repo:t.repo,repoid:t.repoId,category:t.category,categoryid:t.categoryId,mapping:t.mapping,term:t.term,strict:t.strict,reactionsenabled:t.reactionsEnabled,emitmetadata:t.emitMetadata,inputposition:t.inputPosition,theme:t.theme,lang:t.lang,loading:t.loading},null,8,mc)):y("",!0)}}),_c=w({setup(){const n=Ve(),{isDark:e}=ni();return()=>Ue("div",{style:{marginTop:"20px"}},Ue(gc,{repo:"zigcc/zig-course",repoId:"R_kgDOKRsb5Q",category:"Comments",categoryId:"DIC_kwDOKRsb5c4Cbx2i",mapping:"pathname",strict:"1",reactionsEnabled:"1",emitMetadata:"0",inputPosition:"top",theme:e.value?"dark":"light",lang:"zh-CN",term:n.path}))}}),yc={...et,enhanceApp(n){et.enhanceApp(n)},Layout(){return Ue(et.Layout,null,{"doc-after":()=>Ue(_c)})},setup(){const n=Ve();pc(n)}};export{yc as R,cr as c,N as u};
 function __vite__mapDeps(indexes) {
   if (!__vite__mapDeps.viteFileDeps) {
-    __vite__mapDeps.viteFileDeps = ["assets/chunks/VPLocalSearchBox.h_vxVhNN.js","assets/chunks/framework.iEE2KsGo.js"]
+    __vite__mapDeps.viteFileDeps = ["assets/chunks/VPLocalSearchBox.NRnZ9XZ2.js","assets/chunks/framework.iEE2KsGo.js"]
   }
   return indexes.map((i) => __vite__mapDeps.viteFileDeps[i])
 }
diff --git a/assets/engineering_build-system.md.HJZocaoQ.js b/assets/engineering_build-system.md.0lT4HF-R.js
similarity index 99%
rename from assets/engineering_build-system.md.HJZocaoQ.js
rename to assets/engineering_build-system.md.0lT4HF-R.js
index b48a40d1..dd5b9023 100644
--- a/assets/engineering_build-system.md.HJZocaoQ.js
+++ b/assets/engineering_build-system.md.0lT4HF-R.js
@@ -83,7 +83,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
     // 添加到顶级 install step 中作为依赖
     b.installArtifact(exe);
 }
以上，我们通过使用 b.option 来实现从命令行读取一个参数决定是否剥离二进制程序的调试信息，使用 zig build --help 可以看到输出多了一行：
sh
Project-Specific Options:
-  -Dis_strip=[bool]            whether strip executable
Options 编译期配置 ​
Options 允许我们将一些信息传递到项目中，例如我们可以以此实现让程序打印构建时的时间戳：
zig
const std = @import("std");
+  -Dis_strip=[bool]            whether strip executable
Options 编译期配置 ​
Options 允许我们将一些信息传递到项目中，例如我们可以以此实现让程序打印构建时的时间戳：
zig
const std = @import("std");
 const timestamp = @import("timestamp");
 
 pub fn main() !void {
@@ -243,7 +243,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
     .root_source_file = .{ .path = "src/main.zig" },
     .target = target,
     .optimize = optimize,
-});
embedFile ​
@embedFile 是由 zig 提供的一个内嵌文件的方式，它的引入规则与 @import 相同。
在 build.zig 直接使用 b.anonymousDependency 添加一个匿名模块即可，如：
zig
const std = @import("std");
+});
embedFile ​
@embedFile 是由 zig 提供的一个内嵌文件的方式，它的引入规则与 @import 相同。
在 build.zig 直接使用 b.anonymousDependency 添加一个匿名模块即可，如：
zig
const std = @import("std");
 const hello = @embedFile("hello"); 
 // const hello = @embedFile("hello.txt"); 均可以
 
@@ -289,7 +289,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
 
     // 指定该 step 依赖于 run_exe，即实际的运行
     run_step.dependOn(&run_cmd.step);
-}
不仅仅是以上两种方式，匿名模块还支持直接使用其他程序输出,见下方执行其他命令部分！
执行其他命令 ​
zig 的构建系统还允许我们执行一些额外的命令，录入根据 json 生成某些特定的文件（例如 zig 源代码），构建其他的编程语言（不只是 C / C++），如Golang、Rust、前端项目构建等等！
例如我们可以让 zig 在构建时调用系统的 sh 来输出 hello 并使用 @embedFile 传递给包：
zig
const std = @import("std");
+}
不仅仅是以上两种方式，匿名模块还支持直接使用其他程序输出,见下方执行其他命令部分！
执行其他命令 ​
zig 的构建系统还允许我们执行一些额外的命令，录入根据 json 生成某些特定的文件（例如 zig 源代码），构建其他的编程语言（不只是 C / C++），如Golang、Rust、前端项目构建等等！
例如我们可以让 zig 在构建时调用系统的 sh 来输出 hello 并使用 @embedFile 传递给包：
zig
const std = @import("std");
 const hello = @embedFile("hello"); 
 
 pub fn main() !void {
@@ -351,7 +351,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
 
     // 指定该 step 依赖于 run_exe，即实际的运行
     run_step.dependOn(&run_cmd.step);
-}
构建纯 C 项目 ​
在这里我们使用 GTK4 的官方示例 Hello-World 来作为演 示：
WARNING
在进行本部分教程前请先安装好 GTK4 的依赖，具体安装方法见 GTK 的指南。
zig
const std = @import("std");
+}
构建纯 C 项目 ​
在这里我们使用 GTK4 的官方示例 Hello-World 来作为演 示：
WARNING
在进行本部分教程前请先安装好 GTK4 的依赖，具体安装方法见 GTK 的指南。
zig
const std = @import("std");
 
 pub fn build(b: *std.Build) void {
     // 构建目标
@@ -444,7 +444,7 @@ import{_ as s,c as i,o as a,U as n}from"./chunks/framework.iEE2KsGo.js";const F=
   g_object_unref (app);
 
   return status;
-}
以上构建中我们先使用了 addCSourceFile 来添加 C 源代码，再使用 linkLibC 和 linkSystemLibrary 来链接 C 标准库和 GTK 库。
🅿️ 提示
关于头文件的引入，可以使用 exe.addIncludePath(.{ .path = "path" });
针对多个 C 源代码文件，zig 提供了函数 exe.addCSourceFiles 用于便捷地添加多个源文件。
构建纯 C++ 项目 ​
由于 GTK 的 C++ 构建过于复杂（需要手动编译gtkmm），故我们这里选择构建一个 tinytetris:
WARNING
注意：由于依赖了 curses 库，故只能在 linux 进行编译！
zig
const std = @import("std");
+}
以上构建中我们先使用了 addCSourceFile 来添加 C 源代码，再使用 linkLibC 和 linkSystemLibrary 来链接 C 标准库和 GTK 库。
🅿️ 提示
关于头文件的引入，可以使用 exe.addIncludePath(.{ .path = "path" });
针对多个 C 源代码文件，zig 提供了函数 exe.addCSourceFiles 用于便捷地添加多个源文件。
构建纯 C++ 项目 ​
由于 GTK 的 C++ 构建过于复杂（需要手动编译gtkmm），故我们这里选择构建一个 tinytetris:
WARNING
注意：由于依赖了 curses 库，故只能在 linux 进行编译！
zig
const std = @import("std");
 
 pub fn build(b: *std.Build) void {
     // 构建目标
diff --git a/assets/engineering_build-system.md.HJZocaoQ.lean.js b/assets/engineering_build-system.md.0lT4HF-R.lean.js
similarity index 100%
rename from assets/engineering_build-system.md.HJZocaoQ.lean.js
rename to assets/engineering_build-system.md.0lT4HF-R.lean.js
diff --git a/assets/environment_install-environment.md.aoj-uaPQ.js b/assets/environment_install-environment.md.PTNE6kMW.js
similarity index 67%
rename from assets/environment_install-environment.md.aoj-uaPQ.js
rename to assets/environment_install-environment.md.PTNE6kMW.js
index 7887e32b..3d515eb5 100644
--- a/assets/environment_install-environment.md.aoj-uaPQ.js
+++ b/assets/environment_install-environment.md.PTNE6kMW.js
@@ -1,6 +1,6 @@
-import{_ as s,c as i,o as a,U as t}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"环境安装","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"environment/install-environment.md","filePath":"environment/install-environment.md","lastUpdated":1704979746000}'),e={name:"environment/install-environment.md"},n=t(`
环境安装 ​
🅿️ 提示
当前 Zig 还没有发布 1.0 版本，发布周期与 LLVM 的新版本关联，其发布周期约为 6 个月。 因此，Zig 的发布往往要间隔很久，以目前的开发速度，稳定版最终会变得过时（即便此时还没有新的稳定版），所以官方鼓励用户使用 nightly 版本。
Windows ​
windows 输出中文乱码问题
如果你是中文简体用户，那么建议将 windows 的编码修改为UTF-8编码，由于 zig 的源代码编码格式是 UTF-8，导致在windows下向控制台打印输出中文会发生乱码的现象。
修改方法为：
  1. 打开 widnows 设置中的 时间和语言，进入 语言和区域。
  2. 点击下方的管理语言设置，在新打开的窗口中点击 管理。
  3. 点击下方的 更改系统区域设置，勾选下方的 “使用 unicode UTF-8 提供全球语言支持”
  4. 重启计算机。
Scoop ​
推荐使用 Scoop 工具进行安装，Scoop 的 main 仓库和 version 仓库分别有着最新的 release 和 nightly 版本。
安装方式如下：
sh
scoop bucket add main
+import{_ as s,c as i,o as a,U as t}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"环境安装","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"environment/install-environment.md","filePath":"environment/install-environment.md","lastUpdated":1705067788000}'),e={name:"environment/install-environment.md"},n=t(`
环境安装 ​
🅿️ 提示
当前 Zig 还没有发布 1.0 版本，发布周期与 LLVM 的新版本关联，其发布周期约为 6 个月。 因此，Zig 的发布往往要间隔很久，以目前的开发速度，稳定版最终会变得过时（即便此时还没有新的稳定版），所以官方鼓励用户使用 nightly 版本。
Windows ​
windows 输出中文乱码问题
如果你是中文简体用户，那么建议将 windows 的编码修改为UTF-8编码，由于 zig 的源代码编码格式是 UTF-8，导致在windows下向控制台打印输出中文会发生乱码的现象。
修改方法为：
  1. 打开 widnows 设置中的 时间和语言，进入 语言和区域。
  2. 点击下方的管理语言设置，在新打开的窗口中点击 管理。
  3. 点击下方的 更改系统区域设置，勾选下方的 “使用 unicode UTF-8 提供全球语言支持”
  4. 重启计算机。
Scoop ​
推荐使用 Scoop 工具进行安装，Scoop 的 main 仓库和 version 仓库分别有着最新的 release 和 nightly 版本。
安装方式如下：
sh
scoop bucket add main
 scoop install main/zig
sh
scoop bucket add versions
-scoop install versions/zig-dev
🅿️ 提示
在使用 Scoop 时，推荐将 Zig 作为 global 安装，这样 Zig 会被自动添加进环境变量。
其他的包管理器 ​
也可以使用诸如 WinGet，Chocolatey
sh
winget install -e --id zig.zig
sh
choco install zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，普通用户选择 zig-windows-x86_64 即可。
执行以下命令：
powershell
[Environment]::SetEnvironmentVariable(
+scoop install versions/zig-dev
🅿️ 提示
在使用 Scoop 时，推荐将 Zig 作为 global 安装，这样 Zig 会被自动添加进环境变量。
其他的包管理器 ​
也可以使用诸如 WinGet，Chocolatey
sh
winget install -e --id zig.zig
sh
choco install zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，普通用户选择 zig-windows-x86_64 即可。
执行以下命令：
powershell
[Environment]::SetEnvironmentVariable(
    "Path",
    [Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\\your-path\\zig-windows-x86_64-your-version",
    "Machine"
@@ -8,13 +8,17 @@ import{_ as s,c as i,o as a,U as t}from"./chunks/framework.iEE2KsGo.js";const F=
    "Path",
    [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\\your-path\\zig-windows-x86_64-your-version",
    "User"
-)
🅿️ 提示
以上的 System 对应的系统全局的环境变量， User 对应的是用户的环境变量。如果是个人电脑，使用任意一个没有区别。
首先确保你的路径是正确的，其次你可能注意到路径前面还有一个 ; ，此处并不是拼写错误！
Mac ​
Mac安装 zig 就很方便，但是如果要使用 nightly ，还是需要自行下载并添加环境变量
sh
brew install zig
sh
port install zig
Linux ​
Linux安装的话， 由于发行版的不同，安装的方式五花八门，先列出通过包管理器安装 Zig 的方法，再说明如何手动安装 Zig 并设置环境变量。
包管理器安装 ​
以下列出了支持通过包管理器安装 Zig 的发行版和对应命令：
发行版命令备注
Arch Linuxpacman -S zigAUR: zig-dev-bin
Fedoradnf install zig
Fedora Silverbluerpm-ostree install zig
Gentooemerge -av dev-lang/zig
NixOSnix-env -i zig
Ubuntu (snap)snap install zig --classic --beta
Void Linuxxbps-install -Su zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，普通用户选择 zig-linux-x86_64 即可。
以下讲述两种两种方法安装 zig ，一种是采取通用的linux安装方式，一种是在个人目录下安装，添加环境变量
通用linux安装方式 ​
创建目录 /usr/lib/zig，然后将所有文件内容移动到 /usr/lib/zig 目录下，最后将可执行文件 zig 通过软链接映射到 /usr/bin/zig ，具体命令操作如下：
sh
tar -xpf archive.tar.xz
-cd zig-linux
-cp -r . /usr/lib/zig
-ln -s /usr/lib/zig/zig /usr/bin/zig
个人目录安装 ​
这种方案是采取配置PATH来实现：
sh
# 推荐将资源文件放置在 ~/.local/bin
-mkdir ~/.local/bin
-mkdir ~/.local/bin/zig
+)
🅿️ 提示
以上的 System 对应的系统全局的环境变量， User 对应的是用户的环境变量。如果是个人电脑，使用任意一个没有区别。
首先确保你的路径是正确的，其次你可能注意到路径前面还有一个 ; ，此处并不是拼写错误！
Mac ​
Mac安装 zig 就很方便，但是如果要使用 nightly ，还是需要自行下载并添加环境变量
sh
brew install zig
sh
port install zig
Linux ​
Linux安装的话， 由于发行版的不同，安装的方式五花八门，先列出通过包管理器安装 Zig 的方法，再说明如何手动安装 Zig 并设置环境变量。
包管理器安装 ​
以下列出了支持通过包管理器安装 Zig 的发行版和对应命令：
发行版命令备注
Arch Linuxpacman -S zigAUR: zig-dev-bin
Fedoradnf install zig
Fedora Silverbluerpm-ostree install zig
Gentooemerge -av dev-lang/zig
NixOSnix-env -i zig
Ubuntu (snap)snap install zig --classic --beta
Void Linuxxbps-install -Su zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，之后将包含 Zig 二进制的目录加入到 PATH 环境变量即可。
多版本管理 ​
由于 Zig 还在快速开发迭代中，因此在使用社区已有类库时，有可能出现新版本 Zig 无法编译的情况，这时候一方面可以跟踪上游进展，看看是否有解决方案；另一个就是使用固定的版本来编译这个项目，显然这种方式更靠谱一些。
目前为止，Zig 的版本管理工具主要有如下几个：
读者可根据自身需求选择，这里介绍一个通用的版本管理工具：asdf。
  1. 参考 Getting Started 下载 asdf，一般而言，常见的系统管理器，如 brew、apt 均可直接安装
  2. 安装 asdf Zig 插件
bash
asdf plugin-add zig https://github.com/asdf-community/asdf-zig.git
  1. 之后就可以用 asdf 管理 Zig 版本。这里列举一些 asdf 常用命令：
bash
# 列举所有可安装的版本
+asdf list-all zig
 
-tar -xpf archive.tar.xz
-cd zig-linux
-cp -r . ~/.local/bin/zig
然后像bash写入环境变量配置，如 ~/.bashrc ：
sh
export PATH="~/.local/bin/zig/:$PATH"
如果使用其他的shell,则需要用户自己参照所使用的shell的配置来设置PATH
`,37),l=[n];function h(p,d,r,o,k,c){return a(),i("div",null,l)}const u=s(e,[["render",h]]);export{F as __pageData,u as default};
+# 安装指定版本的 Zig
+asdf install zig <version>
+
+# 卸载指定版本的 Zig
+asdf uninstall zig <version>
+
+# 设置全局默认版本，会写到 $HOME/.tool-versions 文件
+asdf global zig <version>
+
+# 设置当前目录使用的版本，会写到 $(pwd)/.tool-versions 文件
+asdf local zig <version>
`,36),l=[n];function h(p,r,d,o,k,g){return a(),i("div",null,l)}const y=s(e,[["render",h]]);export{F as __pageData,y as default};
diff --git a/assets/environment_install-environment.md.aoj-uaPQ.lean.js b/assets/environment_install-environment.md.PTNE6kMW.lean.js
similarity index 52%
rename from assets/environment_install-environment.md.aoj-uaPQ.lean.js
rename to assets/environment_install-environment.md.PTNE6kMW.lean.js
index 693ce8d4..16497d13 100644
--- a/assets/environment_install-environment.md.aoj-uaPQ.lean.js
+++ b/assets/environment_install-environment.md.PTNE6kMW.lean.js
@@ -1 +1 @@
-import{_ as s,c as i,o as a,U as t}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"环境安装","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"environment/install-environment.md","filePath":"environment/install-environment.md","lastUpdated":1704979746000}'),e={name:"environment/install-environment.md"},n=t("",37),l=[n];function h(p,d,r,o,k,c){return a(),i("div",null,l)}const u=s(e,[["render",h]]);export{F as __pageData,u as default};
+import{_ as s,c as i,o as a,U as t}from"./chunks/framework.iEE2KsGo.js";const F=JSON.parse('{"title":"环境安装","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"environment/install-environment.md","filePath":"environment/install-environment.md","lastUpdated":1705067788000}'),e={name:"environment/install-environment.md"},n=t("",36),l=[n];function h(p,r,d,o,k,g){return a(),i("div",null,l)}const y=s(e,[["render",h]]);export{F as __pageData,y as default};
diff --git a/assets/index.md.EcLvnWMr.js b/assets/index.md.EcLvnWMr.js
new file mode 100644
index 00000000..e0b8a101
--- /dev/null
+++ b/assets/index.md.EcLvnWMr.js
@@ -0,0 +1 @@
+import{_ as t,c as e,o as i}from"./chunks/framework.iEE2KsGo.js";const p=JSON.parse('{"title":"","description":"","frontmatter":{"layout":"home","hero":{"name":"Zig 语言圣经","text":"简单、快速地学习 Zig","tagline":"Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件","actions":[{"theme":"brand","text":"📖 开始阅读","link":"/what-is-zig"},{"theme":"alt","text":"🌐 Zig官网","link":"https://ziglang.org/"}]},"features":[{"icon":"📝","title":"语义简单","details":"专注于调试应用程序，而不是调试编程语言知识。无隐式控制流、无隐式内存分配、无预处理器和宏"},{"icon":"🚀","title":"编译期执行","details":"基于编译期代码执行和惰性求值的全新元编程方法,编译期调用任何函数、模拟目标架构，无运行时开销将类型作为值进行操作"},{"icon":"💡","title":"维护代码","details":"改善代码库，将 Zig 作为一个开箱即用的零依赖 C/C++ 编译器，通过 zig build 构建一致的编译环境，跨语言 LTO 默认启用"}]},"headers":[],"relativePath":"index.md","filePath":"index.md","lastUpdated":1705067788000}'),a={name:"index.md"};function n(o,s,r,d,l,c){return i(),e("div")}const g=t(a,[["render",n]]);export{p as __pageData,g as default};
diff --git a/assets/index.md.EcLvnWMr.lean.js b/assets/index.md.EcLvnWMr.lean.js
new file mode 100644
index 00000000..e0b8a101
--- /dev/null
+++ b/assets/index.md.EcLvnWMr.lean.js
@@ -0,0 +1 @@
+import{_ as t,c as e,o as i}from"./chunks/framework.iEE2KsGo.js";const p=JSON.parse('{"title":"","description":"","frontmatter":{"layout":"home","hero":{"name":"Zig 语言圣经","text":"简单、快速地学习 Zig","tagline":"Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件","actions":[{"theme":"brand","text":"📖 开始阅读","link":"/what-is-zig"},{"theme":"alt","text":"🌐 Zig官网","link":"https://ziglang.org/"}]},"features":[{"icon":"📝","title":"语义简单","details":"专注于调试应用程序，而不是调试编程语言知识。无隐式控制流、无隐式内存分配、无预处理器和宏"},{"icon":"🚀","title":"编译期执行","details":"基于编译期代码执行和惰性求值的全新元编程方法,编译期调用任何函数、模拟目标架构，无运行时开销将类型作为值进行操作"},{"icon":"💡","title":"维护代码","details":"改善代码库，将 Zig 作为一个开箱即用的零依赖 C/C++ 编译器，通过 zig build 构建一致的编译环境，跨语言 LTO 默认启用"}]},"headers":[],"relativePath":"index.md","filePath":"index.md","lastUpdated":1705067788000}'),a={name:"index.md"};function n(o,s,r,d,l,c){return i(),e("div")}const g=t(a,[["render",n]]);export{p as __pageData,g as default};
diff --git a/assets/index.md.Lwj7q2PL.js b/assets/index.md.Lwj7q2PL.js
deleted file mode 100644
index dd1361d8..00000000
--- a/assets/index.md.Lwj7q2PL.js
+++ /dev/null
@@ -1 +0,0 @@
-import{_ as t,c as e,o as i}from"./chunks/framework.iEE2KsGo.js";const p=JSON.parse('{"title":"","description":"","frontmatter":{"layout":"home","hero":{"name":"Zig 圣经","text":"简单、快速地学习 Zig","tagline":"Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件","actions":[{"theme":"brand","text":"📖 开始阅读","link":"/what-is-zig"},{"theme":"alt","text":"🌐 Zig官网","link":"https://ziglang.org/"}]},"features":[{"icon":"📝","title":"语义简单","details":"专注于调试应用程序，而不是调试编程语言知识。无隐式控制流、无隐式内存分配、无预处理器和宏"},{"icon":"🚀","title":"编译期执行","details":"基于编译期代码执行和惰性求值的全新元编程方法,编译期调用任何函数、模拟目标架构，无运行时开销将类型作为值进行操作"},{"icon":"💡","title":"维护代码","details":"改善代码库，将 Zig 作为一个开箱即用的零依赖 C/C++ 编译器，通过 zig build 构建一致的编译环境，跨语言 LTO 默认启用"}]},"headers":[],"relativePath":"index.md","filePath":"index.md","lastUpdated":1704982623000}'),a={name:"index.md"};function n(o,s,r,d,l,c){return i(),e("div")}const g=t(a,[["render",n]]);export{p as __pageData,g as default};
diff --git a/assets/index.md.Lwj7q2PL.lean.js b/assets/index.md.Lwj7q2PL.lean.js
deleted file mode 100644
index dd1361d8..00000000
--- a/assets/index.md.Lwj7q2PL.lean.js
+++ /dev/null
@@ -1 +0,0 @@
-import{_ as t,c as e,o as i}from"./chunks/framework.iEE2KsGo.js";const p=JSON.parse('{"title":"","description":"","frontmatter":{"layout":"home","hero":{"name":"Zig 圣经","text":"简单、快速地学习 Zig","tagline":"Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件","actions":[{"theme":"brand","text":"📖 开始阅读","link":"/what-is-zig"},{"theme":"alt","text":"🌐 Zig官网","link":"https://ziglang.org/"}]},"features":[{"icon":"📝","title":"语义简单","details":"专注于调试应用程序，而不是调试编程语言知识。无隐式控制流、无隐式内存分配、无预处理器和宏"},{"icon":"🚀","title":"编译期执行","details":"基于编译期代码执行和惰性求值的全新元编程方法,编译期调用任何函数、模拟目标架构，无运行时开销将类型作为值进行操作"},{"icon":"💡","title":"维护代码","details":"改善代码库，将 Zig 作为一个开箱即用的零依赖 C/C++ 编译器，通过 zig build 构建一致的编译环境，跨语言 LTO 默认启用"}]},"headers":[],"relativePath":"index.md","filePath":"index.md","lastUpdated":1704982623000}'),a={name:"index.md"};function n(o,s,r,d,l,c){return i(),e("div")}const g=t(a,[["render",n]]);export{p as __pageData,g as default};
diff --git a/basic/advanced_type/array.html b/basic/advanced_type/array.html
index d0f518f3..5f04b90d 100644
--- a/basic/advanced_type/array.html
+++ b/basic/advanced_type/array.html
@@ -3,21 +3,21 @@
   
     
     
-    数组 | Zig 圣经
+    数组 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
数组 ​
数组是日常敲代码使用相当频繁的类型之一，在 zig 中，数组的分配和 C 类似，均是在内存中连续分配且固定数量的相同类型元素。
因此数组有以下三点特性：
  • 长度固定
  • 元素必须有相同的类型
  • 依次线性排列
创建数组 ​
在 zig 中，你可以使用以下的方法，来声明并定义一个数组：
zig
const print = @import("std").debug.print;
+    
Zig 语言圣经
Appearance
数组 ​
数组是日常敲代码使用相当频繁的类型之一，在 zig 中，数组的分配和 C 类似，均是在内存中连续分配且固定数量的相同类型元素。
因此数组有以下三点特性：
  • 长度固定
  • 元素必须有相同的类型
  • 依次线性排列
创建数组 ​
在 zig 中，你可以使用以下的方法，来声明并定义一个数组：
zig
const print = @import("std").debug.print;
 
 pub fn main() !void {
     const message = [5]u8{ 'h', 'e', 'l', 'l', 'o' };
@@ -111,7 +111,7 @@
     };
     print("{any}\n", .{fancy_array});
 }
这个示例中，我们使用了编译期的功能，来帮助我们实现这个数组的初始化，同时还利用了 blocks 和 break 的性质，关于这个我们会在 循环 讲解！

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/advanced_type/enum.html b/basic/advanced_type/enum.html
index a2d54bba..abff7c1b 100644
--- a/basic/advanced_type/enum.html
+++ b/basic/advanced_type/enum.html
@@ -3,21 +3,21 @@
   
     
     
-    枚举 | Zig 圣经
+    枚举 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
枚举 ​
举常常用来列出一个有限集合的任何成员，或者对某一种特定对象的计数。
枚举是一种相对简单，但用处颇多的类型。
声明枚举 ​
我们可以通过使用 enum 关键字来很轻松地声明并使用枚举：
zig
const Type = enum {
+    
Zig 语言圣经
Appearance
枚举 ​
举常常用来列出一个有限集合的任何成员，或者对某一种特定对象的计数。
枚举是一种相对简单，但用处颇多的类型。
声明枚举 ​
我们可以通过使用 enum 关键字来很轻松地声明并使用枚举：
zig
const Type = enum {
     ok,
     not_ok,
 };
@@ -96,7 +96,7 @@
     else => false,
 };
 // is_one 也是true
extern ​
注意，我们不在这里使用 extern 关键字。
默认情况下，zig 不保证枚举和 C ABI 兼容，但是我们可以通过指定序列类型来达到这一效果：
zig
const Foo = enum(c_int) { a, b, c };

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/advanced_type/opaque.html b/basic/advanced_type/opaque.html
index a02552f7..18d68e49 100644
--- a/basic/advanced_type/opaque.html
+++ b/basic/advanced_type/opaque.html
@@ -3,28 +3,28 @@
   
     
     
-    opaque | Zig 圣经
+    opaque | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
opaque ​
opaque {} 类型声明一个具有未知（但非零）大小和对齐方式的新类型，它的内部可以包含与结构、联合和枚举相同的声明。
这通常用于保证与不公开结构详细信息的 C 代码交互时的类型安全。
zig
const Derp = opaque {};
+    
Zig 语言圣经
Appearance
opaque ​
opaque {} 类型声明一个具有未知（但非零）大小和对齐方式的新类型，它的内部可以包含与结构、联合和枚举相同的声明。
这通常用于保证与不公开结构详细信息的 C 代码交互时的类型安全。
zig
const Derp = opaque {};
 const Wat = opaque {};
 
 extern fn bar(d: *Derp) void;
 fn foo(w: *Wat) callconv(.C) void {
     bar(w);
 }
anyopaque ​
anyopaque 是一个比较特殊的类型，代表可以接受任何类型的 opaque（由于 opaque 拥有不同的变量/常量声明和方法的定义，故是不同的类型），常用于与 C 交互的函数中，相当于是 C 的 void 类型！
TODO: 添加更多关于该类型使用的示例和说明！

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/advanced_type/pointer.html b/basic/advanced_type/pointer.html
index db5831c5..0065bd8a 100644
--- a/basic/advanced_type/pointer.html
+++ b/basic/advanced_type/pointer.html
@@ -3,21 +3,21 @@
   
     
     
-    指针 | Zig 圣经
+    指针 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
指针 ​
zig 作为一门 low level 语言，那肯定要有指针的。
指针是指向一块内存区域地址的变量，它存储了一个地址，我们可以通过指针来操作其指向内存区域。
取地址：通过 & 符号来获取某个变量所对应的内存地址，如 &integer 就是获取变量 integer 的内存地址。
zig 的指针和 C 的指针略有不同，包含两种指针，一种单项（single-item）指针，一种是多项（many-item）指针，它们的解引用的方式也略有不同。
关于指针运算
zig 本身支持指针运算（加减操作），但有一点需要注意：最好将指针分配给 [*]T 类型后再进行计算。
尤其是在切片中，不可直接对其指针进行更改，这会破坏切片的内部结构！
单项指针 ​
单项指针指向单个元素。
单项指针的类型为：*T，T是所指向内存区域的类型，解引用方法是 ptr.*。
示例
zig
const print = @import("std").debug.print;
+    
Zig 语言圣经
Appearance
指针 ​
zig 作为一门 low level 语言，那肯定要有指针的。
指针是指向一块内存区域地址的变量，它存储了一个地址，我们可以通过指针来操作其指向内存区域。
取地址：通过 & 符号来获取某个变量所对应的内存地址，如 &integer 就是获取变量 integer 的内存地址。
zig 的指针和 C 的指针略有不同，包含两种指针，一种单项（single-item）指针，一种是多项（many-item）指针，它们的解引用的方式也略有不同。
关于指针运算
zig 本身支持指针运算（加减操作），但有一点需要注意：最好将指针分配给 [*]T 类型后再进行计算。
尤其是在切片中，不可直接对其指针进行更改，这会破坏切片的内部结构！
单项指针 ​
单项指针指向单个元素。
单项指针的类型为：*T，T是所指向内存区域的类型，解引用方法是 ptr.*。
示例
zig
const print = @import("std").debug.print;
 
 pub fn main() !void {
     var integer: i16 = 666;
@@ -119,7 +119,7 @@
         try expect(ptr.* == 3);
     }
 }

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/advanced_type/silce.html b/basic/advanced_type/silce.html
index 94e48118..6b28c094 100644
--- a/basic/advanced_type/silce.html
+++ b/basic/advanced_type/silce.html
@@ -3,21 +3,21 @@
   
     
     
-    切片 | Zig 圣经
+    切片 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
切片 ​
切片和数组看起来上很像，在实际使用时，你可能会想要使用切片，因为它相对数组来说，要更加灵活！
你可以对数组、切片、数组指针进行切片操作！
接下来我们演示以下切片的使用方式：
zig
const print = @import("std").debug.print;
+    
Zig 语言圣经
Appearance
切片 ​
切片和数组看起来上很像，在实际使用时，你可能会想要使用切片，因为它相对数组来说，要更加灵活！
你可以对数组、切片、数组指针进行切片操作！
接下来我们演示以下切片的使用方式：
zig
const print = @import("std").debug.print;
 
 pub fn main() !void {
     var array = [_]i32{ 1, 2, 3, 4 };
@@ -60,7 +60,7 @@
     const slice = array[0..runtime_length :0];
     print("slice类型：{}\n", .{@TypeOf(slice)});
 }

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/advanced_type/struct.html b/basic/advanced_type/struct.html
index 18c641f4..aca51681 100644
--- a/basic/advanced_type/struct.html
+++ b/basic/advanced_type/struct.html
@@ -3,21 +3,21 @@
   
     
     
-    结构体 | Zig 圣经
+    结构体 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
结构体 ​
在 zig 中，类型是一等公民！
结构体本身是一个高级的数据结构，用于将多个数据表示为一个整体。
基本语法 ​
结构体的组成：
  • 首部关键字 struct
  • 和变量定义一样的结构体名字
  • 多个字段
  • 方法
  • 多个声明
以下是一个简短的结构体声明：
zig
const Circle = struct {
+    
Zig 语言圣经
Appearance
结构体 ​
在 zig 中，类型是一等公民！
结构体本身是一个高级的数据结构，用于将多个数据表示为一个整体。
基本语法 ​
结构体的组成：
  • 首部关键字 struct
  • 和变量定义一样的结构体名字
  • 多个字段
  • 方法
  • 多个声明
以下是一个简短的结构体声明：
zig
const Circle = struct {
     radius: u8,
 
     const PI: f16 = 3.14;
@@ -86,7 +86,7 @@
     };
 
     std.debug.print("list len is {}\n", .{list.length()});
-}
更复杂的例子
下面是一个日常会用到的一个结构体例子，系统账号管理的使用：
zig
const User = struct {
+}
更复杂的例子
下面是一个日常会用到的一个结构体例子，系统账号管理的使用：
zig
const User = struct {
     userName: []u8,
     password: []u8,
     email: []u8,
@@ -211,7 +211,7 @@
 
 const x = Foo{
     .b = 5,
-};
空结构体 ​
你还可以使用空结构体，具体如下：
zig
const Empty = struct {
+};
空结构体 ​
你还可以使用空结构体，具体如下：
zig
const Empty = struct {
     // const PI = 3.14;
 };
zig
const std = @import("std");
 
@@ -310,7 +310,7 @@
     const ptr: *align(4) S = &foo;
     const ptr_to_b: *u32 = &ptr.b;
     try expect(ptr_to_b.* == 2);
-}
命名规则 ​
由于在 zig 中很多结构是匿名的（例如可以把一个源文件看作是一个匿名的结构体），所以 zig 基于一套规则来进行命名：
  • 如果一个结构体位于变量的初始化表达式中，它就以该变量命名（实际上就是声明结构体类型）。
  • 如果一个结构体位于 return 表达式中，那么它以返回的函数命名，并序列化参数。
  • 其他情况下，结构体会获得一个类似 filename.funcname.__struct_ID 的名字。
  • 如果该结构体在另一个结构体中声明，它将以父结构体和前面的规则推断出的名称命名，并用点分隔。
上面几条规则看着很模糊是吧，我们来几个小小的示例来演示一下：
zig
const std = @import("std");
+}
命名规则 ​
由于在 zig 中很多结构是匿名的（例如可以把一个源文件看作是一个匿名的结构体），所以 zig 基于一套规则来进行命名：
  • 如果一个结构体位于变量的初始化表达式中，它就以该变量命名（实际上就是声明结构体类型）。
  • 如果一个结构体位于 return 表达式中，那么它以返回的函数命名，并序列化参数。
  • 其他情况下，结构体会获得一个类似 filename.funcname.__struct_ID 的名字。
  • 如果该结构体在另一个结构体中声明，它将以父结构体和前面的规则推断出的名称命名，并用点分隔。
上面几条规则看着很模糊是吧，我们来几个小小的示例来演示一下：
zig
const std = @import("std");
 
 pub fn main() void {
     const Foo = struct {};
@@ -326,7 +326,7 @@
 }
sh
variable: struct_name.main.Foo
 anonymous: struct_name.main__struct_3509
 function: struct_name.List(i32)

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/advanced_type/vector.html b/basic/advanced_type/vector.html
index 9710cb8e..1381b574 100644
--- a/basic/advanced_type/vector.html
+++ b/basic/advanced_type/vector.html
@@ -3,21 +3,21 @@
   
     
     
-    向量 | Zig 圣经
+    向量 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
向量 ​
向量（Vector）为我们提供了并行操纵一组同类型（布尔、整型、浮点、指针）的值的方法，它尽可能使用 SIMD 指令。
基本使用 ​
向量支持与底层基本类型相同的内置运算符。这些操作是按元素执行，并返回与输入向量长度相同的向量，包括：
  • 算术运算符 (+, -, /, *, @divFloor, @sqrt, @ceil, @log, ... )
  • 位操作符 (>>, <<, &, |,~, ... )
  • 比较远算符 (<, >, ==, ...)
禁止对标量（单个数字）和向量的混合使用数学运算符，Zig 提供了 @splat 内建函数来轻松从标量转换为向量，并且它支持 @reduce 和数组索引语法以从向量转换为标量，向量还支持对具有已知长度的固定长度数组进行赋值，如果需要重新排列元素，可以使用 @shuffle 和 @select 函数。
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
向量 ​
向量（Vector）为我们提供了并行操纵一组同类型（布尔、整型、浮点、指针）的值的方法，它尽可能使用 SIMD 指令。
基本使用 ​
向量支持与底层基本类型相同的内置运算符。这些操作是按元素执行，并返回与输入向量长度相同的向量，包括：
  • 算术运算符 (+, -, /, *, @divFloor, @sqrt, @ceil, @log, ... )
  • 位操作符 (>>, <<, &, |,~, ... )
  • 比较远算符 (<, >, ==, ...)
禁止对标量（单个数字）和向量的混合使用数学运算符，Zig 提供了 @splat 内建函数来轻松从标量转换为向量，并且它支持 @reduce 和数组索引语法以从向量转换为标量，向量还支持对具有已知长度的固定长度数组进行赋值，如果需要重新排列元素，可以使用 @shuffle 和 @select 函数。
zig
const std = @import("std");
 const print = std.debug.print;
 
 pub fn main() !void {
@@ -77,7 +77,7 @@
 
 const c = @select(i32, pred, a, b);
 // c 是 { 1, 6, 7, 4 }

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/basic_type/char-and-boolean.html b/basic/basic_type/char-and-boolean.html
index 9fcb66ea..1ef7015e 100644
--- a/basic/basic_type/char-and-boolean.html
+++ b/basic/basic_type/char-and-boolean.html
@@ -3,21 +3,21 @@
   
     
     
-    字符与布尔值 | Zig 圣经
+    字符与布尔值 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
字符与布尔值 ​
在计算机中定义的 字符 往往都是 ASCII 码表的值，绝非我们平常所指的单个文字。
布尔值往往通过二进制的 0 和 1 来表示。
字符 ​
这个类型其实平常使用不算多，在 zig 中字符就是 u8，并且需要是 ASCII 码表中的内容,这和 C 的逻辑基本相同（“基本”的原因见 c_char 说明）。
具体可以参照以下例子：
zig
const print = @import("std").debug.print;
+    
Zig 语言圣经
Appearance
字符与布尔值 ​
在计算机中定义的 字符 往往都是 ASCII 码表的值，绝非我们平常所指的单个文字。
布尔值往往通过二进制的 0 和 1 来表示。
字符 ​
这个类型其实平常使用不算多，在 zig 中字符就是 u8，并且需要是 ASCII 码表中的内容,这和 C 的逻辑基本相同（“基本”的原因见 c_char 说明）。
具体可以参照以下例子：
zig
const print = @import("std").debug.print;
 
 pub fn main() void {
     var char: u8 = 'h';
@@ -30,7 +30,7 @@
     print("{c}\n", .{char});
     print("{c}\n", .{char_num});
 }
关于 c_char
你如果自行看了 zig 官方文档中关于类型的部分，应该会注意到 c_char 类型，它对应 C 中的 char 类型。
但是需要注意，u8 和 c_char 并不是全等的，因为 c_char 虽然是 8 位，但是它是否有符号取决于 target (目标机器)。
布尔值 ​
常用于流程控制
在 zig 中，布尔值有两个，分别是 true 和 false， 它们在内存中占用的大小为1个字节。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/basic_type/function.html b/basic/basic_type/function.html
index 6df0d9ac..c4cb631f 100644
--- a/basic/basic_type/function.html
+++ b/basic/basic_type/function.html
@@ -3,21 +3,21 @@
   
     
     
-    函数 | Zig 圣经
+    函数 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
函数 ​
函数是编程语言中最为基本的语句。
基本使用 ​
zig 的函数明显，你可以一眼就看出来它的组成，我们来用一个简单的函数作为说明：
zig
pub fn add(a: u8, b: u8) u8 {
+    
Zig 语言圣经
Appearance
函数 ​
函数是编程语言中最为基本的语句。
基本使用 ​
zig 的函数明显，你可以一眼就看出来它的组成，我们来用一个简单的函数作为说明：
zig
pub fn add(a: u8, b: u8) u8 {
     return a + b;
 }
如果你有 C 的使用经验，一眼就可以看出来各自的作用。
下面来进行说明：
  1. pub 是访问修饰符，有且只有一个选择，那就是 pub，这代表着函数是公共可访问的（其他的文件import该文件后，可以直接使用这个函数）。
  2. fn 是关键字，代表着我们接下来定义了一个函数。
  3. add 是标识符，作为函数的名字。
  4. a: u8 是参数的标识符和类型，这里有两个参数，分别是 a 和 b，它们的类型均是 u8。
  5. u8 是函数的返回类型，在 zig 中，一个函数只能返回一个值。
如果没有返回值，请使用 void，zig 原则上不允许忽略函数的返回值，如果需要忽略可将返回值分配给 _，编译器将自动忽略该返回值。
🅿️ 提示
你可能注意到了有的函数定义是这样子的：
zig
fn max(comptime T: type, a: T, b: T) T {
     return if (a > b) a else b;
@@ -30,7 +30,7 @@
 fn shiftLeftOne(a: u32) callconv(.Inline) u32 {
     return a << 1;
 }
关于可以使用的调用约定格式，可以参考这里std.builtin.CallingConvention。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/basic_type/number.html b/basic/basic_type/number.html
index 7b79ba87..31c35f4f 100644
--- a/basic/basic_type/number.html
+++ b/basic/basic_type/number.html
@@ -3,21 +3,21 @@
   
     
     
-    数值类型 | Zig 圣经
+    数值类型 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
数值类型 ​
数值类型是语言运行时的基本类型，当它编译为机器码时，其中包含着许多的 CPU运算器 的操作指令。
整数 ​
类型 ​
在 zig 中，对整数的类型划分很详细，以下是类型表格：
类型对应C类型描述
i8int8_t有符号8位整数
u8uint8_t无符号8位整数
i16int16_t有符号16位整数
u16uint16_t无符号16位整数
i32int32_t有符号32位整数
u32uint32_t无符号32位整数
i64int64_t有符号64位整数
u64uint64_t无符号64位整数
i128__int128有符号128位整数
u128unsigned __int128无符号128位整数
isizeintptr_t有符号指针大小的整数
usizeuintptr_t size_t无符号指针大小的整数
comptime_int无编译期的整数，整数字面量的类型
zig
// 下划线可以放在数字之间作为视觉分隔符
+    
Zig 语言圣经
Appearance
数值类型 ​
数值类型是语言运行时的基本类型，当它编译为机器码时，其中包含着许多的 CPU运算器 的操作指令。
整数 ​
类型 ​
在 zig 中，对整数的类型划分很详细，以下是类型表格：
类型对应C类型描述
i8int8_t有符号8位整数
u8uint8_t无符号8位整数
i16int16_t有符号16位整数
u16uint16_t无符号16位整数
i32int32_t有符号32位整数
u32uint32_t无符号32位整数
i64int64_t有符号64位整数
u64uint64_t无符号64位整数
i128__int128有符号128位整数
u128unsigned __int128无符号128位整数
isizeintptr_t有符号指针大小的整数
usizeuintptr_t size_t无符号指针大小的整数
comptime_int无编译期的整数，整数字面量的类型
zig
// 下划线可以放在数字之间作为视觉分隔符
 const one_billion = 1_000_000_000;
 const binary_mask = 0b1_1111_1111;
 const permissions = 0o7_5_5;
@@ -71,7 +71,7 @@
 and
 or
 = *= *%= *|= /= %= += +%= +|= -= -%= -|= <<= <<|= >>= &= ^= |=
🅿️ 提示
如果你有使用复数的需求，那么你需要自己实现相关的结构体了（我还未在社区发现高质量的相关包）。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/define-variable.html b/basic/define-variable.html
index 0dac0c9e..5005ddc1 100644
--- a/basic/define-variable.html
+++ b/basic/define-variable.html
@@ -3,21 +3,21 @@
   
     
     
-    基本类型 | Zig 圣经
+    基本类型 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
基本类型 ​
变量的声明和定义是编程语言中最基础且最常见的操作之一。
变量声明 ​
变量是在内存中存储值的单元。
在 zig 中，我们使用 var 来进行变量的声明，格式是 var variable:type = value;，以下是一个示例：
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
基本类型 ​
变量的声明和定义是编程语言中最基础且最常见的操作之一。
变量声明 ​
变量是在内存中存储值的单元。
在 zig 中，我们使用 var 来进行变量的声明，格式是 var variable:type = value;，以下是一个示例：
zig
const std = @import("std");
 
 pub fn main() void {
     // 声明变量 variable 类型为u16, 并指定值为 666
@@ -82,7 +82,7 @@
 const S = struct {
     //! 顶层文档注释
 };
小细节
为什么是作用域顶层呢？实际上，zig 将一个源码文件看作是一个容器。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/error_handle.html b/basic/error_handle.html
index ea821668..f207798e 100644
--- a/basic/error_handle.html
+++ b/basic/error_handle.html
@@ -3,21 +3,21 @@
   
     
     
-    错误处理 | Zig 圣经
+    错误处理 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
错误处理 ​
程序会在某些时候因为某些我们知道或者不知道的原因出错，有的错误我们可以预知并处理，有些错误我们无法预知，但我们可以捕获它们并有效地报告给用户。
🅿️ 提示
事实上，目前 zig 的错误处理方案笔者认为是比较简陋的，因为错误类型在 zig 中只是略微加工后的 enum，这导致错误类型无法携带有效的 payload，你只能通过 error 的 tagName 来获取有效的信息。
基本使用 ​
以下展示了 error 的基本定义和使用：
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
错误处理 ​
程序会在某些时候因为某些我们知道或者不知道的原因出错，有的错误我们可以预知并处理，有些错误我们无法预知，但我们可以捕获它们并有效地报告给用户。
🅿️ 提示
事实上，目前 zig 的错误处理方案笔者认为是比较简陋的，因为错误类型在 zig 中只是略微加工后的 enum，这导致错误类型无法携带有效的 payload，你只能通过 error 的 tagName 来获取有效的信息。
基本使用 ​
以下展示了 error 的基本定义和使用：
zig
const std = @import("std");
 
 const FileOpenError = error{
     AccessDenied,
@@ -81,7 +81,7 @@
 const number = parseU64(str, 10) catch blk: {
     // do things
     break :blk 13;
-};
try ​
try 用于在出现错误时直接向上层返回错误，没错误就正常执行：
zig
fn doAThing(str: []u8) !void {
+};
try ​
try 用于在出现错误时直接向上层返回错误，没错误就正常执行：
zig
fn doAThing(str: []u8) !void {
     const number = try parseU64(str, 10);
     _ = number; // ...
 }
zig
fn doAThing(str: []u8) !void {
@@ -144,7 +144,7 @@
 const Error = error {
     Overflow,
 };
🅿️ 提示
当函数使用推导错误集时，这个函数相对来说会变得更加的通用，但在执行某些操作时会变得有些棘手，例如获取函数指针或者在不同构建目标之间保持相同的错误集合。另外，推导错误和递归并不兼容。
上面这句话看起来有点云里雾里，我们来两个例子来说明就可以：
  1. 不同构建目标之间可能存在着专属于架构的错误定义，这使得在不同架构上构建出来的代码的实际错误集并不相同，函数也同理（与cpu指令集实现有关）。
  2. 当我们使用自动推导时，推导出的错误集是最小错误集，故可能一个函数被推导出 ErrorSetOne!type 和 ErrorSetTwo!type 两个错误集，这就使得在递归上出现了不兼容，不过可以使用 switch 来匹配错误集来解决该问题。
对于上面的问题，其实更好的解决办法就是显示声明一个错误集，这会明确告诉编译器返回的错误种类都有什么。
根据文档说明，上面的这些限制可能在未来会被改善。
堆栈跟踪 ​
zig 本身有着良好的错误堆栈跟踪，错误堆栈跟踪显示代码中将错误返回到调用函数的所有点。这使得在任何地方使用 try 都很实用，并且如果错误最终从应用程序中一直冒出来，我们很容易能够知道发生了什么。
具体的信息可见这里。
完整堆栈跟踪生效的三个方式，从 main 返回一个错误、使用 catch unreachable 捕获的错误、使用@errorReturnTrace。
具体的堆栈跟踪实现细节可以看这里。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/optional_type.html b/basic/optional_type.html
index 8b55e1dd..d7ff7e8d 100644
--- a/basic/optional_type.html
+++ b/basic/optional_type.html
@@ -3,25 +3,25 @@
   
     
     
-    可选类型 | Zig 圣经
+    可选类型 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
可选类型 ​
zig 在不损害效率和可读性的前提下提高代码安全性的一个方案就是可选类型，? 是可选类型的标志，你可以将它放在类型的前面，代表它的值是null或者这个类型。
zig
// 一个普通的i32整数
+    
Zig 语言圣经
Appearance
可选类型 ​
zig 在不损害效率和可读性的前提下提高代码安全性的一个方案就是可选类型，? 是可选类型的标志，你可以将它放在类型的前面，代表它的值是null或者这个类型。
zig
// 一个普通的i32整数
 const normal_int: i32 = 1234;
 
 // i32的可选类型，现在它的值可以是 i32 或者 null
-const optional_int: ?i32 = 5678;
当然，可选类型在整数上没什么大用，更多是在指针上使用，null（空引用）是许多运行时异常的根源，甚至被指责为计算机科学中最严重的错误。
当然这在 zig 中不存在，通过可选类型我们可以解决这个问题，zig 在解决空指针上采取的方式比较保守，它兼顾了代码的可读性和效率问题。
其中目前最为激进的应该是 Rust ，它真的是非常的激进，这增加了程序员在写代码时的心智负担（因为你经常需要和编译期斗智斗勇，但好处大大是减少了你在运行时 debug 的负担）。相对来说，zig 采取的是一种折中的方案，编译期仍然会给你检测，并且这种检测不是很深奥，而且纠正起来很简单，缺点是并不能保证你的运行时是绝对安全的（可选类型仅仅能保证你不使用空指针，却不能保证你出现悬空指针【迷途指针、野指针】等情况的出现）。
zig 会将 null 特殊看待，并且保证你不会将一个可能为 null 的值赋值给一个不能是 null 的变量。
首先我们和 zig 的目标：C 对比一下，看一下两者在处理 null 上的区别，在接下来的代码中，我们尝试调用 malloc，并且申请一块内存：
c
// 引用的是malloc的原型
+const optional_int: ?i32 = 5678;
当然，可选类型在整数上没什么大用，更多是在指针上使用，null（空引用）是许多运行时异常的根源，甚至被指责为计算机科学中最严重的错误。
当然这在 zig 中不存在，通过可选类型我们可以解决这个问题，zig 在解决空指针上采取的方式比较保守，它兼顾了代码的可读性和效率问题。
其中目前最为激进的应该是 Rust ，它真的是非常的激进，这增加了程序员在写代码时的心智负担（因为你经常需要和编译期斗智斗勇，但好处大大是减少了你在运行时 debug 的负担）。相对来说，zig 采取的是一种折中的方案，编译期仍然会给你检测，并且这种检测不是很深奥，而且纠正起来很简单，缺点是并不能保证你的运行时是绝对安全的（可选类型仅仅能保证你不使用空指针，却不能保证你出现悬空指针【迷途指针、野指针】等情况的出现）。
zig 会将 null 特殊看待，并且保证你不会将一个可能为 null 的值赋值给一个不能是 null 的变量。
首先我们和 zig 的目标：C 对比一下，看一下两者在处理 null 上的区别，在接下来的代码中，我们尝试调用 malloc，并且申请一块内存：
c
// 引用的是malloc的原型
 void *malloc(size_t size);
 
 struct Foo *do_a_thing(void) {
@@ -63,7 +63,7 @@
 
     try comptime expect(@typeInfo(@TypeOf(foo)).Optional.child == i32);
 }
可选指针 ​
可选指针会保证和指针有一样的大小，null 会被视作地址 0 考虑！

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/process_control/decision.html b/basic/process_control/decision.html
index f049ecb1..dcfdaaea 100644
--- a/basic/process_control/decision.html
+++ b/basic/process_control/decision.html
@@ -3,21 +3,21 @@
   
     
     
-    条件 | Zig 圣经
+    条件 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
条件 ​
在 zig 中，if 这个语法的作用可就大了！
像基础的 if，if else，else if 我们就不说了，直接看例子：
zig
const print = @import("std").debug.print;
+    
Zig 语言圣经
Appearance
条件 ​
在 zig 中，if 这个语法的作用可就大了！
像基础的 if，if else，else if 我们就不说了，直接看例子：
zig
const print = @import("std").debug.print;
 
 pub fn main() !void {
     var num: u8 = 1;
@@ -28,7 +28,7 @@
     } else {
         print("num is other\n", .{});
     }
-}
三元表达式 ​
zig 中的三元表达式是通过 if else 来实现的：
zig
const a: u32 = 5;
+}
三元表达式 ​
zig 中的三元表达式是通过 if else 来实现的：
zig
const a: u32 = 5;
 const b: u32 = 4;
 const result = if (a != b) 47 else 3089;
zig
const print = @import("std").debug.print;
 
@@ -73,7 +73,7 @@
 } else |_| {
     unreachable;
 }
以上代码中，*optional_value 捕获的是可选类型的指针，我们在内部尝试解引用后再一次捕获指针来进行操作。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/process_control/defer.html b/basic/process_control/defer.html
index 5e8d6933..8b224625 100644
--- a/basic/process_control/defer.html
+++ b/basic/process_control/defer.html
@@ -3,21 +3,21 @@
   
     
     
-    defer | Zig 圣经
+    defer | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
defer ​
defer 将在当前作用域末尾执行表达式。
如果存在多个 defer，它们将会按照出栈方式执行。
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
defer ​
defer 将在当前作用域末尾执行表达式。
如果存在多个 defer，它们将会按照出栈方式执行。
zig
const std = @import("std");
 const print = std.debug.print;
 
 pub fn main() !void {
@@ -34,7 +34,7 @@
         print("exec first", .{});
     }
 }
defer 分别可以执行单个语句和一个块，并且如果控制流不经过 defer，则不会执行。
对应 defer 的还有 errdefer，具体见这里 errdefer。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/process_control/loop.html b/basic/process_control/loop.html
index c6882adc..d60fb190 100644
--- a/basic/process_control/loop.html
+++ b/basic/process_control/loop.html
@@ -3,21 +3,21 @@
   
     
     
-    循环 | Zig 圣经
+    循环 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
循环 ​
在 zig 中，循环分为两种，一种是 while，一种是 for。
for ​
for 循环是另一种循环处理方式，主要用于迭代数组和切片。
它支持 continue 和 break。
迭代数组和切片：
zig
const items = [_]i32 { 4, 5, 3, 4, 0 };
+    
Zig 语言圣经
Appearance
循环 ​
在 zig 中，循环分为两种，一种是 while，一种是 for。
for ​
for 循环是另一种循环处理方式，主要用于迭代数组和切片。
它支持 continue 和 break。
迭代数组和切片：
zig
const items = [_]i32 { 4, 5, 3, 4, 0 };
 var sum: i32 = 0;
 
 for (items) |value| {
@@ -57,7 +57,7 @@
         count += 1;
         continue :outer;
     }
-}
内联 inline ​
inline 关键字会将 for 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
需要注意，内联 for 循环要求迭代的值和捕获的值均是编译期已知的。
zig
pub fn main() !void {
+}
内联 inline ​
inline 关键字会将 for 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
需要注意，内联 for 循环要求迭代的值和捕获的值均是编译期已知的。
zig
pub fn main() !void {
     const nums = [_]i32{2, 4, 6};
     var sum: usize = 0;
     inline for (nums) |i| {
@@ -94,7 +94,7 @@
 
 fn typeNameLength(comptime T: type) usize {
     return @typeName(T).len;
-}
while ​
while 循环用于重复执行表达式，直到某些条件不再成立.
基本使用：
zig
var i: usize = 0;
+}
while ​
while 循环用于重复执行表达式，直到某些条件不再成立.
基本使用：
zig
var i: usize = 0;
 while (i < 10) {
     if (i == 5) {
         continue;
@@ -112,7 +112,7 @@
         std.debug.print("i is {}\n", .{i});
         i += 1;
     }
-}
continue 表达式 ​
while 还支持一个被称为 continue 表达式的方法来便于我们控制循环，其内部可以是一个语句或者是一个作用域（{} 包裹）
zig
var i: usize = 0;
+}
continue 表达式 ​
while 还支持一个被称为 continue 表达式的方法来便于我们控制循环，其内部可以是一个语句或者是一个作用域（{} 包裹）
zig
var i: usize = 0;
 while (i < 10) : (i += 1) {}
zig
var i: usize = 1;
 var j: usize = 1;
 while (i * j < 2000) : ({ i *= 2; j *= 3; }) {
@@ -136,7 +136,7 @@
         while (true) {
             break :outer;
         }
-    }
内联 inline ​
inline 关键字会将 while 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
zig
pub fn main() !void {
+    }
内联 inline ​
inline 关键字会将 while 循环展开，这允许代码执行一些一些仅在编译时有效的操作。
zig
pub fn main() !void {
     comptime var i = 0;
     var sum: usize = 0;
     inline while (i < 3) : (i += 1) {
@@ -173,7 +173,7 @@
 
 fn typeNameLength(comptime T: type) usize {
     return @typeName(T).len;
-}
🅿️ 提示
建议以下情况使用内联 while：
  • 需要在编译期执行循环
  • 你确定展开后会代码效率会更高
解构可选类型 ​
像 if 一样，while 也会尝试解构可选类型，并在遇到 null 时终止循环。
zig
while (eventuallyNullSequence()) |value| {
+}
🅿️ 提示
建议以下情况使用内联 while：
  • 需要在编译期执行循环
  • 你确定展开后会代码效率会更高
解构可选类型 ​
像 if 一样，while 也会尝试解构可选类型，并在遇到 null 时终止循环。
zig
while (eventuallyNullSequence()) |value| {
     sum2 += value;
 } else {
     std.debug.print("meet a null\n", .{});
@@ -197,7 +197,7 @@
         std.debug.print("meet a null\n", .{});
     }
     // 还可以使用else分支，碰到第一个 null 时触发并退出循环
-}
当 |x| 语法出现在 while 表达式上，while 条件必须是可选类型。
解构错误联合类型 ​
和上面类似，同样可以解构错误联合类型，while 分别会捕获错误和有效负载，当错误发生时，转到 else 分支执行，并退出：
zig
while (eventuallyErrorSequence()) |value| {
+}
当 |x| 语法出现在 while 表达式上，while 条件必须是可选类型。
解构错误联合类型 ​
和上面类似，同样可以解构错误联合类型，while 分别会捕获错误和有效负载，当错误发生时，转到 else 分支执行，并退出：
zig
while (eventuallyErrorSequence()) |value| {
     sum1 += value;
 } else |err| {
     std.debug.print("meet a err: {}\n", .{err});
@@ -220,7 +220,7 @@
         std.debug.print("meet a err: {}\n", .{err});
     }
 }
当 else |x| 时语法出现在 while 表达式上，while 条件必须是错误联合类型。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/process_control/switch.html b/basic/process_control/switch.html
index c07871ac..c2e17f52 100644
--- a/basic/process_control/switch.html
+++ b/basic/process_control/switch.html
@@ -3,21 +3,21 @@
   
     
     
-    Switch | Zig 圣经
+    Switch | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
Switch ​
switch 语句可以进行匹配，并且switch匹配不能出现遗漏匹配的情况。
基本使用 ​
zig
var num: u8 = 5;
+    
Zig 语言圣经
Appearance
Switch ​
switch 语句可以进行匹配，并且switch匹配不能出现遗漏匹配的情况。
基本使用 ​
zig
var num: u8 = 5;
 switch (num) {
     5 => {
         print("this is 5\n", .{});
@@ -69,7 +69,7 @@
     else => 9,
 };
 
-try expect(b == 1);
作为表达式使用： ​
zig
const os_msg = switch (builtin.target.os.tag) {
+try expect(b == 1);
作为表达式使用： ​
zig
const os_msg = switch (builtin.target.os.tag) {
     .linux => "we found a linux user",
     else => "not a linux user",
 };
zig
const builtin = @import("builtin");
@@ -80,7 +80,7 @@
         else => "not a linux user",
     };
     _ = os_msg;
-}
捕获 Tag Union ​
我们还可以使用 switch 对标记联合类型进行捕获操作，对字段值的修改可以通过在捕获变量名称之前放置 * 并将其转换为指针来完成：
zig
const Item = union(enum) {
+}
捕获 Tag Union ​
我们还可以使用 switch 对标记联合类型进行捕获操作，对字段值的修改可以通过在捕获变量名称之前放置 * 并将其转换为指针来完成：
zig
const Item = union(enum) {
     a: u32,
     c: Point,
     d,
@@ -172,7 +172,7 @@
         }
     }
 }

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/process_control/unreachable.html b/basic/process_control/unreachable.html
index 6aa3190f..64ba878d 100644
--- a/basic/process_control/unreachable.html
+++ b/basic/process_control/unreachable.html
@@ -3,26 +3,26 @@
   
     
     
-    unreachable | Zig 圣经
+    unreachable | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
unreachable ​
在 Debug 和 ReleaseSafe 模式下，unreachable 会调用 panic ，并显示消息达到 unreachable code。
在 ReleaseFast 和 ReleaseSmall 模式下，编译器假设永远不会执行到 unreachable 来对代码进行优化 。
zig
const x = 1;
+    
Zig 语言圣经
Appearance
unreachable ​
在 Debug 和 ReleaseSafe 模式下，unreachable 会调用 panic ，并显示消息达到 unreachable code。
在 ReleaseFast 和 ReleaseSmall 模式下，编译器假设永远不会执行到 unreachable 来对代码进行优化 。
zig
const x = 1;
 const y = 2;
 if (x + y != 3) {
     unreachable;
 }

-    
+    
     
   
 
\ No newline at end of file
diff --git a/basic/union.html b/basic/union.html
index c7db55c6..87a150bc 100644
--- a/basic/union.html
+++ b/basic/union.html
@@ -3,21 +3,21 @@
   
     
     
-    联合类型 | Zig 圣经
+    联合类型 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
联合类型 ​
联合类型(union)，它实际上用户定义的一种特殊的类型，划分出一块内存空间用来存储多种类型，但同一时间只能存储一个类型。
基本使用 ​
联合类型的基本使用：
zig
const Payload = union {
+    
Zig 语言圣经
Appearance
联合类型 ​
联合类型(union)，它实际上用户定义的一种特殊的类型，划分出一块内存空间用来存储多种类型，但同一时间只能存储一个类型。
基本使用 ​
联合类型的基本使用：
zig
const Payload = union {
     int: i64,
     float: f64,
     boolean: bool,
@@ -105,7 +105,7 @@
 
 // 自动推断
 const i: Number = .{ .int = 42 };
extern union ​
extern union 保证内存布局与目标 C ABI 兼容。
具体可以见 extern struct。
packed union ​
packed union 保证内存布局和声明顺序相同并且尽量紧凑，具体见 extern struct。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/engineering/build-system.html b/engineering/build-system.html
index 42801eb6..2b365e94 100644
--- a/engineering/build-system.html
+++ b/engineering/build-system.html
@@ -3,21 +3,21 @@
   
     
     
-    构建系统 | Zig 圣经
+    构建系统 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
构建系统 ​
zig 本身就是一套完整的工具链，它可以作为任何语言的构建系统（类似Makefile一样的存在，但更加的现代化），不仅仅是 zig、C、CPP。
🅿️ 提示
当前 zig 的标准构建器位置：Github
构建模式 ​
zig 提供了四种构建模式（Build Mode）：
  • Debug
  • ReleaseFast
  • ReleaseSafe
  • ReleaseSmall
如果在 build.zig 中使用了 standardOptimizeOption，则构建系统会接收命令行的参数来决定实际构建模式（缺省时为 Debug），参数类型为 -Doptimize，例如 zig build -Doptimize=Debug 就是以 Debug 模式构建。
以下讲述四种构建模式的区别：
DebugReleaseFastReleaseSafeReleaseSmall
构建速度很快构建速度慢构建速度慢构建速度慢
启用安全检查启用安全检查启用安全检查禁用安全检查
较差的运行效率很好的运行效率中等的运行效率中等的运行效率
二进制体积大二进制体积大二进制体积大二进制体积小
无复现构建可复现构建可复现构建可复现构建
关于 Debug 不可复现的原因
关于为什么 Debug 是不可复现的，ziglang 的文档并未给出具体说明：
效果是在 Debug 构建模式下，编译器会添加一些随机因素进入到程序中（例如内存结构不同），所以任何没有明确说明内存布局的容器在 Debug 构建下可能会有所不同，这便于我们在 Debug 模式下快速暴露某些错误。有意思的是，这并不会影响程序正常运行，除非你的程序逻辑有问题。
这是 zig 加强安全性的一种方式（尽可能提高安全性但又不至于造成类似 Rust 开发时过重的心智负担）。
普通构建 ​
一个最简单的 build.zig 是这样的：
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
构建系统 ​
zig 本身就是一套完整的工具链，它可以作为任何语言的构建系统（类似Makefile一样的存在，但更加的现代化），不仅仅是 zig、C、CPP。
🅿️ 提示
当前 zig 的标准构建器位置：Github
构建模式 ​
zig 提供了四种构建模式（Build Mode）：
  • Debug
  • ReleaseFast
  • ReleaseSafe
  • ReleaseSmall
如果在 build.zig 中使用了 standardOptimizeOption，则构建系统会接收命令行的参数来决定实际构建模式（缺省时为 Debug），参数类型为 -Doptimize，例如 zig build -Doptimize=Debug 就是以 Debug 模式构建。
以下讲述四种构建模式的区别：
DebugReleaseFastReleaseSafeReleaseSmall
构建速度很快构建速度慢构建速度慢构建速度慢
启用安全检查启用安全检查启用安全检查禁用安全检查
较差的运行效率很好的运行效率中等的运行效率中等的运行效率
二进制体积大二进制体积大二进制体积大二进制体积小
无复现构建可复现构建可复现构建可复现构建
关于 Debug 不可复现的原因
关于为什么 Debug 是不可复现的，ziglang 的文档并未给出具体说明：
效果是在 Debug 构建模式下，编译器会添加一些随机因素进入到程序中（例如内存结构不同），所以任何没有明确说明内存布局的容器在 Debug 构建下可能会有所不同，这便于我们在 Debug 模式下快速暴露某些错误。有意思的是，这并不会影响程序正常运行，除非你的程序逻辑有问题。
这是 zig 加强安全性的一种方式（尽可能提高安全性但又不至于造成类似 Rust 开发时过重的心智负担）。
普通构建 ​
一个最简单的 build.zig 是这样的：
zig
const std = @import("std");
 
 pub fn build(b: *std.Build) void {
     // 标准构建目标
@@ -102,7 +102,7 @@
     // 添加到顶级 install step 中作为依赖
     b.installArtifact(exe);
 }
以上，我们通过使用 b.option 来实现从命令行读取一个参数决定是否剥离二进制程序的调试信息，使用 zig build --help 可以看到输出多了一行：
sh
Project-Specific Options:
-  -Dis_strip=[bool]            whether strip executable
Options 编译期配置 ​
Options 允许我们将一些信息传递到项目中，例如我们可以以此实现让程序打印构建时的时间戳：
zig
const std = @import("std");
+  -Dis_strip=[bool]            whether strip executable
Options 编译期配置 ​
Options 允许我们将一些信息传递到项目中，例如我们可以以此实现让程序打印构建时的时间戳：
zig
const std = @import("std");
 const timestamp = @import("timestamp");
 
 pub fn main() !void {
@@ -262,7 +262,7 @@
     .root_source_file = .{ .path = "src/main.zig" },
     .target = target,
     .optimize = optimize,
-});
embedFile ​
@embedFile 是由 zig 提供的一个内嵌文件的方式，它的引入规则与 @import 相同。
在 build.zig 直接使用 b.anonymousDependency 添加一个匿名模块即可，如：
zig
const std = @import("std");
+});
embedFile ​
@embedFile 是由 zig 提供的一个内嵌文件的方式，它的引入规则与 @import 相同。
在 build.zig 直接使用 b.anonymousDependency 添加一个匿名模块即可，如：
zig
const std = @import("std");
 const hello = @embedFile("hello"); 
 // const hello = @embedFile("hello.txt"); 均可以
 
@@ -308,7 +308,7 @@
 
     // 指定该 step 依赖于 run_exe，即实际的运行
     run_step.dependOn(&run_cmd.step);
-}
不仅仅是以上两种方式，匿名模块还支持直接使用其他程序输出,见下方执行其他命令部分！
执行其他命令 ​
zig 的构建系统还允许我们执行一些额外的命令，录入根据 json 生成某些特定的文件（例如 zig 源代码），构建其他的编程语言（不只是 C / C++），如Golang、Rust、前端项目构建等等！
例如我们可以让 zig 在构建时调用系统的 sh 来输出 hello 并使用 @embedFile 传递给包：
zig
const std = @import("std");
+}
不仅仅是以上两种方式，匿名模块还支持直接使用其他程序输出,见下方执行其他命令部分！
执行其他命令 ​
zig 的构建系统还允许我们执行一些额外的命令，录入根据 json 生成某些特定的文件（例如 zig 源代码），构建其他的编程语言（不只是 C / C++），如Golang、Rust、前端项目构建等等！
例如我们可以让 zig 在构建时调用系统的 sh 来输出 hello 并使用 @embedFile 传递给包：
zig
const std = @import("std");
 const hello = @embedFile("hello"); 
 
 pub fn main() !void {
@@ -370,7 +370,7 @@
 
     // 指定该 step 依赖于 run_exe，即实际的运行
     run_step.dependOn(&run_cmd.step);
-}
构建纯 C 项目 ​
在这里我们使用 GTK4 的官方示例 Hello-World 来作为演 示：
WARNING
在进行本部分教程前请先安装好 GTK4 的依赖，具体安装方法见 GTK 的指南。
zig
const std = @import("std");
+}
构建纯 C 项目 ​
在这里我们使用 GTK4 的官方示例 Hello-World 来作为演 示：
WARNING
在进行本部分教程前请先安装好 GTK4 的依赖，具体安装方法见 GTK 的指南。
zig
const std = @import("std");
 
 pub fn build(b: *std.Build) void {
     // 构建目标
@@ -463,7 +463,7 @@
   g_object_unref (app);
 
   return status;
-}
以上构建中我们先使用了 addCSourceFile 来添加 C 源代码，再使用 linkLibC 和 linkSystemLibrary 来链接 C 标准库和 GTK 库。
🅿️ 提示
关于头文件的引入，可以使用 exe.addIncludePath(.{ .path = "path" });
针对多个 C 源代码文件，zig 提供了函数 exe.addCSourceFiles 用于便捷地添加多个源文件。
构建纯 C++ 项目 ​
由于 GTK 的 C++ 构建过于复杂（需要手动编译gtkmm），故我们这里选择构建一个 tinytetris:
WARNING
注意：由于依赖了 curses 库，故只能在 linux 进行编译！
zig
const std = @import("std");
+}
以上构建中我们先使用了 addCSourceFile 来添加 C 源代码，再使用 linkLibC 和 linkSystemLibrary 来链接 C 标准库和 GTK 库。
🅿️ 提示
关于头文件的引入，可以使用 exe.addIncludePath(.{ .path = "path" });
针对多个 C 源代码文件，zig 提供了函数 exe.addCSourceFiles 用于便捷地添加多个源文件。
构建纯 C++ 项目 ​
由于 GTK 的 C++ 构建过于复杂（需要手动编译gtkmm），故我们这里选择构建一个 tinytetris:
WARNING
注意：由于依赖了 curses 库，故只能在 linux 进行编译！
zig
const std = @import("std");
 
 pub fn build(b: *std.Build) void {
     // 构建目标
@@ -677,7 +677,7 @@
   runloop();
   endwin();
 }
🅿️ 提示
关于头文件的引入，可以使用 exe.addIncludePath(.{ .path = "path" });
针对多个 C 源代码文件，zig 提供了函数 exe.addCSourceFiles 用于便捷地添加多个源文件。
关于 libc++ 的问题
zig 的工具链使用的是 libc++（LLVM ABI），而GNU的则是 libstdc++，两者的标准库实现略有不同，这会导致混用可能出现问题！
正确的做法是，手动编译依赖的源代码（一般是出现问题的），或者使用 -nostdinc++ -nostdlib++ 指示不使用默认标准库，并链接 GNU 的标准库，具体可以参考该 issue。
文件生成 ​
TODO

-    
+    
     
   
 
\ No newline at end of file
diff --git a/engineering/unit-test.html b/engineering/unit-test.html
index 514a0a55..63a9db80 100644
--- a/engineering/unit-test.html
+++ b/engineering/unit-test.html
@@ -3,21 +3,21 @@
   
     
     
-    单元测试 | Zig 圣经
+    单元测试 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
单元测试 ​
在计算机编程中，单元测试（英语：Unit Testing）又称为模块测试来源请求，是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。
基本使用 ​
在 zig 中，单元测试的是实现非常简单，只需要使用 test 关键字 + 字符串（测试名字，一般填测试的用途）+ 块即可。
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
单元测试 ​
在计算机编程中，单元测试（英语：Unit Testing）又称为模块测试来源请求，是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。
基本使用 ​
在 zig 中，单元测试的是实现非常简单，只需要使用 test 关键字 + 字符串（测试名字，一般填测试的用途）+ 块即可。
zig
const std = @import("std");
 
 test "expect addOne adds one to 41" {
 
@@ -83,7 +83,7 @@
         _ = &@field(T, decl.name);
     }
 }
它所使用的 std.meta.declarations 只能获取到公共成员（即被 pub 修饰的），非公共成员需要我们手动以 _ = .. 形式引入测试。
跳过测试 ​
跳过测试的一种方法是使用 zig test 命令行参数 --test-filter [text] 将其过滤掉。这使得测试构建仅包含名称包含提供的过滤器文本的测试。请注意，即使使用 --test-filter [text] 命令行参数，也会运行非命名测试（名字为空的测试块）。
要以编程方式跳过测试，请使测试返回错误 error.SkipZigTest 并且默认测试运行程序将认为该测试被跳过。所有测试运行后，将报告跳过的测试总数。
检测内存泄漏 ​
在测试中，我们可以使用 std.testing.allocator 这个内存分配器来检测内存泄漏，默认测试器将报告使用该分配器发现的任何内存泄漏。
检查测试模式 ​
我们可以通过 @import("builtin").is_test 来查看当前是否运行在测试器下。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/environment/editor.html b/environment/editor.html
index 90148c84..28ead718 100644
--- a/environment/editor.html
+++ b/environment/editor.html
@@ -3,21 +3,21 @@
   
     
     
-    编辑器选择 | Zig 圣经
+    编辑器选择 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
编辑器选择 ​
工欲善其事，必先利其器！
目前有以下几种编辑器推荐：
VS Code ​
官网地址：https://code.visualstudio.com/
Visual Studio Code 是一款由微软开发且跨平台的免费源代码编辑器。该软件以扩展的方式支持语法高亮、代码自动补全、代码重构功能，并且内置了命令行工具和Git 版本控制系统。用户可以更改主题和键盘快捷方式实现个性化设置，也可以通过内置的扩展程序商店安装其他扩展以拓展软件功能。
目前最轻量且生态丰富的编辑器，微软出品，zig 官方为其开发了插件，仅需要安装 Zig Language这个插件即可，在初次初始化时会推荐安装 language server， 确认即可！
vscode-zig
VS ​
官网地址：https://visualstudio.microsoft.com/
Microsoft Visual Studio是微软公司的开发工具包系列产品。VS是一个基本完整的开发工具集，它包括了整个软件生命周期中所需要的大部分工具，如UML工具、代码管控工具、集成开发环境等等。
windows 上最棒的开发 IDE，存在第三方插件：ZigVS。
CLion ​
CLion 是一款专为开发 C 及 C++ 所设计的跨平台 IDE。它是以 IntelliJ 为基础设计的，包含了许多智能功能来提高开发人员的生产力。CLion 帮助开发人员使用智能编辑器来提高代码质量、自动代码重构并且深度整合 CMake 编译系统，从而提高开发人员的工作效率。
原本 CLion 仅仅是 C/C++ 的开发IDE，但在安装插件后可以作为 zig 的 IDE 使用。
目前插件市场活跃的两个 zig 插件（均为第三方作者维护）分别是 ZigBrains 和 Zig Support，均支持 zig 的 0.11.0 版本。
Vim / Neovim ​
Vim：https://github.com/vim/vim
Neovim：https://github.com/neovim/neovim
古老的编辑器之一，被誉为“编辑器之神”！
推荐安装插件 zig.vim，由官方维护。
小细节
推荐关闭 vim / neovim 的保存自动格式化功能（默认开启）：
sh
# for vim
+    
Zig 语言圣经
Appearance
编辑器选择 ​
工欲善其事，必先利其器！
目前有以下几种编辑器推荐：
VS Code ​
官网地址：https://code.visualstudio.com/
Visual Studio Code 是一款由微软开发且跨平台的免费源代码编辑器。该软件以扩展的方式支持语法高亮、代码自动补全、代码重构功能，并且内置了命令行工具和Git 版本控制系统。用户可以更改主题和键盘快捷方式实现个性化设置，也可以通过内置的扩展程序商店安装其他扩展以拓展软件功能。
目前最轻量且生态丰富的编辑器，微软出品，zig 官方为其开发了插件，仅需要安装 Zig Language这个插件即可，在初次初始化时会推荐安装 language server， 确认即可！
vscode-zig
VS ​
官网地址：https://visualstudio.microsoft.com/
Microsoft Visual Studio是微软公司的开发工具包系列产品。VS是一个基本完整的开发工具集，它包括了整个软件生命周期中所需要的大部分工具，如UML工具、代码管控工具、集成开发环境等等。
windows 上最棒的开发 IDE，存在第三方插件：ZigVS。
CLion ​
CLion 是一款专为开发 C 及 C++ 所设计的跨平台 IDE。它是以 IntelliJ 为基础设计的，包含了许多智能功能来提高开发人员的生产力。CLion 帮助开发人员使用智能编辑器来提高代码质量、自动代码重构并且深度整合 CMake 编译系统，从而提高开发人员的工作效率。
原本 CLion 仅仅是 C/C++ 的开发IDE，但在安装插件后可以作为 zig 的 IDE 使用。
目前插件市场活跃的两个 zig 插件（均为第三方作者维护）分别是 ZigBrains 和 Zig Support，均支持 zig 的 0.11.0 版本。
Vim / Neovim ​
Vim：https://github.com/vim/vim
Neovim：https://github.com/neovim/neovim
古老的编辑器之一，被誉为“编辑器之神”！
推荐安装插件 zig.vim，由官方维护。
小细节
推荐关闭 vim / neovim 的保存自动格式化功能（默认开启）：
sh
# for vim
 let g:zig_fmt_autosave = 0
 
 # for neovim lua
@@ -29,7 +29,7 @@
 zig build -Doptimize=ReleaseSafe
 # 此处将编译后的zls直接覆盖mason的zls
 cp zig-out/bin/zls  ~/.local/share/nvim/mason/packages/zls/bin/zls
nvim-zig
Emacs ​
如果说 Vim 是编辑器之神，那么Emacs就是神的编辑器！
Zig 官方维护了 Emacs 的插件 zig-mode，参照页面配置即可。
Emacs 也可以使用 lsp-mode 来使用 zls 。
Sublime Text ​
经典的编辑器，插件也是由 zig 官方维护：sublime-zig-language，安装即可。
⛔ 危险
值得注意的是，该插件已经有两年无人维护！

-    
+    
     
   
 
\ No newline at end of file
diff --git a/environment/install-environment.html b/environment/install-environment.html
index 74f6d25d..7f41df04 100644
--- a/environment/install-environment.html
+++ b/environment/install-environment.html
@@ -3,23 +3,23 @@
   
     
     
-    环境安装 | Zig 圣经
+    环境安装 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
环境安装 ​
🅿️ 提示
当前 Zig 还没有发布 1.0 版本，发布周期与 LLVM 的新版本关联，其发布周期约为 6 个月。 因此，Zig 的发布往往要间隔很久，以目前的开发速度，稳定版最终会变得过时（即便此时还没有新的稳定版），所以官方鼓励用户使用 nightly 版本。
Windows ​
windows 输出中文乱码问题
如果你是中文简体用户，那么建议将 windows 的编码修改为UTF-8编码，由于 zig 的源代码编码格式是 UTF-8，导致在windows下向控制台打印输出中文会发生乱码的现象。
修改方法为：
  1. 打开 widnows 设置中的 时间和语言，进入 语言和区域。
  2. 点击下方的管理语言设置，在新打开的窗口中点击 管理。
  3. 点击下方的 更改系统区域设置，勾选下方的 “使用 unicode UTF-8 提供全球语言支持”
  4. 重启计算机。
Scoop ​
推荐使用 Scoop 工具进行安装，Scoop 的 main 仓库和 version 仓库分别有着最新的 release 和 nightly 版本。
安装方式如下：
sh
scoop bucket add main
+    
Zig 语言圣经
Appearance
环境安装 ​
🅿️ 提示
当前 Zig 还没有发布 1.0 版本，发布周期与 LLVM 的新版本关联，其发布周期约为 6 个月。 因此，Zig 的发布往往要间隔很久，以目前的开发速度，稳定版最终会变得过时（即便此时还没有新的稳定版），所以官方鼓励用户使用 nightly 版本。
Windows ​
windows 输出中文乱码问题
如果你是中文简体用户，那么建议将 windows 的编码修改为UTF-8编码，由于 zig 的源代码编码格式是 UTF-8，导致在windows下向控制台打印输出中文会发生乱码的现象。
修改方法为：
  1. 打开 widnows 设置中的 时间和语言，进入 语言和区域。
  2. 点击下方的管理语言设置，在新打开的窗口中点击 管理。
  3. 点击下方的 更改系统区域设置，勾选下方的 “使用 unicode UTF-8 提供全球语言支持”
  4. 重启计算机。
Scoop ​
推荐使用 Scoop 工具进行安装，Scoop 的 main 仓库和 version 仓库分别有着最新的 release 和 nightly 版本。
安装方式如下：
sh
scoop bucket add main
 scoop install main/zig
sh
scoop bucket add versions
-scoop install versions/zig-dev
🅿️ 提示
在使用 Scoop 时，推荐将 Zig 作为 global 安装，这样 Zig 会被自动添加进环境变量。
其他的包管理器 ​
也可以使用诸如 WinGet，Chocolatey
sh
winget install -e --id zig.zig
sh
choco install zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，普通用户选择 zig-windows-x86_64 即可。
执行以下命令：
powershell
[Environment]::SetEnvironmentVariable(
+scoop install versions/zig-dev
🅿️ 提示
在使用 Scoop 时，推荐将 Zig 作为 global 安装，这样 Zig 会被自动添加进环境变量。
其他的包管理器 ​
也可以使用诸如 WinGet，Chocolatey
sh
winget install -e --id zig.zig
sh
choco install zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，普通用户选择 zig-windows-x86_64 即可。
执行以下命令：
powershell
[Environment]::SetEnvironmentVariable(
    "Path",
    [Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\your-path\zig-windows-x86_64-your-version",
    "Machine"
@@ -27,17 +27,21 @@
    "Path",
    [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\your-path\zig-windows-x86_64-your-version",
    "User"
-)
🅿️ 提示
以上的 System 对应的系统全局的环境变量， User 对应的是用户的环境变量。如果是个人电脑，使用任意一个没有区别。
首先确保你的路径是正确的，其次你可能注意到路径前面还有一个 ; ，此处并不是拼写错误！
Mac ​
Mac安装 zig 就很方便，但是如果要使用 nightly ，还是需要自行下载并添加环境变量
sh
brew install zig
sh
port install zig
Linux ​
Linux安装的话， 由于发行版的不同，安装的方式五花八门，先列出通过包管理器安装 Zig 的方法，再说明如何手动安装 Zig 并设置环境变量。
包管理器安装 ​
以下列出了支持通过包管理器安装 Zig 的发行版和对应命令：
发行版命令备注
Arch Linuxpacman -S zigAUR: zig-dev-bin
Fedoradnf install zig
Fedora Silverbluerpm-ostree install zig
Gentooemerge -av dev-lang/zig
NixOSnix-env -i zig
Ubuntu (snap)snap install zig --classic --beta
Void Linuxxbps-install -Su zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，普通用户选择 zig-linux-x86_64 即可。
以下讲述两种两种方法安装 zig ，一种是采取通用的linux安装方式，一种是在个人目录下安装，添加环境变量
通用linux安装方式 ​
创建目录 /usr/lib/zig，然后将所有文件内容移动到 /usr/lib/zig 目录下，最后将可执行文件 zig 通过软链接映射到 /usr/bin/zig ，具体命令操作如下：
sh
tar -xpf archive.tar.xz
-cd zig-linux
-cp -r . /usr/lib/zig
-ln -s /usr/lib/zig/zig /usr/bin/zig
个人目录安装 ​
这种方案是采取配置PATH来实现：
sh
# 推荐将资源文件放置在 ~/.local/bin
-mkdir ~/.local/bin
-mkdir ~/.local/bin/zig
+)
🅿️ 提示
以上的 System 对应的系统全局的环境变量， User 对应的是用户的环境变量。如果是个人电脑，使用任意一个没有区别。
首先确保你的路径是正确的，其次你可能注意到路径前面还有一个 ; ，此处并不是拼写错误！
Mac ​
Mac安装 zig 就很方便，但是如果要使用 nightly ，还是需要自行下载并添加环境变量
sh
brew install zig
sh
port install zig
Linux ​
Linux安装的话， 由于发行版的不同，安装的方式五花八门，先列出通过包管理器安装 Zig 的方法，再说明如何手动安装 Zig 并设置环境变量。
包管理器安装 ​
以下列出了支持通过包管理器安装 Zig 的发行版和对应命令：
发行版命令备注
Arch Linuxpacman -S zigAUR: zig-dev-bin
Fedoradnf install zig
Fedora Silverbluerpm-ostree install zig
Gentooemerge -av dev-lang/zig
NixOSnix-env -i zig
Ubuntu (snap)snap install zig --classic --beta
Void Linuxxbps-install -Su zig
手动安装 ​
通过官方的发布页面下载对应的 Zig 版本，之后将包含 Zig 二进制的目录加入到 PATH 环境变量即可。
多版本管理 ​
由于 Zig 还在快速开发迭代中，因此在使用社区已有类库时，有可能出现新版本 Zig 无法编译的情况，这时候一方面可以跟踪上游进展，看看是否有解决方案；另一个就是使用固定的版本来编译这个项目，显然这种方式更靠谱一些。
目前为止，Zig 的版本管理工具主要有如下几个：
读者可根据自身需求选择，这里介绍一个通用的版本管理工具：asdf。
  1. 参考 Getting Started 下载 asdf，一般而言，常见的系统管理器，如 brew、apt 均可直接安装
  2. 安装 asdf Zig 插件
bash
asdf plugin-add zig https://github.com/asdf-community/asdf-zig.git
  1. 之后就可以用 asdf 管理 Zig 版本。这里列举一些 asdf 常用命令：
bash
# 列举所有可安装的版本
+asdf list-all zig
 
-tar -xpf archive.tar.xz
-cd zig-linux
-cp -r . ~/.local/bin/zig
然后像bash写入环境变量配置，如 ~/.bashrc ：
sh
export PATH="~/.local/bin/zig/:$PATH"
如果使用其他的shell,则需要用户自己参照所使用的shell的配置来设置PATH

-    
+# 安装指定版本的 Zig
+asdf install zig <version>
+
+# 卸载指定版本的 Zig
+asdf uninstall zig <version>
+
+# 设置全局默认版本，会写到 $HOME/.tool-versions 文件
+asdf global zig <version>
+
+# 设置当前目录使用的版本，会写到 $(pwd)/.tool-versions 文件
+asdf local zig <version>

+    
     
   
 
\ No newline at end of file
diff --git a/environment/zig-command.html b/environment/zig-command.html
index 09d7657f..d88a3b7a 100644
--- a/environment/zig-command.html
+++ b/environment/zig-command.html
@@ -3,21 +3,21 @@
   
     
     
-    zig 命令 | Zig 圣经
+    zig 命令 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
zig 命令 ​
现在，我们已经安装了 zig ，也安装了对应的编辑器，接下来就了解一下基本的 zig 命令。
这单单一个命令可神了，它囊括了项目建立、构建、测试、运行，甚至你可以用它来部署你的项目，也可以用来给 C/C++ 作为编译或者依赖管理工具，非常的全面，这一切都是得益于 zig 本身的编译期。
以下仅列出常用的命令！
zig build ​
构建项目，会自动搜索当前目录及父目录的 build.zig 进行构建。
zig init-exe ​
这个命令用于初始化项目（可执行二进制文件），在当前路径下创建 src/main.zig 和 build.zig 两个文件。
关于 build.zig 这个文件的内容涉及到了 zig 的构建系统，我们将会单独讲述。
sh
.
+    
Zig 语言圣经
Appearance
zig 命令 ​
现在，我们已经安装了 zig ，也安装了对应的编辑器，接下来就了解一下基本的 zig 命令。
这单单一个命令可神了，它囊括了项目建立、构建、测试、运行，甚至你可以用它来部署你的项目，也可以用来给 C/C++ 作为编译或者依赖管理工具，非常的全面，这一切都是得益于 zig 本身的编译期。
以下仅列出常用的命令！
zig build ​
构建项目，会自动搜索当前目录及父目录的 build.zig 进行构建。
zig init-exe ​
这个命令用于初始化项目（可执行二进制文件），在当前路径下创建 src/main.zig 和 build.zig 两个文件。
关于 build.zig 这个文件的内容涉及到了 zig 的构建系统，我们将会单独讲述。
sh
.
 ├── build.zig
 └── src
     └── main.zig
WARNING
当前 nightly 版本的 zig 已经将 zig init-exe 和 zig init-lib 合并为一个命令 zig init。
zig init-lib ​
如果你想写一个 zig 的库，那么可以使用该命令，在当前路径下创建 src/main.zig 和 build.zig 两个文件。
🅿️ 提示
创建出来的 main.zig build.zig 和通过 init-exe 命令创建出来的 main.zig build.zig 并不相同。
sh
.
@@ -27,7 +27,7 @@
 12202809180bab2c7ae3382781b2fc65395e74b49d99ff2595f3fea9f7cf66cfa963
当然如果你想将包直接添加到 zon 中，你可以附加 --save 参数来实现效果：
zig
zig fetch --save https://github.com/limine-bootloader/limine-zig/archive/trunk.tar.gz
 // 当包提供 name 时，会自动使用包的 name
 // 当然，你也可以指定包的 name，使用 --save=limine

-    
+    
     
   
 
\ No newline at end of file
diff --git a/epilogue.html b/epilogue.html
index 0e2af254..aaefc9b9 100644
--- a/epilogue.html
+++ b/epilogue.html
@@ -3,22 +3,22 @@
   
     
     
-    后记 | Zig 圣经
+    后记 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
-    
+    
+    
     
   
 
\ No newline at end of file
diff --git a/hashmap.json b/hashmap.json
index f286ab83..0a92d501 100644
--- a/hashmap.json
+++ b/hashmap.json
@@ -1 +1 @@
-{"basic_basic_type_char-and-boolean.md":"atzDn7aO","advanced_comptime.md":"xqbfrK3R","basic_advanced_type_enum.md":"76racOeM","index.md":"Lwj7q2PL","more_atomic.md":"ltnGTFZ8","more_builtin_func.md":"ovUw1IGb","more_miscellaneous.md":"Eut78xjC","basic_optional_type.md":"d6QrqvLi","basic_advanced_type_pointer.md":"l0SvPPfX","basic_advanced_type_opaque.md":"4-6WWT0b","more_zero-type.md":"8qgFni3B","more_wasm.md":"2fHigx_P","more_undefined_behavior.md":"BCbNIkiP","more_style_guide.md":"u9j1EPeD","appendix_well-known-lib.md":"v9y-5Tnc","more_reflection.md":"-_8OdP_I","prologue.md":"uHHI1KVr","advanced_memory_manage.md":"2V38NqCn","what-is-zig.md":"oNL80Xd0","basic_basic_type_number.md":"sub6Vpaa","appendix_community.md":"7nCEsG4m","advanced_package_management.md":"3VV4Fhfu","basic_basic_type_function.md":"qCBIR9qq","about.md":"7GvExAEx","basic_process_control_unreachable.md":"Y64Zdo4Q","basic_advanced_type_vector.md":"jUlFsZSk","basic_advanced_type_array.md":"HyJzum-K","advanced_assembly.md":"UEvDte07","basic_error_handle.md":"DDwEzY8Y","basic_advanced_type_struct.md":"7UsPAPWF","advanced_interact-with-c.md":"lk3QgZYk","basic_define-variable.md":"sDsZwp1U","basic_union.md":"JyaJgpd3","basic_process_control_switch.md":"c7mMGXuW","environment_install-environment.md":"aoj-uaPQ","advanced_type_cast.md":"CfyKnkqc","engineering_unit-test.md":"e_HIdSvv","environment_editor.md":"f-kpUUhp","advanced_async.md":"5aIkVmne","basic_advanced_type_silce.md":"d2m_M-A1","environment_zig-command.md":"cA7HQ_xj","epilogue.md":"_8-XWsk9","basic_process_control_decision.md":"rdtrtJa0","hello-world.md":"l71jl_QV","basic_process_control_loop.md":"G0QbfSeI","basic_process_control_defer.md":"gSBsi8s5","engineering_build-system.md":"HJZocaoQ"}
+{"advanced_async.md":"5aIkVmne","advanced_interact-with-c.md":"lk3QgZYk","basic_advanced_type_silce.md":"d2m_M-A1","advanced_memory_manage.md":"VVXxDYaI","appendix_community.md":"7nCEsG4m","basic_advanced_type_enum.md":"76racOeM","basic_process_control_decision.md":"AilCsfii","basic_error_handle.md":"X3CsP-Vt","basic_advanced_type_opaque.md":"4-6WWT0b","basic_define-variable.md":"sDsZwp1U","basic_union.md":"ugreMmE2","basic_process_control_unreachable.md":"Y64Zdo4Q","basic_process_control_loop.md":"OpaKXOlk","basic_basic_type_char-and-boolean.md":"atzDn7aO","advanced_assembly.md":"UEvDte07","basic_basic_type_number.md":"sub6Vpaa","basic_advanced_type_vector.md":"jUlFsZSk","basic_basic_type_function.md":"qCBIR9qq","appendix_well-known-lib.md":"v9y-5Tnc","advanced_comptime.md":"xqbfrK3R","basic_advanced_type_array.md":"HyJzum-K","more_miscellaneous.md":"Eut78xjC","hello-world.md":"l71jl_QV","index.md":"EcLvnWMr","basic_process_control_defer.md":"gSBsi8s5","basic_optional_type.md":"N1LhwqCi","more_atomic.md":"ltnGTFZ8","more_builtin_func.md":"ovUw1IGb","basic_process_control_switch.md":"Z7KwKgFx","basic_advanced_type_pointer.md":"l0SvPPfX","engineering_unit-test.md":"e_HIdSvv","epilogue.md":"_8-XWsk9","environment_zig-command.md":"cA7HQ_xj","environment_install-environment.md":"PTNE6kMW","about.md":"7GvExAEx","more_wasm.md":"2fHigx_P","advanced_type_cast.md":"CfyKnkqc","more_zero-type.md":"8qgFni3B","basic_advanced_type_struct.md":"REVwY0VS","more_undefined_behavior.md":"BCbNIkiP","environment_editor.md":"f-kpUUhp","more_reflection.md":"-_8OdP_I","advanced_package_management.md":"3VV4Fhfu","prologue.md":"uHHI1KVr","what-is-zig.md":"oNL80Xd0","more_style_guide.md":"u9j1EPeD","engineering_build-system.md":"0lT4HF-R"}
diff --git a/hello-world.html b/hello-world.html
index 1060d431..fe2ab094 100644
--- a/hello-world.html
+++ b/hello-world.html
@@ -3,21 +3,21 @@
   
     
     
-    Hello World | Zig 圣经
+    Hello World | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
Hello World ​
我相信你一定是从 Hello, World! 开始学习其他语言的，在这里我们也不例外，我们来通过一个简单的程序，来向 zig 的世界打一声招呼！
先使用 zig init-exe 命令初始化一个项目，再将以下内容覆写到 src/main.zig 中。
WARNING
当前 nightly 版本的 zig 已经将 zig init-exe 和 zig init-lib 合并为一个命令 zig init。
zig
const std = @import("std");
+    
Zig 语言圣经
Appearance
Hello World ​
我相信你一定是从 Hello, World! 开始学习其他语言的，在这里我们也不例外，我们来通过一个简单的程序，来向 zig 的世界打一声招呼！
先使用 zig init-exe 命令初始化一个项目，再将以下内容覆写到 src/main.zig 中。
WARNING
当前 nightly 版本的 zig 已经将 zig init-exe 和 zig init-lib 合并为一个命令 zig init。
zig
const std = @import("std");
 
 pub fn main() void {
     std.debug.print("Hello, World!\n", .{});
@@ -51,7 +51,7 @@
     try out_buffer.flush();
     try err_buffer.flush();
 }
此时我们就分别得到了使用缓冲区的 stdout 和 stderr， 性能更高了！
更进一步？ ​
上面我们已经完成了带有缓冲区的“打印”，这很棒！
但是，它还没有多线程支持，所以我们可能需要添加一个锁来保证打印函数的先后执行顺序，你可以使用 std.Thread.Mutex，它的文档在这里，但我更推荐你结合标准库的源码来了解它。
了解更多？ ​
如果你想了解更多内容，可以看一看这个视频 Advanced Hello World in Zig - Loris Cro

-    
+    
     
   
 
\ No newline at end of file
diff --git a/index.html b/index.html
index 04847c9f..40ade69e 100644
--- a/index.html
+++ b/index.html
@@ -3,22 +3,22 @@
   
     
     
-    Zig 圣经
+    Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
-    
+    
+    
     
     
   
   
-    
Zig 圣经
Appearance
Zig 圣经
简单、快速地学习 Zig
Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件
📖 开始阅读
🌐 Zig官网
📝
语义简单
专注于调试应用程序，而不是调试编程语言知识。无隐式控制流、无隐式内存分配、无预处理器和宏
🚀
编译期执行
基于编译期代码执行和惰性求值的全新元编程方法,编译期调用任何函数、模拟目标架构，无运行时开销将类型作为值进行操作
💡
维护代码
改善代码库，将 Zig 作为一个开箱即用的零依赖 C/C++ 编译器，通过 zig build 构建一致的编译环境，跨语言 LTO 默认启用

-    
+    
Zig 语言圣经
Appearance
Zig 语言圣经
简单、快速地学习 Zig
Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件
📖 开始阅读
🌐 Zig官网
📝
语义简单
专注于调试应用程序，而不是调试编程语言知识。无隐式控制流、无隐式内存分配、无预处理器和宏
🚀
编译期执行
基于编译期代码执行和惰性求值的全新元编程方法,编译期调用任何函数、模拟目标架构，无运行时开销将类型作为值进行操作
💡
维护代码
改善代码库，将 Zig 作为一个开箱即用的零依赖 C/C++ 编译器，通过 zig build 构建一致的编译环境，跨语言 LTO 默认启用

+    
     
   
 
\ No newline at end of file
diff --git a/more/atomic.html b/more/atomic.html
index d6f3419d..90a26b47 100644
--- a/more/atomic.html
+++ b/more/atomic.html
@@ -3,21 +3,21 @@
   
     
     
-    原子操作 | Zig 圣经
+    原子操作 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
原子操作 ​
原子操作是在多线程环境中非常重要的一个概念，原子操作是指一个或一系列的操作，它们作为一个整体来执行，中间不会被任何其他的操作打断。这意味着原子操作要么全部完成，要么全部不完成，不会出现只完成部分操作的情况。
目前 zig 提供了一些内建函数来进行原子操作，并且提供了 std.atomic 命名空间来实现内存排序、原子数据结构。
内建函数 ​
在讲述下列的内建函数前，我们需要了解一下前置知识：
原子操作的顺序级别：为了实现性能和必要保证之间的平衡，原子性分为六个级别。它们按照强度顺序排列，每个级别都包含上一个级别的所有保证。
关于原子顺序六个级别的具体说明，见 LLVM。
@atomicLoad ​
函数原型：
zig
@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T
用于某个类型指针进行原子化的读取值。
@atomicStore ​
函数原型：
zig
`@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void`
用于对某个类型指针进行原子化的赋值。
@atomicRmw ​
函数原型：
zig
@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T
用于原子化的修改值并返回修改前的值。
其还支持九种操作符，具体 见此。
@cmpxchgWeak ​
函数原型：
zig
@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T
弱原子的比较与交换操作，如果目标指针是给定值，那么赋值为参数的新值，并返回null，否则仅读取值返回。
@cmpxchgStrong ​
函数原型：
zig
@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T
强原子的比较与交换操作，如果目标指针是给定值，那么赋值为参数的新值，并返回null，否则仅读取值返回。
@fence ​
函数原型：
zig
@fence(order: AtomicOrder) void
用于创建一个内存屏障，防止某些类型的内存重新排序，具体细节可以查看内存屏障的相关信息。
std.atomic 包 ​
原子数据结构 ​
可以使用 std.atomic.Value 包裹某种类型获取到一个原子数据结构。
示例：
zig
const RefCount = struct {
+    
Zig 语言圣经
Appearance
原子操作 ​
原子操作是在多线程环境中非常重要的一个概念，原子操作是指一个或一系列的操作，它们作为一个整体来执行，中间不会被任何其他的操作打断。这意味着原子操作要么全部完成，要么全部不完成，不会出现只完成部分操作的情况。
目前 zig 提供了一些内建函数来进行原子操作，并且提供了 std.atomic 命名空间来实现内存排序、原子数据结构。
内建函数 ​
在讲述下列的内建函数前，我们需要了解一下前置知识：
原子操作的顺序级别：为了实现性能和必要保证之间的平衡，原子性分为六个级别。它们按照强度顺序排列，每个级别都包含上一个级别的所有保证。
关于原子顺序六个级别的具体说明，见 LLVM。
@atomicLoad ​
函数原型：
zig
@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T
用于某个类型指针进行原子化的读取值。
@atomicStore ​
函数原型：
zig
`@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void`
用于对某个类型指针进行原子化的赋值。
@atomicRmw ​
函数原型：
zig
@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T
用于原子化的修改值并返回修改前的值。
其还支持九种操作符，具体 见此。
@cmpxchgWeak ​
函数原型：
zig
@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T
弱原子的比较与交换操作，如果目标指针是给定值，那么赋值为参数的新值，并返回null，否则仅读取值返回。
@cmpxchgStrong ​
函数原型：
zig
@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T
强原子的比较与交换操作，如果目标指针是给定值，那么赋值为参数的新值，并返回null，否则仅读取值返回。
@fence ​
函数原型：
zig
@fence(order: AtomicOrder) void
用于创建一个内存屏障，防止某些类型的内存重新排序，具体细节可以查看内存屏障的相关信息。
std.atomic 包 ​
原子数据结构 ​
可以使用 std.atomic.Value 包裹某种类型获取到一个原子数据结构。
示例：
zig
const RefCount = struct {
     count: Value(usize),
     dropFn: *const fn (*RefCount) void,
 
@@ -58,7 +58,7 @@
         spinLoopHint();
     }
 }
TODO：增加更多的讲解，例如使用示例，原子级别讲解等！

-    
+    
     
   
 
\ No newline at end of file
diff --git a/more/builtin_func.html b/more/builtin_func.html
index 07aef8b2..94d6f0ff 100644
--- a/more/builtin_func.html
+++ b/more/builtin_func.html
@@ -3,22 +3,22 @@
   
     
     
-    内建函数 | Zig 圣经
+    内建函数 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
-    
+    
+    
     
   
 
\ No newline at end of file
diff --git a/more/miscellaneous.html b/more/miscellaneous.html
index 1323459f..5d4c673d 100644
--- a/more/miscellaneous.html
+++ b/more/miscellaneous.html
@@ -3,21 +3,21 @@
   
     
     
-    杂项 | Zig 圣经
+    杂项 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
杂项 ​
本部分是关于 zig 一些额外知识的补充，暂时还没有决定好分类到何处！
容器 ​
在 Zig 中，容器 是充当保存变量和函数声明的命名空间的任何语法结构。容器也是可以实例化的类型定义。结构体、枚举、联合、不透明，甚至 Zig 源文件本身都是容器，但容器并不能包含语句（语句是描述程序运行操作的一个单位）。
当然，你也可以这样理解，容器是一个只包含变量或常量定义以及函数定义的命名空间。
注意：容器和块（block）不同！
usingnamespace ​
关键字 usingnamespace 可以将一个容器中的所有 pub 声明混入到当前的容器中。
例如，可以使用将 usingnamespace 将 std 标准库混入到 main.zig 这个容器中：
zig
const T = struct {
+    
Zig 语言圣经
Appearance
杂项 ​
本部分是关于 zig 一些额外知识的补充，暂时还没有决定好分类到何处！
容器 ​
在 Zig 中，容器 是充当保存变量和函数声明的命名空间的任何语法结构。容器也是可以实例化的类型定义。结构体、枚举、联合、不透明，甚至 Zig 源文件本身都是容器，但容器并不能包含语句（语句是描述程序运行操作的一个单位）。
当然，你也可以这样理解，容器是一个只包含变量或常量定义以及函数定义的命名空间。
注意：容器和块（block）不同！
usingnamespace ​
关键字 usingnamespace 可以将一个容器中的所有 pub 声明混入到当前的容器中。
例如，可以使用将 usingnamespace 将 std 标准库混入到 main.zig 这个容器中：
zig
const T = struct {
     usingnamespace @import("std");
 };
 pub fn main() !void {
@@ -29,7 +29,7 @@
     @cDefine("STBI_NO_STDIO", "");
     @cInclude("stb_image.h");
 });

-    
+    
     
   
 
\ No newline at end of file
diff --git a/more/reflection.html b/more/reflection.html
index 3613724c..7849e7fe 100644
--- a/more/reflection.html
+++ b/more/reflection.html
@@ -3,21 +3,21 @@
   
     
     
-    反射 | Zig 圣经
+    反射 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
反射 ​
在计算机学中，反射（reflection），是指计算机程序在运行时（runtime）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。
事实上，由于 zig 是一门强类型的静态语言，因此它的反射是在编译期实现的，允许我们观察已有的类型，并根据已有类型的信息来创造新的类型！
观察已有类型 ​
zig 提供了不少函数来获取已有类型的信息,如：@TypeOf、@typeName、@typeInfo、@hasDecl、@hasField、@field、@fieldParentPtr、@call。
@TypeOf ​
@TypeOf，该内建函数用于使用获取变量的类型。
原型为：@TypeOf(...) type
它接受任意个表达式作为参数，并返回它们的公共可转换类型（使用 对等类型转换），表达式会完全在编译期执行，并且不会产生任何副作用（可以看作仅仅进行来类型计算）。
zig
// 会触发编译器错误，因为 bool 和 float 类型无法进行比较
+    
Zig 语言圣经
Appearance
反射 ​
在计算机学中，反射（reflection），是指计算机程序在运行时（runtime）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。
事实上，由于 zig 是一门强类型的静态语言，因此它的反射是在编译期实现的，允许我们观察已有的类型，并根据已有类型的信息来创造新的类型！
观察已有类型 ​
zig 提供了不少函数来获取已有类型的信息,如：@TypeOf、@typeName、@typeInfo、@hasDecl、@hasField、@field、@fieldParentPtr、@call。
@TypeOf ​
@TypeOf，该内建函数用于使用获取变量的类型。
原型为：@TypeOf(...) type
它接受任意个表达式作为参数，并返回它们的公共可转换类型（使用 对等类型转换），表达式会完全在编译期执行，并且不会产生任何副作用（可以看作仅仅进行来类型计算）。
zig
// 会触发编译器错误，因为 bool 和 float 类型无法进行比较
 // 无法执行对等类型转换
 _ = @TypeOf(true, 5.2);
 // 结果为 comptime_float
@@ -170,7 +170,7 @@
 
     std.debug.print("{}\n", .{D.b});
 }
WARNING
需要注意的是，当前 zig 并不支持构建的类型包含声明（declaration），即定义的变量（常量）或方法，具体原因见此 issue！
不得不说，不支持声明极大地降低了 zig 编译期的特性。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/more/style_guide.html b/more/style_guide.html
index 411005a1..e1eeaf85 100644
--- a/more/style_guide.html
+++ b/more/style_guide.html
@@ -3,21 +3,21 @@
   
     
     
-    风格指南 | Zig 圣经
+    风格指南 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
风格指南 ​
🅿️ 提示
此风格指南来自官方的 英文参考文档！
本风格指南并不是强制性的，仅作为一份参考！
空白 ​
  • 采用四空格缩进
  • 尽量在同一行打开大括号，除非需要换行
  • 如果一个变量（常量）包含的元素数量超过 2，请将每个元素放在单独的行上，并养成在最后一个元素后添加 , 的习惯，这有助于格式化。
命名 ​
简单来说，使用 驼峰命名法、TitleCase 命名法、蛇形命名法
  • 类型声明使用 TitleCase 命名法（除非是一个 0 字段的 struct，此时它被视为一个命名空间，应使用 蛇形命名法 ）
  • 如果 x 是可以被调用的，并且它返回一个类型，那么使用 TitleCase 命名法
  • 如果 x 是可被调用，并且返回非类型，应使用 驼峰命名法
  • 其他情况下，应该使用 蛇形命名法
首字母缩略词、首字母缩写词、专有名词或任何其他在书面英语中具有大写规则的单词与任何其他单词一样，都受命名约定的约束。即使是只有 2 个字母的首字母缩略词也受这些约定的约束。
文件名分为两类：类型和命名空间，如果文件具有字段，则它应该使用 TitleCase 命名法，否则应使用 蛇形命名法，目录名称也应使用 蛇形命名法
以上的约束是在一般情况下，如果已经有了内部约定，请使用内部约定！
以下是一个示例：
zig
// 命名空间，使用蛇形命名法
+    
Zig 语言圣经
Appearance
风格指南 ​
🅿️ 提示
此风格指南来自官方的 英文参考文档！
本风格指南并不是强制性的，仅作为一份参考！
空白 ​
  • 采用四空格缩进
  • 尽量在同一行打开大括号，除非需要换行
  • 如果一个变量（常量）包含的元素数量超过 2，请将每个元素放在单独的行上，并养成在最后一个元素后添加 , 的习惯，这有助于格式化。
命名 ​
简单来说，使用 驼峰命名法、TitleCase 命名法、蛇形命名法
  • 类型声明使用 TitleCase 命名法（除非是一个 0 字段的 struct，此时它被视为一个命名空间，应使用 蛇形命名法 ）
  • 如果 x 是可以被调用的，并且它返回一个类型，那么使用 TitleCase 命名法
  • 如果 x 是可被调用，并且返回非类型，应使用 驼峰命名法
  • 其他情况下，应该使用 蛇形命名法
首字母缩略词、首字母缩写词、专有名词或任何其他在书面英语中具有大写规则的单词与任何其他单词一样，都受命名约定的约束。即使是只有 2 个字母的首字母缩略词也受这些约定的约束。
文件名分为两类：类型和命名空间，如果文件具有字段，则它应该使用 TitleCase 命名法，否则应使用 蛇形命名法，目录名称也应使用 蛇形命名法
以上的约束是在一般情况下，如果已经有了内部约定，请使用内部约定！
以下是一个示例：
zig
// 命名空间，使用蛇形命名法
 const namespace_name = @import("dir_name/file_name.zig");
 // 类型声明，使用 TitleCase 命名法
 const TypeName = @import("dir_name/TypeName.zig");
@@ -75,7 +75,7 @@
 
 // 可被调用，且返回非类型，使用驼峰命名法
 fn readU32Be() u32 {}
文档注释指南 ​
  • 根据名称省略冗余信息，即当可以立即从命名推断出其用途时，无需注释其用途
  • 鼓励将注释信息复制到多个类似的函数上，这有助于 IDE 或者其他工具提供更好的帮助说明
  • 对不变量使用 假设 来表示当违反事先预定情况时会发生未定义行为
  • 使用 断言 表示当当违反预定情况时会触发安全检查的未定义行为

-    
+    
     
   
 
\ No newline at end of file
diff --git a/more/undefined_behavior.html b/more/undefined_behavior.html
index b6c2f794..c1980367 100644
--- a/more/undefined_behavior.html
+++ b/more/undefined_behavior.html
@@ -3,21 +3,21 @@
   
     
     
-    未定义操作 | Zig 圣经
+    未定义操作 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
未定义操作 ​
zig 本身有许多未定义行为，它们可以很方便地帮助开发者找出错误。
如果在编译期就检测到了未定义的行为，那么 zig 会发出编译错误并停止继续编译，大多数编译时无法检测到的未定义行为均会在运行时被检测到。这就是 zig 的安全检查！
安全检查会在debug、ReleaseSafe 模式下开启，但可以使用 @setRuntimeSafety 来强制指定在单独的块中是否开启安全检查（这将忽略构建模式）。
当出现安全检查失败时，zig 会编译失败并触发堆栈跟踪：
zig
test "safety check" {
+    
Zig 语言圣经
Appearance
未定义操作 ​
zig 本身有许多未定义行为，它们可以很方便地帮助开发者找出错误。
如果在编译期就检测到了未定义的行为，那么 zig 会发出编译错误并停止继续编译，大多数编译时无法检测到的未定义行为均会在运行时被检测到。这就是 zig 的安全检查！
安全检查会在debug、ReleaseSafe 模式下开启，但可以使用 @setRuntimeSafety 来强制指定在单独的块中是否开启安全检查（这将忽略构建模式）。
当出现安全检查失败时，zig 会编译失败并触发堆栈跟踪：
zig
test "safety check" {
     unreachable;
 }
sh
$ zig test test_undefined_behavior.zig
 1/1 test.safety check... thread 892159 panic: reached unreachable code
@@ -58,7 +58,7 @@
 var f = Foo{ .int = 42 };
 f = Foo{ .float = 12.34 };
🅿️ 提示
注意：packed 和 extern 标记的联合类型并没有这种安全监测！
浮点转换整数发生越界 ​
当将浮点数转换为整数时，如果浮点数的值超出了整数类型的范围，就会发生非法越界，例如：
zig
const float: f32 = 4294967296;
 const int: i32 = @intFromFloat(float);
指针强制转换为 Null ​
将允许地址为 0 的指针转换为地址不可能为 0 的指针，这会触发非法行为。
C 指针、可选指针、allowzero 标记的指针，这些都是允许地址为 0，但普通指针是不允许的。

-    
+    
     
   
 
\ No newline at end of file
diff --git a/more/wasm.html b/more/wasm.html
index c42d8dc5..977bfa88 100644
--- a/more/wasm.html
+++ b/more/wasm.html
@@ -3,22 +3,22 @@
   
     
     
-    WASM | Zig 圣经
+    WASM | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
-    
+    
+    
     
   
 
\ No newline at end of file
diff --git a/more/zero-type.html b/more/zero-type.html
index 7d2a6ad9..e603290c 100644
--- a/more/zero-type.html
+++ b/more/zero-type.html
@@ -3,22 +3,22 @@
   
     
     
-    零位类型 | Zig 圣经
+    零位类型 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
零位类型 ​
在 zig 中，有一些类型是特殊的零位类型（Zero Type），它们的大小是 0 bit。
它们的特点是，涉及到它们的值不会出现在构建结果中（0 bit不占任何空间）。
void ​
void 是很明显的零位类型，常用于函数无返回值。
但它不止这一种用法，还可以用来初始化泛型实例，例如 std.AutoHashMap：
zig
var map = std.AutoHashMap(i32, void).init(std.testing.allocator);
这样就会获得一个 i32 的 set，尽管可以使用其他方式来实现集合功能，但这样子实现效果内存占用会更少（因为相当于不存在 value）。
整数 ​
整数 声明可以使用 u0 和 i0 来声明零位整数类型，它们的大小也是 0 bit。
数组和切片 ​
数组 和 切片 的长度为 0 时，就是零位类型。
另外，如果它们的元素类型是零位类型，则它们必定是零位类型，此时与数组（切片）长度无关。
枚举 ​
只有一个值的 枚举，也是零位类型。
结构体 ​
结构体 为空或者字段均为零位类型时，此时结构体也是零位类型。
例如，const zero = struct {}; 就是一个零位类型，它的大小为 0。
联合类型 ​
仅具有一种可能类型（且该类型是零位类型）的 联合类型 也是零位类型。

-    
+    
Zig 语言圣经
Appearance
零位类型 ​
在 zig 中，有一些类型是特殊的零位类型（Zero Type），它们的大小是 0 bit。
它们的特点是，涉及到它们的值不会出现在构建结果中（0 bit不占任何空间）。
void ​
void 是很明显的零位类型，常用于函数无返回值。
但它不止这一种用法，还可以用来初始化泛型实例，例如 std.AutoHashMap：
zig
var map = std.AutoHashMap(i32, void).init(std.testing.allocator);
这样就会获得一个 i32 的 set，尽管可以使用其他方式来实现集合功能，但这样子实现效果内存占用会更少（因为相当于不存在 value）。
整数 ​
整数 声明可以使用 u0 和 i0 来声明零位整数类型，它们的大小也是 0 bit。
数组和切片 ​
数组 和 切片 的长度为 0 时，就是零位类型。
另外，如果它们的元素类型是零位类型，则它们必定是零位类型，此时与数组（切片）长度无关。
枚举 ​
只有一个值的 枚举，也是零位类型。
结构体 ​
结构体 为空或者字段均为零位类型时，此时结构体也是零位类型。
例如，const zero = struct {}; 就是一个零位类型，它的大小为 0。
联合类型 ​
仅具有一种可能类型（且该类型是零位类型）的 联合类型 也是零位类型。

+    
     
   
 
\ No newline at end of file
diff --git a/prologue.html b/prologue.html
index 21689a80..22578ad4 100644
--- a/prologue.html
+++ b/prologue.html
@@ -3,22 +3,22 @@
   
     
     
-    前言 | Zig 圣经
+    前言 | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
前言 ​
⚠️ 警告
Zig 这门语言并不适合计算机初学者，如果你已经对计算机有了基础的了解，并且能够较为熟练的掌握一门高级编程语言，我才推荐你来学习它。
实在是太多营销号视频无脑说 zig 已经是 C 的替代品了，或许将来可能是，至少现在不是，目前 zig 只是一个有那么一丁点热度的高级语言。
你可能会疑惑，为什么要再学习一门如此 low level 的语言， C 难道不好吗？
C 很好，非常好，它非常成功，以至于 C 现在已经不再是一门语言，而是一个标准。 你可能会注意到，现在跨语言调用，基本都是遵循的C ABI，包括编译出来的各种库供其他语言使用，也都是 C 可以使用的动态链接库。
但由于历史原因，C 到现在已经处于一种较为割裂的存在，它本身有着一套自己的标准，但是不同的编译器却有着不同的“专属语法”，也就是不同编译器支持的语法实际上是 C 的超集！同时 C 本身没有一个属于自己的包管理器，各式各样的第三方包管理器。。。五花八门，像meson、cmake、xmake、vcpkg，而且均有上手难度。
历史上有不少语言都自诩是 C 的替代品，像Odin、Ada、Modula-2、Go，他们在某种程度上都算是失败了，当然 Zig 的未来也可能是这样子，成为一个不是C的替代品，单独的一门语言，或许有人使用。但就现在来看，我认为 Zig 还是很有希望成为 C 的代替品的，目前的语法均是围绕着语义明确化，减少隐式的执行，更高效的错误跟踪。
或许可能有人会跟我说 Rust 比 Zig 好，我要说的是你说的基本是对的，目前情况来看，Rust 的的确确比 Zig 好很多，更为完善的生态，更多能拿得出手的代表项目，以及相较 Zig 庞大很多的社区等等，但是在未来谁说的准呢？ 更何况 Rust 和 Zig 并不是一个赛道上的东西，在我看来，Rust 的目标是 C++ 的替代， 因此我更愿意称之为“披着高抽象皮的 low level 语言”，Zig 的目标则是 C,而且目前 Zig 的特性也的确在这个方向发展。
Zig 的社区需要更多的人来构建，所以我写了这个文档，帮助新人来更好的理解和学习 Zig！
⚠️ 警告
确保你的 zig 版本是最新的 release 版本，再进行学习！

-    
+    
Zig 语言圣经
Appearance
前言 ​
⚠️ 警告
Zig 这门语言并不适合计算机初学者，如果你已经对计算机有了基础的了解，并且能够较为熟练的掌握一门高级编程语言，我才推荐你来学习它。
实在是太多营销号视频无脑说 zig 已经是 C 的替代品了，或许将来可能是，至少现在不是，目前 zig 只是一个有那么一丁点热度的高级语言。
你可能会疑惑，为什么要再学习一门如此 low level 的语言， C 难道不好吗？
C 很好，非常好，它非常成功，以至于 C 现在已经不再是一门语言，而是一个标准。 你可能会注意到，现在跨语言调用，基本都是遵循的C ABI，包括编译出来的各种库供其他语言使用，也都是 C 可以使用的动态链接库。
但由于历史原因，C 到现在已经处于一种较为割裂的存在，它本身有着一套自己的标准，但是不同的编译器却有着不同的“专属语法”，也就是不同编译器支持的语法实际上是 C 的超集！同时 C 本身没有一个属于自己的包管理器，各式各样的第三方包管理器。。。五花八门，像meson、cmake、xmake、vcpkg，而且均有上手难度。
历史上有不少语言都自诩是 C 的替代品，像Odin、Ada、Modula-2、Go，他们在某种程度上都算是失败了，当然 Zig 的未来也可能是这样子，成为一个不是C的替代品，单独的一门语言，或许有人使用。但就现在来看，我认为 Zig 还是很有希望成为 C 的代替品的，目前的语法均是围绕着语义明确化，减少隐式的执行，更高效的错误跟踪。
或许可能有人会跟我说 Rust 比 Zig 好，我要说的是你说的基本是对的，目前情况来看，Rust 的的确确比 Zig 好很多，更为完善的生态，更多能拿得出手的代表项目，以及相较 Zig 庞大很多的社区等等，但是在未来谁说的准呢？ 更何况 Rust 和 Zig 并不是一个赛道上的东西，在我看来，Rust 的目标是 C++ 的替代， 因此我更愿意称之为“披着高抽象皮的 low level 语言”，Zig 的目标则是 C,而且目前 Zig 的特性也的确在这个方向发展。
Zig 的社区需要更多的人来构建，所以我写了这个文档，帮助新人来更好的理解和学习 Zig！
⚠️ 警告
确保你的 zig 版本是最新的 release 版本，再进行学习！

+    
     
   
 
\ No newline at end of file
diff --git a/sitemap.xml b/sitemap.xml
index a6978f5f..b41e54a8 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -1 +1 @@
-https://zigcc.github.io/zig-course/about.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/assembly.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/async.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/comptime.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/interact-with-c.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/memory_manage.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/package_management.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/type_cast.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/appendix/community.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/appendix/well-known-lib.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/array.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/enum.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/opaque.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/pointer.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/silce.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/struct.html2024-01-11T13:52:57.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/vector.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/basic_type/char-and-boolean.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/basic_type/function.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/basic_type/number.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/define-variable.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/error_handle.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/optional_type.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/decision.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/defer.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/loop.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/switch.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/unreachable.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/union.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/engineering/build-system.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/engineering/unit-test.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/environment/editor.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/environment/install-environment.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/environment/zig-command.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/epilogue.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/hello-world.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/2024-01-11T14:17:03.000Zhttps://zigcc.github.io/zig-course/more/atomic.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/builtin_func.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/miscellaneous.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/reflection.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/style_guide.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/undefined_behavior.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/wasm.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/zero-type.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/prologue.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/what-is-zig.html2024-01-11T13:29:06.000Z
\ No newline at end of file
+https://zigcc.github.io/zig-course/about.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/assembly.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/async.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/comptime.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/interact-with-c.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/memory_manage.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/package_management.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/advanced/type_cast.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/appendix/community.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/appendix/well-known-lib.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/array.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/enum.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/opaque.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/pointer.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/silce.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/struct.html2024-01-11T13:52:57.000Zhttps://zigcc.github.io/zig-course/basic/advanced_type/vector.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/basic_type/char-and-boolean.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/basic_type/function.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/basic_type/number.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/define-variable.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/error_handle.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/optional_type.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/decision.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/defer.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/loop.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/switch.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/process_control/unreachable.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/basic/union.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/engineering/build-system.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/engineering/unit-test.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/environment/editor.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/environment/install-environment.html2024-01-12T13:56:28.000Zhttps://zigcc.github.io/zig-course/environment/zig-command.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/epilogue.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/hello-world.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/2024-01-12T13:56:28.000Zhttps://zigcc.github.io/zig-course/more/atomic.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/builtin_func.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/miscellaneous.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/reflection.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/style_guide.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/undefined_behavior.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/wasm.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/more/zero-type.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/prologue.html2024-01-11T13:29:06.000Zhttps://zigcc.github.io/zig-course/what-is-zig.html2024-01-11T13:29:06.000Z
\ No newline at end of file
diff --git a/what-is-zig.html b/what-is-zig.html
index 669d4543..e61da3bc 100644
--- a/what-is-zig.html
+++ b/what-is-zig.html
@@ -3,22 +3,22 @@
   
     
     
-    什么是 Zig | Zig 圣经
+    什么是 Zig | Zig 语言圣经
     
     
     
     
-    
+    
     
     
-    
+    
     
     
     
   
   
-    
Zig 圣经
Appearance
什么是 Zig ​
根据其官网所述：
Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件
这样的概念解释可能比较模糊，我们来看看维基百科怎么说的：
Zig 是一种命令式、通用、静态类型、编译的系统编程语言，由 Andrew Kelley 设计。 它旨在替代C编程语言，其目标是更小，编程更简单，同时还提供现代功能，新的优化和各种安全机制， 同时不像其他语言那样对运行时安全性的要求。
语言简单性的改进与流控制、函数调用、库导入、变量声明和 Unicode 支持有关。 此外，该语言不使用宏或预处理器指令。从现代语言中采用的功能包括添加编译时泛型类型， 允许函数处理各种数据，以及一小组新的编译器指令，以允许使用反射访问有关这些类型的信息。 Zig 还旨在提高代码的安全性，它不提供垃圾回收（GC），但是使用可选类型代替 null ，这避免了空指针的出现。
为何使用 Zig ​
从本质上看，Zig 是一门 low level 的高级语言，它和 C 很像，但改善旧问题并提供了完善的工具链，并且它可选支持 libc。
一切都是强制显示声明式，这使得代码阅读很轻松！
如果你是嵌入式开发，亦或者对速度有很高的要求，还不想使用心智负担太高的其他高级语言，或许 Zig 很适合你。
特点 ​
  • 类型是一等公民
  • 无隐式执行
  • 手动内存控制，精确的内存泄漏跟踪
  • 完善的堆栈跟踪（在裸机器上也可以）
  • 对交叉编译的一流支持
  • 标准库集成 libc ，但不依赖它
  • 类型作为一等公民
  • 可选类型代替 null，详见 计算机科学中最严重的错误
  • 编译期（可以简单看作在编译时执行的函数）执行实现泛型和反射
  • 无需 FFI/bindings 的 C 库集成
  • 非常强大的构建系统
有几点是非常值得单独拿出来说明一下的：
Zig 会要求你显示传递和管理你的内存，并且编译时就会跟踪你的内存是否发生泄漏， 高明的可选类型（这和 rust 的 option 有异曲同工之妙），强大的编译期运行，你可实现很多花哨的操作，而构建系统则被很多 C 项目拿去作为工具链使用
了解更多 ？ ​
查看这里，列出了一些积极维护的 zig 库或者实现
以下列出了，可以在线执行 zig 的平台：

-    
+    
Zig 语言圣经
Appearance
什么是 Zig ​
根据其官网所述：
Zig 是一种通用的编程语言和工具链，用于维护健壮、最优和可重用的软件
这样的概念解释可能比较模糊，我们来看看维基百科怎么说的：
Zig 是一种命令式、通用、静态类型、编译的系统编程语言，由 Andrew Kelley 设计。 它旨在替代C编程语言，其目标是更小，编程更简单，同时还提供现代功能，新的优化和各种安全机制， 同时不像其他语言那样对运行时安全性的要求。
语言简单性的改进与流控制、函数调用、库导入、变量声明和 Unicode 支持有关。 此外，该语言不使用宏或预处理器指令。从现代语言中采用的功能包括添加编译时泛型类型， 允许函数处理各种数据，以及一小组新的编译器指令，以允许使用反射访问有关这些类型的信息。 Zig 还旨在提高代码的安全性，它不提供垃圾回收（GC），但是使用可选类型代替 null ，这避免了空指针的出现。
为何使用 Zig ​
从本质上看，Zig 是一门 low level 的高级语言，它和 C 很像，但改善旧问题并提供了完善的工具链，并且它可选支持 libc。
一切都是强制显示声明式，这使得代码阅读很轻松！
如果你是嵌入式开发，亦或者对速度有很高的要求，还不想使用心智负担太高的其他高级语言，或许 Zig 很适合你。
特点 ​
  • 类型是一等公民
  • 无隐式执行
  • 手动内存控制，精确的内存泄漏跟踪
  • 完善的堆栈跟踪（在裸机器上也可以）
  • 对交叉编译的一流支持
  • 标准库集成 libc ，但不依赖它
  • 类型作为一等公民
  • 可选类型代替 null，详见 计算机科学中最严重的错误
  • 编译期（可以简单看作在编译时执行的函数）执行实现泛型和反射
  • 无需 FFI/bindings 的 C 库集成
  • 非常强大的构建系统
有几点是非常值得单独拿出来说明一下的：
Zig 会要求你显示传递和管理你的内存，并且编译时就会跟踪你的内存是否发生泄漏， 高明的可选类型（这和 rust 的 option 有异曲同工之妙），强大的编译期运行，你可实现很多花哨的操作，而构建系统则被很多 C 项目拿去作为工具链使用
了解更多 ？ ​
查看这里，列出了一些积极维护的 zig 库或者实现
以下列出了，可以在线执行 zig 的平台：

+    
     
   
 
\ No newline at end of file