vlambda博客
学习文章列表

// 用属性描述所在crate的类型#![crate_type = "lib"]// 用属性来标识fn test_foo为测试单元函数#[test]fn test_foo() { /* ... */}// 用属性来描述指定条件下编译的mod#[cfg(target_os = "linux")]mod bar { /* ... */}// 一个lint属性用来丢弃警告或错误#[allow(non_camel_case_types)]type int8_t = i8;// 用内置属性来说明该函数可包含不可用变量fn some_unused_variables() { #![allow(unused_variables)] let x = (); let y = (); let z = ();}
// 宏元素包括包括宏定义和宏调用；// 宏定义macro_rules! foo { ($l:tt) => { bar!($l); }}
macro_rules! bar { (3) => {}}// 宏调用foo!(3);

// 跟其他语言类似的关键词as、break、const、continue、else、enum、extern、false、for、// if、in loop、match、pub、return、self、Self、static、// struct、super、true、type、where、while// Rust语言专有# 引用外部包crate# 定义模块mod# 定义函数或函数指针fn# 实现trait的功能impl# 定义一个变量let# 在一个值与模式之间进行匹配match# 用于转移值的所有权move# 用于表示变量或引用的值可修改mut# 取其引用ref# 定义一个特性trait# 表示不安全的代码、函数、trait、实现，编译器不检查其安全性unsafe# 将相应ite在当前上下文可见use

