Rust学习笔记 - 函数与所有权

0. 函数

在函数签名中,必须声明每个参数的类型。

fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
}

函数定义也是语句,语句不返回值。具有返回值的函数需这样定义:

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

在 Rust 中,函数的返回值等同于函数体最后一个表达式的值。

1. 所有权 / owner

1.1 所有权简介

所有权有以下几个规则:

  • Rust 中的每一个值都有一个被称为其所有者的变量。
  • 值有且只有一个所有者。
  • 当所有者(变量)离开作用域,这个值将被丢弃。

以下示例展示了移动一个变量后,前一个变量无效的场景。注意,Rust 永远不会自动创建数据的“深拷贝”:

let s1 = String::from("hello");
let s2 = s1;

println!("{}, world!", s1); // error

如果我们确实需要深度复制 String 中堆上的数据,而不仅仅是栈上的数据,则需使用 clone 函数:

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

如果一个类型拥有 Copy trait,一个旧的变量在将其赋值给其他变量后仍然可用。

  • 所有整数类型,比如 u32
  • 布尔类型 bool
  • 所有浮点数类型,比如 f64
  • 字符类型,char
  • 元组,当且仅当其包含的类型也都是 Copy 时。比如,(i32, i32)

一个函数间转移返回权的例子如下:

fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 移给 s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中, 
                                        // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域,但已被移走,
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String {             // gives_ownership 将返回值移动给
                                             // 调用它的函数
 
    let some_string = String::from("hello"); // some_string 进入作用域.

    some_string                              // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

    a_string  // 返回 a_string 并移出给调用的函数
}

1.2 引用与借用

引用允许我们使用值但不获取其所有权,例如:

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
    s.len()
}

获取引用作为函数参数被称为借用,而默认情况下不允许修改引用的值,若需修改必须创建一个可变引用。需要注意几点:

  1. 在特定作用域中的特定数据有且只能有一个可变引用,以避免数据竞争。
  2. 不能在拥有不可变引用的同时拥有可变引用。

一个可变引用的示例如下:

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

Rust 编译器会确保引用永远不会变成悬垂状态:

fn dangle() -> &String { // dangle 返回一个字符串的引用

    let s = String::from("hello"); // s 是一个新字符串

    &s // 返回字符串 s 的引用,解决办法是直接返回 String
} // 这里 s 离开作用域并被丢弃。其内存被释放。

总结来看:

  • 在任意给定时间,要么只能有一个可变引用,要么只能有多个不可变引用。
  • 引用必须总是有效。

1.3 Slice

let s = String::from("hello world");

// .. 是 range 语法,两边下标可省略
let hello = &s[0..5]; // 不包含结束下标
let world = &s[6..=10]; // 包含结束下标

字符串字面值就是 slice。

Leave a Comment