Rust （三）Owner语义与生命周期

一、所有权转移

一般情形下的函数调用移动所有权。

// takes_ownership 取得调用函数传入参数的所有权，所以变量进来了就出不去了
fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放

// gives_ownership 将返回值移动给调用它的函数
fn gives_ownership() -> String {
    let some_string = String::from("hello");
    some_string // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(mut a_string: String) -> String {
    a_string.push_str(", world");
    a_string  // 返回 a_string 将所有权移出给调用的函数
}

fn main()
{
    let s1 = gives_ownership();
    takes_ownership(s1);    // 所有权转给了 takes_ownership 函数
    // println!("s1= {}", s1);   // s1 不可用了
    
    let s2 = String::from("hello");
    let s3 = takes_and_gives_back(s2);  // s2 被移动到 takes_and_gives_back 中
    
    //println!("s2={}", s2);   //s2 不可用了
    println!("s3={}", s3);
}

二、Owner + Move 的语义也会带来一些复杂度。

#[derive(Debug)]          // 使用 `{:?}`的方式输出结构体
struct Person {
    name :String,
    email:String,
}

let _name = p.name;                // 把结构体 Person::name Move掉
println!("{} {}", _name, p.email); //其它成员可以正常访问
// println!("{:?}", p);            //编译出错 "value borrowed here after partial move"
p.name = "Hao Chen".to_string();   // Person::name又有了。
println!("{:?}", p);               //可以正常的编译了

三、生命周期

Rust为了解决“野引用”的问题，在有多个变量引用到一个对象上，还不能使用额外的引用计数来增加程序运行的复杂度。那么，Rust就要管理程序中引用的生命周期了，而且还是要在编译期管理，如果发现有引用的生命周期有问题的，就要报错。

fn order_string(s1 : &str, s2 : &str) -> (&str, &str) {
    if s1.len() < s2.len() {
        return (s1, s2);
    }
    return (s2, s1);
}

let str1 = String::from("long long long long string");
let str2 = "short string";

let (long_str, short_str) = order_string(str1.as_str(), str2);

println!(" long={} nshort={} ", long_str, short_str);

我们有两个字符串，str1 和 str2 我们想通过函数 order_string() 对其排序，你会发现，这段代码编译不过。编译器会告诉你，order_string() 返回的 引用类型 &str 需要一个 lifetime的参数 – “ expected lifetime parameter”。这是因为Rust编译无法通过观察静态代码分析返回的两个引用返回值，到底是(s1, s2) 还是 (s2, s1) ，因为这是运行时决定的。所以，返回值的两个参数的引用没法确定其生命周期到底是跟 s1 还是跟 s2，这个时候，编译器就不知道了。

生命周期标注

fn long_string<'a>(s1 : &'a str, s2 : &'a str) -> (&'a str, &'a str) {
    if s1.len() > s2.len() {
        return (s1, s2);
    }
    return (s2, s1);
}

单引用—无需标注生命周期

函数 foo() 的参数和返回值都是一个引用，他们的生命周期是一样的，编程器可以自己推导出来，也就可以编译通过。

fn foo (s: &mut String) -> &String {
    s.push_str("coolshell");
    s
}

let mut s = "hello, ".to_string();
println!("{}", foo(&mut s))

包含引用类型成员的结构体

#[derive(Debug)]

struct User<'a>{
    username: &'a str,
    email:String,
    age:u8,
}

fn main() {
    let word = String::from("zhang_san");
    let email_ = String::from("zhang_san@qq.com");

    let stu = User{username:&word,email:email_,age:12};
    println!("{:?}",stu);
}

构造函数，我都不知道该如何构造了，在P235 中建造者模式中并没有引用，本来想参考来着

#[derive(Debug)]

struct User<'a>{
    username: &'a str,
    email:String,
    age:u8,
    score:&'a i8,
}


impl <'a> User<'a> {
    // fn new() ->User<'a>{
    //     //
    // }

    fn set_username(&mut self, s : &'a str) {
        self.username = s;
    }
    fn set_score(&mut self,  i : &'a i8) {
        self.score = i;
    }
}


fn main() {
    let word0 = String::from("zhang_san");
    let word1 = String::from("li_si");
    let email_ = String::from("zhang_san@qq.com");
    let score_0 = 90;
    let score_1 = 90;

    let mut stu = User{username:&word0,email:email_,age:12,score:&score_0};
    println!("{:?}",&stu); //User { username: "zhang_san", email: "zhang_san@qq.com", age: 12, score: 90 }

    let stu2 = &stu.set_username(&word1);
    println!("{:?}",stu2);   // ()

    let stu3 = &stu.set_score(&score_1);
    println!("{:?}",stu3);   // ()
}