rust 高级话题

rust高级话题

前言

每一种语言都有它比较隐秘的点。rust也不例外。

动态大小类型DST

无法静态确定大小或对齐的类型。

1. 特征对象trait objects:dyn Mytrait
2. 切片slices:[T]、str

特征包含vtable,通过vtable访问成员。切片是数组或Vec的一个视图。

正确的安装方法

rust是一个快速变化的语言和编译系统，建议用最新版，否则可能出现兼容性问题而无法通过编译。

rustup 管理工具链的版本，分别有三个通道：nightly、beta、stable。如上所述，建议同时安装nightly版本，保持最新状态。

wget -O- https://sh.rustup.rs |sh  #下载安装脚本并执行

安装之后，就可以用rustup命令来控制整个工具链的更新了。

rustup toolchain add nightly #安装每夜版本的工具链
rustup component add rust-src #安装源代码
cargo +nightly install racer #用每夜版本的工具链安装racer，一个代码补全的工具。因为当前只支持每夜版本
rustup component add rls # 这是面向编辑器的一个辅助服务
rustup component add rust-analysis #分析工具

#vscode : 搜索插件rls安装即可

结构体

struct 结构体是一种记录类型。成员称为域field，有类型和名称。也可以没有名称，称为元组结构tuple strcut。 只有一个域的特殊情况称为新类型newtype。一个域也没有称为类单元结构unit-like struct。

类别	域名称	域个数
一般结构	有	>1
元组结构	无	-
新类型	-	1
类单元结构	-	0

枚举和结构是不同的，枚举是一个集合（类似c语言种的联合union，变量的枚举成员可选，而不是全体成员），而结构是一个记录（成员必定存在）。

作为一个描述力比较强的语法对象，结构很多时候都在模拟成基础类型，但是更多时候是具备和基础类型不同的特征，而需要由用户来定制它的行为。

基础数据类型，引用类¹（引用&T，字符串引用&str，切片引用&[T]，特征对象&T:strait，原生指针*T），元组(T²)，数组[T ²;size]，函数指针fn()默认都是copy；而结构、枚举和大部分标准库定义的类型（智能指针，String等）默认是move。

注意：

1. 引用只是复制指针本身，且没有数据的所有权；因为可变引用唯一，在同一作用域中无法复制，此时是移动语义的，但可以通过函数参数复制传递,此时等于在此位置重新创建该可变引用。
2. 元素必须为可复制的

#[derive(Copy,Clone,Debug)] //模拟基础数据类型的自动复制行为,Debug 特征是为了打印输出
struct A;

let a = A;
let b = a;//自动copy 而不是move
println!("{:?}", a);//ok

rust的基本类型分类可以如此安排：

1. 有所有权
   1. 默认实现copy
      1. 基本数据类型
      2. 元素实现copy的复合类型
         1. 数组
         2. 元组
   2. 没有默认实现copy，都是move
      1. 结构
         1. 标准库中的大部分智能指针（基于结构来实现）
         2. 标准库中的数据结构
         3. String
      2. 枚举
2. 无所有权
   1. 引用
      1. &str
      2. &[T]
   2. 指针

特征对象

特征是一个动态大小类型，它的对象大小根据实现它的实体类型而定。这一点和别的语言中的接口有着本质的不同。rust定义的对象，必须在定义的时候即获知大小，否则编译错误。

但是，泛型定义除外，因为泛型的实际定义是延迟到使用该泛型时，即给出具体类型的时候。

或者，可以用间接的方式，如引用特征对象。

trait s{}
fn foo(a:impl s)->impl s{a} //这里impl s相等于泛型T:s,属于泛型技术，根据具体类型单态化

引用、生命周期、所有权

rust的核心创新：

• 引用（借用）：borrowing
• 所有权：ownership
• 生命周期：lifetimes

必须整体的理解他们之间的关系。

借用（引用）是一种怎样的状态？

例子：

• let mut 旧 = 对象;
• let 新 = &旧 或 &mut 旧;

操作	旧读	旧写	新读	新写	新副本
copy	✔	✔	✔	✔	✔
move	✘	✘	✔	✔	✘
&	✔	✔1	✔	✘	✘
&mut	✔	✔1	✔	✔	✘

注1:旧写后引用立即无效。

