Ownership Rules
- Each value in Rust has a variable that’s called its owner.
- There can only be one owner at a time.
- When the owner goes out of scope, the value will be dropped.
内存申请 let s = String::from("xx");
内存释放： s 超出scop，变为不可用。rust自动添加drop调动代码， 归还内存
所有权规则：
堆、栈 中变量的其他 赋值方式：
- stack-only: copy
let x = 5; let y = x; // x, y 都可用， 因为x 为栈上分配， 对于内存方式为 copy， 不影响所有权 - Heap: clone、所有权转移
let s1 = String::from("hello");
let s2 = s1.clone();
// s2 copy s1的内存，s1 依然可用
let s1 = String::from("xx");
let s2 = s1; // s1 不在可用， s2为 字符串的 owner, 这里只是转移 指向 string的指针，而非 copy string
Function 调用：
- Function 调用参数： 跟 赋值 一样的所有权 转移一样
- Function 返回参数： 堆上的内存，作为返回值的时候， 两种情况：
1. 转移所有权 到 函数调用者
2. drop掉 （因为超过 函数中的作用域 scope）
引用： Function 调用： 每次都需要转移所有权，在将所有权转回到调用者。非常麻烦， 所以设计了 引用
指向变量的指针， 并不具有 ownership， 所以drop并不会，释放内存，使得引用的变量不可用。在Function 中使用 非常合适，因为不需要ownership传递回去， 因为根本没有ownership的转移
- 可变 mut 引用: 可以 改变 引用指向的内容。
- 不可变引用
- 引用 规则:
- 任何时候，只有一个 可更改引用，或者 同时多个不可变应用
- 引用需要总是有效的。即： 引用的scope应该小于变量的scope
fn no_dangle() -> &String {
let s = String::from("hello");
&s
}
// 函数返回， s 会drop掉， 所以会造成空指针 null reference
错误的函数，s 在 函数中分配内存，但是只返回引用，引用变量作用于大于 指向的变量作用域
- slice: 同refrence， 引用一个连续的collection，但是没有ownership。 这里用来防止，在同样的作用域使用 mut refrence， 或者 mut 调用 (因为不能同时存在 mut 引用，和 非mut引用。所以自动的添加一份检查)
Generic define & syntax
定义 函数参数签名（告诉编译器 参数类型）, 形式如下:
fn largest<T>(list:&[T]) -> T {
}
struct Point<T> {
x: T,
y: T,
}
// x, y 是同一类型， 也可以写成不一样的类型
struct Point<T, U> {
x: T,
y: U,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
这里为什么显得如此怪异的原因， 在于 我们可以写出 impl Point<String> 来定定制 T=String 时候特有的方法定义。所以我们需要写成如此 impl<T> 来区分于 impl Point<String> , 声明 T 代表是一个place holder
并不会牺牲性能，没有runtime的耗时， 在编译阶段， rust 会填充 placeholder, 来完成， 不同类型的定义。
Trait: Defining Shared Behavior
- impl 定义 及其 实现
pub trait Summary {
fn summarize(&self)-> String;
fn speak(&self) -> {
self.summarize();
println!("speak");
}
}
pub struct NewsArticle {
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
println!("---------");
}
}
- Trait 类似于Interface， 共享 行为（函数） 定义，还可以 实现 类似 模板调用的方法。
- Trait 当 Function 参数
pub fn notify(item: impl Summary) {
println!("---------");
}
// Trait Bound syntax
pub fn notify<T: Summary>(item: T) {
println!("---------");
}
// multiple Trait Bound
pub fn notify<T: Summary + Display>(item: T) {
println!("---------");
}
// use where
pub fn some_function<T, U>(one: T, two: U) {
where T: Display + Clone,
U: Clone + Debug
println!("---------");
}
- Trait 当做Function 的return type, 但是 存在一些限制： 主要有， 返回值不能是不同类型， 而只能是一个确定的类型 impl trait（例如{} 中 通过if else 返回一个完全不同类型，却实现了同样的Trait 的类型）
- Trait with Generic 可以 约束 impl Generic 的 类型为实现了 Trait 的类型。
impl<T: Display + PartialOrd> Point<T> {
fn only_some(&self) {
}// 只有实现了 Display & PartialOrd trait的 Point<_> 类型，才会有 only_some 方法
}
- Advanced Traits: Traits with placeholder
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
}
}
为什么不适用这样的实现呢？
pub trait Iterator<T> {
fn next(&mut self) -> Option<T>;
}
原因在于 如果采用第二种实现， 我们需要 写成这样
impl Iterator<String> for Counter {
}
impl Iterator<i32> for Counter {
}
这里面存在多种实现方式。 更重要的是，我们在调用next时候，需要显式的指定 .next::<Iterator<String>> 来 指导 rust使用哪个Iterator<T> for Counter 的代码实现。所以第一种更可取
但是确实存在 Generic 与 Trait 结合的例子：
trait Add<RHS=Self> {
type Output;
fn add(self, rhs: RHS) -> Self::Output;
}
// 常用的声明可以如下:
struct Point {
x: i32,
y: i32,
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
// 然而我们依然可以这样，指定 RHS Generic参数， 来实现， Millimeters + Meters 的函数调用实现, 只不过，placeholder 并没有作为返回值，所有，可以直接+ 而不需要显示的，指定 + 之后的返回数值类型
struct Millimeters(u32);
struct Meters(u32);
impl Add<Meters> for Millimeters {
type Output = Millimeters;
fn add(self, other: Meters) -> Millimeters {
Millimeters(self.0 + (other.0 * 1000))
}
}
多个Trait 出现同样函数名字的情况：
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
//两个 Trait 拥有同样的函数名称，不同的函数实现。那如何在调用时候，决策函数调用实体呢？
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
// 下面，person.fly 默认调用 Human 自己的实现， 如果需要 显式的调用 Pilot::fly 则需要， 如下格式
fn main() {
let person = Human;
person.fly();
Pilot::fly(&person);
Wizard::fly(&person);
person.fly();
}
// 因为其为实例方法， 存在&self， 如果不存在呢？ 下面示例:
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", Dog::baby_name());// Ok
println!("A baby dog is called a {}", Animal::baby_name()); // Error, 下面是正解
println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
}
SuperTriat： 超级 Trait， 依赖于一个Trait的实现， 示例如下：
use std::fmt;
// 声明语法如下： trait SuperTrait: Trait {}
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
println!("output is --- {}", output);
}
}
// 我们只需要为point 实现 Display， 即可 拥有 outline_print 方法
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, {})", self.x, self.y)
}
}
impl OutlinePrint for Point {}
NewType: 因为 impl Trait for Type, 中的type需要在本地的crate，而不是 引用库 中的Type。 所以 可以通过Newtype类来包装 Type，实现一些 Trait.
这里面包含另外一些需要东西： 如何让 NewType， 伪装成Type？
实现 Deref Trait。
use std::fmt;
struct Wrapper(Vec<String>); // 新的type 类似于下边的
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
impl fmt::Display for Wrapper {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}]", self.0.join(", "))
}
}
fn main() {
let w = Wrapper(vec![String::from("hello"), String::from("world")]);
println!("w = {}", w);
}
Generic 生命周期 syntax： 用于区分函数中 参数生命周期， 对比 参数、返回值 等 生命周期之间的关系。 确保 参数传递生命周期符合 函数声明. 生命周期 需要关联 参数与返回值，才会有效果，只有参数的生命周期没有用处
fn longest(x: &str, y: &str) -> &str {
if x.len() > y.len() {
x
} else {
y
}
}
// error, rust并不能知道 函数返回值， 是x还是y， 无法检查生命周期
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
// 要求 函数返回值，应该小于等于 参数， x y的生命周期, 所以下面的函数调用是可以pass的
fn main() {
let string1 = String::from("long string is long");
{
let string2 = String::from("xyz");
let result = longest(string1.as_str(), string2.as_str());
println!("The longest string is {}", result);
}
}
// 而这个， 则是编译失败的，因为 返回值的生命周期 大于其中参数 y 的生命周期， 会导致 dangling refrence, 比如， result指向 y, 而y 在 内部的scope中已经销毁了
fn main() {
let string1 = String::from("long string is long");
let result;
{
let string2 = String::from("xyz");
result = longest(string1.as_str(), string2.as_str());
}
println!("The longest string is {}", result);
}
// 还可以这样， 总是 返回其中的一个值
fn longest<'a>(x: &'a str, y: &str) -> &'a str {
x
}
- Struct 的生命周期： struct 保持的refrence 的生命周期 与struct 生命周期关联。struct 不应该 长于 内部变量的refrence。
struct ImportantExcerpt<'a> {
part: &'a str,
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.')
.next()
.expect("Could not find a '.'");
let i = ImportantExcerpt { part: first_sentence };
}// 其中 i 的生命从周期不应该长于 novel
// impl Struct Generic 方法时候的 声明语法， 同 impl Generic。 其中声明方法时候，需要不要 生命周期 声明，需要看，是否与struct field 、 返回值 相关
impl<'a> ImportantExcerpt<'a> {
fn announce_and_return_part(&self, announcement: &str) -> &str {
println!("Attention please: {}", announcement);
self.part
}
}
Static lifetime， 静态生命周期，表明变量， 将贯穿于整个program, 将直接保存于， 代码的二进制中。
Closures:
- /|x/| {}
- FnOnce: 获取参数的ownership
- FnMut： 获取参数的 mut 引用
- Fn： 获取参数的 非mut引用
- 以上三种 为 Trait， 可以声明类型为 FN(i32) -> i32
- function as paramas： Function Pointer(fn a Type diff with Fn) ， fn 类型，实现了， Fn, FnMut, FnOnce 的实现， 即 impl Fn, FnMut, FnOnce for fn {....} 所以，可以传递 fn 到 接受 closures的 函数中。 还可以声明接受fn类型的 函数
fn add_one(x: i32) -> i32 {
x + 1
}
fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
f(arg) + f(arg)
}
fn main() {
let answer = do_twice(add_one, 5);
println!("The answer is: {}", answer);
}
// 可以 传递参数fn 类型
let list_of_numbers = vec![1, 2, 3];
let list_of_strings: Vec<String> = list_of_numbers
.iter()
.map(ToString::to_string)
.collect();
