devttl/reference
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

doc: add strcut and enum in the rust (#53)

Browse Source 
* content: add strcut and enum in the rust

* update

* update
This commit is contained in:
fw_qaq 2022-11-13 14:20:13 +08:00 committed by GitHub
parent c4027826df
commit a3a03dc5cf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 180 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

282
docs/rust.md
View File

@ -143,25 +143,30 @@ foo!(3);
### 结构体 ### 结构体
结构体是一个使用关键字 `struct` 定义的标称型(nominal)结构体类型
```rust ```rust
struct Point { x: i32, y: i32 } struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 11 }; let p = Point { x: 10, y: 11 };
let px: i32 = p.x; let px: i32 = p.x;
``` ```
结构体是一个使用关键字 `struct` 定义的标称型(nominal)结构体类型 #### 元祖结构体
### 枚举
```rust ```rust
enum Foo { struct Color (i32, i32, i32);
Bar, // 0 let black = Color(0,0,0);
Baz = 123, // 123 ```
Quux, // 124
}
let baz_discriminant = Foo::Baz as u32; #### 单元结构体
assert_eq!(baz_discriminant, 123);
不关心该类型的内容, 只关心它的行为。
```rust
struct Solution;
impl Solution{
// ...
}
``` ```
### 语句与表达式 ### 语句与表达式
@ -246,6 +251,9 @@ println!("社区的名称是 {community_name}，它有 {no_of_members} 个成员
查看: [字符串](#rust-字符串) 查看: [字符串](#rust-字符串)
### 数组 ### 数组
<!--rehype:wrap-class=row-span-2-->
这里介绍的是固定长度的数组。rust 中常用的是集合类型 vec 表示的[动态数组](#rust-动态数组)
```rust ```rust
┌─────┬─────┬─────┬─────┬─────┬─────┐ ┌─────┬─────┬─────┬─────┬─────┬─────┐
@ -260,28 +268,8 @@ println!("社区的名称是 {community_name}，它有 {no_of_members} 个成员
let array: [i64; 6] = [92,97,98,99,98,94]; let array: [i64; 6] = [92,97,98,99,98,94];
``` ```
### 多维数组
<!--rehype:wrap-class=row-span-2-->
```rust
j0 j1 j2 j3 j4 j5
┌────┬────┬────┬────┬────┬────┐
i0 | 1 | 2 | 3 | 4 | 5 | 6 |
├────┼────┼────┼────┼────┼────┤
i1 | 6 | 5 | 4 | 3 | 2 | 1 |
└────┴────┴────┴────┴────┴────┘
```
---- ----
```rust
let array: [[i64; 6] ;2] = [
[1,2,3,4,5,6],
[6,5,4,3,2,1]];
```
### 可变数组
```rust ```rust
let mut array: [i32 ; 3] = [2,6,10]; let mut array: [i32 ; 3] = [2,6,10];
array[1] = 4; array[1] = 4;
@ -299,14 +287,6 @@ let mut slices: &[i64] = &array[0..3]
println!("切片的元素是：{slices:?}"); println!("切片的元素是：{slices:?}");
``` ```
### 向量
```rust
let some_vector = vec![1,2,3,4,5];
```
使用 `vec!` 宏声明向量
### 元组 ### 元组
```rust ```rust
@ -397,8 +377,68 @@ println!("{:?}", str4);
Rust 动态数组 Rust 动态数组
----------- -----------
### 创建动态数组
```rust
let v: Vec<i32> = Vec::new();
// 使用宏
let v1 = vec![1, 2, 3];
```
### 读取元素
```rust
let v = vec![1, 2, 3, 4, 5];
let element = &v[100];
// panic，越界
let element2 = v.get(100);
println!("{:?}", element2);
//None
```
### 遍历数组
1. 只读取数组中的元素
```rust
let v = vec![1, 2, 3];
for i in &v {
println!("{}", i);
}
```
2. 遍历的同时修改数组中的元素
```rust
let mut v = vec![1, 2, 3];
for i in &mut v {
*i += 10
}
```
### 多维数组
```rust
j0 j1 j2 j3 j4 j5
┌────┬────┬────┬────┬────┬────┐
i0 | 1 | 2 | 3 | 4 | 5 | 6 |
├────┼────┼────┼────┼────┼────┤
i1 | 6 | 5 | 4 | 3 | 2 | 1 |
└────┴────┴────┴────┴────┴────┘
```
----
```rust
let arr = vec![
vec![1, 2, 3, 4, 5, 6],
vec![6, 5, 4, 3, 2, 1]
];
```
### 常用方法 ### 常用方法
<!--rehype:wrap-class=col-span-2 row-span-2--> <!--rehype:wrap-class=col-span-2-->
-|:- -|:-
-|:- -|:-
@ -415,43 +455,84 @@ Rust 动态数组
`drain(range)` | 删除 `vec` 中指定范围的元素,同时返回一个迭代该范围所有元素的迭代器 `drain(range)` | 删除 `vec` 中指定范围的元素,同时返回一个迭代该范围所有元素的迭代器
`split_off(index)` | 切分 `vec`，索引左边的元素保留在原 `vec` 中(含索引)，索引右边的元素(不含索引)在返回的 `vec` 中 `split_off(index)` | 切分 `vec`，索引左边的元素保留在原 `vec` 中(含索引)，索引右边的元素(不含索引)在返回的 `vec` 中
### 创建动态数组 枚举
--------
### 在结构体中使用枚举
```rust ```rust
let v: Vec<i32> = Vec::new(); enum IpAddrKind {
// 使用宏 V4,
let v1 = vec![1, 2, 3]; V6,
``` }
struct IpAddr {
kind: IpAddrKind,
address: String,
}
### 遍历数组 fn main(){
let ip = IpAddr{
只读取数组中的元素 kind: IpAddrKind::V4,
address: String::from("127.0.0.1")
```rust };
let v = vec![1, 2, 3];
for i in &v {
println!("{}", i);
} }
``` ```
遍历的同时修改数组中的元素 ### 枚举的变体
```rust ```rust
let mut v = vec![1, 2, 3]; enum IpAddrKind {
for i in &mut v { V4(u8, u8, u8, u8),
*i += 10 V6(String),
}
fn main() {
let home = IpAddrKind::V4(127, 0, 0, 1);
let loopback = IpAddrKind::V6(String::from("::1"));
} }
``` ```
### 读取元素 ----
```rust ```rust
let v = vec![1, 2, 3, 4, 5]; enum Message{
let element = &v[100]; Quit,
// panic，越界 Move {x:i32, y:i32},
let element2 = v.get(100); Write(String),
println!("{:?}", element2); ChangeColor(i32, i32, i32),
//None }
fn main(){
let q = Message::Quit;
let m = Message::Move {x:10, y:20};
let w = Message:: Write(String::from("hello"));
let c = Message::ChangeColor(10, 20, 30);
}
```
### 模式匹配结构体
```rust
#[derive(Debug)]
enum Grade {
A,
B,
C,
}
enum Subject {
Math(Grade),
English(Grade),
}
fn subject_grade(sub: Subject) {
match sub {
Subject::Math(grade) => println!("The Math is {:?}", grade),
Subject::English(grade) => println!("The Math is {:?}", grade),
}
}
fn main() {
subject_grade(Subject::Math(Grade::A));
}
``` ```
Rust 运算符 Rust 运算符
@ -527,8 +608,8 @@ let left_shift = h << 4; // => 32
示例 | 意义 示例 | 意义
:- | :- :- | :-
`c && d` | 两者都是真的 _(AND)_ `c && d` | 两者都是真的_(AND)_
`c \|\| d` | 要么是真的 _(OR)_ `c || d` | 要么是真的_(OR)_
`!c` | `c` 为假 _(NOT)_ `!c` | `c` 为假 _(NOT)_
---- ----
@ -754,15 +835,15 @@ fn main(){
```rust ```rust
struct Point { struct Point {
x: i32, x: i32,
y: i32, y: i32,
z: i32, z: i32,
} }
let origin = Point { x: 0, y: 0, z: 0 }; let origin = Point { x: 0, y: 0, z: 0 };
match origin { match origin {
Point { x, .. } => println!("x is {}", x), Point { x, .. } => println!("x is {}", x),
} }
``` ```
@ -772,9 +853,9 @@ match origin {
let hello = ('h', 'e', 'l', 'l', 'o'); let hello = ('h', 'e', 'l', 'l', 'o');
match hello { match hello {
(h, _, _, l, o) => { (h, _, _, l, o) => {
println!("char: {}, {}, {}", h, l, o) println!("char: {}, {}, {}", h, l, o)
}, },
} }
``` ```
@ -785,9 +866,9 @@ match hello {
```rust ```rust
let x = Some(10); let x = Some(10);
match x { match x {
Some(1) => println!("x = 1"), Some(1) => println!("x = 1"),
Some(y) => println!("y = {:?}", y), Some(y) => println!("y = {:?}", y),
_ => println!("None"), _ => println!("None"),
}// y = 10 }// y = 10
``` ```
@ -799,27 +880,25 @@ match x {
```rust ```rust
let grade = 'A'; let grade = 'A';
match grade { match grade {
good @ 'A'..='C' => println!("your grade is {}", good), good @ 'A'..='C' => println!("your grade is {}", good),
_ => println!("Come on"), _ => println!("Come on"),
} }
``` ```
<!--rehype:className=wrap-text -->
---- ----
```rust ```rust
#[derive(Debug)] #[derive(Debug)]
struct Point { struct Point {
x: i32, x: i32,
y: i32, y: i32,
} }
fn main(){ fn main(){
let p @ Point {x: px, y: py } = Point {x: 10, y: 23}; let p @ Point {x: px, y: py } = Point {x: 10, y: 23};
println!("x: {}, y: {}", px, py); println!("x: {}, y: {}", px, py);
println!("{:?}", p); println!("{:?}", p);
} }
``` ```
<!--rehype:className=wrap-text -->
---- ----
@ -827,10 +906,10 @@ fn main(){
```rust ```rust
match 1 { match 1 {
num @ (1 | 2) => { num @ (1 | 2) => {
println!("{}", num); println!("{}", num);
} }
_ => {} _ => {}
} }
``` ```
@ -839,12 +918,11 @@ match 1 {
```rust ```rust
let x = Some(2); let x = Some(2);
match x { match x {
Some(1) => println!("x = 1"), Some(1) => println!("x = 1"),
Some(y) if y == 2 => println!("y = {:?}", y), Some(y) if y == 2 => println!("y = {:?}", y),
_ => println!("No match"), _ => println!("No match"),
}// y = 2 }// y = 2
``` ```
<!--rehype:className=wrap-text -->
Rust 函数 Rust 函数
-------- --------
@ -860,23 +938,21 @@ fn print_message(){
``` ```
### 参数值 ### 参数值
<!--rehype:wrap-class=row-span-2-->
rust 需要为函数的参数标明确定的类型 rust 需要为函数的参数标明确定的类型
```rust ```rust
fn another_fn(a:u8, b: &str){ fn another_fn(a:u8, b: &str){
println!("我是 u8:{}", a); println!("我是 u8:{}", a);
println!("我是 &str:{}", b); println!("我是 &str:{}", b);
} }
fn main(){ fn main(){
another_fn(10, "hello") another_fn(10, "hello")
} }
``` ```
### 返回值 ### 返回值
<!--rehype:wrap-class=row-span-2-->
如果不指定返回值，rust 默认返回 `()` 类型 如果不指定返回值，rust 默认返回 `()` 类型
@ -885,14 +961,16 @@ fn main(){
fn main(){} fn main(){}
``` ```
使用 `->` 指定返回值，如果**表达式**在最后一行，无需使用 `return` ----
使用 `->` 指定返回值，如果**表达式**在最后一行，无需使用 return
```rust ```rust
fn add(a:i32, b:i32) -> i32 { fn add(a:i32, b:i32) -> i32 {
if a + b < 100 { if a + b < 100 {
return a - b; return a - b;
} }
a + b a + b
} }
``` ```