从上表格可以看出，引用（借用）并不只是产生一个读写指针，它同时跟踪了引用的原始变从量是否有修改，如果修改，引用就无效。这有点类似迭代器，引用是对象的一个视图。

一般性原则：可以存在多个只读引用，或者存在唯一可写引用，且零个只读引用。（共享不可变，可变不共享）

特殊补充（便利性规则）：
可以将可写引用转换为只读引用。该可写引用只要不写入或传递，rust会认为只是只读引用间的共享，否则，其他引用自动失效（rust编译器在不停的进化，其主要方向是注重实质多于形式上，提供更大的便利性）。

let mut a = 1;
let mut rma = &mut a;
let mut ra = &a;//error
let ra = rma as &i32; //ok
println!("*ra={}", ra);//ok
println!("*rma={}", rma);//ok

*rma = 2; //ra 失效
println!("*ra={}", ra);//error
println!("*rma={}", rma);//ok
a = 3; //ra、rma 都失效
println!("*ra={}", ra);//error
println!("*rma={}", rma);//error

用途在哪里？

let p1 = rma; //error
let p2 = ra; //ok

即：需要产生多个引用，但不是传递函数参数的场合。如转换到基类或特征接口（如for循环要转换到迭代器）。

let v=[1,2,3];
let p1=&mut v;
let p2=p1 as &[i32];

// 注释掉其中一组代码
// 1
for item in p1{}
println!("{}",p1);//error

// 2
for item in p2{}
println!("{}",p2);//ok

引用无法移动指向的数据：

let  a = String::from("hi");
let pa = &a;
let b = *pa; //error

生命周期

1. 所有权生命周期 > 引用

引用并不管理对象生命周期，因为它没有对象的所有权。引用需要判定的是引用的有效性，即对象生命周期长于引用本身即可。

当需要管理生命周期时，不应该使用引用，而应该用智能指针。

一般而言，我们不喜欢引用，因为引用引入了更多概念，所以我们希望智能指针这种东西来自动化管理所有资源。但不可否认，很多算法直接使用更底层的引用能提高效率。个人认为：结构组织需要智能指针，算法内部可以使用引用。

错误处理

为了处理异常情况，rust通过Result定义了基础的处理框架。

fn f1()->Result<(),Error>{
    File::open("file")?; //?自动返回错误
    OK(()) //正常情况
}

//main()函数怎么处理？
fn main()->Result<(),Error>{}

pub trait Termination{ //返回类型须支持该特征
    fn report(self) -> i32;
}
impl Termination for (){
    fn report(self) ->i32{
        ExitCode::SUCCESS.report()
    }
}
impl Termination for Result<(),E>{
    fn report(self)->i32{
        match self{
            Ok(())=>().report(),
            Err(err)=>{
                eprintln!("Error:{:?}",err);
                ExitCode::FAILURE.report()
            }
        }
    }
}

交叉编译

rustup target add wasm-wasi #编译目标为wasm（网页汇编）
cargo build --target=wasm-wasi

智能指针

解引用：

1. 当调用成员函数时，编译器会自动调用解引用，这样&T => &U => &K自动转换类型，直到找到该成员函数。

// *p=>*(p.deref())
// =>*(&Self)
// =>Self
pub trait Deref {
type Target: ?Sized;
fn deref(&self) -> &Self::Target;
}

// *p=>*(p.deref_mut())
// =>*(&mut Self)
// =>mut Self
pub trait DerefMut: Deref {
fn deref_mut(&mut self) -> &mut Self::Target;
}

常用智能指针（管理堆内存上的数据）：

拥有所有权：

1. Box =>T 堆上变量，对应普通栈上变量
2. Vec =>[T] 序列
3. String == Vec =>[u8] 满足utf8编码

共享所有权（模拟引用）：

1. Rc =>T 共享，智能化的&，采用引用计数技术
   1. Rc::clone() 产生镜像，并增加计数
   2. Rc> 模拟&mut,内部元素可写
2. Arc 多线程共享

无所有权：

1. Weak 弱引用

特殊用途：

1. Cell 内部可写
2. RefCell 内部可写
3. Cow Clone-on-Write
4. Pin 防止自引用结构移动

产生循环引用的条件（如：Rc>)：

1. 使用引用计数指针
2. 内部可变性

设计递归型数据结构例子：

