标签：语法 impl .. mut trait 小册子 let rust fn

1. 数据结构

通过关键字定义的数据类型和内存位置

• struct S{}定义一个命名成员的结构体
  • struct S {x:T} 定义一个结构体，成员名为x，成员类型为T
  • struct S(T) 定义元组类型结构体，成员.0类型为T
  • struct S 定义零长单元结构体，不占空间哦
• enum E{} 定义一个枚举类，
  • enum E{A, B(), C{} }定义各种类型枚举，可以是单元A，元组B，或者结构C
  • enum E {A=1} 如果变量只是单元，允许赋值，如FFI使用
• union U{} unsafe 类C联合体，为了FFI兼容
• static X: T = T(); 有'static声明周期的全局变量，单一内存位置
• const X : T = T();定义常量
• let x: T;定义栈T bytes。一次分配，不可变
• let mut x:T; 允许可变的和可变借用
  • x = y; 移动y到x，如果T类型没有实现Copy，那么y将变为不可用，如果实现了Copy，那么将y拷贝给x。

创建和获取结构体数据，可一些siglic类型

• S {x:y} 创建struct S{}或enum E::S{}设置y给成员x
• S {x} 用局部变量x直接赋值
• S {..s} 将其余变量设置为s的
• S {0:x} 类似S(x) 设置.0成员值
• S(x) 创建S(T)或者enum E::S()
• S如果S为单元struct S;或者enum E::S
• E::C {x:y}类似
• ()空元组，即使文本又是类型,(x)括号表达式，(x,)元组单个元素，(S,)元组单个元素
• [S]未定义长度的数组类型，如切片，不能在栈上定义。
• [S; n] 定长数组，长度为n，元素类型为S
• [x; n] 数组实例，长度为n，每个元素都是x
• [x, y] 数组元素，值为x,y
• x[0] 集合索引，实现了Index, IndexMut的trait
  • x[..]所有元素，给个范围
• a..b给了范围[a, b)
• ..b``（-∞，b),..=b``(-∞，b]

2.引用和指针

不属于自己所有内存授权

• &S共享引用，空间可以被任何&s所有
  • &[S] 切片的引用，包含了地址和长度
  • &str string切边的引用，包含地址和长度
  • &mut S 允许可变的引用，唯一性(&mut [S], &mut dyn S)
  • &dyn T trait object引用，包含地址和vtable
• &s共享借用
  • &mut s排它借用允许改变
• *const S不可变裸指针w/o内存安全
  • *mut S可变裸指针
  • &raw const s不通过引用创建裸指针,ptr::addr_of!()
  • &raw mut s同样都是可变的
• ref s用作绑定引用类型
  • let ref r = s; 相当于let r = &s;
  • let S {ref mut x} = s;可变绑定引用let x = &mut s.x;
• *r 解引用或者指向的内容
  • *r = s;如果r是可变的引用，move或者copys给目标内存
  • s = *r;如果r实现了Copy，则将*r复制给s，如果*r没实现Copy将会move
  • s = *my_box如果没实现了Copy则也会move
• 'a在静态分析一个流程的一个声明周期参数
  • &'a S只接受持有s的地址，这个地址存在'a或更长
  • &'a mut S一样，只是可变
  • struct S<'a> {}通知S将会包含声明周期'a地址。S创建来决定'a
  • trait T<'a>{}
  • fn f<'a>(t: &'a T)
• 'static静态声明周期

3.函数和行为

定义代码单元和他们抽象

• trait T {}
• trait T: R {} T是supertraitR的subtrait。任何S必须在实现T之前先实现R
• impl S{}方法
• impl T for S {}实现类型S的T
• impl !T for S {} 关闭autotrait
• fn f() {}
  • fn f() -> S{}
  • fn f(&self) {}
• struct S(T);
• const fn f() {} 编译时常量函数const X:u32 = f(Y)
• async fn f() {}异步函数
  • async fn () -> S{}
  • async {x}
• fn() -> S 函数指针
• Fn() -> S 可调用的闭包FnMut, FnOnce
• ||{}
  • |x|{}
  • |x|x+x
  • move |x| x + y闭包获得捕获的所有权，y转移到了闭包
  • return ||true 返回一个闭包
• unsafe
  • unsafe fn f() {}
  • unsafe trait T {}
  • unsafe { f();}
  • unsafe impl T for S {}

4.控制流

• while x {}
• loop {}
• for x in inter {}
• if x {} else {}
• 'label: loop {}
• break
• break x x作为表达式值，loop中使用
• break 'label 或者break 'label x
• continue和continue 'label
• x?如果x式Err或者None则返回
• x.await async使用
• return x 函数中的先返回
• x.f()
  • X::f()
  • X::f(&x)
  • X::f(&mut x)
• X::f()
  • <X as T>::f() 调用trait T::f()方法

5.代码结构

• mod m {}
• mod m;定义一个模块，从m.rs或m/mod.rs中获取
• a::b
  • ::b搜索crate root或external prelude； global path
  • crate::b crate root中找b
  • self::b当前mod找b
  • super::b 父模块找b
• use a::b; 这个范围可直接使用b
  • use a::{b, c};
  • use a::b as x;
  • use a::b as _;
  • use a::*;
  • pub use a::b;
• pub T
  • pub(crate) T 当前crate可访问
  • pub(super) T
  • pub(self) T
  • pub(in a::b) T祖先a::b可见
