rust
/
rust-course
mirror of https://github.com/sunface/rust-course
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' of https://github.com/sunface/rust-course

Browse Source
pull/668/head
sunface 3 years ago
parent 6a6361d26c b8a807820b
commit 23e30abeec
4 changed files with 41 additions and 29 deletions
Show Stats Download Patch File Download Diff File

2
src/basic/compound-type/intro.md
Unescape View File

@ -2,7 +2,7 @@
行百里者半五十，欢迎大家来到这里，虽然还不到中点，但是已经不远了。如果说之前学的基础数据类型是原子，那么本章将讲的数据类型可以认为是分子。 行百里者半五十，欢迎大家来到这里，虽然还不到中点，但是已经不远了。如果说之前学的基础数据类型是原子，那么本章将讲的数据类型可以认为是分子。
本章的重点在复合类型上，顾名思义，复合类型是由其它类型组合而成的，最典型的就是结构体 `struct` 和枚举 `enum`。例如平面上的一个点 `point(x,y)`，它由两个数值类型的值 `x` 和 `y` 组合而来。我们无法单独去维护这两个数值，因为单独一个 `x` 或者 `y` 是含义不完整的，无法标识平面上的一个点，应该把它们看作一个整体去理解和处理。 本章的重点在复合类型上，顾名思义，复合类型是由其它类型组合而成的，最典型的就是结构体 `struct` 和枚举 `enum`。例如平面上的一个点 `point(x, y)`，它由两个数值类型的值 `x` 和 `y` 组合而来。我们无法单独去维护这两个数值，因为单独一个 `x` 或者 `y` 是含义不完整的，无法标识平面上的一个点，应该把它们看作一个整体去理解和处理。
来看一段代码，它使用我们之前学过的内容来构建文件操作： 来看一段代码，它使用我们之前学过的内容来构建文件操作：

7
src/basic/compound-type/struct.md
Unescape View File

