估计也只有我能看懂了
参考: Rust 程序设计语言
https://kaisery.github.io/trpl-zh-cn/foreword.html参考: Rust 编程之道
https://weread.qq.com/web/reader/0303203071848774030b9d6Rust 死灵书
https://www.bookstack.cn/books/rustonomicon_zh-CNBiliBili令狐一冲
https://space.bilibili.com/485433391该笔记下载
练习Demo
#![feature(generators, generator_trait)]
use std::collections::HashMap;
use mylib::utils::students::Student;
use crypto::digest::Digest;
use std::fs::File;
use std::io;
use std::io::{Read, Write, BufRead};
use std::fmt::{Display, Debug};
use std::rc::{Rc, Weak};
use std::cell::RefCell;
fn print<T>(args:T)
where T: Any + Debug
{
println!("{:?}",args)
}
// 使用 mod 定义一个模块
mod handle1 {
// 定义一个子模块
pub mod people {
pub fn say(){
println!("人 打招呼")
}
}
pub mod dog {
pub fn eat() {
println!("狗 吃骨头")
}
}
}
fn stu1() {
println!("stu1: 变量");
// 1. 变量的声明
let a: i32 = 123_456;
let b = 678u32;
// 2. 变量 (变量默认不可以改变)
// a = 2233 // error: cannot assign twice to immutable variable
// 3. 变量遮蔽 (变量的重新声明赋值,再次使用 let 时, 实际上创建了一块新内存,并绑定变量)
let a: i32 = 2233;
// 注意变量遮蔽并不会导致原本变量的生命周期消失, 直到当前作用域结束, 自动释放, 这在后面可以知道
// 4. 可变变量 (添加 mut 关键字, 每次改变都会在源内存修改值)
let mut a: i32 = 3344;
println!("{:?}", &a as *const i32);
a = 4433;
// a = '1' // 注意 mut 不可以修改类型
println!("{:?}", &a as *const i32);
println!("{:p}", &a);
let mut a: u8 = 123;
// a = 22342342342342; Error: the literal `22342342342342` does not fit into the type `u8` whose range is `0..=255`
// println!("u8 的a 赋值一个很大的数: {}", a);
// 5. 常量 (一般以大写声明, 类似于不可变变量, 但是常量不可以使用 mut, 声明常量使用 const, 且 必须注明值得类型, 常量可以在任何作用域声明包括全局作用域, 常量不能作为函数的返回)
const MAX_NUM: u32 = 2233;
// 6. 赋值表达式的类型, 在rust中 赋值表达式的类型为 unit 即 空tuple
let x = (a = 2);
println!("赋值表达式的值为: {:?}", x)
}
fn stu2() {
println!("stu2: 数据类型");
// 1. bool型
let is_true: bool = true;
let is_false: bool = false;
// 2. char (单引号, 在 rust 里面, char 占 4 个字节, 是 32 位的)
let a: char = '你';
let a: char = 'h';
let a: char = 'ß';
// 3.1 数字类型 (允许使用 _ 做为分隔符以方便读数, i8 i16 i64 u8 u16 u32 u64 f32 f64...)
let a: i128 = -22_223; // 有符号 32 位
let a: u32 = 22_333; // 无符号 32 位
let a: f32 = 0.618; // 浮点型 (rust 中浮点只有 f32 和 f64)
// 3.2 数字类型扩展: 运算符
let a: u32 = 10 + 2;
let a: u32 = 3 - 1;
let a: u32 = 2 * 4;
// 整形相除只能得到整形
let a: i32 = 56 / 32;
// let a: f32 = 56 / 32; // Error: expected `f32`, found integer
// 浮点型相除, 只能得到浮点型
let a: f32 = 56.7 / 32.2;
// let a: i32 = 2.0 / 2.0; // expected `i32`, found floating-point number
// 4. 自适应类型 (usize isize, 根据操作系统的不同有不同的值)
println!("usize max: {}", usize::max_value());
println!("isize max: {}", isize::max_value());
// 5.1 复合类型: 元组 ((Type, Type, Type)一旦声明, 其长度不会增大或缩小,元组中的每一个位置都有一个类型, 且这些不同值的类型也不必是相同的, 通过 tuple.index 访问)
let tup: (i32, u32, char) = (-1314, 2233, 'a'); // 显式的指定类型
let mut tup = (-1314, 2233, 'a'); // 让 rust 自动推导
tup.1; // 通过 . 下标访问元组元素
tup.1 = -223;
// 5.1.1 元组的模式匹配(解构赋值)
let (a, b, c) = tup;
println!("a: {}, b: {}, c: {}", a, b, c);
// 5.2 复合类型: 数组 ([Type; Size], 数组是一整块分配在栈上的内存, 一旦声明, 其长度不会增大或缩小, 数组中的每个元素的类型必须相同, 可以通过 array[index] 访问)
let arr: [char; 5] = ['a', 'b', 'c', 'd', 'e']; // 显式指定类型
let arr = ['a', 'b', 'c', 'd', 'e']; // 让 rust 自动推导
let arr = [0; 5]; // 创建一个长度为5每个元素都是0的数组
// 5.2.1 数组的 Size 也是数组类型的一部分, 在传参时需要注意
fn show(_arr:[char; 3]) { // 接收一个长度为 3 的数组
for i in _arr.iter() {
println!("{}", i)
}
}
// show(arr) // expected an array with a fixed size of 3 elements, found one with 5 elements
// 5.2.2 无效的数组元素访问 会引发 panic
println!("arr[0]: {}", arr[0]);
// println!("arr[5]: {}", arr[5]); // index out of bounds: the len is 5 but the index is 5
// 6. Range 类型
let r = 1..2;
}
fn stu3() {
println!("stu3: 函数");
// 函数中的参数等价于一个隐式的let绑定,而let绑定本身是一个模式匹配的行为
// 1. 函数的调用及定义
say_hello();
fn say_hello() -> (){ // 无返回值 返回类型为 unit ()
println!("hello");
};
// 2. 函数的参数(函数在定义时, 必须声明函数中接收参数的类型)
fn say_info(name: &str) {
println!("我叫 '{}'", name)
}
say_info("小明");
// 3. 包含语句和表达式的函数体 (下面是一个代码块, 他的值是6, 注意这里 x + 1 是没有分号的, 表示这是一个表达式, 如果加上分号 ';' ,则变成了一个语句,不会再有返回值返回到变量y上)
let y = {
let x = 5;
x + 1
};
println!("{}", y);
// 4. 函数的返回值 (在rust中, 如果有返回值,函数需要使用箭头指定函数的返回类型, 如果语句中没有分号结尾, 则最后一行表达式会被当做该函数的返回值)
fn sum(a: i32, b: i32) -> i32{
a + b
// return a + b
}
println!("10 + 5 = {}", sum(10, 5));
}
fn stu4() {
println!("stu4: 控制流");
// 1. 分支判断(rust, 分支判断只能使用 bool 值, 这和其他语言是不同的, 比如其他语言任何非 0 的值都为true, 在rust中则必须为 bool 值)
let a: u32 = 3;
if a > 5 {
println!("a 小于 5, a 是: {}", a)
}else if a == 5 {
println!("a 等于 5")
}else {
println!("a 小于 5, a 是: {}", a)
}
// 2. 值判断
println!("3 < 5: {}", 3 < 5);
println!("3 > 5: {}", 3 > 5);
println!("3 <= 5: {}", 3 <= 5);
println!("3 >= 5: {}", 3 >= 5);
println!("3 == 5: {}", 3 == 5);
println!("3 != 5: {}", 3 != 5);
// 3. 三目运算 (rust 里并没有提供类似语法, 但是赋值语句可以使用表达式, 注意! if else中的返回值必须是相同类型)
let _flag: bool = true;
let a = if _flag {
5
} else {
10
};
println!("使用表达式来进行赋值操作 a: {}", a);
// 4. loop 无条件循环相当于 while true
let mut counter = 0;
loop {
counter += 1;
if counter == 100 {
break
}
if counter % 10 == 0 {
continue
} else if counter % 2 == 0 {
println!("in loop: {}", counter);
}
};
// 循环体表达式返回 (通过 break 关键字, 使循环停止,并把后面的表达式执行结果返回)
let num_100 = loop {
counter += 1;
if counter == 200 {
break counter * counter // 停止, 并返回后面的表达式执行结果
}
};
println!("通过 loop 表达式赋值, num_100: {}", num_100);
// 5. while 循环: while true循环块返回的是单元值 ()
let mut counter = 0;
while counter < 100 {
counter += 1;
if counter % 2 == 0 {
println!("in while: {}", counter);
continue
}
}
// while 循环内 是返回单元值, 这里虽然按照逻辑返回的是123, 但是编译器认为while可真可假 返回(),所以循环体内的表达式会被忽略
// let while_type = || { // Error: | |_____^ expected integer, found `()`
// while true {
// return 123;
// };
// };
// 6. for 循环
let arr: [char; 3] = ['a', 'b', 'c'];
// for i in &arr{
for i in arr.iter(){
println!("in for: {}", i)
}
// 6. 使用 Range 进行 for 循环
for num in 1..4 {
println!("in for range: {}", num)
}
}
fn stu5() {
println!("stu5: 所有权");
// Rust里的赋值与其他语言比起来有点特别，默认是一个移动操作
// 栈中的所有数据都必须占用已知且固定的大小, 指针的大小是已知并且固定的, 你可以将指针存储在栈上, 不过当需要实际数据时, 必须访问指针
// 堆中存放大小未知或大小可能变化的数据, 访问堆上的数据比访问栈上的数据慢, 因为必须通过保存在栈上指针来访问
// Rust 中的每一个值都有一个被称为其 所有者（owner）的变量
// 值在任一时刻有且只有一个所有者
// 当所有者（变量）离开作用域,这个值将被丢弃 执行 drop 相关
// !! 注意, 不可变引用 类型的变量会自动实现Copy, 例子9, 而可变引用是没有实现Copy的 赋值会发生移动(这里为了内存安全,防止一个变量同时有几个可变引用)
// 1. 变量作用域 (一个花括号一个作用域, 外部作用域是无法访问到局部变量的)
let a: i32 = 1;
{
let b: i32 = 2;
println!("a in scope: {}", a);
println!("s in scope: {}", b)
}
// println!("{}", s) // error: not found in this scope
// 2. String 类型与堆 (String有三部分组成: 1.一个指向堆中存放具体内容内存的指针, 2. 长度: 当前使用了多少字节的内存, 3. 容量: 从操作系统总共获取了多少字节的内存, 具体的内容分配在堆上的, 而字面量是因为字面量在编译时就知道了内容,提前分配了内存所以直接硬编码进了可执行文件, 对于String类型,为了支持一个可变的文本片段,需要在运行时向操作系统请求内存,并将指针分配到栈上)
// String 本质是包含了一串u8的 vector
// pub struct String {
// vec: Vec<u8>,
// }
let mut s = String::from("hello"); // 当调用 String::from 时, 请求起所需内存, 当String变量离开作用域的时候会调用 drop 方法清理内存
s.push_str(" world");
println!("String pushed: {}", s);
// let mut s = "abc"; // 创建一个字面量 &str类型 变量
// s. // 由字面量创建的变量, 很多修改方法都是没有的
// 3. 变量与数据交互的方式: 移动 (对保存堆中具体数据的指针的栈数据进行复制的时候, 注意 String类型被移动的时候,只是从栈上拷贝了原本的指针 长度 和容量,但是有一个问题两个变量的中保存的指针都指向了同一个位置,由于String类型在离开作用域的时候回自动执行 drop 方法清理内存,则这两个变量都会尝试释放相同的内存,这就引发了 '二次释放' 的问题,导致内存污染, 所以 rust 在进行这种移动操作类似浅拷贝完成的时候,会同时使第一个变量失效,只剩下最新的变量有效)
let x = String::from("hi");
let y = x;
// println!("移动String x: {}", x); // error: borrow of moved value: `x`
println!("移动String y: {}", y);
// 3.1 变量与数据交互的方式: 拷贝 (对存放栈中的数据是一般来说直接拷贝, 不会使变量失效, 原因是像整型这样的在编译时已知大小的类型被整个存储在栈上,所以拷贝其实际的值是快速的, 没有理由在创建变量 y 后使 x 无效)
let x = 2;
let y = x;
println!("移动i32 x: {}", x);
println!("移动i32 y: {}", y);
// 4. clone 深拷贝(使用clone 使存放 保存数据的堆 的指针 的栈中的数据 进行复制后, 依然有效,其原理是堆中的数据复制一份到新内存中并让新变量保存的指针指向该内存地址)
let x = String::from("say");
let y = x.clone();
println!("Clone String x: {}", x);
// 5. 可Copy的类型(如果一个类型拥有 Copy trait,一个旧的变量在将其赋值给其他变量后仍然可用)
// Copy trait继承自Clone trait,意味着,要实现Copy trait的类型,必须实现Clone trait中定义的方法
// 所有整数类型,比如 u32
// 布尔类型,bool, 它的值是 true 和 false
// 所有浮点数类型,比如 f64
// 字符类型,char
// 元组,当且仅当其包含的类型也都是 Copy 的时候;比如,(i32, i32) 是 Copy 的,但 (i32, String) 就不是
// 6. 所有权与函数 (将值传递给函数在语义上与给变量赋值相似(发生隐式 let 绑定), 向函数传值也会发生移动,或者复制, 就像赋值语句 let x = y 一样
fn say_name(name:String){
println!("hi i am {}", name) // 这里形参离开作用域,并调用 drop 方法
}
fn say_age(age:u32){
println!("hi, i age is {}", age)
}
let x = String::from("abc"); // x 变量进入作用域
let y = 123; // y 变量进入作用域
say_name(x); // x 的值移动到函数中, 之后函数的形参接收该值, 但是!由于形参接收该值之后,在函数执行完毕之后,内部的作用域会执行drop方法,包括形参, 所以下面已经不再有效
// println!("x: {}", x); // error: borrow of moved value: `x`
say_age(y); // y 应该移动到函数中, 但是 u32 是 Copy 的,所以后面可以继续用 y
println!("y: {}", y);
// 7. 所有权与返回值
fn f1()->String{
let x = String::from("abc"); // x 进入作用域
x // 返回 x 并移出给调用的函数
}
fn f2(s:String)->String{
s // 返回 s 并移出给调用的函数
}
let s1 = f1(); // f1 将返回值移给 s1
let s2 = String::from("ohh"); // s2进入作用域
let s3 = f2(s2); // s2 被移动到 f2 中, 但 f2 也将它移动到了 s3中, 所以 "ohh" 现在的所有权在 s3 中, 不在s2 中
// 8. 解引用操作会获得所有权(可能会造成 "野指针")
let s = String::from("hello");
let s1 = &s;
println!("s: {}", s);
// let s2 = *s1; // 如果这里解引用, s2获得了s的所有权, s1是 &s, s1 就变成了 "野指针"
// 9. 不可变引用会实现Copy trait
let a = "hello".to_string();
let b = &a;
let x = b; // 这里发生copy 注意这里 x和b 是同一个生命周期
let f = || b; // 这里发生copy
drop(b);
f(); // 可见上面drop掉, 是不会影响闭包内的变量的( ps: 这里是没有drop的, 因为不可变引用是实现了 copy trait 的, 而实现了copy trait的变量是无法drop的, 只能通过 scope销毁)
// 不可变实现copy
let s = "hello".to_string();
let s1 = &s;
let s2 = s1; // s1 copy 到 s2
s1; // 因为实现了copy 上面没有发生所有权转移, 这里依旧可以使用s1
s2;
s1;
s2;
println!("s1: {}, s2: {}", s1, s2);
// reborrow
// 可变引用变量进行赋值操作, 会发生所有权转移, 可变引用类型是没有Copy在赋值操作会移动引用变量 (写出变量注解,即变成 reborrow)
let mut s = "hello".to_string();
let s1 = &mut s;
// let s2 = s1; // 这里 s1 的所有权给了 s2, 下面再使用s1则无法编译通过
let s2:&mut String = s1; // s1 所有权 move 到 s2, 可变引用赋值操作需要使用变量类型注解变成 reborrow
s2; // s2 生命周期到此结束, 所有权返回归本身的s1, 生命周期没有发生交叉(这里同时可以存在两个可变引用就是因为这个原因)
s1;
}
fn stu6() {
println!("stu6: 引用/借用");
// 借用是一个动作一般常用于右值, 借用后产生一个引用
// 共享不可变,可变不共享
// 引用类型的 所有权返回/回归: 可变引用（借用）的变量,会发生所有权转移,在这个可变引用(最后一次使用) 生命周期结束 后,所有权还是会回到原来的变量上去; 因为只能有一个可变引用, 所以这里rust 使用的所有权转移保证只存在一个可变引用
// 冻结: 数据被不可变地引用时,它还会冻结（freeze）;已冻结的数据无法通过原始 对象来修改或者转移所有权,直到对这些数据的所有引用生命周期结束为止,保证引用数据的准确
// !! 在任意给定时间,要么 只能有一个可变引用,要么 只能有多个不可变引用, 在不可变引用失效之前, 不能创建可变引用
// 引用必须总是有效的
// 引用的作用域/生命周期; 是从声明的地方开始 -> 一直到最后一次使用结束
// 在不可变借用生命周期期间,所有者不能修改资源,并且也不能再进行可变借用; 在可变借用期间,所有者不能访问源资源,并且也不能再出借所有权
// 解引用操作 可能会 因为后续的操作而可能被消耗, 获得所有权(可能会造成 "野指针", 所以对于未实现COPY trait的类型解引用可能会发生move),如果一个没有实现Copy trait的对象 通过引用 解引用, 那因为没有实现Copy,所以会发生move, 如果发生了 move, 那么原本的引用就是"野指针"
// 1. 以一个对象的引用(是指向对象的地址, 指针)作为参数而不是获取值的所有权, 这样在传入函数参数的时候由于传入的是该变量的指针, 因为并不拥有这个值, 当引用离开作用域时其指向的值也不会被丢弃
fn get_len(s:&String)->usize{
s.len()
}
fn push_str(s:& mut String){
s.push_str(" world");
}
let mut s1 = String::from("hello"); // 创建一个变量
let s = &s1; // 通过借用创建一个引用
println!("&s1: {}", s);
let ms = &mut s1; // 创建一个可变引用(之前的引用都无法使用, 失效,禁止使用, 不能在拥有不可变引用的同时拥有可变引用)
println!("&mut s1: {}", ms);
// println!("&s1: {}", s); error 无法使用之前的引用,因为都已经无法使用
push_str(ms); // 通过函数直接操作指针指向的数据
let l = get_len(&s1);
println!("修改后 '{}' 的长度为: {}", s1, l);
// 2. 不能在拥有不可变引用的同时拥有可变引用, 可以同时存在, 但不能同时存活(生命周期发生交叉)
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r3 = &mut s; // 没问题 同时存在, 后面不再使用
let r2 = &s; // 没问题
let r4 = &mut s; // 没问题 同时存在,
// println!("{}, {}, and {}", r1, r2, r3); // 上面会error mutable borrow occurs here 不允许使用, 可变引用和不可变引用同时存活, 生命周期发生了交叉, 如果使用则上方会出错
// 2.1 一个引用的作用域(生命周期)从声明的地方开始一直持续到最后一次使用为止;例如,因为最后一次使用不可变引用在声明可变引用之前, 不可变引用 r1 和 r2 的作用域在 println! 最后一次使用之后结束
let mut s = String::from("say");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{} and {}", r1, r2);
// 此位置之后 r1 和 r2 不再使用, 下方可以借用可变引用
let r3 = &mut s; // 没问题
println!("{}", r3);
// 3. 垂悬引用
// let reference_to_nothing = dangle();
// fn dangle() -> &String { // dangle 返回一个字符串的引用
// let s = String::from("hello"); // 创建一个字符串
// &s // 返回字符串 s 的引用
// } // 这里 s 离开作用域并被丢弃;其内存被释放, 所以上面函数返回的是一个空的引用
// 4. 所有权返回
let mut s1 = String::from("hi");
let s2 = &mut s1;
println!("s2: {}", s2); // 后面没有 s2 的使用, 此时s2的生命周期结束, 被销毁掉了
println!("s1: {}", s1); // 没问题, s2 销毁掉之后, 这里 println 使用的 s1 的不可变引用
// 下面是错误代码以及说明
// println!("s1: {}", s1); // 这里 println 默认使用了 s1 的不可变引用, 但是因为 后续仍然有 s2 的使用, 所以 s2 这个可变引用 并没有被 销毁, 违反了 可变引用和不可变引用 同时存在的规则
// println!("s2: {}", s2);
// 冻结 已经被借用对象, 在引用未结束前, 无法再次分配新值,
let mut b = 1;
{
let c = &b;
// b = 2; // error: assignment to borrowed `b` occurs here, 因为 b 的引用, 在下面还在使用,所以引用还没结束,这里无法修改分配
println!("c: {}",c);
}
// 解引用操作会获得未实现 Copy trait 的对象的所有权(会造成 "野指针")
let s = String::from("hello");
let s1 = &s;
println!("s: {}", s);
// let s2 = *s1; // 如果这里解引用, s2获得了s的所有权, s1是 &s, s1 就变成了 "野指针", 这是编译器禁止的
// 在引用期间,所有者不能再出借所有权 (所以对于未实现COPY trait的类型是无法作为右值解引用的)
struct F1;
impl F1{
fn func(self){}
}
struct F2{
fs:Vec<F1>
};
impl Drop for F2{
fn drop(&mut self){
for f in &mut self.fs{
// f.func(); // 这里自动解引用相当于 调用了 (*f).func(), 因为上方存在可变引用, 而func方法使用的是self会 转移/出借 所有权, 所以这里无法解引用的(在可变借用期间,所有者不能访问源资源,并且也不能再出借所有权)
}
}
}
}
fn stu7() {
println!("stu7: slices");
let s1 = String::from("hello,world");
println!("s1: {}", s1);
let s1_bytes = s1.as_bytes();
for (idx, data) in s1_bytes.iter().enumerate() {
println!("idx: {}, data: {}", idx, data)
}
for i in s1_bytes.iter(){
println!("{}", i)
};
// 使用切片来获得字符串的部分引用
println!("&s1[0..5]: {}", &s1[0..5]); // 看左不看右
println!("&s1[1..=5]: {}", &s1[1..=5]); // 看左同时看右
println!("&s1[..=5]: {}", &s1[..=5]); // 从头开始切片
println!("&s1[1..]: {}", &s1[1..]); // 切片到尾部
println!("&s1[..]: {}", &s1[..]); // 默认全部
// 注意 中文字符的步长为 3 目前这里处理 utf8 字符会有一些问题
let s2 = String::from("你好");
// println!("&s2[..]: {}", &s2[0..2]); error
println!("&s2[..]: {}", &s2[0..3]);
println!("&s2[..]: {}", &s2[..]);
// 字面值其实是slice
let s3 = "我很好";
// 其他类型的slice
let arr1:[i32; 4] = [1,2,3,4];
let slice_arr1 = &arr1[0..2];
println!("&arr1[..]: {} {}, len: {}", slice_arr1[0], slice_arr1[1], slice_arr1.len());
}
fn stu8() {
println!("stu8: 结构体");
// 单元结构体实例就是其本身 struct S; let s1 = S; let s2 = S; 在Debug模式下 s1 和 s2是不同的内存地址, 在release编译模式下,他们进行了优化是相同的内存地址
// 全范围（..）的 RangeFull,就是一个单元结构体
// 1. 定义一个结构体
struct Student {
name: String,
age:u32,
}
// 2. 创建一个结构体实例
let stu1 = Student{
name:String::from("小明"),
age:12
};
// 3. 修改结构体字段 需要添加 mut 关键字
let mut stu2 = Student {
name: String::from("小花"),
age:18
};
stu2.age = 17;
println!("学生2 的年龄为 {}", stu2.age);
// 4. 参数名字和字段名字同名的快速创建对象的方法
fn create_stu(name:String, age:u32) -> Student {
Student{
name,
age
}
}
let stu3 = create_stu(String::from("小亮"),28);
println!("学生3 的名字为 {}", stu3.name);
// 5. 从其他的结构体创建实例(使用 .. 指定了剩余未显式设置值的字段应有与给定实例对应字段相同的值)
let stu4 = Student {
..stu3 // 注意,因为所有权的原因, stu3.name 被解构出来了,在离开作用域时已经被删除了
};
// println!("学生3 的名字为 {}", stu3.name); // error 和上面呼应, 在创建 stu4 的时候, s3部分字段被析构了
println!("学生4 的信息除了名字, 其他都是来自 学生3 的, 名字为 {}, 年龄为: {}", stu4.name, stu4.age);
// 6. 元组结构体(字段没有名字 通过下标访问, 每一个一个结构体有其自己的类型,即使结构体中的字段有着相同的类型)
struct Point(i32, i32);
struct Color(i32, i32);
let a = Point(10, 20);
println!("a.0: {}, a.1: {}", a.0, a.1);
// 7. 没有任何字段的结构体(类单元结构体)
struct Dog{};
// 8. 打印结构体的所有信息 需要添加Debug宏
#[derive(Debug)]
struct Teacher {
name:String,
age:u32
}
let t1 = Teacher{
name:String::from("张三"),
age:29
};
println!("t1的所有信息: {:?}", t1);
println!("t1的所有信息: {:#?}", t1); // 自动换行打印
// 9. 结构体中的方法
#[derive(Debug)]
struct People { // 创建一个结构体
name:String,
};
impl People { // 实现结构体的方法
fn get_name(&self)->&String{ // 传入实例的引用
&self.name // 这里返回 String 的引用, 防止 String 被清理
}
fn eat(&self){
println!("我在吃饭");
}
};
let p1 = People{
name:String::from("李四")
};
p1.eat();
println!("我叫: {}", p1.get_name());
println!("p1 所有的信息: {:#?}", p1);
// 10. 关联函数 允许在 impl 块中定义 不 以 self 作为参数的函数, 因为没有 self 所以这里它们仍是函数 而不是方法,,因为它们并不作用于一个结构体的实例
struct User{
name:String
}
impl User {
fn new(name:String) ->User {
User{
name
}
}
}
let user1 = User::new(String::from("小亮"));
println!("通过关联函数使用结构体名和 :: 语法来调用这个关联函数, 用户1的名字为: {}", user1.name);
}
fn stu9() {
println!("stu9: 枚举类型");
// 注意枚举本质属于 函数指针 类型( 例子 3 )
// 1. 类似c语言定义枚举类型
enum Ip {
V4,
V6
}
struct IpAddr {
ip_type:Ip,
ip_addr:String
}
let i1 = IpAddr {
ip_type: Ip::V4,
ip_addr: String::from("127.0.0.1")
};
// 2. rust语言推荐方法
#[derive(Debug)]
enum IpAddr2{
V4(String)
};
let i1 = IpAddr2::V4(String::from("127.0.0.1"));
let i2 = IpAddr2::V4(String::from("0.0.0.0"));
// 3. !! 枚举本质类似函数指针 如下代码推导 可见 function 和 枚举 在签名上没差, IpAddr2::V4 类似函数 fn(String) -> IpAddr2 的指针
let i4 = |s:String| -> IpAddr2{ IpAddr2::V4(s)};
let i3:fn(String) -> IpAddr2 = IpAddr2::V4;
// 使用 i3 创建一个枚举类型,打印
let i4 = i3("hello".to_string());
dbg!(i4);
// 3. 可以是不同的类型
#[derive(Debug)]
enum IpAddr3{
V4(u32, u32, u32, u32),
V6(u32, u32, u32, u32)
};
let i1 = IpAddr3::V4(127, 0, 0, 1);
println!("{:?}",i1);
// 4. 经典用法, 其每个成员都储存了不同数量和类型的值
#[derive(Debug)]
enum Message {
Quit, // 没有关联任何数据 相当于 struct Quit;
Move{x: i32, y:i32}, // 包含一个匿名结构体 相当于 struct Move {x:i32, y:i32}
Write(String), // 包含单独一个String 相当于 struct Write(String)
Change(i32, i32, i32) // 包含三个i32 相当于 struct Change(i32, i32, i32)
};
// 5 枚举类型的方法( 注意使用match时, 需要给枚举的情况都包括, 如果懒得匹配可以使用 _ 来进行通用匹配 )
impl Message {
fn call(&self){
match &self {
Message::Quit => println!("this is Quit"),
Message::Move{x,y} => println!("this is Move"),
Message::Write(s) => println!("this is Write"),
Message::Change(a, b, c) => println!("this is Change a: {}, b: {}, c: {}, &self: {:?}", a, b, c, &self),
_ => println!("上面没有被匹配的走到了这里: {:?}", &self)
}
}
};
let cm = Message::Change(1,2,3); // 创建了一个拥有类型 Change(1, 2, 3) 的变量 m, 这就是当 m.call() 运行时 call 方法中的 self 的值
cm.call();
let wm = Message::Write(String::from("h"));
wm.call();
// 6. Option 枚举类型(是标准库定义的一个枚举)
// enum Option<T>{
// Some(T),
// None
// }
// 6.1 定义 Option类型
let some_number = Some(5);
let some_string = Some(String::from("hi"));
let none:Option<i32> = None;
println!("some_number: {:?}", some_number);
println!("some_string: {:?}", some_string);
println!("none: {:?}", none);
// 6.2 Option<i32> 无法和 i32 相加
let x:i32 = 5;
let y:Option<i32> = Some(3);
// x + y; // error: no implementation for `i32 + std::option::Option<{integer}>`
// 6.3 Option 类型的使用(使用 match 对 Option 类型匹配的时候, 需要把内部的类型全部匹配上)
let mut temp: i32 = 0;
match y {
Some(i) => {println!("this is Some: {}", i); temp = i;}
None => println!("this is None")
};
println!("x + y(temp) = {}", x + temp);
// 6.4 Option类型 函数中使用
let y = Some(10);
fn f1(x:Option<i32>) -> Option<i32> {
println!("f1 函数接收到参数: {:?}",x);
match x {
None => None,
Some(_x) => {
println!("匹配到Some: {}, 为其增加 1", _x);
Some(_x + 1)
}
}
}
println!("经过f1函数为 Option 类型增加 1 后为: {:?}", f1(y));
// 7. if let 的使用(可以不使用 match 匹配, 来处理只匹配一个模式的值而忽略其他模式的情况, 使用 = 分隔的一个模式和一个表达式)
// if let 可以快速进行制定值匹配
let y = Some(10);
if let Some(v) = y {
println!("if let {}", v)
} else {
println!("None")
}
// 7.1.1 使用 match匹配 Some中值为3的情况
let some_u8_value = Some(3);
match some_u8_value {
Some(3) => println!("match, three"),
Some(2) => println!("match, two"),
Some(1) => println!("match, one"),
_ => (),
}
// 7.1.2 使用if let匹配 Some中值为3的情况
if let Some(3) = some_u8_value{
println!("if let, three")
}
// 7.1.3 可以在if let 后包含一个 else
if let Some(999) = some_u8_value{
println!("if let, 999")
} else {
println!("没找到")
}
// 8. 如果一个函数的参数可能存在或者返回可能为空 我们可以使用Option来传参
fn say(name:&str,age:Option<i32>) -> Option<i32>{
match age {
Some(a)=> {
println!("我叫: {}, 我今年 {} 岁了", name, a);
return Some(a)
}
None => {
println!("我叫: {}, 我也不知道今年多大了", name);
return None
}
};
};
say("小亮",Some(12));
say("小花", None);
}
fn stu10() {
println!("stu10: vector类型: 线性序列");
// 线性序列：向量, 也是一种数组,和基本数据类型中的数组的区别在于,向量可动态增长
// 1. 创建空的 vector Vec<T>
let mut v:Vec<u32> = Vec::new();
v.push(1);
// 2. 创建包含初始值的 vector vec![...]
let v = vec![1,2,3];
// 3. 丢弃 vector
{
let v = vec![2,3,4];
}
// 4. vector读取元素 (同 array 读取一样, 但是多了一个get方法传入index,返回Option<&T>, 是rust推荐的方法,因为索引越界不会错误,会被None捕捉)
let v = vec!['a', 'b', 'c'];
let v_1:&char = &v[1];
let v_2:char = v[1];
println!("v_1: {}", v_1);
println!("v_2: {}", v_2);
let v_3:Option<&char> = v.get(2);
println!("v_3: {:?}", v_3);
match v.get(1) {
Some('b') => println!("通过 match 匹配 b"),
Some('c') => println!("通过 match 匹配 c"),
None => println!("没有找到"),
_ =>()
}
match v.get(999) {
Some('b') => println!("通过 match 匹配 b"),
Some('c') => println!("通过 match 匹配 c"),
None => println!("没有找到"),
_ =>()
}
// 5. 更新元素
let mut v2:Vec<i32> = Vec::new();
v2.push(1);
v2.push(2);
v2.push(3);
println!("经过了3次push: {:?}", v2);
// 6. 不可变的遍历
for i in &v2 {
println!("不可变遍历 值为: {}", i)
}
// 7. 可变的遍历
for i in & mut v2{ // 不推荐, 最好使用 iter_mut
*i += 1
}
println!("经过了可变的遍历: {:?}", v2);
// 8. vector 通过枚举 使用不同类型
enum Context{
Text(String),
Float(f64),
Int(i32)
};
let v1 = vec![
Context::Text(String::from("hi")),
Context::Float(0.618),
Context::Int(64),
];
// 9. 补充(在拥有 vector 中项的引用的同时向其增加一个元素, 之前的不可变引用是无法再使用了,这是因为:在 vector 的结尾增加新元素时, 在没有足够空间 将所有所有元素依次相邻存放的情况下, 可能会要求分配新内存并将老的元素拷贝到新的空间中,这时,第一个元素的引用就指向了被释放的内存, 借用规则阻止程序陷入这种状况)
// 期间也穿插了借用规则, 可变借用与不可变借用的声明周期发生了交叉
let mut v3 = vec![1, 2, 3, 4, 5];
let first = &v3[0]; // 1. 读取了一个不可变引用
v3.push(9); // 2. vector 修改了下标为0的值 这里其实使用了 v3的可变引用, 在使用了可变引用之后, 之前的所有不可变引用后面都无法使用
// println!("first: {}", first) // 3. 这里 无法 使用了 first 的不可变引用
}
fn stu11() {
println!("stu11: String类型");
// 1. 创建一个空的字符串
let mut s1:String = String::new();
s1.push_str("S1");
println!("s1: {}", s1);
// 2. 通过字面值创建一个 String
// 2.1 使用 String::from()
let s2_1: String = String::from("S2_1");
println!("s2_1: {}", s2_1);
// 2.3 使用 str 的方式
let s2:String = "S2".to_string();
println!("s2: {}", s2);
// 3. 更新 String
let mut s3:String = String::new();
// 3.1 pust_str(需要传入 &str, 这里传入push_str的参数是字符串的 slice,所有权并没有转移)
let s = "push_str".to_string();
s3.push_str(&s);
s3.push_str("push_str");
// 3.2 push push只能传入 char 字符
s3.push('p');
s3.push('u');
s3.push('s');
s3.push('h');
println!("经过了 一些列的更新后的值为: {}", s3);
// 3.3 使用 "+" 合并字符串(注意 使用了 + 之后 所有权会转移, 就相当于获取s1 的所有权,附加上从 s2 中拷贝的内容,并返回结果的所有权, 类似 fn add(self, s: &str) -> String { ,这里self没有使用&self 所以所有权会被转移)
let s3_1 = String::from("hello");
let s3_2 = String::from("world");
let s3_3 = s3_1 + &s3_2; // 这里 s3_1 的所有权已经被转移了
println!("使用了 + 进行字符串合并: {}", s3_3);
// println!("s3_1: {}", s3_1); error: value borrowed here after move
// 4. String 索引
println!("通过字符串下标获得, s3: {}",&s1);
// 5. str 索引(由于rust中使用utf8, 一个中文占3个字节,或者其他数量字节, 所以rust不推荐使用索引来访问字符串元素,因为 Rust 不得不检查从字符串的开头到索引位置的内容来确定这里有多少有效的字符;, 可以使用slice, 注意slice 越界问题,)
let s = String::from("你好");
println!("通过字符串slice访问字符串: {}", &s[..3]); // 你
// println!("通过字符串slice访问字符串: {}", &s[..4]); // error: thread 'main' panicked at 'byte index 4 is not a char boundary; it is inside '好' (bytes 3..6) of `你好`'
// 6. 遍历
// 6.1 chars (得到字符串的字符)
for char in s.chars() {
println!("s.chars: {}", char)
}
// 6.2 bytes/as_bytes(性能更快, 没有进行复制之类的操作查看两个源码得知) (返回每一个原始字节, 字符串切片的字节上的迭代器)
for byte in s.bytes() {
println!("s.bytes: {}", byte)
}
for byte in s.as_bytes() {
println!("s.as_bytes: {}", byte)
}
// 7. format! 格式化字符串( 由于是一个宏, 所以所有权不会转移)
let s1 = String::from("hello");
let s2 = "world";
let s3 = format!("{}, {}", s1, s2);
println!("format!: {}", s3)
}
fn stu12() {
println!("stu12: HashMap");
// HashMap是无序的,BTreeMap是有序的
// Key必须是可哈希的类型,Value必须是在编译期已知大小的类型
// 1. 新建一个HashMap, 数据存放在堆中
let mut h: HashMap<&str, i32> = HashMap::new();
h.insert("小亮", 18);
h.insert("小花", 20);
println!("新建了一个HashMap: {:?}", h);
// 1.1 使用vector 的 collect 方法, 对于当时无法确定的类型可以使用 _ 占位, 让rust推导
let names = vec!["小强", "小李"];
let ages = vec![22, 17];
println!("names.iter().zip(ages.iter()): {:?}", names.iter().zip(ages.iter()));
let h2: HashMap<_, _> = names.iter().zip(ages.iter()).collect();
println!("h2: {:?}", h2);
// 2. HashMap和所有权(键值对被插入后就为哈希 map 所拥有)
let n:String = String::from("张三");
let mut h: HashMap<String, i32> = HashMap::new();
h.insert(n, 19);
// println!("n: {}", n) // error: value borrowed here after move
// 3. 访问HashMap中的值 使用get(key)获取的是Option<T>, 或者使用遍历的方式无顺序的获取
println!("通过get获取-> 张三的年龄为: {:?}", h.get(&String::from("张三")));
for (k,v) in h.iter() {
println!("通过循环遍历获取-> {} : {}", k, v)
}
// 4. 更新HashMap
// 4.1 覆盖一个值
let mut h = HashMap::new();
h.insert("李四", 20);
println!("覆盖前: {:?}", h);
h.insert("李四", 22);
println!("覆盖后: {:?}", h);
// 4.2 只在键没有对应值时插入 使用 entry or_insert, Entry 的 or_insert 方法在键对应的值存在时就返回这个值的Entry可变引用( &mut V ), 如果不存在则将参数作为新值插入并返回修改过的 Entry可变引用( &mut V )
h.insert("小花", 19);
let r = h.entry("李四").or_insert(25);
println!("Entry 的 or_insert方法返回的值: {}", r);
println!("使用entry on_insert 插入: {:?}", h);
// 4.3 根据旧值更新一个值 or_insert 方法事实上会返回这个键的值 的一个可变引用( &mut V );这里我们将这个可变引用储存在 count 变量中,所以为了赋值必 须首先使用星号( * )解引用 count
let s = "hello, world";
let mut h: HashMap<char, i32> = HashMap::new();
for i in s.chars() {
let count = h.entry(i).or_insert(0);
*count += 1
}
println!("统计结果: {:?}", h)
// 5. Hash函数
}
fn stu13() {
println!("stu13: 模块");
// 1. 定义并使用一个公开的模块(模块内部都是私有的)
handle1::dog::eat();
// 2. 使用外部lib库 先在项目目录 使用 "cargo new --lib mylib" 创建lib库项目, 然后添加rs模块文件, 在lib.rs中需要向外暴露模块, 注意需要修改 Cargo.toml 文件增加路径
mylib::utils::people::say_hello(); // 使用绝对路径调用外部库
// use mylib::utils::people::*; // 导入该模块下全部
use mylib::utils::people::say_hello as say; // 使用别名
say(); // 使用相对路径调取
// 3. 使用外部库的结构体
use mylib::utils::students::Student;
let stu1 = Student::new(String::from("小明"),18);
stu1.get_info();
stu1.name; // 公开的属性外部可以直接获取
// stu1.age; // 无法获取没有公开的属性 error: field `age` of struct `mylib::utils::students::Student` is private
// 4. 子模块如果想调用父模块的方法, 可以使用在模块汇总 super::function()
use mylib::utils::print_a::print_b;
print_b::print_b_to_a();
// 5. 调用外部网路上的库 来使用sha256加密(如果下载慢,可以百度切换源)
extern crate crypto;
use crypto::sha3::Sha3;
let mut hasher = Sha3::sha3_256();
hasher.input_str("hello, world");
let ret = hasher.result_str();
println!("{:?}", ret)
}
fn stu14() {
println!("stu14: 异常");
// rust 中错误分为两个类别, 可恢复错误/不可恢复错误
// 可恢复错误: 通常表示错误和重试操作是合理的情况, 例如没找到文件, rust中使用Result<T, E> 来实现
// 不可恢复错误: 通常是bug引起的, rust中通过panic!这个宏实现
// 建议 最好使用 ? 处理错误, 传递到上方调用者 而不是使用 unwarp引发panic
//1. 使用 panic! 手动引发异常
// panic!("出错了")
// 2. Result
// enum Result<T, E>{ // T代表成功时返回的Ok成员中的数据类型, E代表失败Err成员中的数据类型, Result通过组合有效输出的数据类型和错误的数据类型来使用类型;例如,如果有效输出的数据类型为u64且错误类型为String ,则返回类型应为Result<u64, String>
// Ok(T),
// Err(E)
// }
// use std::fs::File;
// let f = File::open("./1.txt");
// let r = match f {
// Ok(file) => file,
// Err(e) => panic!("panic!->error: {:?}",e),
// };
// println!("{:?}", r);
// Result 简写方式-1 快速获得结果 unwrap, 如果Option类型具有Some值或Result类型具有Ok值,则其中的值将传递到下一步, 如果是Err则为我们调用panic!(慎用)
// let f = File::open("../1.txt").unwrap();
// println!("简写方式-1, {:?}",f);
// Result 简写方式-2 自定义异常信息
// let f = File::open("../1.txt").expect("出错了");
// println!("简写方式-2, {:?}",f);
// 3. 传播错误
// fn open_file() -> Result<String, io::Error>{ // 如果没有任何错误 函数的调用者会收到一个包含 String 的 Ok 值 ,如果函数遇到任何错误函数的调用者会收到一个 Err 值,它储存了一个包含更多这个问题相关信息的 io::Error 实例
// let f = File::open("../1.txt");
// let mut f = match f {
// Ok(file) => file, // 读取成功返回给 f
// Err(e) => {
// return Err(e); // 如果出错直接结束函数运行
// }
// };
// println!("处理中");
// let mut s = String::from("");
//
// let r = match f.read_to_string(&mut s) {
// Ok(_) => Ok(s), // f读取成功之后写入通过引用写入到了 s 中, 所以这里 s 内容是已经写好的了, 直接返回 Ok(s) 到外部即可
// Err(e) => Err(e) // 结果返回 r
// };
// return r
// };
//
// let r = open_file(); // 获得函数中的结果, 是 Ok(s), 或是 Err(s)类型
//
// match r {
// Ok(s) => println!("读取成功: {}",s),
// Err(e) => println!("出错了: {:?}", e)
// };
// 3. 传播错误简写(使用?简写,如果遇到错误 Err 中的值将作为整个函数的返回值, 注意 ? 只能被用于返回值类型为 Result 的函数)
fn open_file() -> Result<String,io::Error>{
let mut f = File::open("../1.txt")?;
let mut s = String::new();
// let ret = match f.read_to_string(&mut s) {
// Ok(_) => Ok(s), // 这里返回 Ok(s)即可, 这里的 s 之前已经通过引用传入 f.read_to_string 内了,如果是Ok 那么这里 s 中的内容, 应该是读取的内容
// Err(e) => Err(e)
// };
// return ret // 返回 Ok(s) 或者 Err(e)
// 上面的注释简写为
// f.read_to_string(&mut s)?; // 这一行代码如果出错, 通过 ? 简写异常捕捉则直接返回 Err(e)
// Ok(s)
// 连写的方式
let mut s = String::new();
File::open("../1.txt")?.read_to_string(&mut s)?;Ok(s) // 读取文件 1.txt 如果没读取到直接返回 Err(e) 如果读取到往下走执行 .read_to_string 如果没有运行成功则直接返回Err(e), 如果执行成功因为没带";"号 则最后一句直接返回Ok(s)
}
match open_file() {
Ok(s) => println!("读取成功, 内容为: {}", s),
Err(e) => println!("读取失败, 错误为: {}", e)
}
// Result 信息获取, (使用ok 或者 err 来获取一个 option 类型的成功或者失败信息)
let o: Result<i32, &str> = Ok(8);
let e: Result<i32, &str> = Err("message");
println!("o.ok: {:?}", o.ok(),);
println!("o.err: {:?}", o.err(),);
println!("e.err: {:?}", e.err());
println!("e.ok: {:?}", e.ok());
// TODO 目前还不能解决的问题 对整个代码块进行一场捕捉
fn compute(a:i32, b:i32) -> i32 {
a / b
}
compute(1,2);
compute(1,0);
}
fn stu15() {
println!("stu15: 泛型");
// 1. 泛型要解决的问题: 比如 有一个比大小的函数 需要对 [i32] 和 [char] 类型的array比较大小, 当有几种类型就需要定义几个function
fn max1(li: & [i32]) -> i32{
let mut m = li[0];
for i in li.iter() {
if *i > m {
m = *i
}
};
return m;
}
let mut arr1: [i32;5] = [1, 2, 3, 4, 5];
println!("arr1最大的值为: {}", max1(&arr1));
fn max2(li:&[char]) -> char {
let mut m = li[0];
for i in li.iter(){
if *i > m {
m = *i
}
}
m
}
let arr2 = ['a', 'b', 'c'];
println!("arr2最大的值为: {}", max2(&arr2));
// 2. 定义泛型函数 <> 尖括号中补充 对 泛型的 特征trait 约束; PartialOrd: 表示可以进行数据比较, Copy: 表示T类型具有COPY特征
fn max3<T:PartialOrd + Copy> (li:&Vec<T>) -> T {
let mut m = li[0];
for i in li.iter(){
if *i > m {
m = *i
}
}
return m;
}
let arr3_1 = vec![1, 2, 3, 4, 5];
let arr3_2 = vec!['a', 'b', 'c', 'd'];
println!("通过泛型函数, arr3_1最大的值为: {}", max3(&arr3_1));
println!("通过泛型函数, arr3_2最大的值为: {}", max3(&arr3_2));
// 3. 定义泛型结构体
#[derive(Debug)]
struct Point<T>{
x:T,
y:T
};
let p1 = Point{
x:1,
y:2
};
println!("通过泛型结构体, 定义的为: {:?}", p1);
let p2 = Point{
x:2.2,
y:3.4
};
println!("通过泛型结构体, 定义的为: {:#?}", p2);
// 3.1 泛型结构体使用不同类型
#[derive(Debug)]
struct Point2<T, U>{
x:T,
y:U,
};
let p3 = Point2{
x:1,
y:"二"
};
println!("通过泛型结构体使用不同类型: {:?}",p3);
// 4. 枚举中使用泛型
// enum Option<T>{
// Some(T),
// None
// };
// enum Result<T, E>{
// Ok(T),
// Err(E)
// }
// 5. 方法中使用泛型 impl 之后声明泛型, 这样 Rust 就知道Student<T, U>尖括号中的是泛型而不是具体的类型
#[derive(Debug)]
struct Student<T, U>{
name:T,
age:U
}
impl<T,U> Student<T,U>{
fn get_name(&self) -> &T {
&self.name
}
}
let stu1 = Student {
name: "小明",
age:18
};
// 6. 泛型特化:对某些类型进行特殊处理, 一个没有在 impl之后(的尖括号)声明泛型的例子,这里使用了一个具体类型, 这里就意味着 Point<f64> 的实例 会有一个具体的方法 get_x, 而其他的类型的实例就没有这个方法
struct Point_<T>{
x:T,
y:T
}
impl Point_<f64>{
fn get_x(&self) -> f64 {
self.x
}
}
let p1 = Point_ { x: 1, y: 2 };
let p2 = Point_ { x: 0.5, y: 3.1 };
// p1.get_x(); // error: method not found in `stu15::Point_<{integer}>`
p2.get_x(); // 只有 f64类型的实例才会有方法
// 泛型混合使用
// 使用学生1的name 和学生2 的age 组成一个新的stu3
let stu1 = Student { name: "小亮", age: 12 };
let stu2 = Student { name: "小明", age: 14 };
impl<T,U> Student<T,U>{
fn create<Q, W>(&self, other:Student<Q,W>) -> Student<&T,W>{ // create<Q, W, Y, K, L> 声明使用了泛型类型 Q, W, Y, K, L
&self.name;
Student {
name: &self.name,
age:other.age
}
}
}
let stu1 = Student { name: "小亮", age: 12 };
let stu2 = Student { name: "小明", age: 14 };
let stu3 = stu1.create(stu2);
println!("泛型混合使用创建了stu3的信息: {:#?}",stu3)
}
fn stu16() {
println!("stu16: trait");
// 1. 通过 trait 以抽象的方式定义共享的行为, 用于定义与其他类型共享的功能
// “所有的trait都定义了一个隐式的类型Self，它指当前实现此接口的类型。” ——Rust官方文档
// 当self用作函数的第一个参数时，它等价于self: Self。&self参数等价于self: &Self。&mut self参数等价于self: &mut Self
// 2. 定义 trait
pub trait GetInfo {
fn get_name(&self) -> &String; // 函数接收一个参数 &self, 返回 &String 类型
fn get_age(&self) -> i32;
}
// 2.1 定义结构体
#[derive(Debug)]
pub struct Student{
name:String,
age:i32
}
pub struct Teacher{
name:String,
age:i32,
subkey:Vec<String>
}
// 3. 实现特征 使用 impl 特征 for 结构体, 对特征中定义的接口函数 在结构体中对函数一一实现
impl GetInfo for Student {
fn get_name(&self) -> &String {
&self.name
}
fn get_age(&self) -> i32 {
self.age
}
};
impl GetInfo for Teacher {
fn get_name(&self) -> &String {
&self.name
}
fn get_age(&self) -> i32 {
self.age
}
};
let stu1 = Student{name:"小亮".to_string(), age:18};
let t1 = Teacher{name:"张三".to_string(), age:28, subkey:vec!["历史".to_string(), "语文".to_string()]};
println!("学生1的名字是: {}, 年龄: {}", stu1.get_name(), stu1.get_age());
println!("老师1的名字是: {}, 年龄: {}, 老师教的课有: {:?}", t1.get_name(), t1.get_age(), t1.subkey);
// 4. 使用特征约束函数参数, trait 作为参数:通过特征, 指定并限制函数的参数,必须拥有某些行为, 如下,print_info的参数必须实现GetInfo这个trait
fn print_info(item:& impl GetInfo){
println!("print_info, name = {}, age = {} ", item.get_name(), item.get_age());
};
print_info(&stu1);
print_info(&t1);
// 5. trait 默认实现: 在特征中实现函数的代码, 作为函数的默认行为,当然也可以进行重载
trait SchoolName {
fn get_school_name(&self) -> String {
"默认-红星小学".to_string()
}
}
// 这里把上面的特征, 绑定到结构体中, 特征中已经默认实现了函数的行为, 所以可以不用再实现相关方法
impl SchoolName for Student{};
impl SchoolName for Teacher{
fn get_school_name(&self) -> String{
"老师覆盖, 红星小学".to_string()
}
}
println!("学生学校是: {}",stu1.get_school_name());
println!("老师学校是: {}",t1.get_school_name());
// 6. 使用特征约束函数参数, trait bound 特征语法糖,定义泛型,泛型中使用 <T:特征1 + 特征2> 对函数进行特征约束, 如果使用多个特征进行约束 可以使用 "+" 来链接, 编译器会确保其被限制为那些实现了特定 trait 的类型
pub trait GetName{
fn get_names(&self) -> &String;
}
pub trait GetAge{
fn get_ages(&self) -> i32;
}
impl GetName for Student{ // 普通语法
fn get_names(&self) -> &String{
&self.name
}
}
impl GetAge for Student{ // 普通语法
fn get_ages(&self) -> i32 {
self.age
}
}
// 6.1 使用特征约束 泛型函数, trait bound语法
// 写法1: print_info_1 泛型T, 泛型T 必须实现 GetInfo 这个方法
fn print_info_1<T:GetName + GetAge>(item:&T){
println!("trait bound语法糖实现特征, 写法1 name = {}, age = {} ", item.get_names(), item.get_ages());
};
// 写法2: 使用 where T: 特征1 + 特征2 来对对函数进行约束
fn print_info_2<T>(item:&T)
where T: GetName + GetAge
{
println!("trait bound语法糖实现特征, 写法2 name = {}, age = {} ", item.get_names(), item.get_ages());
}
// 调用
print_info_1(&stu1);
print_info_2(&stu1);
// 7. 使用特征约束函数的返回, 使其返回值必须有相关特征
fn get_item() -> impl GetName + GetAge {
Student{
name:"小花".to_string(),
age:16
}
}
let s = get_item();
println!("get_item限制了函数的返回: name: {}, age:{:?}", s.get_names(), s.get_ages());
// 8. impl 限制函数返回使用特征约束的时候, 无法使用不同的结构体,因为虽然都实现了特征中的方法, 但是不同结构体却是不同类型, 而impl属于静态分发,编译期已经展开代码了
// fn get_() -> impl GetName{
// if true {
// return Student {
// name: "小李".to_string(),
// age: 12
// }
// }
// return Teacher { // error: expected struct `stu16::Student`, found struct `stu16::Teacher`
// name: "张三".to_string(),
// age: 12,
// subkey:vec!["数学".to_string()]
// }
// }
// 练习
fn max<T>(li: &[T]) -> T
where T: PartialOrd + Copy
{
let mut m = li[0];
for & i in li.iter(){
if i > m{
m = i
}
};
m
};
let lis = vec![1,2,3];
// let l = &lis;
println!("lis找到最大的数为: {}", max(lis.as_slice()));
// 9. 使用 trait bound 对结构体的方法进行特征约束 impl <T:约束1 + 约束2, U:约束1 + 约束2> 结构体<T, U>, 只有实现了相应约束的实例, 才会有这个包含在大括号的方法
// 定义特征
trait GetName9{
fn get_name(&self) -> &String;
};
trait GetAge9{
fn get_age(&self) -> i32;
};
// 定义结构体, 这个结构体本身有学生和老师
struct People<T,U> {
master:T,
student:U
}
// 定义结构体的方法, 要求 T和U 需要满足对应的特征, 才会有对用的方法
impl <T:GetInfo, U:GetInfo> People <T, U>{
// impl <T, U> People <T, U>{
fn print_all_name(&self){
println!("master name: {}",self.master.get_name());
println!("student name: {}",self.student.get_name())
}
fn print_all_age(&self){
println!("master age: {}",self.master.get_age());
println!("student age: {}",self.student.get_age())
}
};
let t = Teacher { name: "李老师".to_string(), age: 23, subkey: vec!["政治".to_string()] };
let s = Student { name: "小环".to_string(), age: 12 };
let p1 = People{
master:t,
student:s
};
p1.print_all_age();
p1.print_all_name();
// 10. 使用 trait 对 trait 进行约束
trait GetN{
fn get_name(&self) -> &String;
}
trait PrintN{
fn print_name(&self);
}
// 为所有拥有GetN行为的类型 实现PrintN
// impl <T:GetN> PrintN for T{ // 这代码的意思就是 impl 特征 for 结构体, 只要实现了 GetN 特征的结构体, 也同样需要实现了 PrintN的特征, 其中 T 这里是泛型且是结构体, 且由于 我们在下面代码实现了 PrintN特征中的print_name函数的默认实现
// fn print_name(&self){
// println!("我叫: {}", &self.get_name())
// }
// }
impl<T:GetN> PrintN for T{
fn print_name(&self){
println!("我叫: {}", &self.get_name())
}
}
// 定义结构体
struct Stu1{
name:String
}
// 使用特征 对结构体方法进行约束
impl GetN for Stu1{
fn get_name(&self) -> &String{
&self.name
}
}
let s1 = Stu1{name:"小山".to_string()};
s1.print_name() // 由于有了 GetN特征, 这里也就有了 PrintN 的特征, 且PrintN中的print_name方法我们有默认实现
}
fn stu17() {
println!("stu17: 生命周期");
// 生命周期参数是为了帮助借用检查器验证非法借用, 防止垂悬指针; 函数间传入和返回的借用必须相关联, 当然单独返回标注 'static 的字面量之后就为 一个全局的变量，可以认为是处于栈的底部
// 生命周期说白了就是作用域的名字, 每一个引用以及包含引用的数据结构, 都要有一个生命周期来指定它保持有效的作用域
// 1. 函数中的声明周期(错误示范)
// fn gt_lt(x:& str, y:& str) -> &str { // error: expected named lifetime parameter
// if x.len() > y.len() {
// x
// }else {
// y
// }
// };
// 1.1 函数中的参数的显式生命周期, fn function<'a >(x:&'a str, y:& str), 在函数名后<> 声明, 保证返回的值不会变成悬垂引用, 让编译器知道 传出参数的生命周期同传入的参数的生命周期,比函数体内的长不会造成悬垂引用
fn gt_lt<'a>(x:&'a str, y:& str) -> &'a str { // 这里参数 y 并不需要声明生命周期
if x.len() > y.len() {
x
}else {
x
}
};
let str = gt_lt("hello", "hh");
println!("比较大小后: {}", &str);
// 1.3 生命周期始终和引用借用相关, 返回值的生命周期参数需要与一个参数的生命周期参数相匹配,如果没有匹配上那么就会造成垂悬引用,解决方案是返回一个有所有权的数据类型而不是一个引用
// fn get_str<'a>(a:&str)->&'a str{ // error: returns a value referencing data owned by the current function 垂悬引用,因为传进来的参数和返回值没有关系,
// let ret = String::from("really long string");
// ret.as_str()
// };
fn get_i32()->i32 { 2 } // 一个返回所有权的函数
// 2. 结构体中的生命周期, 如果用到了引用借用类型的参数, 则需要声明生命周期
// 结构体实例的生命周期应短于或等于任意一个成员的生命周期
// struct A{ name:&str } // error: expected named lifetime parameter
struct A<'a>{ name:&'a str }; // 这个结构体存在一个字段 是引用的类型 所以必须在结构体名称后面使用尖括号 <> 来进行声明
let zs = "zs".to_string();
let a = A{ name: &zs};
// zs; // 禁止被 let _ = zs, drop 因为后续还在使用 结构体的实例
println!("结构体如果使用了引用类型的参数需要 'a 来声明生命周期 a.neme:&str = {}", a.name);
// 3. 生命周期的省略, 可以用于 impl 和 fn 代码块,如下规则可以不用显式的声明生命周期
// 3.1 每个引用的参数都要有他的生命周期,所以每个省略的生命周期参数 都会隐性添加生命周期
fn get_3_1<'x, 'y>(a:&'x String, b:&'y String)->&'x String{a}
fn get_3_1_<'x>(a:&'x String, b:& String)->&'x String{a} // 这里因为没有返回 b 相关的,所以可以不用声明生命周期
// 3.2 如果只有一个输入生命周期参数, 那么它被赋予所有的输出生命周期
fn get_3_2(a:&str) -> &str{ a } // 只有一个参数 编译器会推导函数为: fn get_str<'a>(a:&'a str)->&'a str{ a }
// 3.3 如果在方法中有多个输入生命周期参数, 如果 该方法中有 &self/self 那么 &self/self 的生命周期被赋予到该方法的所有输出的生命周期 如下
// 4. 方法中的生命周期
struct Student<'a>{
name:&'a String,
}
impl<'c> Student<'c>{ // 这里'c 只是对应属于结构体中 name 的生命周期
// fn get_str(& self, s:& str) -> & str { // 这里满足生命周期省略的第三条规定 返回的 &str 的声明周期对应的是 self 的生命周期
fn get_str<'b>(&'b self, s:& str) -> &'b str { // 上面等价于这一行
"get_str"
}
// fn get_str_s(& self, s:& str) -> & str { // 这里返回了s, 这里输出的生命周期参数是同 self的,如上,返回的 &str 相当于 &'b str, 其中 'b 是属于self的生命周期, 而返回的 s 和self是不同的生命周期, error: this parameter and the return type are declared with different lifetimes
// s
// }
fn get_str_(s:&str) -> &str{ // 满足了第二条省略规则
"get_str_"
}
}
let s1 = Student { name: & "zs".to_string() };
println!("get_str: {}", s1.get_str("hh"));
println!("get_str_: {}", Student::get_str_("hh"));
// 5. 静态生命周期: 使用 'static 定义, 存活在整个程序期间, 所有的字符字面值默认都有 'static 生命周期: let s:& 'static str = "hh"
// 'static 说明这个变量生命周期和和运行程序一样长
let c:& 'static str = "2233"; // 默认的生命周期
let c:& str = "2233"; // 默认添加了 'static 生命周期
// 6. 结合泛型类型参数、trait bounds 和生命周期
use std::fmt::Display;
fn func<'x, T:Display>(a:&'x str, b:&'x str, c:T) -> &'x str{ // 这里是引用类型, 手动指定的生命周期
if a.len() < b.len(){
a
}else {
b
}
}
let c = "2233";
let r = func("hh", "hei", c);
println!("r: {}", r);
//7. 标注多个生命周期,
// fn gt_lt_1<'a, 'b>(a:&'a str, b:&'b str) -> &'a str{ // 因为编译器无法判断这两个生命周期参数的大小,此时可以显式地指定＇a和＇b的关系
// if a.len() > b.len(){a}else { b }
// }
fn gt_lt_1<'a:'b, 'b>(a:&'a String, b:&'b String) -> &'b str{ // 'a:'b 的意思就是 'a 是 'b的子集, 所以返回的生命周期参数是 'b的同时 也满足了 'a(可以看成一个集合 b包含了a, 或者oop思想a继承自b)
if a.len() > b.len(){a}else { b }
}
let s1 = "hi".to_string();
let s2 = "hello".to_string();
let s3 = gt_lt_1(&s1, &s2);
println!("经过比较 s3: {}", s3);
{s1;} // 这里提前drop掉 s1 也不会影响, 因为生命周期声明是帮助编译器检查参数的一切关系的, 对外发生的东西不管
// 8. 结构体实例的生命周期应短于或等于任意一个成员的生命周期 否则编译无法通过,因为不允许结构体还存在, 而成员都不存在了
#[derive(Debug)]
struct Stu<'a>{name:&'a String}
let mut s = "小明".to_string();
let mut s1 = Stu { name: &s };
// {
// s; // 这里让 s 提前drop, 会导致编译不通过 Error: move out of `s` occurs here
// }
// s = "小王".to_string(); // Error: assignment to borrowed `s` occurs here 这里s在上方已经被借用了, 所以无法修改了
println!("s1: {:?}",s1);
// 9. trait对象的生命周期 (1. trait对象的生命周期默认是＇static; 2. 如果实现trait的类型包含&＇a X 或&＇a mut X,则默认生命周期改为＇a; 3. 如果实现trait的类型包含多个类似T：＇a的从句,则生命周期需要明确指定)
struct P<'a>{p:&'a i32} // 定义 结构体
trait P_trait{}; // 定义一个 trait
impl<'a> P_trait for P<'a>{}; // 绑定trait
let p = P { p: &123 };
let p_dyn = &p as & dyn P_trait;
// 9.1 需要需要明确指定trait对象生命周期的例子
struct Pstruct_9_1<'a>{p:&'a i32};
trait Ptrait_9_1<'x>{};
impl<'a,'x> Ptrait_9_1<'x> for Pstruct_9_1<'a>{};
// 定义一个返回 trait对象的函数 这里需要明确指明返回的 trait对象的生命周期, 因为 dyn Ptrait_9_1<'a>是一个 trait对象, 需要添加 'a 来覆盖默认的 'static 生命周期
fn get_trait_object<'a>(p:&'a i32) -> Box<dyn Ptrait_9_1<'a> + 'a>{
Box::new(Pstruct_9_1{p}) // 外部接收一个参数, 在这里生成一个 Pstruct_9_1 的实例 并返回一个 trait 对象
}
let p_obj = get_trait_object(&18);
// 10. 方法中的self
let mut data = vec![1, 2,3];
let x = &data[0];
data.push(4);
// println!("{}", x); // 这里仍然使用了不可变借用 x, 那这里x的声明周期中间穿插了一个 push操作, push操作是使用了 &mut self, 违反了借用规则
}
fn stu18() {
println!("stu18: 闭包");
// 闭包是生成一个结构体, 通过triat调用的, 闭包等价于一个实现了特定Trait(Fn)的结构体
// 闭包作为返回值返回必须使用 trait 对象才能返回
// 1. 定义方式( 闭包可以推导返回类型 )
// 闭包通过 move 关键字可以对环境中的 自由变量 的所有权 手动转移到闭包当中
// 闭包根据内部如何使用外部自由变量来决定是否 copy move borrow
// 闭包会创建新的作用域, 对于环境变量默认使用不可变借用来捕获所有权,其次是可变借用,最后move
// 闭包获取变量的三种方式 (1. 获取所有权FnOnce:获取所有权; 2. 可变借用FnMut:获取可变的借用值所以可以改变环境; 3. 不可变借用Fn)
// 对于 copy 类型的变量, 如果使用 move 则会使用使用变量的Copy的新变量, 而 对于移动语义的变量则会强制执行获取所有权
let func1 = | x:u32 | -> u32 { x + 1};
let func2 = | x:u32 | -> u32 { x };
let func3 = | x:u32 | x; // 推导出了返回类型
// 2. 闭包可以获取到上下文的变量其内部是一个封闭环境
let mut flag: i32 = 1;
let add_1 = |x: i32| x + flag;
// flag = 3; // error: assignment to borrowed `flag` occurs here 上面的那一行闭包中借用了 flag, 所以后面不允许修改(可以通过添加 move 关键字来强制 COPY)
let flag = 2; // 变量覆盖了, 封闭环境再次修改这个变量, 影响不到闭包函数中
let n: i32 = 3;
let n_1 = add_1(n);
println!("n+i 之后: {}", n_1);
// 3. 使用带有泛型 和 Fn trait 类型的闭包
// 创建一个结构体其中需要有回调函数和值, 回调函数通过 trait bound语法 添加特征约束 为 Fn(u32) -> u32
struct Cacher<T>
where T: Fn(u32) -> u32
{
callback:T,
value:Option<u32>
};
impl<T> Cacher<T>
where T:Fn(u32) -> u32
{
fn new(callback:T) -> Cacher<T> { // 关联函数, 创建一个实例, 用来实现缓存功能, 新的实例 value为None
Cacher {
callback,
value:None
}
}
fn value(&mut self, args:u32) -> u32 { // 实例方法, 如果已经有了value 则返回现有value, 如果第一次调用没有value走向None分支 使外部传进来的args参数调用回调函数返回外部
match self.value {
Some(V) => V,
None => {
let v = (self.callback)(args);
self.value = Some(v);
v
}
}
}
}
// 3. 获取环境中的变量有三种方式
// 创建一个闭包时 Rust自动推导如何使用外部变量,所有闭包都可以被调用至少一次, 因此所有闭包都实现了 FnOnce,
// == 号的实现 使用的是 &self 捕获的是不可变借用, 所以这里没有发生所有权转移
let z = String::from("hello");
let fn1 = |f: String| {f == z};
fn1("123".to_string());
println!("{}",z); // 所有权没有转移
// == 号的实现 由于使用的是 &self, 捕获的是不可变借用, 所以不会捕获外部的所有权
let x = vec![1,2,3];
let fn2 = | f | f == x;
fn2(vec![1,2,3]);
println!("{:?}",x); // 所有权没有转移
// 3.1 使用 move 强制手动转移所有权
let x = vec![9,8,7];
let fn2 = move | f | f == x;
fn2(vec![9,8,7]);
// println!("{:?}",x) // 这里由于闭包使用了 move 所以所有权已经转移了 error: value borrowed here after move
// 4. 对于移动语义的变量在闭包捕获时会发生所有权转移
let s = String::from("hello");
let f1 = || { s; }; // 后续无法再使用变量 s 因为内部是 let _ = s;
f1(); // Fnonce
// println!("{}",s); // Error: value borrowed here after move
// f1(); // Error: value used here after move
// 5. Fnmut例子 因为闭包内的数据发生了变化 所以需要 fn指针 本身是可变的
let mut ss = "hello".to_string();
let mut f2 = || { ss+="123"; };
f2();
f2();
// 6. 闭包的逃逸性
// 逃逸闭包必须复制或移动环境变量. 这是很显然的, 如果闭包在词法作用域之外使用, 而其如果以引用的方式获取环境变量, 有可能引起悬垂指针问题
// closure 在捕获外部变量的时候,如果外部变量是引用类型,或者外部变量内部包含引用类型, 或者闭包内捕获的是外部的不可变引用, 如果闭包在词法作用域之外使用(比如多线程中), 会造成垂悬指针的问题
// 对某一类型的'static约束不是用来控制这个类型的对象可以存活多久；'static约束控制的是这个类型的对象所包含的引用类型所允许的生命周期
// 这种情况下 需要使用 move
fn test()->Box<dyn Fn() -> ()>{
// let x = 123;
// let c: Box<dyn Fn() -> ()> = Box::new(|| {
// let d = x;
// x; }); // 这里 闭包捕获 的是外部变量不可变借用 因为i32 实现了 Copy trait 所以这里
// let x = &123;
// let c: Box<dyn Fn()> = Box::new(|| {
// let d = x;
// x; }); // 这里 闭包捕获 的是外部变量的不可变借用 因为 &123(不可变借用)实现了Copy trait
// let x = "123";
// let c: Box<dyn Fn()> = Box::new(|| {
// let d = x;
// x; }); // 这里 闭包使用 &str 不可变借用
// let s = "123".to_string();
// let x = &s;
// let c: Box<dyn Fn()> = Box::new(move || {
// let d = x;
// x;}); // 这里 闭包使用 &String 不可变借用, 不可变借拥有 Coyt trait, 所以闭包这里捕获的是x的值而不是所有权, 而s本身就没有被捕获
// println!("s 依然可以使用: :?{}", s);
// let x = "123".to_string(); // 这个例子不在讨论之中,只是乱入的,只是解释一下:这里变量x 在词法作用域结束之后已经被x 被 drop 了,因为 x 没有实现Copy, x变成了垂悬指针
// let c: Box<dyn Fn()> = Box::new(move || { x; });
// 闭包根据内部如何使用外部自由变量来决定是否 copy move borrow
let s1 = "123".to_string();
let f1 = || { let x = s1; };
// let c1 = s1; // 编译是不通过的
let s2 = "123".to_string();
let f2 = || { let x = &s2; };
let c2 = s2;
let s3 = "123".to_string();
let f3 = move || { let x = &s3; }; // 强制转移所有权
// let c3 = s3; // 编译是不通过的
// // 使用 move 强制执行 Copy或Move
let x = "123";
let c: Box<dyn Fn()> = Box::new(move || { x; });
return c;
// 这之后, 此词法作用域之内的变量被 drop
};
let f1 = test();
f1();
// 7. 闭包作为返回值返回必须使用 trait 对象才能返回
// 7.1 这里使用impl 可以对返回的变量进行约束, 但 impl返回的只是类型占位 , 是非常局限的只支持单分支的代码,如果出现分支 由于impl 静态的,出现多分支的时候会出现闭包类型不一样
fn get_fn1() -> impl Fn(i32,i32)->i32{
let x = |x, y| x + y;
x
}
// let function = get_fn1();
// 7.2 多分支使用 impl 返回 闭包 Error: expected closure, found a different closure
// fn get_fn3(flag:i32) -> impl Fn() -> (){
// if true{
// return move ||{flag;}
// }
// else {
// return move ||{flag;}
// }
// }
// 7.2 闭包作为返回 trait对象
fn get_fn2()-> Box<dyn Fn(i32,i32)->i32>{
let x = |x, y| {x + y};
Box::new(x)
}
let function = get_fn2();
}
fn stu19() {
println!("stu19: 迭代器");
// 1. 迭代器负责遍历序列中的每一项和决定序列何时结束的逻辑
// 2. 迭代器创建之后是惰性的, 在调用之前不会有任何效果
// 3. 每个迭代器都实现了 iterator trait, 定义在标准库中, (next 是被要求实现的唯一的一个方法, next一次返回一个元素,当迭代器结束的时候 返回None)
// 每个实现了 iterator trait 的类型, 也实现了 IntoIterator (impl<T:iterator> IntoIterator for T)
// trait Iterator{
// type Item;
// fn next(&mut self) -> Option<Self::Item>; // type Item 和 Self::Item 这种用法叫做定义 trait 的关联类型
// }
// 迭代器常见的三种: 1. IntoIter,转移所有权,对应self(for循环默认的语法糖就是这个); 2. Iter,获得不可变借用,对应&self; 3. IterMut,获得可变借用,对应&mut self
// for循环实际上是一个语法糖, for循环真正循环的，是一个迭代器(Iterator)，真正在这个语法糖里起作用的，是 IntoIterator trait, 内调用了 into_iter 使用了 self 的方法, 会获取其所有权
// 1. 迭代器使用
let a = vec![1, 2, 3, 4];
// // for i in a{ // 如果不用迭代器遍历数据, 则会发生所有权转移 下面的循环就无法运行了
// // println!("不用迭代器: {}",i)
// // }
let a_iter1 = a.iter(); // 这一步不会对 a 造成任何影响
for i in a_iter1{ // for 调用了 into_iter
println!("使用迭代器: {}",i)
}
// for i in a.iter(){
// println!("使用迭代器: {}",i)
// }
// 2. next 方法 迭代不可变引用
let a = vec![1, 2, 3];
let mut a_iter = a.iter();
if let Some(v) = a_iter.next() {
println!("next1: {}", v) // 1
}
if let Some(v) = a_iter.next() {
println!("next1: {}", v) // 2
}
if let Some(v) = a_iter.next() {
println!("next1: {}", v) // 3
}
if let Some(v) = a_iter.next() {
println!("next1: {}", v) // None
}else {
println!("已经空了: None")
}
// next 方法 迭代可变引用
let mut a = vec![1, 2, 3];
let mut a_iter = a.iter_mut();
if let Some(v) = a_iter.next(){
*v *= 10
}
println!("改变了: {:?}", a);
// 自定义一个迭代器
struct Counter{ // 定义结构体
count:u32
};
impl Counter{ // 定义 new 函数
fn new()->Counter{
Counter{
count:0
}
}
};
impl Iterator for Counter{ // 定义 Iterator trait
type Item = u32;
fn next(&mut self)-> Option<Self::Item>{
if self.count < 5 {
self.count += 1;
Some(self.count)
}else {
None
}
}
}
let mut counter = Counter::new(); // 生成实例
for i in 0..10 {
if let Some(v) = counter.next(){
println!("实现的next方法, 实例调用 next 方法: {}",i)
}else {
println!("实现的next方法, 调用完毕");
break
}
}
// 查看迭代器边界信息(使用 size_hint 方法获取一个迭代器状态, 返回一个元组内有两个元素: 一个元素表示下限（lower bound）,第二个元素表示上限（upper bound）)
let mut lis = vec![1, 2, 3, 4, 5, 6];
let mut lis_iter = lis.iter();
lis_iter.next();
lis_iter.next();
lis_iter.next();
println!("lis_iter.size_hint(): {:?}", lis_iter.size_hint()); // 此时经过了三次迭代打印信息
// 使用迭代器追加字符串
let mut s = "hello".to_string();
s.extend(vec!["1", "2"]);
println!("字符串增加后: {}", s);
// 迭代器返回指定下标元素 使用 nth方法 获得指定下标的元素(注意此方法会消费迭代器指定下标元素之前的迭代器)
let v = vec![2, 3, 1, 45];
let mut v_iter = v.into_iter();
let idx_2 = v_iter.nth(2);
println!("idx_2: {:?}",idx_2);
// slice 数组使用迭代器(在for循环中使用 &arr 可以自动转换为迭代器)
let mut lis = [1, 2, 3, 4];
for i in &lis{}; // slice 有into_iter方法, 被for自动调用了
for i in lis.iter(){};
for i in lis.iter_mut(){};
// 适配器
let v1 = vec![1,2,3];
let mut v1_iter = v1.iter();
let sum:u32 = v1_iter.sum(); // 调用消费适配器
println!("调用消费适配器之后求和为: {}",sum);
// if let Some(v) = v1_iter.next() { // 这里直接所有权被移走了
// println!("{}", v)
// } else { println!("调用消费适配器之后,迭代器内已经没有值了 {:?}", v1_iter) }; // 不会走到这一步因为所有权都已经被移走了
// 迭代适配器 map 映射
let v1 = vec![1, 2, 3];
let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
println!("迭代适配器 映射 之后的值: {:?}", v2);
// 迭代过滤器 filter 过滤
let v1 = vec![1, 2, 3];
let v2: Vec<_> = v1.into_iter().filter(|x| *x < 3 ).collect();
println!("迭代适配器 过滤 之后的值: {:?}", v2);
// 迭代器翻转 rev (使用 rev 得到一个翻转的迭代器, 其本质是调用本身迭代器的 next_back 方法)
let lis = vec![1, 2, 3];
// lis.iter().next_back();
let lis_back = lis.iter().rev(); // 得到一个翻转的迭代器
// 消费器 any
let v = vec![1, 2, 3, 4, 5];
let mut v_iter = v.iter();
println!("查找容器中是否存在满足条件的元素返回bool: {}", v_iter.any(|&x| x == 2));
// 消费器 fold
let v = vec![1, 2, 3, 4, 5];
let mut v_iter = v.iter();
println!("第一个为初始值,第二个为带有两个参数的闭包。其中闭包的第一个参数被称为累加器: {}", v_iter.fold(100, |acc, x| acc + x));
// ## 消费器 collect(使用时需要显示添加收集后类型); collect消费器有“收集”功能,在语义上可以理解为将迭代器中的元素收集到指定的集合容器中
let v = vec![1, 2, 3, 4, 5];
let mut v_iter = v.iter();
let mut new_iter = v_iter.map(|x| x * x); // 加法操作会自动解引用
// let new_vec:Vec<i32> = new_iter.collect(); // 定义变量时 使用类型注解
let new_vec = new_iter.collect::<Vec<i32>>(); // 显式的添加类型
println!("显式的添加类型, 使迭代器转为一个Vec: {:?}",new_vec);
// ##自定义集合实现FromIterator, 以支持使用 collect, 如果一个容器可以转成iter, 那么iter也可以转为这个容器类型
use std::iter::FromIterator;
#[derive(Debug)]
struct MyVec(Vec<i32>); // 创建结构体
// 定义结构体方法
impl MyVec{
fn new()->MyVec{
MyVec(Vec::new())
}
fn push(&mut self, value:i32) -> (){
self.0.push(value)
}
}
// 实现FromIterator
impl FromIterator<i32> for MyVec{
fn from_iter<I>(iter:I) -> Self // 接收一个泛型
where I:IntoIterator<Item = i32> // 其泛型必须满足具体的特征约束
{
let mut c = MyVec::new();
for i in iter{
c.push(i)
};
c
}
}
// 使用 MyVec::from_iter
let iter = vec![1, 2, 3, 4].into_iter();
let mut my_vec = MyVec::from_iter(iter);
println!("my_vec: {:?}", my_vec);
// 使用 collect
let iter = vec![2, 2, 3, 4].into_iter();
let mut my_vec:MyVec = iter.collect();
println!("my_vec: {:?}", my_vec);
// 使用 collect
let iter = vec![3, 2, 3, 4].into_iter();
let mut my_vec:MyVec = iter.collect::<MyVec>();
println!("my_vec: {:?}", my_vec);
}
fn stu20() {
println!("stu20: 智能指针");
// 指针是一个包含内存地址的变量, 数据保存在堆上, 而栈上保存的是 数据 在堆上的地址, 除了数据被存储在堆上以外,Box没有任何性能损失
// 对于Box＜T＞类型来说,如果包含的类型T属于复制语义,则执行按位复制；如果属于移动语义,则移动所有权
// 智能指针拥有继承自 Box<T> T 变量中的方法
// 智能指针是一种数据结构, 类似于指针, 但是却有额外的信息,比如有一些引用计数, 当智能指针没有任何所有者的时候清除数据
// 普通引用和智能指针的区别: 引用只是借用数据的指针, 而智能指针则是拥有他们指向的数据
// 智能指针一般使用结构体实现, 其实现了 Deref(解引用操作的相关操作) 和 Drop(允许自定义智能指针离开作用与执行的代码) 这两个 trait
// drop 标志储存在栈中, 并不在实现 Drop 的类型里。
// 适用场景:当有一个未知大小类型比如String,但是上下文中使用这个变量又需要知道大小, 当有大量数据希望不copy的情况下转移所有权, 当希望有一个值只关心他的类型是否实现了特定trait并不关心具体类型的时候
// Box＜T＞使用操作符（*）进行解引用,对于未实现Copy trait 的类型, 可能会出现转移所有权的行为, Rc＜T＞和Arc＜T＞不支持解引用移动
// 1. String类型实现 Deref 返回的是 &str, 如果一个类型 T实现了Deref＜Target=U＞,则该类型T的引用（或智能指针）在引用的时候会被自动转换为类型U
// String类型实现的add方法的右值参数必须是&str类型, &s2这里自动是&String类型,会被自动隐式转换为&str
let s1 = "hello".to_string();
let s2 = "world".to_string();
let s3 = s1 + &s2; // 这里 &String 会被转换为 &str
// let s3 = s1 + &&&*&&*&&&&s2.deref();
let s4 = s3.deref();
// 1. 基本使用
let a = Box::from(1);
println!("BOX a.to_string(): {}", a.to_string());
// enum List { // 定义一个链表 递归类型 这里在使用的会后会出现问题,因为无法知道 list占用的大小
// Cons(i32,List),
// Nil
// }
enum List { // 定义一个链表 递归类型 使用 Box<T> 可以进行递归 得到大小,因为 Box<T>存储的是指针,指针又在栈上,任何 List 值最多需要一个i32 加上 box 指针数据的大小
Cons(i32, Box<List>),
Nil
}
use List::Cons;
use List::Nil;
// 创建链表, 保存的是栈上的数据(堆上的地址), 所以一开始就是知道栈上大小的,
let list = Cons(2,
Box::new(Cons(4,
Box::new(Cons(5,
Box::new(Nil))))));
// Deref 实现 Deref trait 即可使用解引用操作
let a = 5;
let b = &a;
assert_eq!(*b, a); // 解引用 由此可得知 b 存的是 a 的地址
let box_a = Box::from(a); //
assert_eq!(*box_a, a); // 解引用 智能指针, 由此可见 智能指针指向了 a 的地址
// 2. 手动实现一个 Box
use std::ops::Deref;
struct MyBox<T>(T); // 创建结构体
impl<T> MyBox<T>
{
fn new(x:T)->MyBox<T>{
MyBox(x)
}
}
// 3. 实现解引用 "*" 操作 需要实现实现标准库的 Deref 特征 名为 deref 的方法返回 值的引用, 在我们使用 *a 的时候, 内部做的就是 *(a.deref()), 通过调用deref得到引用 再解引用
// Rust内将 * 运算符替换为 deref 方法调用和一个普通解引用,我们就不需要调用 deref 方法了
// impl<T> MyBox<T> // 特征约束
// where T:Deref // 特征约束
impl<T> Deref for MyBox<T> // 特征实现
{
type Target = T;
fn deref(&self) -> &T { // 这里使用 &self 不希望解引用的时候拿掉 实例的所有权
match &self.0 {
i32=>{
println!("发现了一个 i32 类型")
}
}
&self.0 // 这里返回引用,是我们不希望内部值得所有权被移出
}
}
let x = 2;
let a = MyBox::new(x);
assert_eq!(*a,x);
// 自动解引用
let mut s = MyBox::new("234".to_string());
s.len();
// 3.1 自动解引用(变量 a 是Box＜&str＞类型,它并没有实现过chars（）方法;但是现在可以直接调用,因为Box＜T＞实现了Deref＜Target＜T＞＞, 使用起来完全透明,就好像Box并不存在一样)
// 如果一些方法, 这个变量中没有, 那么该变量会自动解引用为 T 类型
let a = Box::new("hello");
println!("{:?}", a.chars());
// 4. 解引用多态与可变性交互
// 如果一个类型 T实现了Deref＜Target=U＞,则该类型T的引用（或智能指针）在引用的时候会被自动转换为类型U
// 4.1 当T: Deref<target=U>时, 从 &T 变成 &U类型的引用, 一个 &T 而 T 实现了 U 类型的 Deref ,则可以直接得到 &U, 比如 String类型的deref得到的就是&str
// 4.2 当T: DerefMut<target=U> 时, 从 &mut T 变成 & mut 的引用
// 4.3 当T: Deref<target=U> 时, 从 &mut T 变为 &U, 不可能从 & T 变成 & mut T因为同一个变量只能有一个可变引用
let function_1 = |x: &str| println!("function_1, 解引用多态后: {}", x); // 这里将MyBox 变为MyBox<String>,再将 String的解引用 变成字符串的slice &str, 目标类型: &str, 初始类型: &String 都是不可变的 符合 4.1
let s = MyBox(String::from("hehe"));
function_1(&(*s)[..]); // 如果没有实现解引用多态时需要这样调用 (*s) 将 MyBox<String> 解引用为 String, [..]得到slice 再使用 & 得到引用
function_1(&s); // 实现了解引用多态, 可以直接调用
// 5. Drop trait: 当值离开作用域的时候,执行次函数的代码, drop函数需要传入可变引用, 因为要修改/清空变量内的数据
impl<T> Drop for MyBox<T>{
fn drop(&mut self){
// self.count -= 1 上面传入 & mut self 原因就是因为可能会计算并修改实例的引用计数,
println!("清理了一个变量")
}
}
{
println!("----开始声明a变量");
let a = MyBox(123);
}
println!("----这里a变量已经被清理");
// 6. Drop 提前释放, rust 提供了一个 std::mem::drop() 通过传递希望提早强制丢弃的值作为参数当然并不是一定会drop(这里 编译器会酌情处理)
struct Student{
name:String
}
impl Drop for Student{
fn drop(&mut self){
println!("被释放了: {}",&self.name)
}
}
let s = Student { name: "小明".to_string() };
drop(s); // 提前释放
// println!("生成了一个: {}", s.name); // error: value borrowed here after move
// 7. 使用操作符（*）进行解引用可能会出现转移所有权的行为
let bs = Box::new(String::from("hello"));
let bi = Box::new(123);
*bs; // 这一解引用之后所有权已经被转移走 let _ = *bs
*bi; // bi则不会因为 bi 实现了Copy trait
// println!("bs:{}",bs); // Error: value borrowed here after partial move
println!("bi:{}",bi)
}
fn stu21() {
println!("stu21: Rc智能指针");
// 通过RC<T> 允许通过不可变引用来 只读的 在 程序的 多个部分, 共享数据不允许改变, 共享数据 (如果是多个可变引用,会违反借用规则之一,可能会造成数据竞争)
// 它不影响包裹对象的方法调用形式(即不存在先 解开 包裹, 再调用值这一说)
// 1. 如果有多个变量 想同时拥有某保存在堆上数据的所有权, 则需要使用智能指针, 否则 1个堆上数据只能有一个变量拥有其所有权
enum List{
Cons(i32,Box<List>),
Nil
};
use List::{Cons, Nil};
let li_1 = Cons(2,
Box::new(Cons(4,
Box::new(Nil))));
let li_3 = Cons(12, Box::new(li_1));
// let li_4 = Cons(29, Box::new(li_1)); // error: value used here after move
// 2. 使用 Rc 智能指针重新定义 链表, 并使用 Rc::clone() 或 &self.clone(), 来不转移所有权的情况下 共享数据, 推荐使用 Rc::clone Rc::clone 的实现并不像大部分类型的 clone 实现那样对所有数据进行深拷贝; Rc::clone 只会增加引用计数,这并不会花费多少时间
enum Li {
Item(i32, Rc<Li>),
Null
}
use Li::{Item,Null};
use std::rc::Rc;
let lis_1 = Rc::new(Item(8,
Rc::new(Item(17,
Rc::new(Null)))));
let lis_2 = Item(13, Rc::clone(&lis_1));
let lis_3 = Item(13, Rc::clone(&lis_1));
// 3. 引用计数: 通过 Rc::strong_count 来获取Rc的引用计数
{
let lis_3 = Item(13, lis_1.clone());
println!("las_1的引用计数为: {}", Rc::strong_count(&lis_1))
}
// 3. 获得 Rc 智能指针的引用计数
println!("las_1的引用计数为: {}", Rc::strong_count(&lis_1))
}
fn stu22() {
println!("stu22: RefCell");
// Cell＜T＞一般适合复制语义类型（实现了Copy）,RefCell＜T＞一般适合移动语义类型（未实现Copy）
// Cell＜T＞无运行时开销,并且永远不会在运行时引发panic错误;RefCell＜T＞需要在运行时执行借用检查,所以有运行时开销,一旦发现违反借用规则的情况,则会引发线程panic而退出当前线程
// 内部可变性: 通过 borrow_mut 允许在使用不可变引用的时候获得变量的可变引用 并修改数据: 即使 Rc<RefCell<T>>
// RefCell<T> 在运行时检查借用规则,通常情况下检查作用规则是在编译阶段, RefCell<T>代表其数据的唯一所有权
// 类似于 RC<T> RefCell<T>只能用于单线程场景
// ---三种指针的区别
// Rc<T> 允许相同的不可变的数据有多个所有者; Box<T> 和 RefCell<T> 只允许有一个可变的所有者
// Box<T> 允许在编译时执行不可变或可变借用检查; Rc<T>仅允许在编译时执行不可变借用检查, RefCell<T>允许在运行时执行不可变或可变检查
// 因为 RefCell 允许在运行时执行可变借用检查
// 1. 定义一个链表 其中 Item 第一个参数为 Rc<RefCell<i32>> 类型, 第二个为 Rc智能指针类型
// 使用 *Rc<RefCell<T>>.borrow_mut()可以得到 T 的可变借用,
#[derive(Debug)]
enum List{
Item(Rc<RefCell<i32>>,Rc<List>),
Null
}
use List::{Item,Null};
// 创建一个变量, 智能指针包裹的RefCell类型的变量,当做 Item 的第一个变量
let value = Rc::new(RefCell::new(5));
let a = Rc::new(Item(value.clone(), Rc::new(Null)));
let b = Item(Rc::new(RefCell::new(9)), Rc::clone(&a)); // 使用 Rc::clone
let c = Item(Rc::new(RefCell::new(1)), a.clone()); // 使用 self.clone()
println!("a: {:?}",a);
println!("b: {:?}",b);
println!("c: {:?}",c);
// 2. 对于RefCell中的数据可以直接修改
let b = RefCell::new(123);
*b.borrow_mut() = 2233;
println!("Refcell 可以直接修改数据为: {:?}",b);
*(b.borrow_mut()) = 3344;
println!("Refcell 可以直接修改数据为: {:?}",b);
// 3. 修改 Rc<Refcell<T>> 中的 T
let b = Rc::new(RefCell::new(10));
*((*b).borrow_mut()) *= 20;
println!("Rc<Refcell<T>> 修改内部数据: {:?}", b);
}
fn stu23() {
println!("stu23: 循环引用");
// 由于Rust 中智能指针只有在 strong_count 为0的时候才会被清理, 如果两个变量相互引用, 则出现递归,超过栈深度那么会导致栈溢出, 造成内存泄漏,
#[derive(Debug)]
enum List{
Item(i32, RefCell<Rc<List>>),
Null
}
// 定义一个获取最尾部元素的方法
impl List{
fn get_item(&self) -> Option<&RefCell<Rc<List>>> {
match self {
Item(_, item) => Some(item),
Null => None
}
}
}
use List::{Item, Null};
// 创建一个 RefCell<Rc<T>> 的List
let l1 = Rc::new(Item(1, RefCell::new(Rc::new(Null))));
println!("l1_strong_count: {}",Rc::strong_count(&l1));
println!("l1_get_item: {:?}", l1.get_item());
let l2 = Rc::new(Item(2, RefCell::new(Rc::clone(&l1)))); // 这里让 l2 直接使用 l1 的引用
println!("l2_strong_count: {}", Rc::strong_count(&l2));
println!("l2_get_item: {:?}", l2.get_item());
// 修改l1的尾部指向, 这里由于 get_item 返回的是Option<&RefCell<Rc<List>>> 所以可以直接使用 if let Some(v) 进行匹配
if let Some(last) = l1.get_item(){
*last.borrow_mut() = Rc::clone(&l2)
}
// 再次打印一下 l1 l2 的引用计数
println!("l1_strong_count: {}", Rc::strong_count(&l1));
println!("l2_strong_count: {}", Rc::strong_count(&l2));
// 由于修改了l1的尾部元素让其指向了l2 这里再次打印两者的尾部元素
println!("l1_get_item: {:?}", l1.get_item()); // # thread 'main' has overflowed its stack 栈溢出了
println!("l2_get_item: {:?}", l2.get_item());
let a = 123;
}
fn stu24() {
println!("stu24: 弱引用");
// RefCell<Weak<List>> 通过Weak::new()来创建,然后通过Rc::downgrade(&self) 向内传递值
// 弱引用 通过 Rc::downgrade传递 Rc 实例的引用到Weak内, 调用Rc::downgrade会得到Weak<T>的智能指针,同时将 Weak count 加1
// Weak count 无需为 0, 实例在strong_count为0的时候drop,无视Weak count 的引用计数
// Weak<T> 通过 upgrade() 方法来获取弱引用中具体的内容
use std::rc::Weak;
#[derive(Debug)]
enum List{
Item(i32, RefCell<Weak<List>>),
Null,
}
impl List{
fn get_item(&self) -> Option<& RefCell<Weak<List>>>{
match self {
Item(_,item)=> Some(item),
Null => None
}
}
}
use List::{Item, Null};
let l1 = Rc::new(Item(1, RefCell::new(Weak::new())));
let l2 = Rc::new(Item(2, RefCell::new(Weak::new())));
println!("l1: {:?}, l2: {:?}", l1, l2);
println!("l1_strong_count: {}, l1_Weak_count: {}",Rc::strong_count(&l1), Rc::weak_count(&l1));
println!("l2_strong_count: {}, l2_Weak_count: {}",Rc::strong_count(&l2), Rc::weak_count(&l2));
// 获取 匹配得到 l2 的尾部, 并传递 l1的引用 到l2尾部
if let Some(item) = l2.get_item(){
let f = Rc::downgrade(&l1);
println!("f: {:?}",f); // 传入了 &l1 的引用, 得到Weak<T>的智能指针, 这里智能指针在下面作为值 传入到 *item.borrow_mut() 中
println!("f.upgrade(): {:?}",f.upgrade()); // 打印Weak<T>中的具体内容需要 upgrade升级
println!("item: {:?}",item); // RefCell { value: (Weak) }
println!("item.borrow(): {:?}",item.borrow()); // 打印一下值: 这里 item.borrow_mut() 得到的是 &RefCell<Weak<List>>中的 Weak
println!("item.borrow_mut(): {:?}",item.borrow_mut()); // 打印一下值: 这里 item.borrow_mut() 得到的是 &RefCell<Weak<List>>中的 Weak
println!("*item.borrow_mut(): {:?}",*item.borrow_mut());
*item.borrow_mut() = f; // 这一步也就是将上面得到的 Weak<T> 智能指针 复制给 item 的 解 可变引用
};
println!("l1_strong_count: {}, l1_Weak_count: {}",Rc::strong_count(&l1), Rc::weak_count(&l1));
println!("l2_strong_count: {}, l2_Weak_count: {}",Rc::strong_count(&l2), Rc::weak_count(&l2));
// 获取 l1 的尾部, 并传递 l2 的引用 到尾部
if let Some(item) = l1.get_item(){
*item.borrow_mut() = Rc::downgrade(&l2)
};
println!("l1_strong_count: {}, l1_Weak_count: {}",Rc::strong_count(&l1), Rc::weak_count(&l1));
println!("l2_strong_count: {}, l2_Weak_count: {}",Rc::strong_count(&l2), Rc::weak_count(&l2));
println!("l1: {:?}, l2: {:?}", l1, l2);
// 树形结构1
#[derive(Debug)]
struct Person{
value:u32,
parent:RefCell<Weak<Person>>, // 父节点中 保存 weak弱引用, 如果是 rc 引用,那么则会出现无限递归
children:RefCell<Vec<Rc<Person>>>
}
let leaf = Rc::new(
Person {
value: 1,
parent:RefCell::new(Weak::new()),
children:RefCell::new(vec![])
}
);
let p = leaf.parent.borrow().upgrade();
println!("子节点 leaf: {:?}, 子节点的父节点: {:?}",leaf,p);
println!("子节点的引用, strong_count: {}, weak_count: {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf));
// 创建父节点
let branch = Rc::new(
Person{
value:2,
parent:RefCell::new(Weak::new()),
children:RefCell::new(vec![Rc::clone(&leaf)])
});
println!("父节点 branch: {:?}",branch);
println!("父节点的引用, strong_count: {}, weak_count: {}", Rc::strong_count(&branch), Rc::weak_count(&branch));
// 添加父节点信息到子节点上
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
let p = leaf.parent.borrow().upgrade();
println!("子节点 leaf: {:?}, 子节点的父节点: {:?}",leaf,p);
println!("子节点的引用, strong_count: {}, weak_count: {}", Rc::strong_count(&leaf), Rc::weak_count(&leaf));
println!("父节点的引用, strong_count: {}, weak_count: {}", Rc::strong_count(&branch), Rc::weak_count(&branch));
// let a = RefCell::new(vec![Rc::new(123)]);
// let b = a.borrow();
// let c = vec![Rc::new(123)];
// println!("a: {:?}, b: {:?}, c: {:?}", a, b, c);
// let a = Rc::new(vec!['a', 'b']);
// let b:Option<&char> = a.get(0);
// let c:char = a[2];
}
fn stu25() {
println!("stu25: 多线程");
use std::thread;
use std::time::Duration;
// JoinHandle实现的join方法会返回Result＜T＞, 当子线程内部发生恐慌时, 该方法会返回Err, 但是通常不会对此类Err进行处理, 当子线程发生恐慌时, 不会影响到其他线程, 恐慌不会在线程间传播
// 1. 直接使用thread::spawn 生成的线程管理对象 JoinHandle<T>,默认没有名称,并且其栈大小默认为2MB
// 1.1 我们也可以使用 thread::Builder 来定制一个有名字和给定大小的线程, 注意: Builder 返回的是 Result<JoinHandle<T>>
// 2.5 线程内主动阻塞的能力 std::thread::park 提供了阻塞线程的基本能力, std::thread::unpark 可以将阻塞的线程重启, std::thread::park_timeout 显示的指定阻塞超时时间
// 1. 创建一个线程程序 thread::spawn 会返回一个线程对象
let handle = thread::spawn(|| {
for i in 0..10{
println!("thread_i: {}",i);
thread::sleep(Duration::from_millis(1))
}
});
for i in 0..5 {
println!("main_i: {}", i);
thread::sleep(Duration::from_millis(1))
};
println!("main 执行完毕");
// 1.1 使用 Builder 来自定义一个线程
let thread_name = String::from("my_thread");
let size:usize = 1024 * 10;
let builder = thread::Builder::new().name(thread_name).stack_size(size);
let child = builder.spawn(|| {
println!("my builder thread");
}).unwrap();
child.join().unwrap();
// 2. 阻塞线程: 使用 join 阻塞主线程, join会等待子线程执行完毕之后主线程才会继续往下运行 (等待子线程执行完毕)
handle.join();
// 2.5 park unpark 主动阻塞线程或者重启
let h1 = thread::spawn(|| {
println!("准备阻塞");
thread::park(); // 主动阻塞
println!("结束阻塞, 开始运行");
});
thread::sleep(std::time::Duration::from_millis(10));
println!("h1线程创建完毕");
let j1 = h1.thread(); // 拿到线程对象
j1.unpark(); // 解除阻塞
h1.join();
// 3. move 移动所有权到线程中( 注意移动到线程中, 主线程中已经没有所有权了 )
let mut sum:Vec<u32> = vec![1, 2, 3];
let handle1 = move || {
println!("通过外部move到线程内部的变量: {:?}", sum)
};
let h1 = thread::spawn(handle1);
// println!("{:?}",sum); // error: borrow of moved value: `sum`
h1.join();
// 4. 消息传递 use std::sync::mpsc; let (tx, rx) = mpsc::channel(), 这里使用解构获取 tx: 发送端, rx: 接收端
// 异步无界Channel: 对应 channel 函数, 发送消息是异步的,并且不会阻塞。无界,是指在理论上缓冲区是无限的;
// 通道类似于 单所有权方式, 调用rx send 的时候 会发生 move 操作, 被发送的 变量 后续无法再次使用 (一旦将值发送到另一个线程后,那个线程可能会在我们 后续 再次使用 它之前就将其修改或者丢弃)
// 发送者或者接收者任一被丢弃时rust就认为通道被关闭了
// 发送者 tx 的 send 会返回 Result 类型<T, E>, 如果接收端已经被丢弃了, 将没有发送目标,此时发送会返回错误
// 接收者 rx 的 recv 方法 当发送通道关闭会返回一个错误
// 接收者 rx 的 recv 方法 是一个阻塞方法, 不用join即可阻塞主线程, rx的 try_recv 方法不会阻塞主线程运行
// 接收者 rx 本身实现了迭代方法, 迭代器内部实现了 rx的 recv 方法 源码中iterator中next调用self.rx.recv().ok(), 所以下面可以通过 for 循环阻塞 获取消息
// !!如果存在多个发送者(共享通道) 注意如果 tx 不被析构, rx在接收消息时会一直阻塞, 见下面 例子 7
use std::sync::mpsc;
// 4.1.1 mpsc::channel 创建多个生产者 单个消费者的通道
let (tx, rx) = mpsc::channel(); // 异步无界
// 创建一个线程
thread::spawn(move || {
let val = "hello".to_string();
let ret = tx.send(val).unwrap(); // 返回 Result 类型
// println!("{}", val) // 注意这里所有权已经被转移了
});
// 在主线程中接收
let msg = rx.try_recv(); // try_recv 不会阻塞主线程, 主线程运行到这里, 子线程还没运行所以这里接收的消息为 error
println!("在h1子线程中 try_recv 接收的是: {:?}", msg);
let msg = rx.recv(); // 这里接收者的 recv 方法是一个阻塞方法,所以不需要用join 阻塞, 所以会等待接收完毕才会向下执行代码
println!("在h1子线程中 recv 接收的是: {:?}",msg);
// 4.1.2 一次发送多个信息
let (tx, rx) = mpsc::channel::<String>();
thread::spawn( move ||{
let values = vec!["小明".to_string(), "小花".to_string(), "小亮".to_string()]; // 定义多个数据
for i in values.into_iter(){ // 循环发送数据
tx.send(i).unwrap();
thread::sleep(Duration::from_secs(1)) // 每次发送完毕, 睡眠 1 秒
}
});
for msg in rx.iter() {
println!("接收到线程内的消息: {}", msg)
}
// 4.1.3 多个生产者, 单个消费者, 多个生产者使用 mpsc::Sender::clone 传入消费者 tx 的引用 创建
let (tx, rx) = mpsc::channel::<String>();
let tx1 = mpsc::Sender::clone(&tx); // 创建另一个消费者
// 创建两个生产者
thread::spawn(move || {
let values = vec!["小明".to_string(), "小花".to_string(), "小亮".to_string()];
for i in values {
tx.send(format!("tx: {}",i).to_string()).unwrap();
thread::sleep(Duration::from_secs(1));
} // 闭包作用域结束, drop掉 tx, 关闭通道
});
thread::spawn(move || {
let values = vec!["张三".to_string(), "李四".to_string(), "王二".to_string()];
for i in values {
tx1.send(format!("tx1: {}",i).to_string()).unwrap();
thread::sleep(Duration::from_secs(1));
} // 闭包结束 drop 掉tx1, 关闭通道
});
for i in rx{
println!("取到的数据: {}", i)
}
// 4.2 创建单个生产者 多个消费者的通道
// use std::thread;
// use std::sync::mpsc;
// use std::time::Duration;
// 5. 互斥器 Mutex<T>
// 任意时刻, 只允许一个线程访问某些数据, 互斥器使用时, 需要先获取到锁, 使用后需要释放锁, 如果获取不到会阻塞线程, 等待别的线程释放锁
// Mutex 内部实现了 drop 方法, 锁在离开作用域的时候自动释放, Mutex实例通过 lock 获得锁
// Mutex 是一个智能指针, 在调用 lock 时, 返回一个 MutexGuard<i32> 的智能指针
// 锁可以提前释放
// 一旦获取了锁,就可以将返回值(在这里是 num )视为一个其内部数据的可变引用了, 所以可以 * 解引用
use std::sync::Mutex;
// 创建一个互斥器
let sum = Mutex::new(5);
{
let mut lock = sum.lock().unwrap();
*lock = 13; // 锁在下面离开作用域的时候自动释放 调用了 drop
drop(lock) // 提前释放锁
}
println!("Mutex<i32>: {:?}",sum);
// 5.1 Arc 智能指针, 原子引用计数, 多线程多所有权, 多线程使用的 Arc 智能指针包裹互斥器(Rc不是线程安全的所以无法使用 如果多线程修改一个数据, 可以使用 Arc 智能指针 进行包裹)
// Arc 智能指针是基于线程安全的,
use std::sync::Arc;
let curr = Arc::new(Mutex::new(0)); // Arc 指针 创建一个包含 互斥锁的对象
// 创建10个线程
let mut lis = vec![];
for i in 0..10 {
let curr_clone = Arc::clone(&curr); // 为了防止所有权转移, 每次循环 需要 clone Arc指针, 等下传入到线程内部
let h = thread::spawn(move || { // 循环创建线程,并将 外部变量 curr_clone 的所有权 传入到内部闭包
{
let mut num = curr_clone.lock().unwrap(); // 得到锁, 如果没有得到锁, 那么等待
*num += 1;
println!("线程: {}, 对 sum 增加了1, 目前 sum 为 : {}", i, num); // 下一行作用域结束, 释放锁
}
thread::sleep(Duration::from_secs(1))
});
lis.push(h)
}
for handle in lis {
handle.join(); // 依次等待执行(这里tm变成串行了)
}
println!("线程调度完毕");
// 6. 读写锁 读线程只允许进行只读访问, 而写线程只能进行独占写操作
// 读锁和写锁要使用显式作用域块隔离开, 在离开作用域时自动释放, 否则会造成死锁
// 因为读锁和写锁不能同时存在
// 只要线程没有拿到写锁, RwLock＜T＞就允许任意数量的读线程获得读锁
use std::sync::RwLock;
let lock = RwLock::new(123);
{
let r1 = lock.read();
let r2 = lock.read();
}
{
let w1 = lock.write();
}
// 7. channel 死锁(共享通道 使用的还是MPSC（多生产者单消费者）队列), 下面的代码中, 在闭包结束的时候仅仅只drop了 tx_clone, 而 rx 会一直阻塞等待消息, 但是有没有了新的消息, 就导致了 tx 不会被drop, 所以造成了死锁
let (tx, rx) = std::sync::mpsc::channel();
for i in 0..5{
let tx_clone = tx.clone(); // 仅仅是在 for 循环中使用的 clone,而 clone 使用的是 &self, 所以不会造成 tx 在for循环之后被 drop
thread::spawn(move ||{
tx_clone.send(i);
}); // 这里闭包结束, 仅仅 drop 掉了 tx_clone
};
drop(tx); // 显式 的 drop 掉 tx,在rx之上, 以关闭通道 可以避免死锁(注释掉这一行, 则会发生死锁)
for i in rx{
println!("例子7: channel 死锁, {}", i)
};
println!("如果发生死锁, 那么永远不可能执行到这里");
// 8. 原子类型: 原子类型本身虽然可以保证原子性, 但它自身不提供在多线程中共享的方法, 所以需要使用 Arc＜T＞将其跨线程共享
// 原子类型拥有的操作有:
// Load(表示读取原子类型内部值),
// Store(往原子类型内部写入值),
// CAS(Compare-And_Swap表示比较并交换),
// Swap(表示原子交换操作)
// Compare-Exchange(表示比较/交换操作)
// Fetch-* 表示 fetch_add, fetch_sub, fetch_and 和fetch_or等一系列原子操作
// Ordering模块中定义的5种内容不同的内存操作顺序:
// 排序一致性顺序: SeqCst 最直观、最简单的内存顺序(一般情况下选择该顺序), 必须是先存储store, 再加载load, 多线程环境下, 所有的原子写操作都必须在读操作之前完成, 强行指定了底层多线程的执行顺序
// 自由顺序: Relaxed 完全不会对线程的顺序进行干涉(尽量不要使用该顺序), 但线程之间会存在竞态条件, 使用这种内存顺序是比较危险的
// 获取-释放 顺序 Release Acquire 和AcqRel
use std::sync::atomic::{AtomicUsize, Ordering};
// 创建一个Arc包裹原子类型
let spinlock = Arc::new(AtomicUsize::new((1)));
let spinlock_clone = spinlock.clone();
let t = thread::spawn(move || {
// 修改原子类型的值, 并制指定内存操作顺序
spinlock_clone.store(0, Ordering::SeqCst);
});
println!("自旋锁开始, 当前状态: {}", spinlock.load(Ordering::SeqCst));
// 死循环(线程内 改变原子类型的值之后, 循环结束)
while spinlock.load(Ordering::SeqCst) != 0 {};
if let Err(panic) = t.join() {
println!("Error: {:?}", panic);
} else {
println!("子线程修改了原子类型的值为: {}", spinlock.load(Ordering::SeqCst));
};
}
fn stu26() {
println!("stu26: 结构体");
// Rust 里, 结构体, trait, 枚举类型 impl块, 组成了对象
struct Dog{
name:String
};
impl Dog {
fn new(name:String) -> Dog{
Dog{
name
}
}
fn say(&self){
println!("{}: wangwang",self.name)
}
}
let d = Dog::new("小虎".to_string());
d.say();
// 2. 封装(主要是外部包, 外部包中如果没有使用 pub 声明的变量 和方法是无法在其他位置使用的)
// 3. Rust 没有继承, 但是Rust可以通过特征来进行行为的共享
trait A {
fn say(){
println!("默认的say")
}
}
struct Student;
impl A for Student{};
// 默认行为 也可以认为是继承了
Student::say()
}
fn stu27() {
println!("stu27: trait 对象");
// 什么是Trait Object呢？指向trait的指针就是Trait Object;假如Bird是一个trait的名称,那么 &Bird 和 Box<dyn Bird> 都是一种Trait Object 一个胖指针;
// 类似鸭子模型!! 注意 这里在使用 dyn修饰的变量会在编译器包装成为一个 trait Object
// trait本身也是一种类型,但它的类型大小在编译期是无法确定的,所以trait对象必须使用指针 &dyn trait, Box<dyn trait>; trait对象中包含两个指针：data指针和vtable指针
// 在rust 中, 泛型是惰性执行的, 对泛型使用 trait bound 编译器会单态化处理 进行 静态分发, 一旦确定类型, 则后续显然无法再改变, 比如 Clone, 所以这里需要使用 trait 对象
// 使用 trait 对象时, Rust 必须使用动态分发, 编译器无法知晓可能用于 trait 对象代码的类型,所以也无法知道该调用哪个类型的那个方法, 为此在运行时 使用 trait 对象的指针来知晓需要调用哪个方法, 而不是实例的方法
// !!! trait 对象要求对象安全,只有对象安全(object safe) 的 trait 才可以组成 trait对象, trait 对象必须要满足: 1. 返回值类型不为 Self:因为特征对象无法知道返回的self是什么类型(动态分配), 2. 方法中没有使用任何泛型类型参数 ,3. 第一个参数必须为 Self 类型或可以解引用为 Self 的类型, 4. self不能出现在除第一个参数之外的地方,包括返回值中
// !!! 总结一句话: 没有额外Self类型参数的非泛型成员方法
// 1. 首先看一个错误, 这里 Student 接收一个泛型,且需要实现 Stu trait, 首先 vec 内的第一个参数为 six, rust编译器推导 vec内部的所有元素都同 six 相同类型,但是后续出现了其他类型,这就导致了编译不通过,虽然他们都满足了泛型的条件
// 定义一个类型为Student, 内部有学生列表若干,其中分为six6年级的学生,seven7年级的学生, 他们有一个共同 特征就是 学习
trait Stu{ // 定义 trait
fn stu(&self);
}
struct Student<T> // 学生结构体, 需要同时包含 six 和 seven 年级, 这里使用泛型
where T:Stu
{
lis:Vec<Rc<T>>
}
impl<T> Student<T> // 学生调动其内的行为
where T:Stu
{
fn action(&self){
for i in self.lis.iter(){
i.stu()
}
}
}
struct Six{ // 定义年级结构体
name:String
}
struct Seven{ // 定义年级结构体
name:String
}
impl Stu for Six{ // 实现特征
fn stu(&self) {
println!("six {}, 正在学习", self.name)
}
}
impl Stu for Seven{ // 实现特征
fn stu(&self) {
println!("seven {}, 正在学习", self.name)
}
}
// 创建学生实例
let six = Rc::new(Six { name: "小亮".to_string() });
let seven = Rc::new(Seven { name: "小张".to_string()});
// 出错了: expected struct `stu27::Six`, found struct `stu27::Seven`
// let students = Student{
// lis:vec![six, seven] // 虽然他们都实现了 trait 中 的 stu 方法,但他们是不同类型, 是无法创建 vec
// };
// 2. 上方出现错误明显是编译器 认为 vec 内部的元素 T 都是统一类型的, 但是却出现了两种类型,虽然他们都是现实了 Stu trait
// 使用 dyn 修饰参数为 trait 对象, 替代上方的 泛型加约束的方式
// 重新定义
struct Student_ { // 重新定义 学生结构体, 使用 dyn 修饰, 表示这是一个 满足了 trait 对象 (一个胖指针)
lis:Vec<Rc<dyn Stu>>
}
impl Student_ {
fn st(&self){
for i in self.lis.iter(){
i.stu()
}
}
}
let students = Student_{
lis:vec![six, seven]
};
students.st();
// 3. 深入理解特征对象
use std::mem;
trait Bird {
fn fly(&self);
}
struct Duck;
struct Swan;
impl Bird for Duck {
fn fly(&self) { println!("duck duck"); }
}
impl Bird for Swan {
fn fly(&self) { println!("swan swan");}
}
fn print_trati_object(obj: &dyn Bird){ // trait object 类型,obj 是一个胖指针
// 使用不安全的 rust 获取胖指针内的相关信息
let (data, vtable):(usize, usize) = unsafe { mem::transmute(obj) };
println!("TraitObject [data:{}, vtable:{}]", data, vtable);
// 使用as执行强制类型转换,将vtable从 `usize` 类型转为 `*const usize` 类型
unsafe {
let v: * const usize = vtable as * const () as * const usize;
// 打印出指针 v 指向的内存区间的值
println!("data in vtable [{}, {}, {}, {}]",
*v, *v.offset(1), *v.offset(2), *v.offset(3));
}
}
print_trati_object(&Duck);
// 4. trait Object在内存中的表现(可以通过 as 对实例强制类型转换为 trait 对象)
// 获得一个实例
let duck = Duck;
// 获得一个实例的引用
let duck_borrow = &duck;
// 手动获得一个trait对象
let duck__ = duck_borrow as &dyn Bird;
// 分别打印大小(针对对象取指针,得到的是普通指针,它占据 64bit 的空间;如果我们把这个指针使用as运算符转换为Trait Object,它就成了胖指针,携带了额外的信息)
println!("Size of duck_ {}, Size of duck__ {}", mem::size_of_val(&duck_borrow), mem::size_of_val(&duck__));
// 5. 对象安全
// 通过 Self加上Sized 限制胖指针中的函数运行, 虽然是对象安全的, 但是 trait对象 无法调用
// Self表示 "调用者" 的类型, 这里 eat 调用者是 trait对象, trait对象编译时无法确定大小
trait Action{
fn say(&self){println!("say! say! say!");}
fn eat(&self) where Self:Sized {println!("eat! eat! eat!");} // 这里 给eat 添加了 Self:Sized 约束, 那么在trait对象中将无法使用这个方法, trait对象无法确定大小
}
struct People;
impl Action for People{};
fn action(s:& dyn Action){
// s.eat(); // Error: this has a `Sized` requirement; 无法编译通过, 因为eat 添加了Self:Sized限定 这就必须保证 trait对象 大小是可知的,然而 trait object 无法可知
s.say();
};
action(&People);
// 尝试获取一个 trait对象 调用方法
let a = &People as & dyn Action;
a.say();
// a.eat() Error; this has a `Sized` requirement
// 6. 分离不安全的方法( 添加 Self: Sized 约束, 让 trait对象 不生成对应的方法)
trait Double {
// fn new() -> Self; // 使用这个会报错因为在尝试生成 trait object时, 这里 会尝试为trait object 生成 new方法, trait对象中的 Self就是 trait对象类型, 返回了一个 Self由于trait object 未知大小, 无法分配内存, 所以 编译失败
fn new() -> Self where Self: Sized; // 加上 Self: Sized, 编译器编译时, 不会为 trait object 生成这个方法, 虽然返回了 Self未知大小, 但是编译器由于 Sized限定 根本没有生成这个方法, 剔除了
fn double(&mut self);
}
impl Double for i32 {
fn new() -> i32 { 0 }
fn double(&mut self) { *self *= 2; }
}
let mut i = 1;
let p : &mut Double = &mut i as &mut Double;
p.double();
// 7. 当函数中有Self类型作为参数或者返回类型时, 为什么返回值不允许有Self类型作为参数或者返回类型, (trait对象中的 Self就是 trait对象类型, 因为根本不知道这个trait object到底多大, trait对象无法知道大小,只有运行时才知道, 所以编译失败)
// ## self Self的区别, self代表调用者, Self代表调用者的类型, 这里 Clone::clone 要求返回的需要和 调用者相同类型
// 因为 p 是一个 trait object,我们只知道,它是一个“胖指针”,包括了指向具体对象的指针以及指向虚函数表的指针; p指向的具体trait对象,它的类型是什么,我们已经不知道了,我们知道的仅仅是,这个类型实现了 Clone trait,其它的就一无所知了;而这个 clone() 方法又要求返回一个与 p 指向的具体类型一致的返回类型;对编译器来说,这是无法完成的任务
// pub trait Clone {
// fn clone(&self) -> Self;
// fn clone_from(&mut self, source: &Self) { ... }
// let p: &Clone = ...;
// let o = p.clone();
// 8. 当函数有泛型参数时
// x是trait object,通过它调用成员方法,是通过vtable虚函数表来进行查找并调用;现在需要被查找的函数成了泛型函数,而泛型函数在Rust中是编译阶段自动展开的, 在trait对象中没法把这些展开的函数都塞进虚表中,
// rust 禁止使用trait object来调用泛型函数,泛型函数是从虚函数表中剔除掉了的
trait SomeTrait {
fn generic_fn<A>(&self, value: A);
}
// fn func(x: &dyn SomeTrait) { // 无法编译, 因为有泛型则无法创建 trait对象 Error: this trait cannot be made into an object
// x.generic_fn("foo"); // A = &str
// x.generic_fn(1_u8); // A = u8
// }
// 9. trait对象 无法构造的一些条件:
// 9.1 当trait有Self:Sized约束时 (见上方, Self代表调用者的类型, trait对象中的 Self就是 trait对象类型, trait对象无法知道大小,只有运行时才知道)
// 9.2 当函数中有Self类型作为参数或者返回类型时 (见上方的clone)
// 9.3 当函数第一个参数不是self时 (如果一个 trait 中存在静态方法,而又希望通过 trait object 来调用其它的方法如果想调用参照上 静态方法后面加上 Self: Sized 约束,将它从虚函数表中剔除出去)
// 9.4 当函数有泛型参数时 见上方
}
fn stu28() {
println!("stu28: 模式");
// 模式分为可反驳 与 不可反驳的, 能匹配任何传递的可能值的模式是不可反驳的, 对值匹配可能会失败的模式是可被反驳的
// 不可反驳的模式有:match, 函数, let语句, for循环,因为通过不匹配的值,程序无法进行有意义的工作 必须匹配所有的条件
// 可反驳的模式: if let, while let 只能接受可反驳的模式,因为他们的定义就是为了有可能失败的条件 可以忽略一些条件
// let: let PATTERN = EXPRESSION
let x = 1;
let (a, b, c) = (1, 2, 3);
// 1.1 match 字面值匹配 必须匹配所有的情况 可以使用 | 或 操作符, 且必须返回同类型
let num = 1;
match num {
1 | 3 => println!("match 匹配到了: 1 | 3"),
2 => println!("match 匹配到了: 2"),
// i32 => ("类型匹配上了"),
_ => println!("match 通配符"),
}
// 1.2 匹配命名变量 (在 match 内是一个独立的作用域)
let x = Some(1);
let y = 2;
match x {
Some(3) => println!("x: 3"),
Some(y) => println!("y: {}", y), // 这里是独立的y, 是一个形参
_ => println!("other")
};
println!("x: {:?}, y: {:?}", x, y);
// 1.3 通过 .. 进行匹配
let x = 5;
match x {
0..=5 => println!("使用 0..=5"),
_ => ()
};
let c = 'c';
match c {
'a'..='z' => println!("使用 'a'..='z'"),
_ =>()
}
// if let, else if, else if let, else 根据条件匹配
let num = Some(2233);
let i = 13;
if let Some(2) = num{
println!("if let 匹配到了: {}", 2);
}else if let Some(111) = num{
println!("else if let 匹配到了: {}", 111)
}else {
println!("else 什么都没有匹配到")
}
// while let 只要模式匹配就会一直执行
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
while let Some(top) = stack.pop() {
println!("while let : {}", top);
}
// for 匹配 (for 本身就是一个匹配模式)
let b = vec![(1,2),(3,4)];
for (c, _) in b.iter(){
// for (c, ..) in b.iter(){
println!("c: {}", c )
}
// 解构结构体
struct Student{
name: String,
age:i32
}
let s1 = Student { name: "小亮".to_string(), age: 13 };
let Student{ name: n, age: a } = &s1;
let Student{ name, age } = &s1; // 同名的可以简写
println!("解构结构体: name: {}, age:{}",n,a);
println!("解构结构体: name: {}, age:{}",name,age);
assert_eq!(*a,13);
// match 匹配结构体 可以使用 .. 忽略 或者指定具体的值
let n = String::from("小亮");
match s1 {
Student{name,age:13}=>println!("这个人匹配 年龄 为 13"),
Student{..}=>println!("这个人名字 年龄 为 小亮"),
_ => ()
}
// 解构枚举类型
enum Message{
Quit,
Move{x:i32,y:i32},
Write(String),
ChangeColor(i32, i32, i32)
}
let msg = Message::ChangeColor(255, 255, 255);
match msg {
Message::Quit => println!("匹配枚举类型的 Quit"),
Message::Move{x,y} => println!("匹配枚举类型的 Move: x: {}, y: {}", x, y),
Message::Write(text) => println!("匹配枚举类型的 Write: {}", text),
Message::ChangeColor(r, g, b) => println!("匹配枚举类型的 ChangeColor: r: {}, g: {}, b: {}", r, g, b),
}
// 解构嵌套的枚举 1
enum Message_{
Quit,
Move{x:i32,y:i32},
Write(String),
ChangeColor(Color)
}
enum Color{
Rgb(i32, i32, i32),
Hsv(i32, i32, i32)
}
let msg = Message_::ChangeColor(Color::Hsv(100, 155, 255));
match msg {
Message_::ChangeColor(Color::Rgb(r, g, b)) => println!("匹配到了 Rgb格式, r: {}, g:{}, b:{}", r, g, b),
Message_::ChangeColor(Color::Hsv(h, s, v)) => println!("匹配到了 Hsv格式, h: {}, s:{}, v:{}", h, s, v),
_=>()
}
// 结构体嵌套结构体 2
struct Point{
x:i32,
y:i32
}
let ((a, b), Point{x, y}) = ((1, 2), Point{ x: 3, y: 4 });
println!("a: {}, b: {}, x: {}, y:{}", a, b, x, y);
// _下划线 忽略模式中的值
let f = |_:i32,y:i32|{ println!("在传参的时候忽略了一些值, y: {}", y);};
f(1, 2);
let lis = (1, 2, 3, 4);
match lis{
(one, _, three, _) => println!("one: {}, three: {}",one, three)
}
// 变量名前增加 _ 编译器忽略这个值,只是忽略警告仅此而已, 变量的所有权依旧会被转移(这个单纯的 _ 下划线 不同)
let _x = 5; // 虽然下面没有使用
let y = 4;
let s = Some(String::from("hello")); // 单独的使用 _ 不会转移所有权, 因为省略语义
if let Some(_) = s{
println!("发现一些 String")
}
let s = Some(String::from("hello")); // error: borrow of moved value: `s`
if let Some(_sc) = s{
println!("String")
}
// println!("{:?}", s) // 所有权已经被转移
// 使用 .. 忽略一部分值, 使用 .. 匹配的时候不能有 歧义(需要有始有终)
let li = (1, 2, 3, 4, 5);
match li {
(first, .., last) => println!("first: {}, last: {}", first, last)
};
let li = (1, 2);
match li {
(first, ..) => println!("first: {}", first)
};
// 匹配守卫 (用于 match 匹配)
let num = Some(11);
match num {
Some(x) if x < 10 => println!("这个x 小于 10"),
Some(x) if x > 10 => println!("这个x 大于 10"),
Some(x) if x == 10 => println!("这个x 等于 10"),
_ => ()
};
// 匹配守卫 (可以直接使用外部变量, 但是内部变量会沿用自身的)
let num = Some(10);
let y = 10; // 位置1
let x = 12; // 位置2
match num {
Some(x) if x < y => println!("这个x 小于 y"),
Some(x) if x > y => println!("这个x 大于 y"),
Some(x) if x == y => println!("这个x 等于 y"), // 此处的 x 是本作用域的x, y是 位置1 的y
_ => ()
};
// 匹配守卫的优先级 (3 | 4 | 5) if b 优先判断前面匹配, 然后进入匹配守卫
let x = 3;
let b = false;
match x {
3 | 4 | 5 if b => println!("匹配守卫的优先级"),
_ => ()
}
// @ 运算符, 允许我们在创建一个存放值得同时, 测试这个变量是否匹配模式
enum _Message{
Idx { id: i32 }
}
let msg = _Message::Idx { id: 2233 };
match msg { // 普通的匹配模式, 匹配成功后结构体内的值进行过滤, 是不能的
_Message::Idx {id:i} => println!("普通的过滤方式无法限制 id 的值 i: {}", i),
}
match msg { // 使用 @ 运算符 可以对结构体/枚举内的值过滤并赋值
_Message::Idx { id: id_value @ 3..=18 } => println!("使用 @ 运算符,匹配到了一些值 id: {}", id_value),
_ => ()
}
}
fn stu29() {
println!("stu29: 不安全的Rust");
// unsafe 并不会关闭借用检查器或禁用任何其他 Rust 安全检查:如果在不安全代码中使用引用,它仍会被检查,unsafe 关键字只是提供了那五个不会被编译器检查内存安全的功能,你仍然能在不安全块中获得某种程度的安全
// 1. 解引用裸指针 2. 调用不安全的函数或方法 3. 访问或修改可变静态变量 4. 实现不安全 trait 5. 访问 union 的字段
// 解引用裸指针, 分为可变和不可变: *mut T, *const T, 这里 * 是类型的一部分, 并不是解引用, 意为 可变指针/指针常量,
// 1. 裸指针允许忽略借用规则, 可以同时拥有多个可变和不可变的指针,或者多个指向相同位置的可变指针
// 2. 不保证指向的内存是有效的
// 3. 允许为空
// 4. 不能实现任何自动清理的功能
// 1. 可以在安全的代码中创建 可变/不可变 裸指针, 只是不能使用和解引用
let mut num = 3;
let r1 = num as *const i32;
let r2 = num as *mut i32;
// println!("r1; {:?}", *r1); // 安全的代码中禁止使用不安全的变量
unsafe {
// println!("r1; {:?}", *r1);
// println!("r2; {:?}", *r2);
println!("r2; {:?}", r1);
println!("r2; {:?}", r2);
}
// 允许为空 下面可能就是一个空的内存地址
let add = 0x12345usize;
let _r = add as *const i32;
// 调用不安全的函数或者方法
unsafe fn dangerous(){
println!("dangerous fucntion")
};
// dangerous(); // 禁止调用
unsafe {
dangerous()
}
// 创建不安全的代码抽象
fn function_1(){
let mut num = 3;
let r1 = num as *const i32;
let r2 = num as *mut i32;
unsafe {
// println!("r1; {:?}", *r1);
// println!("r2; {:?}", *r2);
}
}
function_1();
// 调用 c 语言的函数, 属于不安全的代码
extern "C" {
fn abs(input:i32) -> i32;
}
unsafe {
println!("abs(-3) = {}", abs(-3));
}
}
static NUM_STR:&str = "2233";
static mut COUNTER:u32 = 0;
fn stu30() {
println!("stu30: 不安全的可变静态变量");
// 静态变量和常量的区别: 静态变量有固定的内存地址,使用这个值总是访问相同的地址, 常量则允许任何被用到的时候复制其数据
// 静态变量可以是可变的, 虽然可变后是不安全的
// 可变的静态变量 是无法在安全的代码中 读取和修改的
// 静态变量和程序代码一起被存储于静态存储区中
println!("静态变量, NUM_STR: {}",NUM_STR); // 读取全局的静态变量
// COUNTER += 1; // 禁止在安全的代码中 修改可变静态变量
// println!("COUNTER: {}", COUNTER); // 安全的代码中, 禁止读取 可变静态变量
unsafe {
COUNTER += 1;
println!("COUNTER: {}", COUNTER)
}
}
fn stu31() {
println!("stu31: 不安全的trait");
// 当至少有一个方法包含编译器不能验证的 变量 时, 该 trait 就是不安全的
// 在 trait 之前增加 unsafe 声明为不安全的, 同时 trait 的实现也必须用 unsafe 标记
unsafe trait Say{
fn say(&self);
}
struct Student;
unsafe impl Say for Student{
fn say(&self){
println!("say, say, hello")
}
}
let s1 = Student{};
s1.say()
}
fn stu32() {
println!("stu32: 关联类型");
// 1. 关联类型在 trait定义中 指定占位符类型
// 2. 关联类型是一个 将类型占位符与trait 相关联的方式
// 3. trait 的实现者 会针对特定的实现,在这个类型的指定位置指定相应的具体类型(可以定义一个使用多种类型的 trait, 直到实现此 trait 时都无需知道这些类型具体是什么)
// 如此可以定义使用多种类型的trait
// trait Iterator{
// type Item;
// fn next(&mut self) -> Option<Self::Item>;
// };
// 如果不使用关联类型, 而是使用泛型那么会出现一些问题, 出现无法推断类型的情况(因为泛型, 在编译期会展开)
// 定义泛型迭代器特征
trait Iterator<T>{
fn next(& mut self) -> Option<T>;
}
// 定义迭代器
struct List{
value:i32
}
// 实现迭代器特征 String
impl Iterator<String> for List{
fn next(&mut self) -> Option<String>{
println!("调用了 String 的迭代器");
if self.value <5 {
self.value += 1;
Some(String::from("哈哈"))
}else { None }
}
}
// 实现迭代器特征 i32 类型
impl Iterator<i32> for List{
fn next(&mut self) -> Option<i32>{
println!("调用了 i32 的迭代器");
if self.value <5 {
self.value += 1;
Some(self.value)
}else { None }
}
}
// 下面 使用 next 已经无法推断类型了
let mut l1 = List { value: 1 };
// l1.next(); // 无法推导类型Error: cannot infer type for type parameter `T` declared on the trait `Iterator`
// 使用完全限定语法可以调用上面无法推断类型的迭代器 TODO 但是这是超出预期的, 与我们的设计想法不符
<List as Iterator<i32>>::next(&mut l1);
<List as Iterator<String>>::next(&mut l1);
}
fn stu33() {
println!("stu33: 默认泛型类型参数和运算符重载");
// 1. 使用泛型类型参数时, 可以为泛型指定一个默认的具体类型
// 2. 运算符重载是指在特定情况下自定义运算符行为的操作
// Rust不允许创建自定义的运算符或者重载运算符, 不过对于std::ops中列出的运算符和相应的 trait, 我们可以使用运算符相关 trait 来重载
use std::ops::Add;
#[derive(Debug)]
struct Point{
x:i32,
y:i32
}
// 重载 Point 的 + 操作
impl Add for Point{
type Output = Point;
fn add(self, other:Point) -> Point{
Point{
x:self.x + other.x,
y:self.y + other.y
}
}
}
let p1 = Point { x: 1, y: 2 };
let p2 = Point { x: 3, y: 5 };
let p3 = p1 + p2;
println!("p1 + p2 = {:?}", p3);
// 默认泛型类型
// 尖括号里面为默认类型参数, Rhs 是一个 泛型类型参数 right hand side, 这里大写的RHS 是用来指定下方小写rhs的类型的, 这里默认使用了 Self 所以只能和自己本身的类型相加
// RHS和Output,分别代表加法操作符右侧的类型和返回值的类型
// pub trait Add<Rhs = Self> {
// type Output;
// fn add(self, rhs: Rhs) -> Self::Output;
// }
// 修改默认泛型类型, 实现不同结构体相加
// 手动覆盖 Rhs为 其他类型, 因为这是两种不同的结构体 默认的Rhs是self 只能同类型的相加,无法不同类型相加
struct Ms1(u32);
struct Ms2(u32);
impl Add<Ms2> for Ms1{ // 这里 Ms2 就是准备与之相加的结构体
type Output = Ms1;
fn add(self,other:Ms2) -> Ms1{
Ms1(self.0 + other.0)
}
}
let m1 = Ms1(1);
let m2 = Ms2(2);
let m3 = m1 + m2;
// println!("{}",m2.0); // error: value borrowed here after move
// 例子2
trait Stu<T=i32>{ // 写法1 (设置默认泛型类型)
fn say(&self, value:T)
// trait Stu{ // 写法2
// fn say<T>(&self, value:T)
where T:Display
{
println!("{}", value);
}
}
struct Student_{};
impl Stu<String> for Student_{}; // 这里在实现 trait 时 指定类型
let s = Student_{};
s.say("123".to_string())
}
fn stu34() {
println!("stu34: 完全限定语法");
// Rust 既不能避免一个 trait 与另一个 trait 拥有相同名称的方法,也不能阻止为同一类型同时实现这两个 trait,甚至直接在类型上实现开始已经有的同名方法也是可能的
// 可以让对象按照指定特征运行
// 使用 <Type as trait>::function(), 调用 特定 Type 特定 trait 的方法
// <Type as Trait>::function(receiver_if_method, next_arg, ...);
// 1. 有 self 参数的 同名 方法, 如果特征 和结构体本身的 方法重复, 且有self 参数,那么 在调用方法时 可以自动匹配到对应的方法
// 定义两个特征
trait A{
fn print(&self);
};
trait B{
fn print(&self);
};
// 结构体
struct MyType;
// 特征实现
impl A for MyType{
fn print(&self){
println!("this is A trait")
}
}
impl B for MyType{
fn print(&self){
println!("this is B trait")
}
}
// 本身方法
impl MyType{
fn print(&self){
println!("MyType")
}
}
// 创建实例
let my_type = MyType;
my_type.print(); // 等价于下面的方法
MyType::print(&my_type);
// 调用 MyType 实现了 特征 A/B 的 方法
A::print(&my_type);
B::print(&my_type);
// 2. 完全限定语法 调用没有 self 参数的方法
trait Animal {
fn get_name() -> String;
}
struct Dog;
impl Dog{
fn get_name()->String{
"Dog".to_string()
}
}
impl Animal for Dog{
fn get_name() -> String{
"Animal trait Dog".to_string()
}
}
// 调用 Dog 本身的方法
println!("Dog 本身方法: {}", Dog::get_name());
// 调用 Animal 特征的方法
// println!("Animal trait 的方法: {}", Animal::get_name()); // error: required by `stu34::Animal::get_name`
// 使用完全限定语法调用 指定 trait 的方法
let dog_name = <Dog as Animal>::get_name();
println!("使用完全限定语法: {}", dog_name)
}
fn stu35() {
println!("stu35: 父 trait");
// 类似于为 trait 增加 trait bound
// 类似 "继承", 有时候我们需要某个 trait 使用另一个 trait 的功能, 可以使用 trait trait1:trait2 + trait3 {} 的方法定义 trait
// impl trait1:trait2 + trait3 for T {}, 实现了 trait1的类型, 必须也实现 trait2 和trait3, 否则无法编译失败
use std::fmt; // 引入trait
// 定义一个特征, 这个特征也拥有一些继承过来的特征
trait Output: fmt::Display{ // 这里 "继承" fmt::Display
fn out_print(&self){
let output = self.to_string();
println!("out_print: {}", output)
}
}
// 定义一个结构体
#[derive(Debug)]
struct Point{
x:i32,
y:i32
};
// 实现 Output 特征
impl Output for Point{};
// 实现 fmt::Display 特征, 因为这是 Output 特征继承的,如果实现了Output特征, 那么也必须实现继承过来的特征
impl fmt::Display for Point{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
println!("实现了 Display"); // 这里在我本机上明没有打印 奇怪
write!(f, "{}, {}",self.x, self.y)
}
}
let p1 = Point{x:1, y:2};
println!("{:?}",p1)
}
use std::fmt;
use std::sync::{Arc, Mutex};
use std::convert::TryInto;
use std::future::Future;
use std::ops::{Deref, Add};
use std::borrow::{Cow, Borrow, BorrowMut};
use std::any::Any;
use serde_json::value::Value::Array;
use futures::future::{BoxFuture, err};
use rand::{random, Rng};
use std::process::id;
use std::hash::Hash;
use futures::stream::futures_unordered::Iter;
use futures::io::Error;
use std::ptr::swap;
use futures::AsyncBufRead;
#[derive(Debug)]
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
write!(f, "({})",self.0.join(", "))
}
}
fn stu36() {
println!("stu36: 孤立规则");
// !! 这里在我本机上 输出并不是 ("小红", "小明") 奇怪
// 孤立规则: 只要 trait 或者类型 对于当前 crate 是本地的话,就可以再此类型上实现该trait
// 如果要实现某个trait,那么该trait和要实现该trait的那个类型至少有一个要在当前crate中定义
// newtype 模式在外部类型上实现外部的trait, 比如一个结构体
// 绕开孤立规则的方法就是使用 newtype 模式
// 使用 Box 脱离孤立规则: Rust 内部使用了一个叫＃[fundamental]的属性标识, 使Box 脱离孤儿规则, 源码中可得知; 除了Box＜T＞,还有Fn、FnMut、FnOnce、Sized
Box::new(123);
let w = Wrapper(vec![String::from("小红"), String::from("小明")]); // 生成一个 newtype(比如这里是一个类似 vec 的类型)
println!("{:?}", w);
// 下面如果使用被注释的那行,会报错, is not defined in the current crate, 很明显这里 Option 并不是在本地 crate 实现的 struct, 而是外部标准库引用过来的违反孤立规则在本地不能给它实现特征
// 而再下面一行的 MyData 是本地的所以使用 trait
use std::ops::Add;
struct MyData(i32);
// impl Add<i32> for Option<MyData>{ //
impl Add<i32> for MyData{
type Output =i32;
fn add (self,other:i32)->Self::Output{
(self.0) + other
}
}
}
fn stu37() {
println!("stu37: 动态大小类型");
// Sized标识是无尺寸大小类型, DST指在编译期可确定大小的类型
// Unsize标识的是动态大小类型, 在编译期无法确定其大小, 目前Rust中的动态类型有trait和[T], 只可以通过胖指针来操作Unsize类型,比如&[T]或&Trait
// ？Sized标识的类型包含了Sized和Unsize所标识的两种类型
// 1. 动态大小类型
// 动态大小类型: DST, 这些类型只有在运行的时候才知道大小的类型, 比如 &str 类型
// 动态大小类型的黄金规则: 必须将动态大小类型的值, 置于某种指针之后: 如Box<str>, Rc<str>
// 另一个动态大小类型是 trait, 每一个 trait 都是一个可以通过 trait 名称来引用的 动态大小类型, 为了将 trait 用于 trait 对象, 必须将他们放到指针之后, 比如 &Trait 或 Box<Trait>/Rc<Trait>
// Rust提供了两种主要的 DST：trait 对象和 slice
// slice的&[T], 这个是&[T] 的内存表示，不是[T]的内存表示。[T]没有值
// &str 是Unsize, 是一个胖指针,保存了两个值: str的地址和长度. &str的大小在编译时就可以知道,长度是 2*usize
let s1 :&str = "hi";
// 2. Sized trait
// 为了除了 DST, Rust 用Sized trait 来决定一个类型的大小是否是在编译时可知
// 这个 trait 自动为编译器在编译时就知道大小的类型实现
// ?Sized 包括了所有的动态大小类型和所有可确定大小的类型
fn generic<T>(t:T){}; // T 为编译时就自动推导大小和 类型, 和下面等价
fn generic_<T:Sized>(t:T){}; // 和上面等价, T 要求实现 Sized 的特征
// 3. Sized trait 放宽, 对于泛型约束使用 ?Sized, 有可能传入的参数我们也不知道大小, 所以这里需要忽略 T 的大小, 可能是 Sized, 也可能不是 Sized
fn _generic<T: ?Sized>(t: &T){};
}
fn stu38() {
println!("stu38: 高阶函数和闭包");
// 函数指针允许我们 使 函数 作为另一个函数的参数
// 函数的类型是 fn, fn被称为函数指针, 指定参数为函数指针的语法类似于闭包
// 函数指针实现了闭包的三个特征: Fn, FnMut, FnOnce
// Fn代表函数trait, fn则是函数类型
// 1.
fn add_one(x:i32) -> i32{
x + 1
}
fn utils(func:fn(i32) -> i32, val:i32) -> i32 {
func(val)
}
let num = utils(add_one, 3);
println!("num: {}",num);
// 2. 实现一个泛型修饰函数, 要求传入的第一个参数为 实现了 Fn trait 的类型,
fn wrapper_func<T>(f:T, val:i32) -> i32
where T: Fn(i32) -> i32
{
f(val)
}
fn func(v:i32) -> i32{
v + 1
}
let a = wrapper_func(|x| x * 2, 3); // 使用闭包
let b = wrapper_func(func, 3); // 使用函数指针
// 返回闭包/函数 1
fn return_func_1()-> fn(i32) -> i32{
|x| x + 1
}
let func_1 = return_func_1();
let num_1 = func_1(5);
println!("return_func_1: {}", num_1);
// !! 返回满足了 Fn trait 特征的对象, 使用 dyn 修饰表示这里是满足了 Fn trait 的对象
fn return_f() -> impl Fn(i32) -> i32{ | x:i32 | x }
fn return_func_2() -> Box<dyn Fn(i32) -> i32>{
Box::new( |x| x * x)
}
let func_2 = return_func_2();
let num_2 = func_2(3);
println!("return_func_2: {}", num_2)
}
fn stu39() {
println!("stu39: 宏");
}
fn stu40() {
println!("stu40: From/Into");
// From 和 Into 两个 trait 是内在地联系着的,事实上这是它们的实现的重要 部分:如果能把类型 A 转换成类型 B,那么很容易相信我们也能把类型 B 转换成类型 A
// 你的类型实现了Into From ,那么同时你也就免费获得了 Into
// 使用 Into trait 通常要求指明要转换到的类型,因为编译器大多数时候不能推断转为哪一个类型,因为一个类型可能会有很多 Into
// TryFrom 和 TryInto 是 类型转换的通用 trait;不同于 From / Into 的是, TryFrom 和 TryInto trait 用于易出错的转换,也正因如此,其返回值是 Result 型
// 关于Into有一条默认的规则：如果类型U实现了From＜T＞,则T类型实例调用into方法就可以转换为类型U, 调用时会把 T当做参数传入U的from方法中
#[derive(Debug)]
struct Number{
val:i32
}
// 为结构体实现 From trait
impl From<i32> for Number{
fn from(val:i32) -> Self{
println!("调用了 from");
Number{val}
}
}
let i = Number::from(123);
println!("i: {:?}",i);
// println!("i: {:?}",i.into()); // error: cannot infer type for type parameter `T` declared on the trait `Into`
// let i_into = i.into(); error: // consider giving `i_into` a type
let i_into_ok:Result<Number,_> = 2123123.try_into(); // 注意!: 使用 try_into 的时候需要给与返回值一个类型,因为编译器无法推导
println!("i_into:Result<Number,_>: {:?}",i_into_ok);
let i_ = Number::from(2233);
let i__into:Number = 123.into(); // 注意!: 使用 into 的时候需要给与返回值一个类型,因为编译器无法推导转为哪一个类型
println!("i__into:Number,_>: {:?}",i__into);
// Complex 实现 From<i32> 后,也可以在 i32 上使用 into 方法,转换到 Complex
// T类型实例调用into方法就可以转换为类型U
#[derive(Debug)]
struct Complex {
re: i32,
im: i32
}
impl From<i32> for Complex{
fn from(re: i32) -> Self {
Complex{
re,
im:0
}
}
}
println!("Hello, world!");
let b: Complex = 1.into(); // 需要手动注明类型, 因为编译器无法自动推导
println!("Complex: {:?}", b);
// 约束泛型时, 用 into()方法 的时候, 会直接把调用者传入 from 中的形参中
fn utils<T>(s:T)
where T:Into<Complex>
{
println!("s.into {:?}",s.into()) // s作为调用者, 被传入到了 from中的参数中了
}
utils(123);
}
fn stu41() -> std::io::Result<()>{
println!("stu41: 网络监听");
use std::net::{TcpListener, TcpStream, SocketAddr, IpAddr};
use std::io::Read;
use std::time;
use std::thread;
// listener.incoming 相当于loop循环中的 listener.accept()
// 由于 str 实现了 ToSocketAddrs trait 所以可以直接传入并绑定 ip:port
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
// 接收消息
for msg in listener.incoming(){ // 内部实现了 迭代器 特征可以直接迭代
match msg {
Ok(stream) => client_handle(stream),
_ => {}
}
};
// 对请求的内容进行处理
fn client_handle(mut stream:TcpStream){
// 读取 1
let mut value:[u8;512] = [0;512]; // 注意这里保存的字节, 需要在下面 转一下类型
stream.read(& mut value).unwrap(); // 使 流读取的内容保存到 value 中
println!("收到了一些内容: {}", String::from_utf8_lossy(&value)); // 使用 from_utf8_lossy 方法把字节转为 String
// 返回
let response = "HTTP/1.1 200 OK \r\n\r\n";
println!("返回的消息为: {:?}", response.as_bytes());
stream.write(response.as_bytes()); // 把response 写入到流中,返回
stream.flush(); // 处理完毕, 刷新流
// 手动睡眠 10秒, 模拟延时操作
thread::sleep(time::Duration::from_secs(1));
}
Ok(())
}
fn stu42() -> std::io::Result<()>{
println!("stu42: 多线程处理 WebServer");
use std::net::{TcpListener, TcpStream, SocketAddr, IpAddr};
use std::io::Read;
use std::time;
use std::thread;
// 由于 str 实现了 ToSocketAddrs trait 所以可以直接传入并绑定 ip:port
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
// 接收消息(这里使用多线程处理)
for msg in listener.incoming(){ // 内部实现了 迭代器 特征可以直接迭代
match msg {
Ok(stream) => {thread::spawn(move ||client_handle(stream));},
_ => {}
}
};
// 对请求的内容进行处理
fn client_handle(mut stream:TcpStream){
// 读取
let mut value:[u8;512] = [0;512]; // 注意这里保存的字节, 需要在下面 转一下类型
stream.read(& mut value).unwrap(); // 使 流读取的内容保存到 value 中
println!("收到了一些内容: {}", String::from_utf8_lossy(&value)); // 使用 from_utf8_lossy 方法把字节转为 String
// 返回
let response = "HTTP/1.1 200 OK \r\n\r\n <!DOCTYPE html>123123";
stream.write(response.as_bytes()); // 把response 写入到流中,返回
stream.flush(); // 处理完毕, 刷新流
// 手动睡眠 10秒, 模拟延时操作
thread::sleep(time::Duration::from_secs(3));
}
println!("结束了");
Ok(())
}
fn stu43() -> std::io::Result<()>{
println!("stu43: 线程池 WebServer");
use std::net::{TcpListener, TcpStream, SocketAddr, IpAddr};
use std::io::Read;
use std::time;
use std::thread;
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
// 任务结构体
#[derive(Debug)]
struct Worker{
id:usize,
thread:Option<thread::JoinHandle<()>>
}
// 任务方法: 返回一个任务方法
impl Worker{
// 1.
// fn new(id:usize) -> Self {
// let t = thread::spawn(move || {});
// Worker{id,thread:t}
// }
// fn new(id:usize, receiver:mpsc::Receiver<Job>) ->Self {
fn new(id:usize, receiver:Arc<Mutex<mpsc::Receiver<Message>>>) ->Self { // receiver是一个 一个线程安全的的接收端
let thread = thread::spawn(move || { // 创建一个子线程, 子线程在后台loop循环接收任务
loop{ // 无限循环 接收端 阻塞 接收任务
let message = receiver.lock().unwrap().recv().unwrap(); // 如果收到通道的内容
match message { // 判断通道中内容的类型,是执行新的任务还是停止当前子线程
Message::Run(job)=>{
println!("收到任务: {:?}", id);
job()
}
Message::Stop => { // 如果收到Stop 则子线程 立刻停止循环, 下面即执行完毕
println!("结束任务: {}", id);
break
}
}
}
});
Worker{id, thread:Some(thread)} // 返回这个任务到外部主线程
}
}
enum Message{ // 发送给channel中的消息: Run(新增一个任务), Stop(停止该线程)
Run(Job),
Stop
}
// 一个 类型别名, 当做 线程池接收的 函数 的约束
type Job = Box<dyn Send + FnOnce() + 'static>;
// 定义线程池
struct ThreadPool{
// threads:Vec<thread::JoinHandle<()>>
workers:Vec<Worker>,
sender:mpsc::Sender<Message>
}
impl ThreadPool{
fn new(size:usize) -> Self {
assert!(size > 0);
// let mut threads = Vec::with_capacity(size);
// 线程需要传入闭包
// ThreadPool{threads}
let mut workers = Vec::with_capacity(size); // 任务容器
let (sender, receiver) = mpsc::channel::<Message>(); // 发送端, 接收端
let receiver = Arc::new(Mutex::new(receiver)); // 线程安全的接收端
for id in 0..size{ // 循环 根据 size 创建 子线程, 子线程内接受一个 receiver 接收端, 在线程内循环阻塞接收任务
let worker = Worker::new(id, Arc::clone(&receiver));
println!("创建了子线程: {:?}", worker);
workers.push(worker);
};
ThreadPool{ // 返回创建的线程池
workers,
sender
}
}
fn execute<F>(&self, f:F) // 提交任务
where F:FnOnce() -> () + Send + 'static
{
let job = Box::new(f); // 使用 Box 封装为一个智能指针
self.sender.send(Message::Run(job)).unwrap();
}
}
// 线程池关闭处理
impl Drop for ThreadPool{
fn drop(&mut self){
// 给所有线程发送停止消息(每个线程收到消息后会 break,停止loop接收后续消息了)
for _ in 0..self.workers.len(){
self.sender.send(Message::Stop);
}
// 循环拿出所有的worker, 等待所有的 worker内部 的线程结束
for worker in &mut self.workers{
println!("{:?}", worker);
// worker.thread.join().unwrap(); // Error: cannot move out of `*s` which is behind a mutable reference; 因为worker.thread在 可变引用 之后, 调用这个方法会自动解引用, 在上方使用了 &mut worker可变引用, 可变引用未实现Copy trait 解引用会转移所有权
if let Some(thread) = worker.thread.take(){ // 使用 take 拿到Option中的内容,内部补为None, 且不会转移 worker的所有权
thread.join(); // 等待子线程结束
}
}
println!("线程池关闭")
}
}
println!("Server Start");
// 由于 &str 实现了 ToSocketAddrs trait 所以可以直接传入并绑定 ip:port
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
let thread_pool = ThreadPool::new(2);
// 接收连接(这里使用多线程处理), 使用take, 表示只接收10次连接, 10次连接之后,就不再阻塞接收消息, 直接结束程序
for msg in listener.incoming().take(10){ // 内部实现了 迭代器 特征可以直接迭代
match msg {
Ok(stream) => {
thread_pool.execute(|| client_handle(stream)); // 接收到连接之后 提交任务到线程池中
},
_ => {}
}
};
// 对请求的内容进行处理
fn client_handle(mut stream:TcpStream){
// 读取
let mut value:[u8;512] = [0;512]; // 注意这里保存的字节, 需要在下面 转一下类型
stream.read(& mut value).unwrap(); // 使 流读取的内容保存到 value 中
// println!("收到了一些内容: {}", String::from_utf8_lossy(&value)); // 使用 from_utf8_lossy 方法把字节转为 String
// 返回
let response = "HTTP/1.1 200 OK \r\n\r\n <!DOCTYPE html>123123";
stream.write(response.as_bytes()); // 把response 写入到流中,返回
stream.flush(); // 处理完毕, 刷新流
// 手动睡眠 10秒, 模拟延时操作
thread::sleep(time::Duration::from_secs(10));
}
println!("结束了");
Ok(())
}
fn stu44(){
println!("stu44: 读取文件");
use std::fs;
// read 读取字节到 Vector 中
let text = fs::read("./1.txt").unwrap(); // 这里读取到的是 Vec<u8>
println!("读取字节到 Vector 中: {:?}",String::from_utf8_lossy(&text));
// 读取字节并转为 String
let text = fs::read_to_string("./1.txt").unwrap();
println!("读取字节并转为 String: {:?}",text)
// 读取目录 read_dir
}
fn stu45() ->Result<(), String>{
println!("stu45: Option 方法");
// 1. take: 把值从Option中拿出来，不转移其所有权,内部留下 None
let mut s: Option<String> = Some("hello".to_string());
let b = s; // 所有权发生了转移
// println!("s: {:?}, b:{:?}", s, b); // Error: value borrowed here after move
let mut s: Option<String> = Some("hello".to_string());
let b = s.take(); // 使用 take 取出内部的值, 而不转移所有权, 因为不用 take 那么在赋值的时候, 会获得 Option<T> 中T 的所有权, 获取了所有权 Option那保存成了啥! 这是禁止的
println!("s: {:?}, b:{:?}", s, b);
// 2. is_some: 当Option中有值得时候, 返回true
let s: Option<u32> = Some(1);
let b: Option<u32> = None;
println!("s.is_some: {}, b.is_some: {}", s.is_some(), b.is_some());
// 3. is_none 同上, 只不过取反
// 4. contains: 判断内部的值是否相等
// #![feature(option_result_contains)];
// let n = Some(123);
// println!("n.contains(&123): {:?}", n.contains(&123))
// 5. as_ref: 将 &Option<T> 转为 Option<&T>, 把引用本身 转为内部值得引用
// let s = Some("hello".to_string());
// let l = s.map(|x| x.len()); // 如果这样处理会造成所有权转移到闭包内
// println!("s: {:?}, s.as_ref(): {:?}",s, l); // Error: value borrowed here after move
let s = Some("hello".to_string());
let l = s.as_ref().map(|x| x.len());
println!("s: {:?}, s.as_ref(): {:?}",s, l);
// 6. unwrap_or, 提供了一个默认值default，当值为None时返回default
// 7. ok_or 使Option变为Result 类型, 让我们可以进行 ? 操作 而不是会引发panic的unwarp
let s = Some(123);
let s_r = s.ok_or("转换失败")?;
println!("s_r 转换可以使用 ? 操作: {}", s_r);
Ok(())
}
fn stu46() {
println!("stu46: Queue 队列");
#[derive(Debug)]
struct Queue<T>(Vec<T>, usize);
impl<T> Queue<T>{
// 不限定大小
// fn new() -> Self{
// Queue(Vec::new())
// }
// 限定大小
fn new(size:usize) -> Self {
Queue(Vec::with_capacity(size), size)
}
fn push(&mut self, item:T) -> Result<(), String>{
if self.0.len() == self.1{
println!("没有空间了");
return Err("".to_string());
}
else {
self.0.push(item);
return Ok(())
}
}
fn pop(&mut self) -> Option<T>{
if self.0.len() > 0 {
Some(self.0.remove(0)) // 使用 remove 方法 弹出 指定下标位置元素, 并返回
} else {
None
}
}
fn len(&self) -> usize {
self.0.len()
}
}
let mut q: Queue<i32> = Queue::new(3); // 设置队列最大元素数量
q.push(1);
q.push(13);
q.push(24);
q.push(66);
q.push(74);
q.push(85);
// q.pop(); // 删除一个
println!("q: {:?}, q.len(): {:?} ", q, q.len());
}
fn stu47() {
println!("stu47: Stack 栈结构");
// 定义栈结构体
#[derive(Debug)]
struct Stack<T>(Vec<T>, usize);
impl<T:Debug> Stack<T>{
fn new()->Self{
Stack(Vec::new(), 0)
}
fn push(&mut self, item:T){
println!("入栈了: {:?}", &item);
self.0.push(item);
self.1 += 1;
}
fn pop(&mut self) -> Option<T>{
if self.1 == 0{
return None;
}
self.1 -= 1;
return self.0.pop()
}
fn len(&self) -> usize {
self.0.len()
}
}
let mut stack = Stack::<i32>::new();
stack.push(2233);
stack.push(1234);
stack.push(7878);
stack.pop();
println!("stack 经过出栈入栈: {:?}, 栈深度为: {}", stack.0, stack.1);
}
fn stu48() {
println!("stu48: 链表实现一个栈");
// 定义Node元素
#[derive(Debug)]
struct Node<T>{
value:T,
next:Option<Box<Node<T>>>
}
// 定义栈
#[derive(Debug)]
struct Stack<T>{
top: Option<Box<Node<T>>>
};
impl<T> Stack<T>{
fn new() -> Self{
Stack{
top:None
}
}
fn push(&mut self, value:T) -> (){
// 创建一个节点
let mut node = Node {
next: None,
value,
};
// 新的节点 next应指向曾经给的top节点
let mut top = self.top.take();
node.next = top;
// 新的top 指向刚创建的节点
self.top = Some(Box::new(node));
}
fn pop(&mut self) -> Option<Box<Node<T>>> {
// 修改top 为当前top的next
let mut node = self.top.take(); // 这里如果不使用take, Option<T> 中 T的所有权, 这是禁止的
match node {
Some(mut v) => {
self.top = v.next.take(); // 取出旧node节点中的 next 中的内容, 并把内容赋给栈顶
Some(v) // 返回旧的栈顶 node节点
}
None => None
}
}
}
let mut s = Stack::new();
s.push(1);
s.push(3);
s.push(7);
println!("s: {:#?}", s);
s.pop();
println!("s: {:#?}", s);
s.pop();
s.pop();
s.pop();
println!("s: {:#?}", s);
}
fn stu49() -> io::Result<()>{
println!("stu49: TcpServer");
use std::net::{TcpStream, TcpListener};
use std::time;
use std::io::{Result,self};
use std::thread;
// 监听端口
let listener = TcpListener::bind("127.0.0.1:8080")?;
// 循环读取消息
for stream in listener.incoming(){
println!("创建连接");
// 创建线程处理stream
let stream = stream?;
let handle = thread::spawn(move || stream_handle(stream).expect("处理失败"));
}
fn stream_handle(mut stream:TcpStream) -> io::Result<()>{
loop {
let mut content = [0;512];
let bytes_read = stream.read(&mut content)?; // 读取内容,并获取读取到的大小
if bytes_read == 0 { // 如果读取的内容为0, 说明读取完毕了
println!("断开连接");
return Ok(())
}
let mut text = String::from_utf8_lossy(&content);
println!("读取到内容: {}, 长度为: {}", text, bytes_read);
stream.write(text.as_bytes());
stream.flush();
thread::sleep(time::Duration::from_millis(100)); // 睡眠 0.1秒
}
println!("读取完毕");
Ok(())
}
Ok(())
}
fn stu50() -> io::Result<()> {
println!("stu50: TcpClient");
use std::net::{TcpStream};
use std::time;
use std::io::{Result,self, BufReader};
// 创建连接
let mut stream = TcpStream::connect("192.168.2.34:8080").unwrap();
// 发送10次消息
for i in 0..10{
// 从标准流让用户输入
// let mut msg = String::new();
// io::stdin().read_line(&mut msg);
let mut msg = format!("发送: {}", i).to_string();
// 从当前的流中读取消息(使用 BufReader 提高读取速度)
let mut stream = BufReader::new(&stream);
let mut buffer:Vec<u8> = Vec::new();
stream.read_until(b'\n', &mut buffer).expect("读取失败");
println!("读取的内容: {}", String::from_utf8_lossy(&buffer));
// 发送消息 直接使用 BufReader包裹的stream 写入消息 get_mut() 返回的就是内部的stream
stream.get_mut().write(msg.as_bytes()).unwrap();
stream.get_mut().write("\n".as_bytes());
stream.get_mut().flush();
}
Ok(())
}
fn stu51() -> io::Result<()> {
println!("stu51: UDPServer");
use std::net::UdpSocket;
// 监听端口
let socket = UdpSocket::bind("192.168.2.34:8080")?;
// 循环接收消息
loop {
// 创建缓冲区
let mut buf = [0u8; 512];
// 读取消息, 得到一个读取的大小, 和地址
let (amt, src) = socket.recv_from(&mut buf)?;
// 读取的消息翻转一下
let buf = &mut buf[..amt];
buf.reverse();
// 返回翻转后的消息
socket.send_to(&buf, src)?;
}
Ok(())
}
fn stu52() -> io::Result<()> {
println!("stu52: mio");
// mio是一个异步io库
use mio::net::{TcpStream, TcpListener};
use mio::{Events, Token, Interest, Poll};
// 定义一个 Server
const SERVER:Token = Token(0);
const CLIENT:Token = Token(1);
// 创建一个轮训实例
let mut poll = Poll::new().unwrap();
// 创建事件对象, 最大监听128个事件
let mut events = Events::with_capacity(128);
let addr = "127.0.0.1:8000".parse().unwrap();
// 创建服务端 监听连接
let mut server = TcpListener::bind(addr)?;
// 注册事件 到poll中
poll.registry().register(&mut server,SERVER, Interest::WRITABLE).unwrap();
loop {
// 把事件读到 事件对象中
poll.poll(&mut events, None).unwrap();
// 循环获取事件
for event in events.iter(){
println!("收到连接");
// 匹配事件的 TOKEN 进行分发
match event.token() {
SERVER => {
// 通过事件 的方法 获得事件的 "兴趣"
let is_read = event.is_readable();
let is_write = event.is_writable();
println!("is_read: {}, is_write: {}", is_read, is_write);
// 服务端接收连接
let connect = server.accept();
println!("Server Read");
drop(connect)
}
CLIENT => {
}
_ => {}
}
}
}
Ok(())
}
fn stu53() -> io::Result<()> {
println!("stu53: 序列化/反序列化");
use serde::{Serialize, Deserialize};
#[derive(Debug,Serialize,Deserialize)] // 为结构体显式 的添加相应宏, 使其可以支持序列化以及反序列化操作
struct ServerConfig{
workers:u64,
ignore:bool,
auth_server:Option<String>
}
let config = ServerConfig {
workers: 128,
ignore: true,
auth_server: Some("ServerConfigInstance".to_string()),
};
println!("json格式:");
let serialized = serde_json::to_string(&config).unwrap(); // 序列化操作字符串
let serialized_vec = serde_json::to_vec(&config).unwrap(); // 序列化操作为字节
println!("serialized: {}", serialized);
println!("serialized_vec: {:?}", serialized_vec);
let deserializede = serde_json::from_str::<ServerConfig>(&serialized).unwrap(); // 反序列化需要标识反序列化之后的类型
let deserializede = serde_json::from_slice::<ServerConfig>(&serialized_vec); // 反序列化需要标识反序列化之后的类型
println!("deserializede: {:?}", deserializede);
println!("yaml格式:");
let serialized = serde_yaml::to_string(&config).unwrap(); // 序列化操作
println!("serialized: {}", serialized);
let deserializede:ServerConfig = serde_yaml::from_str(&serialized).unwrap(); // 反序列化需要标识反序列化之后的类型
println!("deserializede: {:?}", deserializede);
Ok(())
}
fn stu54(){
println!("stu54: 异步编程1, async基本使用");
use futures::{executor };
use std::thread::sleep;
println!("通过 block_on 阻塞调用");
// 1. 使用 async 关键字, 修饰让 function 变为一个符合 Future trait 的状态机, 调用时可以使用 block_on 阻塞 调用
// 使用 executor::block_on 提交状态机, block_on会阻塞直到Future执行完成
// await也是阻塞执行, 但是会移交线程控制权, 不会阻塞线程
async fn say1(){
println!("async say 1");
sleep(std::time::Duration::from_secs(2));
}
let f1 = say1(); // 返回一个实现了 futures trait 的状态机
executor::block_on(f1);
fn say2(){ println!("say 2");} // 这里由于上面是阻塞用, 所以这里会在调用完 f1 之后才调用
say2();
// 2. 使用await 调用状态机,会阻塞的运行, 但不会阻塞线程,
// await 会以阻塞方式运行, 并交出线程控制权, join! 宏,会并发异步的调用传入内的状态机, 可以等待多个 future 并发完成;
// 通过 await 这一操作, 我们允许 join 宏中的其他任务并发的执行
// 在调用 f_3_4 的时候,内部使用了 await 发生了短暂阻塞, 但是不会阻塞线程, 所以线程转而调用 f5(f5 会接管当前线程)
println!("使用 await 阻塞调用,并交出线程控制权");
async fn say3(){
// 睡眠 3 秒
sleep(std::time::Duration::from_secs(3)); // 注意使用 sleep 会达不到想要的效果,因为这是标准库thread中的sleep 这里会让线程完全阻塞
println!("async say 3");
}
async fn say4(){
println!("async say 4");
}
async fn say5(){
println!("async say 5");
}
// 使用 await 让 say3 和 say4 依照顺序调用, 必须先调用 3, 再调用 4
async fn say_3_4(){
println!("调用say_3_4");
say3().await; // await 会阻塞的方式调用, 并让出线程 但是这里并没有让出线程 是因为 sleep是标准库的sleep
say4().await;
}
async fn main_async(){
let f_3_4 = say_3_4();
let f5 = say5();
futures::join!(f_3_4,f5); // 使用 join 调用状态机, 并发的执行
}
let async_func = main_async();
executor::block_on(async_func); // 阻塞调用状态机
}
fn stu55() {
println!("stu55: 实现一个简单的 future");
use std::thread;
use std::time::Duration;
// 定义Future trait
trait SimpleFuture{
type Output;
fn poll(&mut self, wake:u64) -> Poll<Self::Output>;
}
// 任务状态
enum Poll<T>{
Ready(T),
Pending
}
// 一个类似 future 的结构
struct MySleeper{
polls:u64,
wake:u64
}
impl MySleeper{
fn new(wake: u64) -> Self{
MySleeper{
polls: 0, // 循环次数
wake // 序号
}
}
}
// 创建一个任务的状态
static mut STATUS:bool = false;
// 实现 future trait
impl SimpleFuture for MySleeper{
type Output = ();
// 执行任务, 返回当前future 状态
fn poll(&mut self, wake:u64) -> Poll<Self::Output>{
unsafe{
if STATUS{ // 模拟任务执行完毕
println!("Ready");
Poll::Ready(())
}else { // 模拟执行任务中
self.wake = wake;
self.polls += 1;
println!("Pending");
Poll::Pending
}
}
}
}
struct MyReactor{
wake:u64,
handle:Option<thread::JoinHandle<()>>
}
impl MyReactor{
fn new() -> Self{
MyReactor{
wake:0,
handle:None
}
}
fn register_wake(&mut self, wake:u64){
self.wake = wake;
}
fn check_status(&mut self){
if self.handle.is_none(){
let _wake = self.wake;
let handle = thread::spawn(||{ // 创建一个线程模拟future执行
loop{ // 模拟 一直检测 future 执行状态
thread::sleep(Duration::from_secs(5)); // 模拟 future 执行5秒后完成了任务
unsafe{ // 完成任务后, 模拟 future 执行完毕调用了其 wake唤醒, 改变 Status
STATUS = true;
}
}
});
self.handle = Some(handle);
};
}
}
struct MyExecutor;
impl MyExecutor{
// 提交任务, 内部 loop 循环检测 future中的任务执行状态
fn block_on<F:SimpleFuture>(mut my_future:F, wake:u64){
loop{
match my_future.poll(wake) {
Poll::Ready(_)=>{
println!("my future is ok");
break // 如果完成了任务, 直接跳出
}
Poll::Pending => { // 如果正在 Pending 中进入下面不安全的循环体
unsafe{
while !STATUS { // 100毫秒检测一下future是否完成任务, 模拟等待reactor的通知, 循环 STATUS 为false, 如果为 true 说明reactor发现到 future 执行完毕,那么跳出循环, 到外部循环执行future的poll方法
thread::sleep(Duration::from_millis(100));
}
}
}
}
}
}
}
// 创建一个 future
let mut sleeper = MySleeper::new(5);
let wake = sleeper.wake;
// 创建一个reactor 执行器
let mut reactor = MyReactor::new();
reactor.register_wake(wake); // 注册
reactor.check_status(); // 开启一个线程进行监听 future执行状态(TODO 注意这里 线程内部内部模拟future执行完毕的操作)
// 使用调度器 执行 future
MyExecutor::block_on(sleeper, wake);
}
fn stu56() {
println!("stu56: async/await");
use futures::{executor };
// async 有三种主要的使用方法：async fn，async块和 async闭包, 使用 async 修饰之后的代码块或函数, 变为一个符合 Future trait 的对象
// async 主体中使用的任何变量都必须能够在线程之间传输，因为任何 await 操作都可能导致切换到新线程
// 使用 RC，&RefCell 或任何其他没实现 Send 特征的类型，包括引用未实现 Sync 特质的类型, 是不安全的
// 在future 需要使用 futures::lock 中的 Mutex 而不是 std::sync::Mutex 中的锁, 来进行数据加锁, 因为使用await是交出线程控制权,使用 std::sync中的锁因为交出了线程控制权所以不会释放锁,其他future在获取锁的时候会导致死锁
// 1. 这个函数为异步调用的函数
async fn say_1() -> u8 {
5
}
let f = say_1();
// 2. 单独修饰代码块变为 Future trait
fn say_2() -> impl Future<Output=u8>{
async {
5
}
}
let f = say_2();
// 3. async 生命周期
async fn f1(value:& u8) -> u8{
*value
}
// 上面的例子 等同于下面代码(详见生命周期省略规则), 但是无法编译的: TODO 这里 rust异步编程书 内有坑, 下面这个例子根本无法编译的
// fn f2<'a>(value: &'a u8) -> impl Future<Output=u8> + 'a {
// async {
// *value
// }
// }
// 调用
// fn bad()-> impl Future<Output = u8>{ // 这种调用方式无法编译通过, 因为 x 变量在本函数结束之时就被drop了, 而future返回到了外部,使用的却是被drop的x的引用,造成了垂悬指针
// let x = 5;
// let f = f1(&x);
// return f;
// }
fn good() -> impl Future<Output = u8> { // 使用 async 代码块 使其内的 f1 和 变量x 在一个 future内, 这样 内部的x 和f1 是在一个上下文中, 内部的future用多久, 外部的x就存活多久
return async {
let x = 5;
return f1(&x).await // 使用await 阻塞的运行future, 交出线程控制权, 运行完毕作为返回值, 所以good的签名为 impl Future<Output = u8>, 因为 f1(&x).await阻塞运行直到得到返回值 u8
}
}
let g = good();
}
fn stu57() {
println!("stu57: 异步操作 使用 move");
// 使用move关键字,强制转移其所有权, 就像在线程中那样, 防止垂悬引用
fn move_block(){
let hello = "hello".to_string();
let f = async move { // 强制移动到了 async 块中(async块内实际上是一个future)
let s_ = &hello;
println!("hello: {}",s_)
};
// println!("after move hello: {}",hello) // value borrowed here after move
}
}
fn stu58() {
println!("stu58: join宏");
// 使用futures中的 join! 宏会让传入的 future 并发的执行
// delay_for 可以让future进行阻塞等待(睡眠), 其本身是个future, 需要await执行
// TODO 注意 join 宏只能在 async 代码块中运行 在外面会出错: only allowed inside `async` functions and blocks
use futures;
use tokio::time::{delay_for, Duration};
use tokio::runtime::Runtime; // 使用 tokio 中的 block_on 的执行器( ps 因为使用了异步库中的 sleep
async fn func1(){
delay_for(Duration::from_secs(3)).await; // 睡眠 3 秒, 移除线程控制权
println!("this is func1");
}
async fn func2(){
println!("this is func2");
}
async fn func_1_2(){
let f1 = func1();
let f2 = func2();
futures::join!(f1, f2);
}
let mut run_time = Runtime::new().expect("执行器创建失败"); // 创建一个执行器
run_time.block_on(func_1_2()) // 按照预期, 先打印 func2, 再打印func1
}
fn stu59() {
println!("stu59: try_join宏");
// 使用try_join, 在执行出错的时候, 会马上返回
// try_join 执行结果也是一个 Result 类型, 在内部所有的 future 执行完毕的时候返回执行结果
// try_join 内的future 需要返回 Result 类型
use std::fs;
use std::io::{Result};
use futures;
use tokio::time::{delay_for, Duration};
use tokio::runtime::Runtime; // 使用 tokio 中的 block_on 的执行器( ps 因为使用了异步库中的 sleep
async fn func1() -> Result<()>{ // 需要返回 Result类型
delay_for(Duration::from_secs(3)).await; // 睡眠 3 秒
println!("this is func1");
// 手动引发一个错误, 并返回上层
let text = fs::read("./xxxxx.txt")?;
Ok(())
}
async fn func2() -> Result<()>{
println!("this is func2");
Ok(())
}
async fn func_1_2(){
let f1 = func1();
let f2 = func2();
let ret = futures::try_join!(f1, f2); // 返回一个 Result 类型
match ret {
Ok(_) => println!("全部执行成功"),
Err(e) => (println!("有些 Future 失败~ {:?}", e)),
}
}
let mut run_time = Runtime::new().unwrap(); // 创建一个执行器
run_time.block_on(func_1_2()) // 按照预期, 先打印 func2, 再打印func1
}
fn stu60() {
println!("stu60: select!宏");
// select! 宏会在提交的future 中,任意分支返回即结束运行
// select! 宏中的future必须实现 Unpin trait 和 FusedFuture trait,
// select! 宏内的 future 需要返回 Fuse(Result) 类型, 使用fuse方法, 且注意需要使用 pin_mut 钉住
// select 内的future 在执行 完成 一次之后, 该future之后无法再次执行(当然其他的分支不影响)
// select 宏内是按照 future 的可变引用获取的, 通过不获取 future 的所有权,所以在调用select后未完成的future可以反复继续使用
// select 完成之后不会再轮训 future, 因此需要实现FusedFuture trait 来跟踪 future是否完成 (对应的Stream流里的future也会要求实现对应FusedStream trait)
// select 本身是不会循环的, 可以通过外部的 loop 循环, 如果 select全部完成, 则会走到 complete 分支
// 用在 select 中的 future 必须实现 Unpin 和 FusedFuture
use futures::{select,future::FutureExt, pin_mut};
use tokio::runtime::Runtime;
use std::io::Result;
async fn func1() -> Result < String > {
tokio::time::delay_for(tokio::time::Duration::from_secs(3)).await; // 睡眠3秒
println!("func1 end");
Ok("f1".to_string())
};
async fn func2() -> Result < String > {
println!("func2 end");
Ok("f2".to_string())
};
async fn async_main() -> Result<()>{
let f1 = func1().fuse(); // 使用 fuse 方法转换
let f2 = func2().fuse();
// 使用 pin_mut 生成了一些代码
pin_mut!(f1, f2);
// 使用select! 宏(其内任意future执行完毕,立即返回)
loop {
select!{
a = f1 => println!("select f1 {:?}", a),
b = f2 => println!("select f2 {:?}", b), // f2 执行完毕立即返回了
complete => {println!("全部执行完毕");break},
}
}
Ok(())
}
let mut run_time = Runtime::new().unwrap();
run_time.block_on(async_main());
}
fn stu61() {
println!("stu61: select!宏中的complete/default");
// 使用 ready 可以创建一个有状态的 future
// select! 宏调度时会可以增加匹配 有complete(期内future都执行完毕,并且不会再次取)和default(都没执行完毕)两个状态
// complete 表示select内future都执行完毕,并且future不会再有相应的后续
// default 表示没有分支完成
use futures;
use futures::{select,executor};
async fn async_main(){
let mut a_fut = futures::future::ready(4i32);
let mut b_fut = futures::future::ready(7i32);
let mut num = 0;
loop {
select!{
a = a_fut => num += a,
b = b_fut => num += b,
complete => {println!("全部执行完毕");break},
default => unreachable!()
};
};
println!("经过了select之后: {}", num);
};
executor::block_on(async_main());
}
fn stu62() {
println!("stu62: future副本");
// 当需要同时运行一个 Future 的多个副本的时候, 可以使用FuturesUnordered类型
}
fn stu63() {
println!("stu63: 返回错误类型");
use std::io::Result;
use futures::executor;
async fn func1(){
// "func1" // 历史问题已经修复: expected `()`, found `&str` 而不是 &'static str 的类型
}
fn func2(){
// "func2" // 和上方错误一样: expected `()`, found `&str`
}
executor::block_on(func1());
// !! 注意在 async 中对错误是可以使用 ? 的
async fn func3() -> Result<()> {
Ok(())
}
async fn func4() -> Result<()> {
let foo = async {
func3().await;
Ok(())
};
foo.await
}
executor::block_on(func4());
}
fn stu64() {
println!("stu64: Send trait");
// 1. 如果一个结构体所有的子类型,都是实现了 Send trait的, 那么其结构体也自动实现 Send trait
// 2. rust中有两个并发概念 std::marker 中的 Sync和 Send trait, 在Rust标准库std::marker模块内部, 就为所有类型默认实现了Send和Sync, 换句话说, 就是为所有类型设定好了默认的线程安全规则
// 3.1 通过Send 允许在线程间转移所有权, 任何有Send类型组成的类型,也会自动标记为Send, struct A {a,b,c}如果a,b,c是Send类型那么A也是Send类型的
// 3.1 Send标记 trait 表明类型的所有权可在线程间传递,几乎所有的 Rust类型都可以Send 但是比如 Rc<T>是不能被 Send的
// 3.2 Sync标记 trait 表明一个实现了 Sync类型可以安全的在多个线程中拥有其值的引用, 允许多线程访问, RefCell<T>和Cell<T>都不是 Sync 的, Mutex 是Sync的
// 4. 手动实现 Send 和 Sync 是不安全的
#[derive(Default)]
struct NoSend(Rc<()>); // 一个没有实现 Send 的结构体
async fn bar(){};
async fn foo(){
// let x = NoSend::default(); // 这行代码是无法编译的, 因为为foo 创建的future的子类型 x 没有实现 Send trait(Rc不是Send trait)
NoSend::default(); // 这个可以编译成功是因为,该值直接被析构忽略了 let _ = NoSend::default()
let _ = NoSend::default(); // 同样也是直接被析构了,因为使用了忽略参数 _
{
let x = NoSend::default(); // 这样也是可以编译成功的, 因为x在作用域结束也被析构了, 为foo实现的 future 没有保存这个x
}
bar().await;
}
fn run(_:impl Send){};
run(foo()) // 可以运行
}
fn stu65(){
println!("stu65: 递归调用 BoxFuture");
// 由于future 递归调用的时候是无法确定其大小的, 可以使用 BoxFuture 一个胖指针包裹
use futures::future::{BoxFuture, FutureExt};
// 注意声明时不需要用 async 声明, 内部返回的 async 块需要使用 boxed方法 转为一个 BoxFuture 返回
fn re() -> BoxFuture<'static, ()>{
async move {
re().await;
}.boxed()
}
}
fn stu_66(){
println!("stu66: self的强制解引用");
// 1. 在未实现Copy trait的struct中使用self
struct S;
impl S{
fn by_ref(&self){}
fn by_mut_ref(&mut self){}
fn by_self(self){}
}
// 拥有所有权 三种方法都可以调用
let mut s = S;
s.by_ref();
s.by_mut_ref();
s.by_self();
// 拥有引用
let mut s = &S;
s.by_ref();
// s.by_mut_ref(); // 这里是无法调用的, 因为签名需要使用的是可变引用
// s.by_self(); // 这里也无法调用, 因为没有实现Copy trait, 所以这里自动解引用获得了所有权,导致外部的变量s成为了野指针
// 拥有可变引用
let mut s = &mut S;
s.by_ref();
s.by_mut_ref();
// s.by_self(); // 这里也无法调用, 因为没有实现Copy trait, 所以这里自动解引用获得了所有权,导致外部的变量s成为了野指针
// 实现了Copy trait的 struct
#[derive(Copy, Clone)]
struct Y;
impl Y{
fn by_ref(&self){}
fn by_mut_ref(&mut self){}
fn by_self(self){}
}
// 拥有所有权
let mut y = Y;
y.by_ref();
y.by_mut_ref();
y.by_self();
// 拥有引用
let mut y = &Y;
y.by_ref();
// y.by_mut_ref(); // 无法使用, 因为这里签名使用的可变借用, 而变量声明时是不可变的
y.by_self(); // 实现了Copy trait的这里解引用之后直接 Copy 一份变量到方法里了
// 拥有可变引用
let mut y = & mut Y;
y.by_ref();
y.by_mut_ref();
y.by_self();
}
fn stu68() {
println!("stu68: Vector 标准库");
// with_capacity(cap) 方法会函数则会分配指定的 cap 大小的内存块, 此时它的长度还是 0, 容器的容量和容器的长度是两个不同的概念
// 通过这种方式分配的内存块是没有初始化的, 它指向的内存块中可能还保存有上一个用户的痕迹比如字节
// as_slice 返回 Vector的 slice
let v = vec![3, 2, 1, 4, 7];
let v = v.as_slice();
let v = &v[..];
let v: &[_] = v;
// borrow/borrow_mut 获得 Vector 的不可变/可变 引用, 此方法的返回值需要手动使用变量注解声明
let mut v = vec![3, 2, 1, 4, 7];
let v_borrow:&[i32] = v.borrow();
let v_borrow_mut:&mut [i32] = v.borrow_mut();
// contains 检测 Vector 中是否有指定的值, 返回 bool
let v = vec![3, 2, 1, 4, 7];
let ret = v.contains(&3);
// capacity 返回 Vector的容量: 无需重新分配即可容纳的容量
let v:Vec<i32> = Vec::with_capacity(4);
let size:usize = v.capacity();
// chunks 返回一切块的迭代器, 对 Vector 进行 切块
let v = vec![3, 2, 1, 4, 7];
let mut chunk_iter = v.chunks(2);
let chunk1:Option<&[i32]> = chunk_iter.next(); // Some([3, 2])
let chunk2:Option<&[i32]> = chunk_iter.next(); // Some([1, 4])
let chunk3:Option<&[i32]> = chunk_iter.next(); // Some([7])
println!("{:?}", chunk3);
// clear 清除所有元素, 内部调用的 truncate 方法截断为0个元素
let mut v = vec![3, 2, 1, 4, 7];
let ret = v.clear();
}
fn stu69() {
println!("stu69: 迭代器 常用消费器");
// 1. size_hint() 主要用于优化，比如为迭代器的元素保留空间, 返回一个元组内有两个元素: 一个元素表示下限(lower bound),第二个元素表示上限(upper bound), 默认返回 (0, None)
// 1.1 next 会同时改变上限和下限
let v = [1, 2, 3];
let mut v = v.iter();
v.next();
v.next();
print(v.size_hint()); // (1, Some(1)) 表示元素还剩1个元素
v.next();
print(v.size_hint()); // (0, Some(0))
// 1.2 一个无限的迭代器没有上限, 以及一个最大的下限
// Range 类型也实现了 iterator trait
print((1..).size_hint());
// 1.3 使用 filter 根据回调,返回回调为True的filter, 也会消耗迭代器本身, 不会消耗上限
let iter = (0..10).filter(|x|x & 2 == 2);
print(format!("使用filter 不会消耗上限: {:?}", iter.size_hint()));
// 2. count 消耗迭代器, 计算迭代次数并返回
let v = [1, 2, 3, 4];
let mut v = v.iter();
println!("count 方法: {:?}", v.count()); // value moved here
// 3. last 消耗迭代器, 并返回最有一个元素(这个方法将对迭代器求值，直到它返回None。在None返回之后，last()将返回它看到的最后一个元素。)
let v = [1, 2, 3];
let mut v = v.iter();
let last = v.last();
println!("使用last 方法获取的最后一个元素为: {:?}",last);
// 4. nth 返回迭代器的第n个元素, 此方法,会消耗之前的元素
let v = [1, 2, 3, 4];
let mut v = v.iter();
let nth_test = v.nth(2); // 得到下标为2个元素
println!("nth 得到了下标为2的元素: {:?}, 迭代器目前状态: {:?}", nth_test, v.size_hint());
// 5. step_by 返回一个新的迭代器,根据步长 依次跳跃, 不管给定的步长是什么，迭代器的第一个元素都将被返回
let v = [1, 2, 3, 1, 123, 23];
let mut v = v.iter().step_by(2);
println!("step_by 根据步长进行返回: {:?}", v.next()); // 1
println!("step_by 根据步长进行返回: {:?}", v.next()); // 3
println!("step_by 根据步长进行返回: {:?}", v.next()); // 123
// 6. chain 链接两个迭代器, 将返回一个新的迭代器，它将首先遍历第一个迭代器的值，然后遍历第二个迭代器的值, 注意 这会转移两个旧迭代器所有权
let v1 = [1, 2, 3].iter();
let v2 = [2, 3, 4].iter();
let i = v1.chain(v2);
println!("chain 链接了两个迭代器状态 新的迭代器为: {:?}", i.size_hint());
// 6.1 由于chain()的参数需要符合IntoIter trait，所以我们可以传递任何可以转换为迭代器的内容，而不仅仅是迭代器本身。例如，slices (&[T])实现了IntoIter，因此可以直接传递给chain()
let v1 = &[1, 2];
let v2 = &[2, 2, 4, 4, 5];
let mut i = v1.iter().chain(v2);
println!("chain 链接 slice &[T] 状态为: {:?}", i.size_hint());
//7. zip, 将两个迭代器压缩到一个迭代器中, 迭代其他两个迭代器，返回一个元组，其中第一个元素来自第一个迭代器，第二个元素来自第二个迭代器, 一个迭代器返回None, zip将短路，返回 None
let v1 = [2, 2, 3, 4];
let v2 = ['a', 'b', 'c', 'd'];
let mut i = v1.iter().zip(v2.iter());
println!("zip 将两个迭代器进行叠加状态为: {:?}, next的值为: {:?}", i.size_hint(), i.next());
// 7.1 同样 zip 也可以使用 slice &[T], 因为 slice &[T] 实现了 IntoIterator
let v1 = &[1, 2];
let v2 = &['a', 'b', 'c', 'd'];
let mut i = v2.iter().zip(v1.iter());
i.next();
i.next();
i.next(); // 短路了, 这里返回的None
println!("zip 使用 slice 进行叠加, 迭代之后的值为: {:?}", i.next());
// 8. for_each消费器 主动执行 迭代器的每个元素调用闭包, 类似for循环, 但是比 for 循环要快
let v = [1, 2, 3];
v.iter().for_each(|x|println!("for_each 会为每个元素调用闭包: {}",x));
// 9. map,惰性执行 接收一个闭包, 对迭代器内的每个元素进行调用, 注意! map 是惰性执行的, 在没有next之前是不会执行的
let mut i = (3..5).map(|x| x * x);
println!("map 会惰性的为迭代器依次调用: {:?}", i.next());
// 10. filter 惰性执行, 过滤(接收一个闭包, 元素传入闭包中,获得返回 True 的元素)
let v = [-1i32, 0, 1, 2, 3, 4];
let mut f = v.iter().filter(|x| x.is_positive()); // 这里判断正数
println!("使用filter 得到 只为正数的 元素, 第一个为: {:?}",f.next());
// 10.1 注意!: iter.filter(f).next() 等价 iter.find(f) 都是寻找第一个满足条件的元素
let v = [1, 2, 3];
println!("iter.filter(f).next() 和 iter.find(f), 查找的结果是一样的: {:?}, {:?}", v.iter().filter(|x| x < &&2).next(), v.iter().find(|x| x < &&2));
// 11.filter_map 惰性执行 创建一个迭代器，先执行filter 再执行map, 它在每个元素上调用这个闭包。如果闭包返回一些(元素)，则返回该元素, 如果闭包返回None则跳过该元素, 尝试下个元素
// filter 有局限性, filter 返回的是bool值, 如果想取值, 需要在 .map 一下, filter_map 类似 filter().map()
let mut v = [1, 2, 3, 4, 5, 6];
let mut i = v.iter().filter_map(|&x| {if x % 2 ==0 {return Some(x)};None});
for c in i{
println!("filtermap 进行联合过滤: {:?}",c)
}
// 12. peekable 创建一个迭代器，它可以使用peek查看迭代器的下一个元素而不消耗迭代器
let mut v = [1, 2, 3, 4, 5].iter().peekable();
println!("peek: {:?}", v.peek());
println!("next: {:?}", v.next()); // 这里依然 是 Some(1)
// 13. skip_while 接收一个闭包, 跳过对闭包返回 true 的元素, 注意!: 闭包在遇到 返回 false 的情况则停止闭包调用, 剩下的元素不再判断
let v = [-1, -2, 4, -7].iter().skip_while(|x| **x < 0);
for i in v{
println!("skip_while 后的结果: {:?}",i) // 4, -7 遇到4之后后面的不再判断了
}
// 14. take 获取指定位置 之前 的元素(不包括指定位置的值), 如果取出的值超过最大元素数量,则只会取到末尾
let v = ['a', 'b', 'c', 'd'];
let i = v.iter().take(3);
for c in i {
println!("使用 take 取之前的值: {:?}", c)
};
// 15. scan 一个类似于fold的迭代器适配器，它保存内部状态并生成一个新的迭代器(接收两个参数, 一个初始的状态初始值, 一个闭包), 迭代器将生成来自闭包的返回值成为一个新的迭代器
let v = [1, 2, 3, 4];
let i = v.iter().scan(1, |status, x| {
*status = *status * x; // 修改状态
Some(*status) // 返回外部
});
for c in i{
println!("scan 为每个元素执行闭包, 并保存相应的状态后: {}", c)
}
// 16. flatten 消除迭代器的中间层
let v = vec![vec![2, 3], vec![9]];
for i in v.iter().flatten(){
println!("flatten: 消除中间层之后: {:?}",i)
}
// 多次调用,可以消除多层
let d3 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
let d2 = d3.iter().flatten().collect::<Vec<_>>();
assert_eq!(d2, [&[1, 2], &[3, 4], &[5, 6], &[7, 8]]);
let d1 = d3.iter().flatten().flatten().collect::<Vec<_>>();
assert_eq!(d1, [&1, &2, &3, &4, &5, &6, &7, &8]);
// 17. flat_map 消除迭代器中间层之前, 为每个元素执行一次map操作, 类似 map(f).flatten()
let v = vec!["abc", "def"];
let i = v.iter().flat_map(|x| x.chars());
for c in i{
println!("{}", c);
}
// 18. by_ref, 使用 by_ref 可以不转移所有权 调用消费器
let mut v = [1, 2, 3, 4].iter();
let sum = v.take(2).fold(0, |status, x| status + x);
println!("一些消费器会转移其所有权,有时候我们不希望被转移所有权: {}", sum);
// println!("这里无法调用, 所有权已经被转移了:{:?}", v.next());
let mut v = [1, 2, 3, 4].iter();
let v_ref = v.by_ref();
let v_ref= &mut v;
let sum = v_ref.take(2).fold(0, |status, x| status + x);
println!("使用sum 下面依然可以调用: {}", sum);
println!("依然可以调用: {:?}",v.next());
// // 接上面的take 的使用这里有一点疑问, 为啥我这里实现的示例 &mut T 调用使用 self 的方法, 会转移 T的所有权(& mut iter.take(self n) 不会转移iter的所有权, & mut String.into(self) 会转移String的所有权) 两个method 同样使用了self 为何一个转移一个没有转移
// 对疑问的释疑: 上面的take 是 &mut iter 其本身的 take, 而不是 iter 的take
// &T 和& mut T 也是和T一样属于独立的类型, 查看源码得知, impl<I: Iterator + ?Sized> Iterator for &mut I {} 这里 所有实现Iterator的 T他的 &mut T也实现了Iterator
// 19. collect 将迭代器转为集合
let v = ['a', 'b'].iter().collect::<String>();
println!("使用 collect 直接收集为字符串: {}", v);
// 20. partition 根据闭包的规则划分两个新的 迭代器, 一个是闭包返回 true 一个是闭包返回 false 的
let v = [1, 2, 3, 4, 5];
let (even, odd):(Vec<i32>,Vec<i32>) = v.iter().partition(|x| **x % 2 == 0);
println!("使用 partition 分离之后 偶数为: {:?}", even);
println!("使用 partition 分离之后 奇数为: {:?}", odd);
// 21. fold_first 与 fold 相同, 只不过使用 迭代器的第一个元素为初始值, 这是一个 unstable library
let mut i = [1, 2, 3, 4].iter();
// let sum = i.fold_first(|status, x| status + x);
// 22. all 根据闭包调用,如果每个元素调用后都返回 true 那么 all 也就是 true
// 23. any 根据闭包调用,如果其内有一个元素返回了 true 那么 any 也就是 true
// 24. find 根据闭包调用, 返回第一个结果 为 true 的元素
// 25. position 根据闭包调用, 返回第一个结果为 true 的下标
// 26. rposition 从右边开始找, 返回从左到右的下标
// 27. rev 翻转迭代器,调用 next() 的时候是从后往前, 内部实现的 Rev struct 实际上也是调用的 next_back
// 28. sum 对迭代器求和
// 29. eq 判断两个迭代器 其内的元素 是否完全相等
assert_eq!([2,5].iter().eq([2,5].iter()), true); // index 对应的元素也必须相等
// 30. ne 判断两个迭代器内的元素是否不相等
// 31. lt 判断第一个迭代器内的 元素相加 小于 第二个迭代器
assert_eq!([1,3].iter().lt([1,6,3].iter()), true); // 1+3 是小于 1+6+3的
// 32. le 小于等于
// 33. gt: 大于; ge: 大于等于
}
fn stu67() {
println!("stu67: 高阶生命周期");
// 下面的,我运行正常, 暂时没有发现 where for 的应用场景
// 定义一个结构体, 该结构体有一个方法返回本数据的某引用
struct Closure<F>
// where F: Fn(&(i32, i64)) -> &i32
{
data:(i32,i64),
func:F
}
impl<F> Closure<F>
where F: Fn(&(i32, i64)) -> &i32
{
fn call(&self) -> &i32{
(self.func)(&self.data)
}
}
fn func(data:&(i32, i64)) -> &i32{ &data.0};
// 创建一个实例
let clo = Closure { data: (10, 20), func };
println!("{:?}", clo.call());
}
fn stu_80() {
println!("stu_81: Pin 探索");
// Pin 探索: https://www.mdzz.wiki/index.php/archives/571.html
// 创建一个自引用变量
#[derive(Debug)]
struct Test {
a: String,
b: *const String,
}
impl Test {
fn new(txt: &str) -> Self {
Test {
a: String::from(txt),
b: std::ptr::null(),
}
}
fn init(&mut self) {
let self_ref: *const String = &self.a;
self.b = self_ref;
}
fn a(&self) -> &str {
&self.a
}
fn b(&self) -> &String {
unsafe {&*(self.b)}
}
}
let mut test1 = Test::new("test1");
test1.init();
let mut test2 = Test::new("test2");
test2.init();
println!("a: {}, b: {}", test1.a(), test1.b());
// 使用swap()函数交换两者，这里发生了move
std::mem::swap(&mut test1, &mut test2);
test1.a = "I've totally changed now!".to_string();
println!("a: {}, b: {}", test2.a(), test2.b());
// 出问题了! 问题出在哪? 原因是Test结构体中的字段b是一个指向字段a的指针, 它在栈上存的是字段a的地址
// 通过swap()函数交换两个Test结构体之后, 字段a,b分别移动到对方的内存区域上, 但是a和b本身的内容没有变
// 也就是指针b依然指向的是原来的地址, 但是这个地址现在已经属于另外一个结构体了!
// 我们可以通过增加 PhantomPinned 这个实现了 !Unpin 的struct 来让类型 !Upin
// Pin到堆上 这里使用Box::pin()把Test钉在了堆上, 取消注释任意一行都会编译不通过, 因为Test是!Unpin的。
use std::pin::Pin;
use std::marker::PhantomPinned;
#[derive(Debug)]
struct Test1 {
a: String,
b: *const String,
_marker: PhantomPinned,
}
impl Test1 {
fn new(txt: &str) -> Pin<Box<Self>> {
let t = Test1 {
a: String::from(txt),
b: std::ptr::null(), // b这里是一个空指针
_marker: PhantomPinned,
};
let mut boxed = Box::pin(t);
let self_ptr: *const String = &boxed.as_ref().a; // 获得 Pin 内部的 String 的指针 下面赋值给 空指针 b
unsafe { boxed.as_mut().get_unchecked_mut().b = self_ptr };
boxed
}
fn a<'a>(self: Pin<&'a Self>) -> &'a str {
&self.get_ref().a
}
fn b<'a>(self: Pin<&'a Self>) -> &'a String {
unsafe { &*(self.b) }
}
}
let mut test1 = Test1::new("test1");
let mut test2 = Test1::new("test2");
println!("a: {}, b: {}",test1.as_ref().a(), test1.as_ref().b());
// std::mem::swap(test1.get_mut(), test2.get_mut());
// std::mem::swap(&mut *test1, &mut *test2);
println!("a: {}, b: {}",test2.as_ref().a(), test2.as_ref().b());
}
fn stu_81() {
println!("stu_81: generator");
// 目前版本使用 generator 需要在文件第一行加入 #![feature(generators, generator_trait)] 开启才可以使用
// 使用 resume方法会让程序的执行流程跳回到生成器中执行代码, 并且在遇到yield关键字时跳出生成器, 返回给调用者
// 生成器属于一种半协程(Semi-Coroutine), 半协程是一种特殊的且能力较弱的协程, 它只能在生成器和调用者之间进行跳转, 而不能在生成器之间进行跳转
// 1. 引入该 trait, 该trait定义了 生成器的行为
use std::ops::{Generator, GeneratorState};
use std::pin::Pin;
let mut generator = || {
yield 1;
return "foo"
};
match Pin::new(&mut generator).resume(()) {
GeneratorState::Yielded(1) => {}
_ => panic!("unexpected return from resume"),
}
match Pin::new(&mut generator).resume(()) {
GeneratorState::Complete("foo") => {}
_ => panic!("unexpected return from resume"),
}
// 2. 将生成器用作迭代器, 如果只关注计算的过程, 而不关心计算的结果, 可以将Return设置为(),
// 只保留Yield的类型也就是Generator<Yield=T, Return=()>那么生成器就可以化身为迭代器
// 由于生成器是延迟计算或惰性计算, 所以往往比迭代器性能更高
fn up_to1() -> impl Generator<Yield=u64, Return=()>{
|| {
for i in 0..100{
yield i;
}
return ();
}
}
let mut gen = up_to1();
loop {
match Pin::new(&mut gen).resume(()) {
GeneratorState::Yielded(i) => println!("执行中: {}", i),
_ => {
println!("完毕");
break
}
}
}
// 用生成器模拟Future
// 不关心过程, 只关注结果, 则可以将 Yield 设置为单元类型，只保留 Return 的类型
// Generator<Yield=(), Return=Result<T, E>>, 生成器就可以化身为Future
fn up_to2(num:u64) -> impl Generator<Yield=(), Return=Result<u64, ()>>{
move || {
let mut c = 0;
for i in 0..num{
c += i;
yield ();
}
return Ok(c);
}
}
let mut gen = up_to2(100);
loop {
match Pin::new(&mut gen).resume(()) {
GeneratorState::Complete(i) => {
println!("执行完毕: {:?}", i);
break;
}
_ => {// 忽略执行中
}
}
}
}
#[tokio::main]
async fn stu_82() {
println!("stu_82: tokio Implementing Future");
// #[tokio::main] 是一个宏，宏下面的 async 函数，是作为宏的 Future 输入。tokio::main 做的主要工作是 builder 一个 runtime ， 然后启动 block_on 函数，把 Future 包装进入 Block_on
// 比如: #[tokio::main]
// async fn main() {
// println!("hello");
// }
// 会被转化为: fn main() {
// let mut rt = tokio::runtime::Runtime::new().unwrap();
// rt.block_on(async {
// println!("hello");
// })
// }
// 参考资料 https://tokio.rs/tokio/tutorial/async
// Future的所有者负责通过轮询Future来推进计算, 这可以通过调用Future::poll来实现
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};
// 1. 实现一个 Future struct 等到特定的时间, 输出一些字符串, 并结束轮训
struct Delay {
when: Instant,
}
impl Future for Delay {
type Output = &'static str;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<&'static str>{
// Future 会一直循环轮训该状态机
println!("轮训中---");
if Instant::now() >= self.when {
println!("Hello world");
Poll::Ready("done")
} else {
cx.waker().wake_by_ref();
Poll::Pending
}
}
}
let when = Instant::now() + Duration::from_millis(10*99999);
let future = Delay { when }; // 实例化了一个 future
let out = future.await; // 并调用了await
assert_eq!(out, "done");
// 2. 上面的 Future 编译器会生成大概 如下的实现(一个未来可能状态的枚举, 未来从 state0 开始)
// 如果 future 没有完成, 那么会收到 Poll:pending表名该future将在稍后的时间完成, 调用者应稍后再次调用 poll
// 我们可以对任何实现Future的值调用.await, 用一个异步函数会返回一个实现Future的匿名类型
enum MainFuture {
// Initialized, never polled
State0,
// Waiting on `Delay`, i.e. the `future.await` line.
State1(Delay),
// The future has completed.
Terminated,
}
impl Future for MainFuture {
type Output = ();
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>)
-> Poll<()>
{
use MainFuture::*;
// 循环内部查询执行结果 并状态转移
loop {
match *self {
State0 => {
// 实例化一个 future
let when = Instant::now() + Duration::from_millis(10);
let future = Delay { when };
// 状态转移
*self = State1(future);
}
State1(ref mut my_future) => {
// 通过 Pin 钉住执行 实例化的 future
match Pin::new(my_future).poll(cx) {
Poll::Ready(out) => {
assert_eq!(out, "done");
*self = Terminated;
return Poll::Ready(());
}
Poll::Pending => {
return Poll::Pending;
}
}
}
Terminated => {
panic!("future polled after completion")
}
}
}
}
}
}
fn stu_83() {
println!("stu_82: xxx");
}
fn stu_84() {
println!("stu_82: pyo3");
use pyo3::{types::{PyBytes, PyDict}, prelude::*};
use std::thread;
use std::time::{Duration, Instant};
let start = Instant::now();
for i in 0..10 {
thread::spawn(move || {
let gil = pyo3::Python::acquire_gil();
let py = gil.python();
let mut locals = PyDict::new(py);
py.run(
r#"
import time
time.sleep(2) # 注意该sleep不会阻止 GIL 去执行其他线程中的代码
"#,
None,
Some(locals),
).unwrap();
// 注释下面的一句, 就会变成 并行执行
std::thread::sleep(std::time::Duration::from_secs(1)); // 这里会完全阻塞子线程,导致 GIL 无法去执行其他线程中的代码, 导致串行
println!("{:?}", i);
});
};
println!("{:?}", start.elapsed());
thread::sleep(std::time::Duration::from_secs(100));
}
fn stu_85() {
use pyo3::{types::{PyBytes, PyDict}, prelude::*};
use std::thread;
use std::time::{Duration, Instant};
let start = Instant::now();
for i in 0..10 {
thread::spawn(move || {
let gil = pyo3::Python::acquire_gil();
let py = gil.python();
let mut locals = PyDict::new(py);
py.run(
r#"
c = 0
while True:
c+=1
"#,
None,
Some(locals),
).unwrap();
println!("{:?}", i);
});
};
// for i in 0..10 {
// thread::spawn(move || {
// let gil = pyo3::Python::acquire_gil();
// let py = gil.python();
// let mut locals = PyDict::new(py);
// py.run(
// r#"
// while True:
// pass
// "#,
// None,
// Some(locals),
// ).unwrap();
// // 注释下面的一句, 就会变成 并行执行
// std::thread::sleep(std::time::Duration::from_secs(1)); // 这里会完全阻塞子线程,导致 GIL 无法去执行其他线程中的代码, 导致串行
// println!("{:?}", i);
//
// });
//
// };
println!("{:?}", start.elapsed());
thread::sleep(std::time::Duration::from_secs(100));
}
fn stu_86() {
// let mut a = 123;
// if a = 0 {
//
// }
// u32 和 u32 无法进行算术运算
// let c = a - b;
// println!("c: {:?}", c);
let d = -123i32 as u32;
println!("d: {:?}", d);
}
fn main() {
// 1. 变量
// stu1()
// 2. 数据类型
// stu2();
// 3. 函数
// stu3();
// 4. 控制流
// stu4();
// 5. 所有权
// stu5();
// 6. 引用
// stu6()
// 7. slices
// stu7();
// 8. 结构体
// stu8()
// 9. 枚举类型
// stu9()
// 10. vector 类型
// stu10()
// 11. String 类型
// stu11()
// 12. HashMap
// stu12()
// 13. 模块
// stu13();
// 14. 异常
// stu14()
// 15. 泛型
// stu15()
// 16. trait
// stu16()
// 17. 生命周期
// stu17();
// 18. 闭包
// stu18();
// 19. 迭代器
// stu19();
// 20. Box智能指针
// stu20();
// 21. Rc智能指针
// stu21();
// 22. RefCell智能指针
// stu22();
// 23. 循环引用/弱引用
// stu23();
// stu24();
// let a = "123";
// let a_Box = Box::new(a);
// let a_Rc = Rc::new(a);
// assert_eq!(*a_Box, *a_Rc)
// 24. 多线程
// stu25();
// Refcell<T>/RC<T> 和 Mutex<T>/Arc<T> 的区别
// 1. Mutex 提供内部的可变性, 类似于 RefCell
// 2. RefCell 和 Rc 是非线程安全的, Mutex, Arc 是线程安全的
// 25. 对象
// stu26();
// 26. trait 对象
// stu27();
// 27. 模式匹配
// stu28();
// 28. 不安全的 Rust
// stu29();
// 29. 不安全的 static 可变静态变量
// stu30();
// 30. 不安全的 trait
// stu31();
// 31. 关联类型
// stu32();
// 32. 默认泛型类型参数和运算符重载
// stu33();
// 33. 完全限定语法
// stu34();
// 34. 父 trait
// stu35();
// 35. 孤立规则
// stu36();
// 36. never type
// rust中有一个叫做 ! 的特殊类型, 没有值 的类型, 在函数不返回的时候用来当做返回值, 且可以转为其他任意类型
//
// fn f1() -> ! {loop{}};
// let never_type = f1();
//
// let a = Some(1);
// let num:i32 = match a{
// Some(v) => 0,
// // None => '1' // `match` arms have incompatible types
// None => panic!()
// };
// 37. 动态大小类型
// stu37();
// 38. 高阶函数和闭包
// stu38();
// 39. 宏
// stu39()
// 40. From Into
// stu40();
// fn func2(lis: &Vec<i32>){
//
// let ret1 = &lis[..];
// let ret3 = &(lis[..]);
//
//
// let v1 = vec![1, 2, 3];
// let v2 = &vec![1, 2, 3];
// }
//
// struct A{num:i32};
// fn f(r:&mut i32){};
//
// let mut a = A { num: 123 };
// let mut mr1 = &mut a;
// let mut mr2 = &mut mr1;
//
// let num = mr2.num; // 这里自动解引用了
// f(& mut mr2.num);
// fn func(args:&& i32){
// let t = args;
// let t = *args;
// }
// let s1 = "hello";
// let s2 = "hello".to_string();
// let s = s1;
// println!("{}", s);
// let s = s2;
// println!("{}", s);
// let a = [1, 2, 3];
// let l = a.len();
// let b = &a;
// println!("{:p}",b);
// 预分配内存, 避免因为扩充重新分配
// let mut s = "123".to_string();
// s.reserve(10);
// //
// println!("{:?}",s.len());
// // ## 编译时函数执行
// const fn get_num()->usize{ 5 };
// let arr = [0; get_num()];
//
// // ## for循环与迭代器(for 循环是一个语法糖, 会调用 for 循环对象的 into_iter方法)
// let li = [1, 2, 3, 4];
// for i in &li {}; // for循环需要借用内的元素
// for i in li.iter() {};
//
// // range 类型
// let a = 0..100;
// &str 指针和长度
// let s = "hello";
// println!("as_ptr: {:?}, p: {:p}", s.as_ptr(), s);
//
// Box
// let a = *Box::new(30);
// // ## 在x持有某个对象的所有权的情况下,对x赋值,那么x原来持有的对象就会drop, 因为这个"位置" 已经被占用了, 所以需要对旧值drop
// // 如果作为函数的返回值, 没有对应的接收者, 那么返回值会立即析构 let _ = function()
// // 解释2: 就是当x持有某个对象所有权, 如果 x 绑定到了另外一个变量, 那么原来的变量就发生了移动会被加上 drop-flag 标签,在运行时会调用析构函数, 加上 drop-flag的变量意味着生命周期的结束
// #[derive(Debug)]
// struct Student{name:String};
// impl Drop for Student{
// fn drop(&mut self){
// println!("清理了: {}", self.name)
// }
// }
//
// let mut x = Student { name: "x1".to_string() };
// let mut y = x; // 这里 x 已经变为一个空的变量了, x所有权转移到了y
//
// println!("1");
// x = Student { name: "x2".to_string() }; // 对空变量重新赋值
// x = Student { name: "x3".to_string() }; // 再次赋值挤走了 x2, 此时x2执行析构函数
// x = Student { name: "x4".to_string() }; // 再次赋值挤走了 x3, 此时x3执行析构函数
// println!("2");
// y = x; // 对 y 重新赋值, y本身保存的是x1, 这时x4 把 x1 挤走, x1被drop了
//
// println!("3");
// x = Student { name: "x5".to_string() }; // 上面 x本身的变量的所有权被移走了, 这里对空变量x 重新赋值
// println!("4");
// y = x; // x里现在是x5, 挤走了y中的x4, y中 x4被析构 替换为了x5, x为空,
//
// println!("5");
// x = Student { name: "x6".to_string() };
// println!("6");
// y = x;
// println!("7");
// // TODO 神奇 接着上方, 下面有一个疑点, 为啥打印: x2 被那么快析构
// // 1
// // 清理了: x2
// // 2
// // 清理了: x3
// // 3
// // 清理了: x1
// let mut x = &mut Student { name: "x1".to_string() }; // let 将临时变量的生存期延长到当前作用域结束
// println!("1");
// x = &mut Student { name: "x2".to_string() }; // temp的生存期只到语句末尾
// println!("2");
// x = &mut Student { name: "x3".to_string() };
// println!("3");
// 接着上方, 为啥第二行解开注释 就报错, 提示使用了一个临时变量
// let mut a = &mut "123".to_string();
// // a = &mut "2233".to_string();
// println!("{}", a);
// 野喵理论: https://doc.rust-lang.org/stable/reference/destructors.html?highlight=temp#temporary-lifetime-extension
// let mut x = &S { name: S!("tmp1") }; let 语句, 这句会触发rust语言里的临时生存期延长功能, 产生一个直到当前块作用域结束的生存期, 记录在x 的类型里: x: &'<special lifetime> S 这个是let里才有的
// 然后第二句 x = &S{ name: S!("tmp2")}; 这句没啥特别的，如果不是nll，这句应该报错, 但是反正你也没用，S 构建出来了，然后又析构了
// * let绑定一个temp的引用，会将temp的生存期拓展到作用域结束（一般temp的生存期只到语句末尾）
// * 强行将temp的引用赋值给x，x就用不了了，因为temp在赋值语句结束就drop了 这也就是上面的这个例子解开第二行注释就出错的原因
// 实例
// let mut x = &mut 0; // let语句中表达式的临时范围有时会 扩展到包含该let语句的块的范围, 如果借位，解除引用，字段或元组索引表达式具有扩展的临时范围，其操作的临时变量 也将扩展包含该let语句的块的范围
// println!("x 可以打印: {}", x);
// x = &mut 1; // 临时变量立即释放
// // println!("x 禁止打印: {}", x); 禁止使用 Error: creates a temporary which is freed while still in use
// ## 如果复合结构本身实现了Drop,则会 先调用它自己的析构函数 后调用其成员的析构函数；否则,如果本身没有析构函数会调用其成员的析构函数
// struct Stu1{name:String};
// impl Drop for Stu1{
// fn drop(&mut self){
// println!("清理了: Stu1")
// }
// }
// struct Stu_meta{s:Stu1}
// impl Drop for Stu_meta{
// fn drop(&mut self){
// println!("清理了: Stu_meta")
// }
// }
// let s_meta = Stu_meta {s: Stu1{name:"Stu1".to_string()}};
// {
// s_meta;
// }
// println!("s_meta END");
// 一个安全地实现 Drop 的类型，它的泛型参数生命周期必须严格地长于它本身(Rust死灵书, Drop检查一节)
struct Inspector<'a>(&'a u8);
impl<'a> Drop for Inspector<'a> {
fn drop(&mut self) {
println!("再过{}天我就退休了！", self.0);
}
}
// let (inspector, days); // 同时声明变量, 不可知谁被先销毁 如果days碰巧先被销毁了, 那么当销毁Inspector的时候，它会读取被释放的内存
// days = Box::new(1);
// inspector = Inspector(&days);
// // ## 较高性能 for循环
// for i in vec![(); 100] {}; // 这种更快: 使用单元类型 创建一个长度为 100 的向量
// // for i in 0..100 {}; // 这种循环还需要给 i 创建 i32 类型的值
// vec![(); 100].iter().for_each(|x|{
//
// });
//
//
// _ 是个 pattern 表示跳过,let 不绑定位置, 因为没有绑定位置, 所以所有权没有转移
// let a = "123".to_string();
// let _ = a;
// println!("{}", a); // 显然所有权 没有转移
// // ## 对象安全
// trait Stu{ // 定义 trait 对象
// fn stu(&self);
// }
// struct S1;
// impl Stu for S1{
// fn stu(&self){
// println!("trait object call")
// }
// }
// // fn utils(f:& impl Stu){ // 这里已经被包装成 trait 对象了, 这里是静态分发的
// fn utils(f:& dyn Stu){ // 这里已经被包装成 trait 对象了
// // assert_eq!(f, S1);
// f.stu(); // 在运行期 先去查虚表, 这里调用的是 trait Object 中虚指针保存的一些信息, 而不是下方传入的 S1的方法
// }
// utils(&S1); // 传入参数包装成 trait 对象
// // ## 对象不安全 this trait cannot be made into an object because method `stu` has generic type parameters
// // 这里 trait 中的函数中使用了泛型,在运行时使用了泛型无法确定调用哪个方法
// // trait Stu{ // 定义 trait 对象
// // fn stu<T>(&self, a:T);
// // }
// // struct S1;
// // impl Stu for S1{ // 这是在编译的时候 在这句代码中创建了 一个 trait object? 那创建的这个 trait object 保存在哪了?
// // fn stu<T>(&self, a:T){
// // println!("trait object call")
// // }
// // }
// // fn utils(f:& dyn Stu){
// // // assert_eq!(f, S1);
// // f.stu(1); // 在运行期 先去查虚表, 这里调用的是 trait Object 中虚指针保存的一些信息, 而不是下方传入的 S1的方法
// // }
// // ## trait 专属方法, 使用 impl dyn trait {} 定义
// trait Say{
// fn say(&self){println!("say")}
// }
// impl dyn Say { // 定义 Say 的 trait 专有方法
// fn say_hello(){println!("say_hello")}
// }
// struct P;
// impl Say for P{};
// P.say();
// // P.say_hello() // 无法调用, 因为 say_hello 是 Say trait 的方法,
// Say::say_hello(); // 需要使用 trait::method() 的方式调用
//
// let dyn_p = &P as &dyn Say;
// // dyn_p.say_hello() // 显然 trait object 无法调用
// ## trait 静态分发: 使用 impl
struct Pig;
struct Duck;
trait Fly{
fn fly(&self)->bool;
}
impl Fly for Pig{
fn fly(&self)->bool{false}
}
impl Fly for Duck{
fn fly(&self)->bool{true}
}
fn utils_fly(s:impl Fly){ // 在编译阶段静态分发
s.fly();
}
let p1 = Pig;
utils_fly(p1);
let d1 = Duck;
utils_fly(d1);
//
//
// 静态分发 泛型版本通过 trait bound
fn utils_fly_t<T:Fly>(s:T){s.fly();}
//
//
// // ## trait 动态分发 使用 dyn, 这里传入到函数内的 s 就是一个 trait对象 胖指针了,
// fn utils_fly_dyn(s:&dyn Fly){
// s.fly();
// }
// // ## String类型实现 Deref 返回的是 &str, 如果一个类型 T实现了Deref＜Target=U＞,则该类型T的引用（或智能指针）在应用的时候会被自动转换为类型U
// // String 类型是一串 u8的 vector:
// // pub struct String {
// // vec: Vec<u8>,
// // }
// // String类型实现的add方法的右值参数必须是&str类型, &s2这里自动是&String类型,会被自动隐式转换为&str
// let s1 = "hello".to_string();
// let ss1 = &(*s1);
// let ss1: &str = &s1; // String 解引用后为 str, 那接收 &str的地方, 也必然可以接受&String, 这里 可以通过签名发现, 编译通过 右值明明是 &String 但是可以被 &str绑定位置
// let ss1:&String = &s1;
// let s2 = "world".to_string();
// let s3 = s1 + &s2;
// // let s3 = s1 + &&&*&&*&&&&s2.deref();
// let s4 = s3.deref();
//
//
// // ## self Self的区别, self代表调用者, Self代表调用者的类型, 这里 Clone::clone 要求返回的需要和 调用者相同类型
// // 因为 p 是一个 trait object, 我们只知道,它是一个“胖指针”,包括了指向具体对象的指针以及指向虚函数表的指针;p指向的具体对象,它的类型是什么,我们已经不知道了,我们知道的仅仅是,这个类型实现了 Clone trait,其它的就一无所知了;而这个 clone() 方法又要求返回一个与 p 指向的具体类型一致的返回类型;对编译器来说,这是无法完成的任务
// // pub trait Clone {
// // fn clone(&self) -> Self;
// // fn clone_from(&mut self, source: &Self) { ... }
// // let p: &Clone = ...;
// // let o = p.clone();
// // // ## Rust中内存对齐: u8占1个字节, u32占4个字节, u16占2个字节; 结构体 Mem_test_1 在对其之后 是 8 个字节
// struct Mem_test_1{c:u32, b:u16, a:u8}
// println!("Mem_test_1 的内存大小为: {:?}",std::mem::size_of::<Mem_test_1>()); // 8
// let mem_instance = Mem_test_1 { a: 1, b: 2, c: 3 };
// println!("mem_instance 的内存大小为: {:?}",std::mem::size_of_val(&mem_instance)); // 8
// // 联合体以最长成员为对齐数, 联合体中的所有成员都共享一段内存
// union Mem_union{c:u32, b:u16, a:u8}
// println!("union 的内存大小为: {:?}",std::mem::size_of::<Mem_union>());
//
//
//
//
// // ## Rust内存中重新初始化: 所有权转移之后 对变量重新赋值, 会对其初始化
// let mut x = Box::new(123);
// let y = x;
// x = Box::new(2233);
// println!("{:?}", x);
// // ## 关联类型约束, (在使用trait 约束泛型的时候, 使用trait内的 关联类型 进行再次约束)
// trait MyTrait{
// type Flag;
// }
//
// fn my_utils<T>(f:T) -> ()
// where T: MyTrait<Flag=i32> // 对于实现了 Mytrait 特征的参数, 其内的 Flag 关联类型 也必须为 i32 类型
// {}
//
// struct MyStruct1;
// struct MyStruct2;
//
//
// impl MyTrait for MyStruct1{ type Flag = i32;};
// impl MyTrait for MyStruct2{ type Flag = f32;};
//
// my_utils(MyStruct1);
// // my_utils(MyStruct2); // Error: expected `i32`, found `f32`
// // ## 函数指针( 函数指针需要显式指定函数指针类型fn)
// fn function()->(){};
// let f1 = function; // rust自动推导的无法打印地址说明这不是一个函数指针
// // println!("非函数指针: {:p}", f1); // Error: the trait `std::fmt::Pointer` is not implemented for `fn() {main::function}`
// let f2: fn()->() = function; // 显式的写出类型签名
// println!("函数指针: {:p}",f2);
// // ## Rust中变量的析构顺序是和其声明顺序相反的, 元组内部是按元素的出现顺序依次进行析构的, 结构体内部元素的析构顺序是按排列顺序来析构的
// // Option 中的map方法, 直接取值, 接收一个闭包对于匹配的变量直接操作并根据业务返回
// let s1 = Some(2);
// let num = s1.map(|x| x * x);
// // Rust中分层的错误处理体系
// // 在Rust中 Panic只能被任务的所有者捕获, 而捕获后需要立即对他进行处理, 否则任务自己会立即停止
// // catch_unwind 捕捉恐慌(代码传入一个闭包中运行), 可以再不启动一个线程的情况下捕获Panic
// use std::panic;
// let a = 1;
// let b = 0;
// let ret = panic::catch_unwind(|| a / b);
// match ret {
// Ok(x)=>(),
// Err(_)=> println!("catch_unwind捕捉恐慌: {:?}", ret)
// };
// // Rust中 Any
// // ## TypeId是一个结构体，其字段t存储了一串数字，这就是全局唯一类型标识符
// // TypeId of函数来获取类型T的全局唯一标识符t(可以判断具体类型)
// // &dyn Any 可以使用 downcast_ref 可以进行类型转换, 转换any为特定类型 内部源码是Some(&*(self as *const dyn Any as *const T))
// use std::any::{Any, TypeId};
// let a = "hello".to_string();
// println!("对比String的type_id: {:?}, {:?}", a.type_id(), TypeId::of::<String>());
//
// // Any trait 对象 使用(把引用类型的变量转为一个 trait Object, 可以通过 is 判断类型)
// let b = &a as & dyn Any;
// println!("通过any 的is函数判断类型: {}", b.is::<String>());
//
// let c = b.downcast_ref::<String>(); // 再转回来, 转换成 Any 是为了有机会获取到他的类型信息,转换回来,则是为了去使用这个值本身
// println!("c: {:?}", c);
//
// // ## 类型当做参数传入fn中,(这里泛型 T 仅仅代表的是一个类型, 而没有具体的值, 需要 method::<type> 传入具体 type)
// trait Get{
// fn check_type<T:Any>(&self) -> bool
// where Self:Any
// {
// // 获取类型的名字
// println!("获取类型的名字: {:?}", std::any::type_name::<Option<T>>(), );
//
// // 校验类型
// TypeId::of::<T>() == self.type_id()
// }
// }
// impl <T:Any> Get for T{}; // 这里的 T:Any 表示 对 后面的 T 进行约束, 表示满足 Get trait 的前置条件是 T实现了Any trait,
// let s = "hello".to_string();
//
// s.check_type::<String>();
//
// // 获取类型的名字
// println!("获取类型的名字: {:?}", std::any::type_name::<Option<String>>(), );
// 41. 网络监听
// stu41();
// 42. 多线程处理 WebServer
// stu42();
// 43. 线程池处理 WebServer
// stu43();
// 44. 文件读取
// stu44();
// 45. Option 方法
// stu45();
// 46. Queue 实现简单队列
// stu46();
// 47. Stack 实现简单栈解构
// stu47();
// 48. 链表实现一个栈
// stu48();
// 49. TcpServer
// stu49();
// 50. TcpClient
// stu50();
// 51. UDPServer
// stu51();
// 52. mio
// stu52();
// 53. 序列化/反序列化
// stu53();
// 54. 异步编程1, 基本使用
// stu54();
// 55. 异步编程2, 实现一个简单的 future
// stu55();
// 56. 异步编程3, async/await
// stu56();
// 57. 异步编程4, move
// stu57();
// 58. 异步编程5, join! 宏
// stu58();
// 59. 异步编程6, try_join 宏
// stu59();
// 60. 异步编程7, select! 宏
// stu60();
// 61. 异步编程8, select! 宏中的complete/default
// stu61();
// 62. 异步编程9, future 副本
// stu62();
// 63. 异步编程10, 返回错误类型
// stu63();
// 64. Send trait
// stu64();
// 65. 异步编程12, 递归调用 BoxFuture
// stu65();
// 66. 关于self相关(自动解引用)
// stu_66();
// 67. 高阶生命周期
// stu67();
//
// 68. reborrow
// // 不可变引用类型的变量是实现了Copy trait 的, 当对一个引用变量赋值给其他变量, 那会Copy 一份到新的变量上 他们共用一个生命周期
// // reborrow相关操作,会存在两个可变引用,并不是真的存在两个可变引用, 而是中间发生了所有权转移, 和所有权回归
// // 可变引用类型是move 的, 写上注解会让 borrow 变为reborrow
// let mut s = "hello".to_string();
// let s1 = &mut s;
// // let s2 = &mut s; // 有问题! 下面还在使用s1, 这里发生了borrow mut, 违反借用规则(同时存在两个可变借用,生命周期发生交叉)
//
// let s2 = &mut *s1; // 没问题! 这里 *s1 是一个临时变量 忽略借用规则, 这句可以看成这样 &mut(*s1) 其中 *s1是一个temp
// // let s2:&mut String = s1; // 没问题! s1 move 到 s2, 使用变量注解
//
// s2; // s2 生命周期到此结束, 被drop 所有权返回s1, 两段可变生命周期并没有发生交叉, 如果这两句打印调换一下位置, 则会编译错误,因为违反借用规则
// s1; // s1 生命周期到此, 无问题
//
// // 关于temp
// let mut s = "hello".to_string();
// let s1 = & mut s;
// let _ = *s1; // 忽略借用规则, 解引用并没有让 s 的所有权转移, 注意这里 _ 和 temp 是不同的
// &(*s1); // temp 解引用并没有让 s 的所有权转移
// // let a = *s1; // 禁止 使用具名变量
// println!("{}", s);
// // 69. 泛型再次研究
// // 1.
// // T、&T和&mut T都是无限集, 因为可以无限次地借用一个类型;
// // T是&T和&mut T的超集;
// // &T和&mut T是不相交的集合
// trait Trait1 {}
// impl<T> Trait1 for T {}
// // impl<T> Trait1 for &T {} // compile error 冲突了, 因为 上面 T 已经包含了 &T
// // impl<T> Trait1 for &mut T {} // compile error 冲突了, 因为 上面 T 已经包含了 &mut T
//
// trait Trait2 {}
// impl<T> Trait2 for &T {} // 没问题 因为是不相交的集合
// impl<T> Trait2 for &mut T {} // 没问题
//
// // 2.
// // &'static T和T: 'static是不同的
// // T: 'static; 应该读作"T被'static lifetime约束"
// // T: 'static 可以拥有任意的lifetime, 如果T: 'static，那么T: 'a，因为任意'a均满足'static >= 'a
// // T: 'a包括了所有&'a T，但反过来是不成立的。
// // T: 'a比&'a T更通用和灵活; T: 'a接受独立类型，含有引用的独立类型，以及引用; &'a T只接受引用
//
// let a = 123;
// let b = &a;
// println!("{:?}", a);
// // static 生命周期的思考 1
// use rand::Rng;
// fn test_static() -> &'static str{
// let mut rng =rand::thread_rng();
//
// let n2:u64 = rng.gen();
//
// let s1 = format!("{}", n2);
// let s2: &'static str = s.as_str(); // 显然 无法编译, 虽然标注的 'static 但是借入 生命周期不足, s1 的生命周期明显只到当前作用域结束, 而要求s1的借用 变为 'static 这是不行的(短的无法变成长的)
// return s2;
// }
// // static 生命周期的思考 2
// // 通过static 限制, 限制入参必须 为 &'static 生命周期
// // 当然 对于泛型 T 也可以认为 是 &'static
// fn call<T:'static>(f:T) -> T {
// f
// }
// let i = 123;
// let ref_i = &123;
// // 调用得知 i 和 &i 都是符合 'static的
// call(i);
// call(ref_i);
// 70, impl 与 trait bound, 对于泛型来说, impl 只是一个稍微短的语法, 但是有一个区别, 就是下面的操作 s.check_type_::<String>(); impl是无法完成的 因为无法展开
// use std::any::{TypeId};
// trait Get_{
// fn check_type_<T:Any>(&self) -> bool
// where Self:Any
// {
// TypeId::of::<T>() == self.type_id()
// }
// }
// impl <T:Any> Get_ for T{};
// let s = "hello".to_string();
// s.check_type_::<String>();
// 71. Vector 标准库
// stu68();
// 72. iter常用消费器
// stu69();
// 80. Pin 探索
// stu_80();
// Rust中的 generator
// stu_81();
// // 关于内存的理解
// let mut s1 = "hello".to_string(); // s1 初始化了里面有个值
// let mut s2 = s1; // s1 的值移到了 s2, s1 内的值被移走了
// drop(s2); // s2 的值被移走了
// s1 = "hi".to_string(); // 再次被初始化了
// s2 = "hi".to_string(); // 再次被初始化了
//
// // 实现可 Copy 的类型 只能通过 scope 进行销毁, 满足Copy特质的，位置里面的值无法被移走，换句话说，不存在存储位置存在但是里面的值已经死亡的情况
// let i = 123;
// drop(i); // 无法drop
// {
// i; // 对于 实现了 Copy trait的类型, 子作用域显然无法 销毁上级作用域的变量
// }
// i; // 依然使用
//
// // 实现了 析构行为的 类型, 无法 实现 Copy
// // #[derive(Copy, Clone)] // 无法实现 Copy trait
// struct Students{
// age:i32
// }
// impl Drop for Students{
// fn drop(&mut self){
// println!("被释放了: {}",&self.age)
// }
// }
// // 计算程序运行时间
// let t = std::time::Instant::now();
// for i in 0..100 * 100 * 100 {};
// println!("{:?}", t.elapsed());
// // 注意 rust 中的类型的方法, 方法内部不允许内部转移类型本身元素发生 move,因为本身的元素发生了move, 那么这个类型就变成"残缺" 的了, 本身可以使用 clone
// struct S{
// next:String,
// current:String
// }
// impl S{
// fn update(&mut self, value:String){
// // self.current = self.next; // 这里是禁止的
// self.current = self.next.clone();
// self.next = value;
// }
// }
//// 72. result 相关方法
// // 72.1 map error: 改变 Err, 接收一个闭包 如果变量为err, 则err的值使用闭包调用的结果, 就是将 Result<T, E> 变为 Result<T, F>
// let f = |x: i32|->String{ format!("出错了: {}", x)};
// let o:Result<i32,i32> = Ok(123);
// let o_ret: Result<i32, String> = o.map_err(f);
// println!("o_ret: {:?}", o_ret);
//
// let e:Result<i32,i32> = Err(2233);
// let e_ret: Result<i32, String> = e.map_err(f);
// println!("e_ret: {:?}", e_ret);
//
// // 72.2 and 对两个Result 进行组合, 如果x是ok 那么就返回y, 如果x不ok 那么就返回x本身的Err, 参考 与操作 短路运算
// let x: Result<i32, i32> = Ok(0);
// let y: Result<i32, i32> = Err(1);
// println!("x.and(y): {:?}", x.and(y)); // Err(1) 这里x是ok的,这里返回了y的值
//
// let x: Result<i32, i32> = Err(0);
// let y: Result<i32, i32> = Ok(1);
// println!("x.and(y): {:?}", x.and(y)); // Err(0) // 这里x是Err的 返回x本身的Err
//
// let x: Result<i32, i32> = Err(0);
// let y: Result<i32, i32> = Err(1);
// println!("x.and(y): {:?}", x.and(y)); // Err(0) // 这里x是Err的 返回x本身的Err
//
// let x: Result<i32, i32> = Ok(0);
// let y: Result<i32, i32> = Ok(1);
// println!("x.and(y): {:?}", x.and(y)); // Ok(1) // 这里x是ok 的, 这里返回了y的值
//
// // 72.3 and_then, 基于结果值的回调, x.and_then(|x| {...}), 如果x是ok的, 那么x结果进入一个闭包可以再次处理, 如果不ok 那么返回x的Err
//
// // 72.4 unwrap_or, 提供了一个默认值default，当值Err时返回default
// let x: Result<i32, _> = Err(2233);
// println!("x.unwrap_or: {}", x.unwrap_or(7788));
//
// // 72.5 Err的kind 返回简单的错误信息
// fn test_fn() -> Result<(),Error>{
// use std::fs;
// let f = fs::read("./xxxxx.txt");
// match f {
// Ok(_) => {}
// Err(e) => println!("出现错误: {:?}", e.kind())
// };
// Ok(())
// }
// println!("{:?}", test_fn());
// // 73. 生命周期缺陷
// #[derive(Debug)]
// struct Foo;
// impl Foo{
// fn mutate(&mut self)->&Self{&*self} // 发生了 reborrow生命被拉长 到外部
// fn share(&self){}
// }
//
// let mut foo = Foo;
// let loan = foo.mutate(); // mutable borrow occurs here
// foo.share();
// // let x = loan; // error: mutable borrow later used here, 这里无法编译, 明明 loan 是不可变引用,但是这里却变成了可变引用, 还是用的mutate方法中的 &mut self的生命周期
//
// 74. 表达式的返回值: 在rust中, 表达式的返回值是 unit () 单元类型
// let f = ||{ let a=123; };
// println!("通过打印可以得出表达式的返回值是 unit类型: {:?}", f());
// 75. break语句和continue语句可以再多重循环中选择跳出到那一层循环, 在 log while for 循环前加上生命周期标识符, 即可实现阉割版 "goto" 功能
// let mut c = 0;
// 'a: for i in 0..10 {
// 'b: for d in 0..10{
// c += 1;
// println!("{}", d);
// if c < 5 {
// continue 'a;
// } else {
// break 'b;
// };
// }
// }
// 76. 内联参数 使用 inline 属性, 编译器会酌情考虑编译为内联函数
#[inline]
fn test_inline() {
// #[inline] - 建议编译器内联这个函数
// #[inline(always)] - 要求编译器必须内联这个函数
// #[inline(never)] - 要求编译器不要内联这个函数
}
// // 77. 强制类型转换
// // 如果两个结构体, 字段完全相同, 在safe的rust里是没有办法进行类型转换的
// #[derive(Debug)]
// struct Foo{
// a:i32
// }
// #[derive(Debug)]
// struct Bar{
// a:i32
// }
//
// let f1 = Foo { a: 1 };
// let mut b1 = Bar { a: 1 };
// // b1 = f1; // 这是禁止编译的 expected struct `main::Bar`, found struct `main::Foo`
//
// // 尝试使用 unsafe 进行强制类型转换
// let b2 :&Foo;
// unsafe {
// b2 = &*(&b1 as *const Bar as *const Foo); // 先把 引用数据b1转为 Bar类型的指针 再转为 Foo类型的指针, 如果这是后解引用, 由于转换后的类型的指针和 b1 指针指向的同一个位置的数据, 那么会获取b1的所有权, 所以应该reborrow, &* 让新的变量其位于指针之后
// }
// println!("{:?}", b2); // Bar类型的 b1 转为了 Foo 类型
//
// b1.a = 2; // 修改了b1
// println!("{:?}", b2); // 同样影响了b2, 由此可见强制类型转换后的新类型的的指针, 数据实际指向的是b1,
//
// // 77.1 强制转换 struct 为二进制数据 ! TODO 注意 &[T] 是slice的抽象内存表现 表示一块连续的内存里面存放的都是 T 类型数据
// struct MyText{
// data: String
// }
//
// let mt = MyText { data: "123123hello".to_string() };
// unsafe {
// // &mt as *const MyText 指 指向MyText 类型数据的指针 后面as *const &[u8] 把 指向MyText 类型数据的指针强制转换为 指向slice的指针
// let a = (&mt as *const MyText as *const &[u8]);
// println!("{:?}", a);
// }
//
//
// // 78. transmute 和 transmute_copy
// // mem::transmute<T, U> 接受一个 T 类型的值，然后将它重新解析为类型 U。唯一的限制是 T 和 U 必须有同样的大小
// // mem::transmute_copy<T, U> 很神奇地上面这更加不安全。它从 &T 拷贝 size_of<U> 个字节并将它们解析为 U。mem::transmute 仅有的类型大小的检查都不见了（因为拷贝类型前缀有可能是合法的），只不过 U 的尺寸比 T 大会被视为一个未定义行为
// let b2 = Bar { a: 2233 };
// unsafe {
// let f2 = std::mem::transmute::<&Bar, &Foo>(&b2);
// println!("通过transmute创建的f2: {:?}", f2);
//
// // 下面不知道为何 无法运行
// // let f2_u8 = *(std::mem::transmute_copy::<&Foo, *const &[u8]>(&f2));
// // println!("通过transmute 转换的二进制数据: {:?}", f2_u8);
// }
// 79 变量初始化
// 在rust中, 么有初始化的变量是禁止读取的
// let x1: i32;
// if true {
// x1 = 123;
// };
// // println!("x1: {}", x1); // use of possibly-uninitialized `x1` 禁止使用, 因为编译器不知道判断条件是否成立 而对x1 进行初始化操作
let x2: i32;
loop {
if true{
x2 = 3344;
break
}
}
// println!("x1: {}", x2); // 这里可以读取是因为, 编译器知道loop循环中只有一个break, 且和break同一个作用域中, 有对x2 进行赋值的操作, 所以这里编译器知道只要代码运行到这一行, 那是肯定已经对x2 进行赋值的
// 79.1 如果一个位置已经初始化了, 再次赋值, 那么会位置中的数据drop, 然后再覆盖, 请查看 5108行和rust内存模型 https://www.mdzz.wiki/index.php/archives/519.html
// Rust高级编程中有一段话: Rc 和 UnsafeCell 是典型的非线程安全的：它们允许非同步地共享可变状态。可是，裸指针严格来说并不一定非得是非线程安全不可。通过裸指针做任何有意义的事情都需要先对它解引用，这一步就已经是非安全的了。从这个角度来说，有人可能会认为把它标为线程安全的也未尝不可
// 我这里想验证一下裸指针的原子性, 但是却编译失败, 不知道是不是思路错了, 线程中禁止传递 *const i32
// let mut x = 0;
// let s_ref = &mut x;
// fn get_ptr(value:&i32) -> *const i32{
// return value as *const i32;
// }
//
// unsafe {
// let x_ptr = &x as *const i32;
// // let a_x_ptr = Arc::new(Mutex::new(x_ptr));
// for i in 0..2{
// // let ac = Arc::clone(&a_x_ptr);
// std::thread::spawn(|| {
// // get_ptr()
// // for c in 0..100_0000 {
// // *x_ptr += 1;
// // *x_ptr -= 1;
// // }
// });
// }
// }
// 打印彩色文本到终端 https://rust-guide.budshome.com/6-cli/6.2-ansi-terminal/6.2.1-ansi-term-basic.html#%E6%89%93%E5%8D%B0%E5%BD%A9%E8%89%B2%E6%96%87%E6%9C%AC%E5%88%B0%E7%BB%88%E7%AB%AF
// use ansi_term::Colour;
// println!("This is {} in color, {} in color and {} in color",
// Colour::Red.paint("red"),
// Colour::Blue.paint("blue"),
// Colour::Green.paint("green"));
// hashmap 和 struct 性能测试(结果 struct 更快)
use std::time::{Duration, Instant};
use serde::{Serialize, Deserialize};
#[derive(Serialize,Deserialize)]
struct dt {
dma3:(i32, String, f64),
dma4:(i32, String, f64)
}
use rand::Rng;
let mut rng = rand::thread_rng();
let start = Instant::now();
for i in 0..1 {
let _1:i32 = rng.gen();
let _2_s:String = format!("{:?}",_1);
let _3:f64 = rng.gen();
let _4_s:String = format!("{:?}",_3);
// let mut d = HashMap::new();
// d.insert("dma3", (_1, _2_s, _3));
// d.insert("dma4", (_1, _4_s, _3));
let d = dt {
dma3:(_1, _2_s, _3),
dma4:(_1, _4_s, _3)
};
let s = serde_json::to_string(&d);
// println!("{:?}",s);
}
let duration = start.elapsed();
// println!("Time elapsed in expensive_function() is: {:?}", duration);
// 共享内存探究
// use std::fs::OpenOptions;
// use std::path::PathBuf;
//
// use memmap::MmapMut;
// // let path: PathBuf = "/Users/zhangy233/my_mmap".into().unwarp();
// let file = OpenOptions::new()
// .read(true)
// .write(true)
// .create(true)
// .open("/Users/zhangy233/my_mmap").unwrap();
//
// file.set_len(128).unwrap();
//
// let mut mmap = unsafe { MmapMut::map_mut(&file).unwrap() };
//
// let c = &mut *mmap;
//
// (&mut c[0..2]).write(b"rtpy").unwrap();
// let c = (&mut mmap[..]);
//
// (&mut mmap[..]).write_all(b"Hello, world!")?;
// // rust中的move(等曾操作的还是指针)
// // move 性能测试
// #[derive(Clone)]
// struct TestMove{
// n1:u64,
// n2:u64,
// n3:u64,
// n4:u64,
// n5:u64,
// n6:u64,
// n7:u64,
// n8:u64,
// n:String
// }
//
//
// let mut rng =rand::thread_rng();
//
// let start = Instant::now();
// // let mut v = Vec::new();
// for i in 0..100000000 {
// let n:u64 = rng.gen();
//
// // let m = TestMove{
// // n1: n+1,
// // n2: n+2,
// // n3: n+3,
// // n4: n+4,
// // n5: n+5,
// // n6: n+6,
// // n7: n+7,
// // n8: n+8,
// // n:format!("{}", n)
// // };
// // 什么都不做, 稳定使用 10.5s 左右
// //
//
// // 使用Box 25s 在创建box的时候会有一次内存拷贝
// let m1 = Box::new(TestMove{
// n1: n+1,
// n2: n+2,
// n3: n+3,
// n4: n+4,
// n5: n+5,
// n6: n+6,
// n7: n+7,
// n8: n+8,
// n:format!("{}", n)
// });
//
// let m2 = m1;
// let m3 = m2;
// let m4 = m3;
//
// // 3次 move, 2次 加法, 稳定使用使用13s
// // let mut m1 = m;
// // m1.n1 += i;
// // let mut m2 = m1;
// // m2.n2 += i;
// // let m3 = m2;
//
// // 1次 clone, 使用 26s
// // let m1 = m.clone();
//
//
// };
// let duration = start.elapsed();
// println!("Time elapsed in expensive_function() is: {:?}", duration);
//
// // -----------------
// // 函数宏
// macro_rules! my_print {
// () => {
// println!("no info")
// };
// ($info1:expr) => {
// println!("say info 1: {}", $info1)
// };
// ($info1:expr, $info2:expr) => {
// println!("say info 1: {}, info 2: {}", $info1, $info2)
// };
// }
// my_print!();
// my_print!("哈哈哈");
// my_print!("哈哈哈", "乌拉拉");
// my_print!("123".to_string() + "223");
//
// // 重复的宏: $ ( ... ) sep rep ( ... ) 为要重复匹配的模式, sep 为可选的分隔符，常见的有 , 和 ; rep 为必选的重复标记，目前 Rust 支持三种重复标记：*（零次或多次）、+（一次或多次）、?（零次或一次）
// macro_rules! my_vec {
// ($($i:expr,)*) => {
// $(
// eprintln!("($($i:expr,)*) 必须有逗号结尾 {}", $i);
// )*
// };
//
// ($($i:expr),*) => {
// $(
// eprintln!("($($i:expr),*) 0次次多次逗号结尾 {}", $i);
// )*
// };
// }
// my_vec!(1,2,3,4);
// my_vec!(7,8,9,0,);
//
//
// // derive 派生宏(有些不足之处, 建议直接使用属性宏, 属性宏是派生宏的扩展版本, 派生宏需要属性宏的支持)
// use hello_macro_derive::MyMacro; // 这里导入的是宏
// use hello_macro::MyMacro; // 这里导入的是trait
//
// #[derive(MyMacro, Debug)]
// struct Student {
// name:String
// }
//
// // error: conflicting implementation for `main::Student` 可见已经在派生宏中实现了
// // impl MyMacro for Student {
// // fn hello_macro(&mut self){
// // self.name = "123".to_string();
// // }
// // }
//
// let mut s1 = Student{name:"小明".to_string()};
// s1.hello_macro();
//
// dbg!(s1);
// 实现一个 Future struct
// stu_82();
// 使用一个异步 fn 实现为 Future
// stu_83();
// pyo3 使用
// stu_84();
// stu_85();
// stu_86();
}
|´・ω・)ノ
师傅，收徒弟吗？( ๑´•ω•) "(ㆆᴗㆆ)୧(๑•̀⌄•́๑)૭
不错 当日记来翻翻，到此一游！୧(๑•̀⌄•́๑)૭
感谢分享！