• extern crate a;依赖外部crate，可以直接使用use a::b
• extern "C" {}依赖外部ABI
• extern "C" fn f() {}定义可被外部访问的FFI

6.类型重命名和转换

• type T = S;
• Self
• self
  • &self
  • &mut self
  • self: Box<Self>
• S as T
• S as R
• x as u32

7.宏和属性

• m!()宏调用，也可以m!{}，m![]根据具体宏

• #[attr]外部属性

• #![attr]内部属性

• $x:ty宏捕获，:..fragment声明$x允许的内容

• $x宏替换，使用上面的声明内容

• $(x),* 宏重复，零或更多

  • $(x),? 0或1
  • $(x),+, 1或更多
  • $(x)<<+ 分隔符不是,这里是<<

8.样式匹配

• match m {}
• let S(x) = get()
  • let S {x} = s;
  • let (_, b, _) = abc;
  • let (a, ..) = abc;
  • let (.., a, b) = (1, 2)
  • let s & S{x} = get(); 将s绑定到S，同时x绑定到是s.x
  • let w @ t @ f = get();存放3个复制get()结果，分别给w,t,f
  • let Some(x) = get() {}不能工作，使用if let
• if let Some(x) = get() {}
• while let Some(x) = get() {}
• fn f(S {x} : S)函数参数也可以项let一样将s.x给f(s)

语法糖
match get() { Some(x) => {}, _ => () }

arm匹配

• E::A => {}匹配枚举类型A
• E::B(..) => {} 匹配枚举元组变量，忽略所有索引
• E::C {..} => {} 匹配结构体变量C，忽略所有成员
• S {x:0, y:1} => {} 匹配结构体(只接收s.x=0和s.y=1)
• S {x: a, y: b} => {}匹配结构体任何结构体，绑定s.x给a,s.y给b
  • S{x, y} => {}同样，但是简写方式
• S{..} => {}匹配结构体有任何值的
• _ => {}匹配剩余的
• 0 | 1 => {} 匹配可选，或者模式
  • E::A | E::Z => {}
  • E::C {x} | E::D {x} => {}
  • Some(A | B) => {}也可以多层嵌套
• (a, 0) => {}匹配任何a和第二个是0的元组
• [a, 0] => {}切片样式，匹配数组第一个任何为a，第二个为0
  • [1, ..] => {}
  • [1, .., 5] => {}
  • [1, x @ .., 5] => {}中间的绑定为x
  • [a, x @ .., b] => {}
• 1 .. 3 => {}
  • 1 ..= 3 => {}
  • 1 .. => {}
• x @ 1..=5 => {}绑定匹配给x
  Err(x @ Error {..}) => {} 嵌套绑定
• S{x} if x > 10 => {}条件匹配，条件要为true

9.模板和约束

• S<T>
• S<T:R> trait bound R必须是具体的trait，T必须实现R
  • T： R， P：S
  • T: R, S这个是不对的，要写成T: R + S
  • T: R + 'a
  • T: ?Sized可选退出预定义的trait边界
  • T: 'a如果T是引用，必须长于'a
  • T: 'static
  • 'b : 'a 'b周期大于等于'a
• S<const N: usize>常量约束
  • S<10>使用方法
  • S<{5 + 5}>表达式必须放入大括号中
• S<T> where T: R 和S<T: R>相同，看起来好点
  • S<T> where u8: R<T>可以用来条件称述
• S<T = R> 默认参数
  • S<const N: u8 = 0>
  • S<T = u8>
• S<'_>推断匿名声明周期，如果明显的让编译器计算出
• S<_>推断匿名类型let x: Vec<_> = iter.collect()
• S::<T>调用地方消除歧义f::<u32>()
• trait T<X> {}可以有多个impl T for S(每个X)
• trait T { type X;}关联类型，只能一个impl T for S
  • type X = R; 在S中设置关联类型impl T for S {type X = R;}
• impl<T> S<T> {}实现任何类型T在S<T>,这个T类型参数
• impl S<T> {}例如S<u32>
• fn f() -> impl T
• fn f(x: &impl T)
• fn f(x: &dyn T)
• fn f() where Self::R; 在trait T{},让f可认识类型为impl R
  • fn f() where Self::Sized;使用 Sized 可以选择 f 退出 dyn T trait object vtable，启用 trait obj
  • fn f() where Self::R {}其他 R 有用的 w. dflt.方法（反正非dflt.需要拔）

10.higher-ranked 项目

实际类型和traits，某个内容的抽象，通常生命周期

• for<'a> higer-ranked bounds
• trait T: for<'a> R<'a> {}
• fn (&'a u8)
• for<'a> fn(&'a u8)
  • fn (&'_ u8)
  • fn(&u8)
• dyn for<'a> Fn(&'a u8)
  • dyn Fn(&'_ u8)
  • dyn Fn(&u8)

11.字符串和字符

• ...string类型,UTF-8,包含\n
• r"..." raw string不会有\n
• r#"..."# 可以包含" #数量可变的
• b"..." byte string ASCII类型[u8]，不是string
• br"...",br#"..."# raw byte string ASCII类型[u8]
• '

  标签：语法,impl,..,mut,trait,小册子,let,rust,fn
  来源： https://www.cnblogs.com/ellabrain/p/16652225.html

  本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
  2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
  3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
  4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
  5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。