@ -278,7 +278,7 @@ help: consider introducing a named lifetime parameter
## 使用 `#[derive(Debug)]` 来打印结构体的信息 ## 使用 `#[derive(Debug)]` 来打印结构体的信息
在前面的代码中我们使用 `#[derive(Debug)]` 对结构体进行了标记，这样才能使用 `println("{:?}", s)` 的方式对其进行打印输出，如果不加，看看会发生什么: 在前面的代码中我们使用 `#[derive(Debug)]` 对结构体进行了标记，这样才能使用 `println!("{:?}", s);` 的方式对其进行打印输出，如果不加，看看会发生什么:
```rust ```rust
struct Rectangle { struct Rectangle {
@ -424,8 +424,7 @@ $ cargo run
可以看到，我们想要的 debug 信息几乎都有了：代码所在的文件名、行号、表达式以及表达式的值，简直完美！ 可以看到，我们想要的 debug 信息几乎都有了：代码所在的文件名、行号、表达式以及表达式的值，简直完美！
## 课后练习 ## 课后练习
> [Rust By Practice](https://zh.practice.rs/compound-types/struct.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。 > [Rust By Practice](https://zh.practice.rs/compound-types/struct.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

15
src/basic/ownership/borrowing.md
Unescape View File

@ -4,7 +4,7 @@
Rust 通过 `借用(Borrowing)` 这个概念来达成上述的目的，**获取变量的引用，称之为借用(borrowing)**。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来，当使用完毕后，也必须要物归原主。 Rust 通过 `借用(Borrowing)` 这个概念来达成上述的目的，**获取变量的引用，称之为借用(borrowing)**。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来，当使用完毕后，也必须要物归原主。
### 引用与解引用 ## 引用与解引用
常规引用是一个指针类型，指向了对象存储的内存地址。在下面代码中，我们创建一个 `i32` 值的引用 `y`，然后使用解引用运算符来解出 `y` 所使用的值: 常规引用是一个指针类型，指向了对象存储的内存地址。在下面代码中，我们创建一个 `i32` 值的引用 `y`，然后使用解引用运算符来解出 `y` 所使用的值:
@ -35,7 +35,7 @@ error[E0277]: can't compare `{integer}` with `&{integer}`
不允许比较整数与引用，因为它们是不同的类型。必须使用解引用运算符解出引用所指向的值。 不允许比较整数与引用，因为它们是不同的类型。必须使用解引用运算符解出引用所指向的值。
### 不可变引用 ## 不可变引用
下面的代码，我们用 `s1` 的引用作为参数传递给 `calculate_length` 函数，而不是把 `s1` 的所有权转移给该函数： 下面的代码，我们用 `s1` 的引用作为参数传递给 `calculate_length` 函数，而不是把 `s1` 的所有权转移给该函数：
@ -102,7 +102,7 @@ error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` ref
正如变量默认不可变一样，引用指向的值默认也是不可变的，没事，来一起看看如何解决这个问题。 正如变量默认不可变一样，引用指向的值默认也是不可变的，没事，来一起看看如何解决这个问题。
### 可变引用 ## 可变引用
只需要一个小调整，即可修复上面代码的错误： 只需要一个小调整，即可修复上面代码的错误：
@ -118,9 +118,9 @@ fn change(some_string: &mut String) {
} }
``` ```
首先，声明 `s` 是可变类型，其次创建一个可变的引用 `&mut s` 和接受可变引用的函数 `some_string: &mut String`。 首先，声明 `s` 是可变类型，其次创建一个可变的引用 `&mut s` 和接受可变引用参数 `some_string: &mut String` 的函数。
##### 可变引用同时只能存在一个 #### 可变引用同时只能存在一个
不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制： **同一作用域，特定数据只能有一个可变引用**： 不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制： **同一作用域，特定数据只能有一个可变引用**：
@ -173,7 +173,7 @@ let mut s = String::from("hello");
let r2 = &mut s; let r2 = &mut s;
``` ```
##### 可变引用与不可变引用不能同时存在 #### 可变引用与不可变引用不能同时存在
下面的代码会导致一个错误： 下面的代码会导致一个错误：
@ -310,7 +310,6 @@ fn no_dangle() -> String {
- 同一时刻，你只能拥有要么一个可变引用, 要么任意多个不可变引用 - 同一时刻，你只能拥有要么一个可变引用, 要么任意多个不可变引用
- 引用必须总是有效的 - 引用必须总是有效的
## 课后练习 ## 课后练习
> [Rust By Practice](https://zh.practice.rs/ownership/borrowing.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。 > [Rust By Practice](https://zh.practice.rs/ownership/borrowing.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

46
src/index-list.md
Unescape View File

@ -18,19 +18,23 @@
## Sym ## Sym
| 名称 | 关键字 | 简介 | | 名称 | 关键字 | 简介 |
| ----------------------- | ------------ | -------------------------- | | ----------------------- | ------------ | ------------------------------------------------ |
| [?] | 错误传播 | 用于简化错误传播 | | [?] | 错误传播 | 用于简化错误传播 |
| [()] | 单元类型 | 单元类型，无返回值 | | [()] | 单元类型 | 单元类型，无返回值 |
| `!` : [1 函数] [2 类型] | 永不返回 | 永不返回 | | `!` : [1 函数] [2 类型] | 永不返回 | 永不返回 |
| [@] | 变量绑定 | 为一个字段绑定另外一个变量 | | [&] | 引用 | 常规引用是一个指针类型，指向了对象存储的内存地址 |
| ['a: 'b] | 生命周期约束 | | | [\*] | 解引用 | 解出引用所指向的值 |
| A | | AIntroduction | | [@] | 变量绑定 | 为一个字段绑定另外一个变量 |
| ['a: 'b] | 生命周期约束 | |
| A | | AIntroduction |
[?]: https://course.rs/basic/result-error/result.html#传播界的大明星- [?]: https://course.rs/basic/result-error/result.html#传播界的大明星-
[()]: https://course.rs/basic/base-type/function.html#无返回值 [()]: https://course.rs/basic/base-type/function.html#无返回值
[1 函数]: https://course.rs/basic/base-type/function.html#永不返回的函数 [1 函数]: https://course.rs/basic/base-type/function.html#永不返回的函数
[2 类型]: https://course.rs/advance/into-types/custom-type.html#永不返回类型 [2 类型]: https://course.rs/advance/into-types/custom-type.html#永不返回类型
[&]: https://course.rs/basic/ownership/borrowing.html#引用与解引用
[\*]: https://course.rs/basic/ownership/borrowing.html#引用与解引用
[@]: https://course.rs/basic/match-pattern/all-patterns.html#绑定 [@]: https://course.rs/basic/match-pattern/all-patterns.html#绑定
['a: 'b]: https://course.rs/advance/lifetime/advance.html#生命周期约束-hrtb ['a: 'b]: https://course.rs/advance/lifetime/advance.html#生命周期约束-hrtb
@ -40,6 +44,7 @@
| 名称 | 关键字 | 简介 | | 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- | | ---- | ------ | ------------- |
| [] | | |
| A | KWA | AIntroduction | | A | KWA | AIntroduction |
[back](#head) [back](#head)
@ -217,22 +222,31 @@
## S ## S
| 名称 | 关键字 | 简介 | | 名称 | 关键字 | 简介 |
| -------------- | ------ | ------------------------------------------------------------------------------------------------------ | | --------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------ |
| [所有权与堆栈] | | Rust 所有权提供的强大保障 | | [所有权与堆栈] | | Rust 所有权提供的强大保障 |
| [所有权原则] | | Rust 中每一个值都 `有且只有` 一个所有者(变量)<br> 当所有者(变量)离开作用域范围时，这个值将被丢弃(drop) | | [所有权原则] | | Rust 中每一个值都 `有且只有` 一个所有者(变量)<br> 当所有者(变量)离开作用域范围时，这个值将被丢弃(drop) |
| S | KWS | SIntroduction | | [slice 切片] | `&str` | 允许你引用 `String` 中部分连续的元素序列，而不是引用整个 `String` <br>语法：`[开始索引..终止索引]`<br>字符串字面量是切片 |
| [String 字符串] | `String` 类型 | Rust 中的字符串是 UTF-8 编码，也就是字符串中的字符所占的字节数是变化的(1 - 4) |
| [String 操作] | `String` 方法 | 由于 `String` 是可变字符串，因此我们可以对它进行创建、增删操作 |
| S | KWS | SIntroduction |
[所有权与堆栈]: https://course.rs/basic/ownership/ownership.html#所有权与堆栈 [所有权与堆栈]: https://course.rs/basic/ownership/ownership.html#所有权与堆栈
[所有权原则]: https://course.rs/basic/ownership/ownership.html#所有权原则 [所有权原则]: https://course.rs/basic/ownership/ownership.html#所有权原则
[slice 切片]: https://course.rs/basic/compound-type/string-slice.html#切片slice
[string 字符串]: https://course.rs/basic/compound-type/string-slice.html#什么是字符串
[string 操作]: https://course.rs/basic/compound-type/string-slice.html#操作字符串
[back](#head) [back](#head)
## T ## T
| 名称 | 关键字 | 简介 | | 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- | | ------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| T | KWT | TIntroduction | | [Tuple 元组] | | 由多种类型组合一起，元组的长度是固定的，元组中元素的顺序也是固定的<br>用模式匹配解构元组： `let (x, y, z) = (20, 19.2, 1)`<br>用 `.` 来访问元组： `tuple.0` 索引从 0 开始 |
| T | KWT | TIntroduction |
[tuple 元组]: https://course.rs/basic/compound-type/tuple.html#元组
[back](#head) [back](#head)

Write Preview
Loading…
Cancel
Save