//递归型数据结构，需要使用引用
//引用是间接结构，否则该递归数据结构有无限大小
//其次，引用需要明确初始化，引用递归自身导致无法初始化
//因此，需要Option来定义没引用的情况
//Node(Node) ：无限大小
//=> Node(Box) ：不能初始化
//=> Node(Option>) ：ok

struct Node{
    next: Option>,
    data:T,
}

有些数据结构，一个节点有多个被引用的关系，比如双向链表，这时只能用Option>>这套方案，但存在循环引用的风险，程序员需要建立一套不产生循环引用的程序逻辑，如正向强引用，反向弱引用。

编译器会对自引用（自己的成员引用自己，或另一个成员）的情况进行检查，因为违反了移动语义。

闭包

pub trait FnOnce {
type Output;
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

pub trait FnMut : FnOnce {
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}

pub trait Fn : FnMut {
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

动态分派和静态分派

静态分派：泛型

动态反派：特征对象（指针）

特殊类型

// 只读转可写引用：
#[lang = "unsafe_cell"]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct UnsafeCell {
value: T,
}

// 假类型（占位类型）
#[lang = "phantom_data"]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct PhantomData;

// 内存分配器
#[derive(Copy, Clone, Default, Debug)]
pub struct Heap;

成员方法

struct A;

impl A{
    fn f1(self){}
    fn f2(this:Self){}

