update

src/chapter_3/chapter_3_2.md

@@ -1,9 +1,10 @@
-## 3.2 基本数据类型
+# 3.2 基本数据类型
 
 Rust是静态类型语言，编译时就必须知道所有变量的类型。根据值以及其使用方式，Rust编译器通常能自动推导出变量的类型。
 Rust有两种数据类型子集，分别是：标量（scalar）类型和复合（compound）类型。
 
-### 3.2.1 标量类型
+## 3.2.1 标量类型
+
 标量类型包括：整型、浮点型、布尔类型和字符类型。
 
 - 整型和浮点型
@@ -19,9 +20,9 @@ Rust中的整型和浮点型如下：
 |128 bit| i128 |   u128 |       |
 | arch | isize |  usize |       |
 
-说明：isize和usize的长度是和平台相关，如果CPU是32位的，则这两个类型是32位的，如果CPU是64位的，则这两个类型是64位的。
+说明：`isize`和`usize`的长度是和平台相关，如果CPU是32位的，则这两个类型是32位的，如果CPU是64位的，则这两个类型是64位的。
 
-上面的表格中，f32和f64为浮点型，其它为整型。浮点型和整型一起构成数值型。
+上面的表格中，`f32`和`f64`为浮点型，其它为整型。浮点型和整型一起构成数值型。
 
 （1）可以在数值字面量后面加上类型表示该类型的数值，如下：
 ```Rust
@@ -71,103 +72,106 @@ fn main() {
 
 - 布尔型
 
-Rust中的布尔型用bool表示，有两个可能的值，为true和false。布尔类型使用的场景主要是条件表达式（控制流的内容），使用如下：
-```Rust
-fn main() {
-    // 定义方式
-    let a: bool = true;
-    let b: bool = false;
+    Rust中的布尔型用bool表示，有两个可能的值，为true和false。布尔类型使用的场景主要是条件表达式（控制流的内容），使用如下：
 
-    // 使用场景
-    if a {
-        println!("a is true");
-    } else {
-        println!("a is false");
-    }
+    ```Rust
+    fn main() {
+        // 定义方式
+        let a: bool = true;
+        let b: bool = false;
 
-    if b {
-        println!("b is true");
-    } else {
-        println!("b is false");
+        // 使用场景
+        if a {
+            println!("a is true");
+        } else {
+            println!("a is false");
+        }
+
+        if b {
+            println!("b is true");
+        } else {
+            println!("b is false");
+        }
     }
-}
-```
+    ```
 
 - 字符类型
 
-char类型用于存放单个unicode字符，占用4个字节空间。当存储char类型数据时，Rust会将其转换为utf-8编码的数据存储。char字面量是单引号包含的任意单个字符，字符类型使用示例如下：
-```Rust
-fn main() {
-    let c: char = 'z';
-    let x: char = 'x';
-    let heart_eyed_cat: char = '😻';
-}
-```
+    char类型用于存放单个unicode字符，占用4个字节空间。当存储char类型数据时，Rust会将其转换为utf-8编码的数据存储。char字面量是单引号包含的任意单个字符，字符类型使用示例如下：
 
-### 3.2.2. 原生复合类型
+    ```Rust
+    fn main() {
+        let c: char = 'z';
+        let x: char = 'x';
+        let heart_eyed_cat: char = '😻';
+    }
+    ```
+
+## 3.2.2. 原生复合类型
 复合类型是将多个值组合成一个类型。Rust有两个原生复合类型：元组和数组。
 
 - 元组
 
-圆括号以及其中逗号分割的值列表组成元组，定义一个元组方式如下：
-```Rust
-fn main() {
-    let tup: (i32, f64, u8) = (500, 6.4, 1);
-}
-```
-可以将元组重新结构到变量上，如下：
-```Rust
-fn main() {
-    let tup = (500, 6.4, 1);
-    let (x, y, z) = tup;
-    //接下来你可以使用x、y、z
-}
-```
-也可以直接使用元组的元素，如下：
-```Rust
-fn main() {
-    let x: (i32, f64, u8) = (500, 6.4, 1);
-    let first = x.0;
-    let second = x.1;
-    let third = x.2;
-}
-```
+    圆括号以及其中逗号分割的值列表组成元组，定义一个元组方式如下：
+    ```Rust
+    fn main() {
+        let tup: (i32, f64, u8) = (500, 6.4, 1);
+    }
+    ```
+    可以将元组重新结构到变量上，如下：
+    ```Rust
+    fn main() {
+        let tup = (500, 6.4, 1);
+        let (x, y, z) = tup;
+        //接下来你可以使用x、y、z
+    }
+    ```
+    也可以直接使用元组的元素，如下：
+    ```Rust
+    fn main() {
+        let x: (i32, f64, u8) = (500, 6.4, 1);
+        let first = x.0;
+        let second = x.1;
+        let third = x.2;
+    }
+    ```
 
-不带任何值的元组，称为unit类型（单元元组），可以代表空值或者空的返回类型，如下：
-```Rust
-fn main() {
-    let x: () = (); // 将值()保存到类型为()的变量x中
-}
-```
+    不带任何值的元组，称为unit类型（单元元组），可以代表空值或者空的返回类型，如下：
+    ```Rust
+    fn main() {
+        let x: () = (); // 将值()保存到类型为()的变量x中
+    }
+    ```
 
 - 数组
 
-数组中的每个元素的类型必须相同，数组的长度是固定的，数组的定义方式如下：
-```Rust
-fn main() {
-    let a = [1, 2, 3, 4, 5];           //直接写数组的值
-    let b: [i32; 5] = [1, 2, 3, 4, 5]; //显示指定数组的类型和长度
-    let c: [i32; 5] = [3; 5];          //数组每个元素为同样的值，等价于let a = [5, 5, 5, 5, 5];
-}
-```
-数组通过索引来访问元素，索引从0开始计数，如下：
-```Rust
-fn main() {
-    let a = [1, 2, 3, 4, 5];
+    数组中的每个元素的类型必须相同，数组的长度是固定的，数组的定义方式如下：
 
-    let first = a[0];   // first = 1
-    let second = a[1];  // second = 2
-}
-```
-Rust中，访问无效的索引元素会报错，如下：
-```Rust
-fn main() {
-    let a = [1, 2, 3, 4, 5];
-    let b = a[5]; // 错误，只能放为0-4，所以这个代码将无法编译
-}
-```
+    ```Rust
+    fn main() {
+        let a = [1, 2, 3, 4, 5];           //直接写数组的值
+        let b: [i32; 5] = [1, 2, 3, 4, 5]; //显示指定数组的类型和长度
+        let c: [i32; 5] = [3; 5];          //数组每个元素为同样的值，等价于let a = [5, 5, 5, 5, 5];
+    }
+    ```
+    数组通过索引来访问元素，索引从0开始计数，如下：
+    ```Rust
+    fn main() {
+        let a = [1, 2, 3, 4, 5];
 
-### 3.2.3 类型转换 (少一个From, Into, TryFrom, TryInto)
+        let first = a[0];   // first = 1
+        let second = a[1];  // second = 2
+    }
+    ```
+    Rust中，访问无效的索引元素会报错，如下：
+    ```Rust
+    fn main() {
+        let a = [1, 2, 3, 4, 5];
+        let b = a[5]; // 错误，只能放为0-4，所以这个代码将无法编译
+    }
+    ```
+
+## 3.2.3 类型转换 (少一个From, Into, TryFrom, TryInto)
 
 Rust中可以使用as进行类型转换。