Forem: sdttttt

Rust 新概念

sdttttt — Wed, 26 Feb 2020 05:43:11 +0000

Rust 在指针安全上做了很多功夫。

所有权

在Rust中出现的新概念。


let str1 = String::from("H");
let str2 = str1;

// 编译是不会通过了
println!("{}", str1)

在这里 str1 把它指向地址的所有权给了 str2，str1不再指向任何地址。

可变引用

可变引用有一个很大的限制：在特定作用域中的特定数据有且只有一个可变引用。
这些代码会失败：

    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s;
    println!("{}, {}", r1, r2);

这个限制允许可变性，不过是以一种受限制的方式允许。

新 Rustacean 们经常与此作斗争，因为大部分语言中变量任何时候都是可变的。这个限制的好处是 Rust 可以在编译时就避免数据竞争。

数据竞争（data race）类似于竞态条件，它可由这三个行为造成：

两个或更多指针同时访问同一数据。
至少有一个指针被用来写入数据。
没有同步数据访问的机制。

数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！

悬垂引用

让我们尝试创建一个悬垂引用，Rust 会通过一个编译时错误来避免：

fn main() { 
    let reference_to_nothing = dangle(); 
} 

fn dangle() -> &String { 
    let s = String::from("hello"); 
    &s 
}

dangle Function 尝试返回其内部变量 s 的引用，然而返回之后s 的所被分配的内存因为出栈就会被回收，得到引用的Main Function 引用的也是个未知的内存地址。这非常的危险。

fn no_dangle() -> String {
    let s = String::from("hello");
    s
}

这样就没问题了，所有权被转移。

&str和String

sdttttt — Wed, 26 Feb 2020 05:28:46 +0000

在 Rust 中 &str 是字面量值, 程序编译成二进制文件后，这个字符串会被保存在文件内部, 为了保持这个字符串在固定位置的引用, 所以要加引号.由于已经被保存在文件内变成了二进制, 所以不需要生命周期, 它是Static的, 整个程序的任何时候都能访问.

而 String 它其实是Vec的一种实现.

关于 Box

sdttttt — Wed, 26 Feb 2020 05:16:59 +0000

适用场景

当有一个编译时未知大小的数据类型，而有需要在确切大小的上下文中使用这个类型值的时候；
当有大量数据并希望在确保数据不被拷贝的情况下转移所有权。
当希望拥有一个值并只关心它的类型是否实现了特定的Trait而不是其具体类型时。

Rust 为什么需要生命周期注解

sdttttt — Wed, 26 Feb 2020 05:14:10 +0000

fn main() {
    let b;
    {
        let a = 10;
        b = &a;
    }       
    println!("{}", b);  
}

此时，a的作用域比b要小。rust的生命周期检查器发现a的生命周期比b要大，但是拥有一个生命周期比它小的对象，编译器就会拒绝编译。简而言之，rust的编译器能帮助我们确定某个引用是否有效(无效的话在编译时就会报错)，以此来避免悬垂引用等一系列问题。

然而，现实是，编译器有时候并不能确定某个引用是否有效。我们来看下面这个例子:

fn longest_str(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let str1 = String::from("123");
    let str_longer;
    {
        let str2 = String::from("12345");
        str_longer = longest_str(&str1, &str2);
    }

    println!("{}",str_longer);
}

这段代码是无法编译通过的，报错信息如下:

error[E0106]: missing lifetime specifier
 --> src/main.rs:1:37
  |
1 | fn longest_str(x: &str, y: &str) -> &str {
  |                                     ^ expected lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0106`.
error: Could not compile `lifetime_test`.

To learn more, run the command again with --verbose.

表明在函数longest_str里需要生命周期注解，这是为什么呢？我们来分析一下代码。在上面这段代码里，str_longer拥有的引用是否有效呢？答案是不确定。我们只从函数内部来看是无法确认哪个参数的生命周期长或者是短.

需要注意的是，生命周期注解并不改变任何引用的生命周期的长短。也就是说，单个生命周期其实是没什么意义的，生命周期最大的作用就是告诉 Rust 多个引用的泛型生命周期参数如何相互联系的。加入有一个有一个生命周期为'a的参数x，一个生命周期也为'a的参数y，那么就说明x与y的生命周期是一样长的。这么一来就可以解决刚才longest_str函数的问题了。我们给函数标上生命周期注解:

fn longest_str<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let str1 = String::from("123");
    let str_longer;
    {
        let str2 = String::from("12345");
        str_longer = longest_str(&str1, &str2);
    }

    println!("{}",str_longer);
}

虽然仍然无法编译通过，但是错误信息变成了:

error[E0597]: `str2` does not live long enough
  --> src/main.rs:14:41
   |
14 |         str_longer = longest_str(&str1, &str2);
   |                                         ^^^^^ borrowed value does not live long enough
15 |     }
   |     - `str2` dropped here while still borrowed
16 |
17 |     println!("{}",str_longer);
   |                   ---------- borrow later used here

即错误信息变成了编译器检查出引用生命周期无效了，而不是longest_str这个函数的错误了，即str2和str1生命周期不一致。我们只需要修改main函数里参数的生命周期，使str1与str2生命周期保持一致即可。

fn longest_str<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let str1 = String::from("12345");
    let str_longer;
    let str2 = String::from("123");
    str_longer = longest_str(&str1, &str2);

    println!("{}",str_longer);
}

那么问题来了，在上面这段代码里，函数longest_str里，x，y和函数返回值的生命周期都是一致的，那我们可不可以将它们标注成不同的呢？就像

fn longest_str<'a, 'b, 'c>(x: &'a str, y: &'b str) -> &'c str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

这并没有任何意义, 生命周期注解说到底也只是起一个标识作用.并不会改变程序的任何逻辑.它只是用来给Rust生命周期检查器核对的.

最后，总结一下，当且仅当输出值的生命周期为所有输入值的生命周期交集的子集时，生命周期合法。这个应该很好理解，也很好的解释了我们举的例子中生命周期注解的用法。rust也正是通过这种方式解决了"共享"这一问题，从某种程度上保证了内存的安全。

总结

生命周期注解只是给编译器检查使用的。
注解本身无法改变任何生命周期。
但是标出后能尽量让程序和你预期的一样工作。