    fn f3()->Self{A}
}

trait X{fn fx(self);}
impl X for A{fn fx(self){}}

//Self 表示实现的具体类型，本例为A
//self = self:Self
//&self = self:&Self
//&mut self = self:&mut Self
let a = A;
a.f1(); //ok 可以用.调用成员方法
a.f2(); //error 不可以，因为第一个参数名字不是self，虽然是Self类型
A::f2(a); //ok

let a=A::f3(); //无参数构造函数的形式，名字随意

impl i32{} //error ，i32不是当前项目开发的，不能添加默认特征的实现，但可以指定一个特征来扩展i32
impl X for i32{} //ok

规则： 特征和实现类型，必须有一个是在当前项目，也就是说不能对外部类型已经实现的特征进行实现。也就是说，库开发者应该提供完整的实现。

规则： 用小数点.调用成员函数时，编译器会自动转换类型为self的类型（只要可能）。

但是要注意，&self -> self是不允许的，因为引用不能移动指向的数据。可以实现对应&T的相同接口来解决这个问题。

let a = &A;
a.fx(); //error 相当于调用fx(*a)
impl X for &A{
    fn fx(self){} //这里的self = self:&A
}
a.fx(); //ok

容器、迭代器、生成器

容器	说明
Vec	序列
VecDeque	双向队列
LinkedList	双向链表
HashMap	哈希表
BTreeMap	B树表
HashSet	哈希集
BTreeSet	B树集
BinaryHeap	二叉堆

trait Iterator {
type Item;
fn next(&mut self) -> Option;
...
}

//for 循环实际使用的迭代器
trait IntoIterator {
type Item;
type IntoIter: Iterator;
fn into_iter(self) -> Self::IntoIter;
}

容器生成三种迭代器：

1. ·iter() 创造一个Item是&T类型的迭代器;
2. ·iter_mut() 创造一个Item是&mut T类型的迭代器;
3. ·into_iter() 根据调用的类型来创造对应的元素类型的迭代器。
   1. T => R 容器为T，返回元素为R，即move
   2. &T => &R
   3. &mut T=> &mut R

适配器（运算完毕返回迭代器）：

生成器(实验性）：

let mut g=||{loop{yield 1;}};
let mut f = ||{ match Pin::new(&mut g).resume(){
    GeneratorState::Yielded(v)=>println!("{}", v),
    GeneratorState::Complete(_)=>{},
};
f(); //print 1
f(); //print 1

类型转换

pub trait AsRef {
fn as_ref(&self) -> &T;
}

pub trait AsMut {
fn as_mut(&mut self) -> &mut T;
}

//要求hash不变
pub trait Borrow {
fn borrow(&self) -> &Borrowed;
}

pub trait From {
fn from(T) -> Self;
}

//标准库已经有默认实现，即调用T::from
pub trait Into {
fn into(self) -> T;
}

//克隆后转换
pub trait ToOwned {
    type Owned: Borrow;
    fn to_owned(&self) -> Self::Owned;

    fn clone_into(&self, target: &mut Self::Owned) { ... }
}

//克隆写入
pub enum Cow<'a, B>
where
B: 'a + ToOwned + ?Sized,
{
Borrowed(&'a B),
Owned(::Owned),
}

pub trait ToString {
fn to_string(&self) -> String;
}

pub trait FromStr {
type Err;
fn from_str(s: &str) -> Result;
}

运算符重载

trait Add {
type Output;
fn add(self, rhs: RHS) -> Self::Output;
}

I/O 操作

平台相关字符串：

• OsString
  • PathBuf
• OsStr
  • Path

文件读写：

• File
• Read
  • BufReader
• Write

标准输入输出：

• Stdin
  • std::io::stdin()
• Stdout
  • std::io::stdout()
• std::env::args()
• std::process::exit()

反射

std::any

多任务编程

启动新线程框架代码：

use std::thread;

let child = thread::spawn(move ||{});

child.join(); //等待子线程结束

数据竞争三个条件：

1. 数据共享
2. 数据修改
3. 没有同步（ rust 编译器保证同步）

数据同步框架：

• Sync 访问安全
  1. rust引用机制保证了数据访问基本是安全的
  2. 内部可变的类型除外（用了不安全代码）
  3. 被lock()的内部可变类型也是安全的
• Send 移动安全
  1. 没有引用成员的类型；
  2. 泛型元素T是Send的；
  3. 或被lock()包装的。

多线程下的数据总结：

1. T ：移动（或复制），因而无法共享（也就是只能给一个线程使用）
2. &T
   1. 指向局部变量，生命周期报错
   2. 指向static T,ok
3. &mut T
   1. 同理
   2. 指向static mut T, 不安全报错
4. Box：普通智能指针没有共享功能，等价T
5. Rc：普通共享指针没有Send特征，技术实现使用了内部可变，但没有加线程锁进行安全处理
6. Arc 提供了线程安全的共享指针
7. Mutex提供了线程安全的可写能力。
   1. RwLock
   2. AtomicIsize

use std::sync::{Arc,Mutex};
use std::thread;
const COUNT:u32=1000000;

let a = Arc::new(Mutex::new(123));//线程安全版共享且内部可变
// 1
let c = a.clone();
let child1 = thread::spawn(move ||{for _ in 0..COUNT {*c.lock().unwrap()+=2;}});
// 2
let c = a.clone();
let child2 = thread::spawn(move ||{for _ in 0..COUNT {*c.lock().unwrap()-=1;}});

// 多任务同步
child1.join().ok();
child2.join().ok();
println!("final:{:?}", a);//1000123

模式匹配

模式匹配我之前没什么接触，所以感觉挺有意思的（所以有了这一节）。

在rust中，let，函数参数，for循环，if let，while let，match等位置实际上是一个模式匹配的过程，而不是其他语言中普通的定义变量。

let x = 1; //x 这个位置是一个模式匹配的过程

模式匹配会有两种结果，一种是不匹配，一种是匹配。一个模式匹配位置，要求不能存在不匹配的情况，这种叫必然匹配“irrefutable”，用于定义。否则，用于分支判断。

很明显定义变量必然是要求匹配的，如let，函数参数，for循环。而用于分支判断的是if let，wdhile let，match。

那为什么要用模式匹配来定义变量？因为很灵活，看一下它的表达能力：

1. 普通类型的匹配：x --> T
2. 解构引用：&x --> &T 得 x=T
3. 解构数组：[_,_,x,_,_] --> [T;5] 得 x= 第三个元素
4. 解构元组：(..,x) --> (1,2,"x") 得 x= 第三个成员
5. 解构结构：T{0:_,1:x} --> T(1,"x") 得 x= 第二个成员

通过与目标类型差不多的写法，对复杂类型进行解构，相对直观。

另一方面，用于判断的模式匹配可以针对动态的内容，而不只是类型来进行匹配，如：

1. [email protected] --> 7 得 x=7
2. x@[2,_] --> &[1,2,3][1..3] 得 x=&[2,3]

//演示代码
let [_,_,x,_,_] = [1;5];
let (..,x) = (1,2,'y');
let hi = &['h','e','l','l','o'][2..4];

struct Ax(i32,char);
let Ax{1:_,0:x} = Ax(1,'x');
if let x@['l',_]=hi {println!("{:?}", x)};
if let [email protected] = 7 {println!("{}",x)};