mod math { type Complex = (f64, f64); fn sin(f: f64) -> f64 { /* ... */ } fn cos(f: f64) -> f64 { /* ... */ } fn tan(f: f64) -> f64 { /* ... */ }}
mod inline { // 属性path用来描述mod对应的rs文件 #[path = "other.rs"] mod inner;}

mod foo {    pub trait Zoo {        fn zoo(&self) {}    }    impl<T> Zoo for T {}}
use self::foo::Zoo as _;// Underscore import avoids name conflict with this item.struct Zoo;use std::fs as self_fs; fn main() {    let z = Zoo;    z.zoo();}

fn initialization_example() {    let init_after_if: ();    let uninit_after_if: ();    if random_bool() {        init_after_if = ();        uninit_after_if = ();    } else {        init_after_if = ();    }    let mut x = 2;    x = 3;    let y = x as float;    init_after_if; // ok    // compile err:use possibly uninitialized`uninit_after_if`    // uninit_after_if; }

// ->let mut x/let x区别// x代表一个变量的名称，其值为数字5，代表值5的所有者let x = 5;// x = 2; compile fail, x变量未声明成mutlet mut y = 5;y = 2;

// ->从T到&T、&mut T// 从值5的所有者中使用&符合来获取到它的引用let x = 5// y代表对x对应的值的引用，y本身也是一个变量，它的类型或为&i8，// 可以直接y来读取它所引用的值let y = &x;println!("y={}", y);// *y = 10 // compile fail,y为引用，不是借用，无法被赋值

// 从值5的所有者中使用&mut符合来获取到它的借用// 只有声明成mut，才可以生成&mut借用// let x = 5let mut x = 5// y代表对x对应的值的借用，y本身也是一个变量，它的类型或为&mut i8，// 可以直接y来读取和改写它所借用的值let y = &mut x;
// &mut T类型的借用，可以当成&T来使用，// 由编译自行检查在不影响内存安全的情况下转换使用println!("y={}", y);*y = 10;

// ->所有者T、&T、&mut T混合使用的排他性let mut x = 5let y = &mut x;// x = 20; // compile fail，x已被y借用，在y借用使用完成以前，// 不能通过所有者直接修改// let z = &mut x; // compile fail，x已被y借用，// 在y借用使用完成以前，不能再次被借用// let t = &x; // compile fail，x已被y借用，在y借用使用完成以前，// 不能被引用println!("y={}", y);*y = 10;

let mut x = 5let y = &x; // let z = &mut x; // compile fail，x已被y引用，// 在y引用使用完成以前，不能再次被借用println!("y={}", y);// *z = 10;

// -->参数传递&返回值所有权转移movestruct Point {x: i32, y: i32}fn sumPointByMove(p: Point) -> i32 {   p.x + p.y}
fn sumPointByRef(p: &Point) -> i32 {   p.x + p.y}
fn getPoint(x: i32, y: i32) -> Point {   Point { x: x, y: y}}
let p = Point {x: 10, y: 11};let x = sumPointByMove(p);// compile fail, p变量对应的值所有权已转移到sumPointByMove函数，// 无法再引用// println!("p={}", p.x); let p1 = Point {x: 10, y: 11};// compile fail, sumPointByRef函数参数类型是引用，// 传入对象非引用，严格参数检查，不匹配// let x1 = sumPointByRef(p1);
let x1 = sumPointByRef(&p1);// compile ok, p1变量对应的值所有权只是引用过，// 没有转移到sumPointByRef函数，可继续引用println!("p={}", p1.x); 
// compile pass返回一个转移move所有权的对象let p2 = getPoint(10, 11); 
let x = sumPointByMove(p2);

// -->参数传递&返回值 复制#[derive(Copy, Clone)]struct Point {x: i32, y: i32}
fn sumPointByMove(p: Point) -> i32 {   p.x + p.y}
fn sumPointByRef(p: &Point) -> i32 {   p.x + p.y}
fn getPoint(x: i32, y: i32) -> Point {   Point { x: x, y: y}}
let p = Point {x: 10, y: 11};
let x = sumPointByMove(p); // compile pass, p变量对应的值由于具有Copy特性，进行了复制后， // 传递给sumPointByMove函数，后面可继续引用println!("p={}", p.x);// compile pass返回一个转移move所有权的对象let p2 = getPoint(10, 11); let x = sumPointByMove(p2);

fn main() {  let mut s1 = String::from("hello"); let s2 = s1; // s1的所有权转移给了s2，这里发生了move // let s3 = s1; // s1的所有权以及转移走了，不能再move， // 否则会报错：error[E0382]: use of moved value: `s1`}

// 使用类似'a语法来表示一个引用变量的生命周期，用来描述它的上下文范围，// 只有在有效上下文范围以内引用才可作为有效的引用使用。fn the_longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {    if s1.len() > s2.len() { s1 } else { s2 }}
fn main() {    let s1 = String::from("Python");    let s1_b;    {        let s2 = String::from("C");        s1_b = the_longest(&s1, &s2);    }    // compile fail,`s2` dropped here while still borrowed    println!("{} is the longest if you judge by name", s1_b);}

// Lifetimes are annotated below with lines denoting the // creation and destruction of each variable.
// `i` has the longest lifetime because its scope entirely//  encloses both `borrow1` and `borrow2`.// The duration of `borrow1` compared // to `borrow2` is irrelevant since they are disjoint.
fn main() {    let i = 3; // Lifetime for `i` starts. ────────────────┐    //                                                     │    { //                                                   │        let borrow1 = &i; // `borrow1` lifetime starts. ──┐│        //                                                ││        println!("borrow1: {}", borrow1); //              ││    } // `borrow1 ends. ──────────────────────────────────┘│    //                                                     │    //                                                     │    { //                                                   │        let borrow2 = &i; // `borrow2` lifetime starts. ──┐│        //                                                ││        println!("borrow2: {}", borrow2); //              ││    } // `borrow2` ends. ─────────────────────────────────┘│    //                                                     │} // Lifetime ends. ─────────────────────────────────────┘

// One input reference with lifetime `'a` which must live// at least as long as the function.fn print_one<'a>(x: &'a i32) {    println!("`print_one`: x is {}", x);}// Mutable references are possible with lifetimes as well.
fn add_one<'a>(x: &'a mut i32) {    *x += 1;}// Similarly,both references here must outlive this structure.#[derive(Debug)]struct NamedBorrowed<'a> {    x: &'a i32,    y: &'a i32,}// An enum which is either an `i32` or a reference to one.#[derive(Debug)]enum Either<'a> {    Num(i32),    Ref(&'a i32),}
fn main() {    let x = 18;    let y = 15;    let single = Borrowed(&x);    let double = NamedBorrowed { x: &x, y: &y };    let reference = Either::Ref(&x);    let number    = Either::Num(y);    println!("x is borrowed in {:?}", single);    println!("x and y are borrowed in {:?}", double);    println!("x is borrowed in {:?}", reference);    println!("y is *not* borrowed in {:?}", number);}

// lifetime省略前fn annotated_pass<'a>(x: &'a i32) -> &'a i32 { x }fn annotated_input<'a>(x: &'a i32) {    println!("`annotated_input`: {}", x);}// lifetime省略后fn elided_pass(x: &i32) -> &i32 { x }fn elided_input(x: &i32) { println!("`elided_input`: {}", x);
}

struct User {    username: String,    email: String,    sign_in_count: u64,    active: bool,}
let mut user1 = User {    email: String::from("[email protected]"),    username: String::from("someusername123"),    active: true,    sign_in_count: 1,};

// ->通过对象值访问字段field，user1.email字段属于String类型，// 与user1共用一个所有权user1.email = String::from("[email protected]");

// ->通过对象值的引用访问字段fieldlet mut user1_ref = &user1// 虽然user1_ref.email字段属于String类型，// 不过user1_ref是引用类型，所以user1_ref.email无法修改// user1_mut_ref.email = String::from("[email protected]");

let mut user1_mut_ref = &mut user1// user1_mut_ref.email字段属于String类型，但user1_mut_ref是借用类型，// 由于与user1共用一个所有权，所以可以修改user1_mut_ref.email = String::from("[email protected]");

// ->通过对象值访问字段field变量，可以move转移字段变量的所有权 fn printUsername(name :String) {    println!("name:{}", name);}// user1.username字段变量的所有权已转移到函数printUsername中printUsername(user1.username);// 再次访问user1.username会编译失败// println!("name:{}", user1.username);// 从mut引用user1_mut_ref中，转移username所有权，会编译失败let mut user1_mut_ref = &mut user1// printUsername(user1_mut_ref.username);

// struct字段带有引用类型的字段变量，如没有指定lifetime，// 由于无法确定字段变量lifetime导致编译失败struct User {    username: &str,    email: &str,    sign_in_count: u64,    active: bool,}
fn main() {    let user1 = User {        email: "[email protected]",        username: "someusername123",        active: true,        sign_in_count: 1,    };}
-----------------------------------------// struct中带有引用类型字段变量，指定lifetime后可编译通过// lifetime 'a表示一个User对象的lifetime 'a, 而其中的字段变量成员// username和email所引用的值同样具有lifetime 'astruct User<'a> {    username: &'a str,    email: &'a str,    sign_in_count: u64,    active: bool,}
let email_ = String::from("[email protected]");let username_ = String::from("someusername123");// email_、username_、user1具有相同的lifetime值let mut user1 = User {    email: &email_,    username: &username_,    active: true,    sign_in_count: 1,};
println!("username:{}", user1.username);

// 由于self类型是引用类型，// 函数体内没有使用到跟lifetime 'a相关的变量，可以省略&'a self中'a.impl<'a> User<'a> {    fn doube_sig_count(&self) -> u64 {        self.sign_in_count * 2    }}println!("new sig count:{}", user1.doube_sig_count());
// 非省略lifetime写法如下：impl<'a> User<'a> {    fn doube_sig_count(&'a self) -> u64 {        self.sign_in_count * 2    }}

struct Point<T> {    x: T,    y: T,}
impl<T> Point<T> {    fn x(&self) -> &T {        &self.x    }}
fn main() {    let integer = Point { x: 5, y: 10 };    let float = Point { x: 1.0, y: 4.0 };    // integer和float变量属于不同的类型}
enum Option<T> {    Some(T),    None,}
enum Result<T, E> {    Ok(T), Err(E),
}

// struct中带有引用类型字段变量，需要指定lifetimestruct User<'a> {    username: &'a str,    email: &'a str,    sign_in_count: u64,    active: bool,}
let email = String::from("[email protected]");let username = String::from("someusername123");let mut user1 = User {    email: &email,    username: &username,    active: true,    sign_in_count: 1,};

pub trait Summary {    fn summarize(&self) -> String;}
pub struct NewsArticle {    pub headline: String,    pub location: String,    pub author: String,    pub content: String,}
impl Summary for NewsArticle {    fn summarize(&self) -> String {        format!("{}, by {} ({})", self.headline,             self.author, self.location)    }}
pub struct Tweet {    pub username: String,    pub content: String,    pub reply: bool,    pub retweet: bool,}
impl Summary for Tweet {    fn summarize(&self) -> String {        format!("{}: {}", self.username, self.content) }
}

pub trait Sized { // Empty.}
pub trait Unsize<T: ?Sized> { // Empty.}
pub trait Copy: Clone { // Empty.}
pub unsafe auto trait Sync { // Empty}pub unsafe auto trait Send { // empty.}
#[stable(feature = "rust1", since = "1.0.0")]// ！Sync表示没有Sync特性或能力impl<T: ?Sized> !Sync for *const T {}#[stable(feature = "rust1", since = "1.0.0")]impl<T: ?Sized> !Sync for *mut T {}
pub auto trait Unpin {}
pub struct PhantomPinned;#[stable(feature = "pin", since = "1.33.0")]impl !Unpin for PhantomPinned {}

pub fn notify(item: &impl Summary) { println!("Breaking news! {}", item.summarize());}

pub fn notify<T: Summary>(item: &T) { println!("Breaking news! {}", item.summarize());}
pub fn notify(item: &(impl Summary + Display)) {}
pub fn notify<T: Summary + Display>(item: &T) {}
fn some_function<T, U>(t: &T, u: &U) -> i32 where T: Display + Clone, U: Clone + Debug{}

// 宏调用，使用宏名加!来触发println!("hello lrfrc!");// println 宏定义，宏定义中可以嵌套调用宏// std/src/macros.rsmacro_rules! print { ($($arg:tt)*) => ($crate::io::_print($crate::format_args!($($arg)*)));}// core/src/macros/mod.rsmacro_rules! format_args { ($fmt:expr) => {{ /* compiler built-in */ }}; ($fmt:expr, $($args:tt)*) => {{ /* compiler built-in */ }};}