2510rs,rust清单2

`引用`&指针

访问非拥有内存.

cpp 复制代码

&S
//共享`引用`(类型,用来保存任何`&s`的空间).
 &[S]
//包含`(addr,count)`的特殊切片`引用`.
 &str
//包含`(addr,byte_len)`的特殊串切片`引用`.
 &mut S
//允许可变的独占(还有`&mut[S],&mut dyn S,...`).
 &dyn T
//特殊特征对象.`按as(addr,vtable);`T必须是`对象安全`的.
&s
//共享借用(如,`addr.,len,vtable,..`.比如`0x1234`).
 &mut s
//允许可变的独占借用.
*const S
//不变`原始指针`类型的内存安全.
 *mut S
//可变`原始指针`类型,内存安全.
 &raw const s

//通过引用,创建`原始指针`.`;c.ptr:addr_of!()`
 &raw mut s
//相同,但可变.未对齐,打印包的字段需要.
s
//按`引用`绑定,造绑定`引用`类型.
 let r = s;
//相当于`letr=&s`.
 let S { mut x } = s;
//`可变引用绑定`(let x=&mut s.x)`,快捷析构版本.
*r
//`解引用r`访问所指的内容.
 *r = s;
//如果r是可变的`引用`,则在目标内存移动或复制s.
 s = *r;
//如果它是`Copy`,使s为r引用的副本.
 s = *r;
//如果`*r`不是`Copy`,则不管用,因为这会移动并留空.

 s = *my_box;
//可移出而不是`Copy`的`b`内容,`框`的特例.
'a
//`生命期`参数,静态分析中流的`持续时间`.

 &'a S
//只接受部分s的地址;解决现有`"a`或更长.

 &'a mut S
//相同,但允许更改地址内容.

 struct S<'a> {}
//表示此S将包含小于`'a`的地址.`S`的创建者决定`'a`.

 trait T<'a> {}
//表示任何`S`(即实现`T`的S)可能包含地址.

 fn f<'a>(t: &'a T)
//表示此函数处理某些地址.调用者决定`"a`.

'static
//特殊`生命期`,持续整个程序执行.

函数或行为

cpp 复制代码

trait T {}
//定义特征;可遵守的常见行为类型.
trait T : R {}

//T是超特征R的子特征.任何S都必须先实现`R`,然后才能实现`T`.
impl S {}
//类型S的功能实现,如方法.

impl T for S {}
//为S类型实现`T`特征;指定S如何像T一样行事.

impl !T for S {}
//禁止`自动继承`的自动特征.

fn f() {}
//函数或(如果在`实现`中)相关函数的定义.

 fn f() -> S {}
//相同,返回S类型的值.
 fn f(&self) {}
//定义一个方法,如,在`impl S{}`中.

struct S  (T);
//更难懂的是,也定义了`fn S(x:T)->S``构造器函数.
const fn f() {}
//在`编译时`可用的`常函数,`如,`const X:u32=f(Y)'

 const { x }
//在函数中使用,确保在编译过程中计算`{x}`.

async fn f() {}
//`Async`函数转换,使f返回一个`impl Future`.
 async fn f() -> S {}
//相同,但让f返回一个`impl Future<Output=S>`.

 async { x }
//在函数中使用,使`{x}`变成`impl Future<Output=X>`.
 async move { x }
//将抓的变量移动进未来.移动闭包.↓

fn() -> S
//函数`引用s`,内存保存可调用的地址.
Fn() -> S
//可调用特征(也叫`FnMut,FnOnce`),闭包,函数实现
AsyncFn() -> S
 //可调用异步特征(也叫`AsyncFnMut,AsyncFnOnce`),异步实现

|| {}
//借用其抓的闭包↓(如,`局部变量`).
 |x| {}
//接受叫x的参数的闭包,`函数体`是块式.
 |x| x + x
//相同,没有块式;只能由单个式组成.

 move |x| x + y
//移动闭包,取物主;即,`y`转移到闭包中.

 async |x| x + x
//异步闭包.按`impl Future<Output=X>`转换结果.

 async move |x| x + y
//异步移动闭包.以上的组合.

 return || true
//闭包有时像逻辑`OR`(这里:返回一个闭包).
unsafe
//如果喜欢调试`段错误`;不安全的代码.↓

 unsafe fn f() {}
//意思是"调用会导致`UB`,你必须检查要求".

 unsafe trait T {}
//意思是"粗心的`impl`.T会导致`UB`;`实现者必须检查`".

 unsafe { f(); }
//向`编译器`保证:"我已检查了要求,相信我".

 unsafe impl T for S {}
//保证S在T上,表现良好;人们可安全地在S上使用`T`.

 unsafe extern "abi" {}
//从`Rust2024`开始,`extern"abi"{}`块↓必须是不安全的.

pub safe fn f();
//在不安全的`extern"abi"{}`中,标记实际上可安全地调用f.

2510rs,rust清单2

引用&指针

函数或行为

`引用`&指针