Rust 中 *、&、mut、&mut、ref、ref mut 的用法和区别

Rust 中 *、&、mut、&mut、ref、ref mut 的用法和区别

在 Rust 中，*、ref、mut、& 和 ref mut 是用于处理引用、解引用和可变性的关键字和操作符，它们在不同的上下文中有不同的用法。

一、* 解引用

* 属于操作符

1. 作用

用于解引用指针或引用，以访问其指向的值。
通过解引用，可以从指针或引用中获取实际的值。

2. 用法

2.1. 解引用不可变引用

fn main() {
    let x = 5;
    let y = &x; // y 是对 x 的不可变引用
    println!("y: {}", *y); // 通过解引用 y 获取 x 的值，输出: y: 5
}

2.2. 解引用可变引用

fn main() {
    let mut x = 10;
    let y = &mut x; // y 是对 x 的可变引用
    *y += 5; // 通过解引用 y 修改 x 的值
    println!("x: {}", x); // 输出: x: 15
}

2.3. 解引用指针

fn main() {
    let x = 42;
    let y = &x as *const i32; // 创建不可变裸指针
    unsafe {
        println!("y: {}", *y); // 解引用不可变裸指针
    }
    
    let x = Box::new(10); // Box 智能指针
    println!("x: {}", *x); // 解引用 Box，获取其值，输出: x: 10
}

二、& 借用引用

& 也是操作符

1. 作用

创建一个值的不可变引用，允许读而不获取所有权，该值在引用期间是只读的。

2. 用法

2.1. 不可变引用

fn main() {
    let x = 10;
    let y = &x; // y 是对 x 的不可变引用
    println!("y: {}", y); // 输出: y: 10
}

2.2. 函数中的借用

fn print_value(x: &i32) {
    println!("Value: {}", x);
}

fn main() {
    let a = 10;
    print_value(&a); // 传递 a 的不可变引用
}

2.3. match 中使用

fn main() {
    let reference = &4;
    match reference {
        &val => println!("Got a value via destructuring: {:?}", val),
    }
}

2.4. 结构体中使用

struct Point<'a> {
    x: &'a i32,
    y: &'a i32,
}
fn main() {
    let x = 10;
    let y = 20;
    let point = Point { x: &x, y: &y }; // 使用引用初始化结构体字段
    println!("Point: ({}, {})", point.x, point.y); // 输出: Point: (10, 20)
}

2.5. 集合中使用

fn main() {
    let vec = vec![1, 2, 3];
    for val in &vec {
        println!("Value: {}", val); // 输出: 1, 2, 3
    }
}

2.6. 切片中使用

fn main() {
    let s = String::from("hello");
    let slice = &s[0..2]; // 创建字符串切片
    println!("Slice: {}", slice); // 输出: Slice: he
}

三、mut 可变

mut 是一个关键字

1. 作用

声明一个变量或引用为可变的，可以修改其值。

2. 用法

2.1. 可变变量

fn main() {
    let mut x = 5; // x 是可变的
    x += 1;
    println!("x: {}", x); // 输出: x: 6
}

2.2. 函数中可变参数

fn increment(mut num: i32) -> i32 {
    num += 1;
    num
}

2.3. 可变引用

fn main() {
    let mut x = 5;
    let y = &mut x;
    *y += 1;
    println!("{}", x); // 输出 6
}

2.4. 可变结构体

struct Point {
    x: i32,
    y: i32,
}
fn main() {
    let mut p = Point { x: 0, y: 0 };
    p.x = 5;
    p.y = 10;
    println!("Point: ({}, {})", p.x, p.y); // 输出 Point: (5, 10)
}

2.5. 可变元组

let mut tuple = (5, 10);
tuple.0 = 15;

2.6. match 中使用

match Some(10) {
    Some(mut value) => {
        value += 1;
        println!("{}", value); // 输出 11
    }
    None => {},
}

2.7. 集合中使用

let mut vec = vec![1, 2, 3];
for num in &mut vec {
    *num += 1;
}
println!("{:?}", vec);

四、&mut 可变借用引用

&mut 既不属于操作符也不属于关键字

1. 作用

创建一个值的可变引用，允许修改值而不获取所有权。

2. 用法

2.1. 可变引用

fn main() {
    let mut x = 10;
    {
        let y = &mut x; // y 是对 x 的可变引用
        *y += 5; // 修改 x 的值
    } // y 的生命周期结束，此时 x 的可变借用结束
    println!("x: {}", x); // 输出: x: 15
}

2.2. 函数中的可变引用

fn add_one(x: &mut i32) {
    *x += 1;
}

fn main() {
    let mut a = 10;
    add_one(&mut a); // 传递 a 的可变引用
    println!("a: {}", a); // 输出: a: 11
}

2.3. 结构体中的可变引用

struct Point<'a> {
    x: &'a mut i32,
    y: &'a mut i32,
}
fn main() {
    let mut x = 10;
    let mut y = 20;
    let point = Point { x: &mut x, y: &mut y }; // 使用可变引用初始化结构体字段
    *point.x += 1;
    *point.y += 1;
    println!("Point: ({}, {})", point.x, point.y); // 输出: Point: (11, 21)
}

2.4. 集合中的可变引用

fn main() {
    let mut vec = vec![1, 2, 3];
    for val in &mut vec {
        *val += 1; // 修改集合中的元素
    }
    println!("{:?}", vec); // 输出: [2, 3, 4]
}

2.5. match 中使用

fn main() {
    let mut pair = (10, 20);
    match pair {
        (ref mut x, ref mut y) => {
            *x += 1;
            *y += 1;
            println!("x: {}, y: {}", x, y); // 输出: x: 11, y: 21
        },
    }
}

2.6. 结构体中使用

struct Counter {
    value: i32,
}
impl Counter {
    fn increment(&mut self) {
        self.value += 1;
    }
}
fn main() {
    let mut counter = Counter { value: 0 };
    counter.increment(); // 使用可变引用调用方法
    println!("Counter value: {}", counter.value); // 输出: Counter value: 1
}

五、ref 模式匹配中创建引用

ref 属于关键字

1. 作用

在模式匹配中借用值的不可变引用，而不是获取所有权。

2. 用法

2.1. 元组中使用

fn main() {
    let tuple = (1, 2);
    let (ref x, ref y) = tuple; // x 和 y 是对 tuple 中元素的不可变引用
    println!("x: {}, y: {}", x, y); // 输出: x: 1, y: 2
}

2.2. match 中使用

fn main() {
    let pair = (10, 20);
    match pair {
        (ref x, ref y) => {
            println!("x: {}, y: {}", x, y); // x 和 y 是 pair 元素的不可变引用
        }
    }
}

2.3. if let / while let 中使用

// if let
fn main() {
    let some_value = Some(42);
    if let Some(ref x) = some_value {
        println!("Found a value: {}", x); // x 是 some_value 的不可变引用
    }
}
// while let
fn main() {
    let mut stack = vec![1, 2, 3];
    while let Some(ref x) = stack.pop() {
        println!("Popped: {}", x); // x 是 stack 中最后一个元素的不可变引用
    }
}

2.4. 函数中使用

fn print_ref((ref x, ref y): &(i32, i32)) {
    println!("x: {}, y: {}", x, y); // x 和 y 是元组元素的不可变引用
}
fn main() {
    let pair = (10, 20);
    print_ref(&pair); // 传递 pair 的引用
}

2.5. for 循环中使用

fn main() {
    let vec = vec![1, 2, 3];
    for ref x in &vec {
        println!("x: {}", x); // x 是 vec 中元素的不可变引用
    }
}

六、ref mut 模式匹配中创建可变引用

ref mut 属于关键字

1. 作用

在模式匹配中借用值的可变引用，允许修改该值。

2. 用法

2.1. match 中使用

fn main() {
    let mut pair = (10, 20);
    match pair {
        (ref mut x, ref mut y) => {
            *x += 1;
            *y += 1;
            println!("x: {}, y: {}", x, y); // 输出: x: 11, y: 21
        }
    }
    // pair 的值已经被修改
}

2.2. if let / while let 中使用

fn main() {
    let mut some_value = Some(42);
    if let Some(ref mut x) = some_value {
        *x += 1;
        println!("Found a value: {}", x); // 输出: Found a value: 43
    }
}
fn main() {
    let mut stack = vec![1, 2, 3];
    while let Some(ref mut x) = stack.pop() {
        *x += 1;
        println!("Popped: {}", x); // 输出: Popped: 4, Popped: 3, Popped: 2
    }
}

2.3. 函数中使用

fn increment_tuple((ref mut x, ref mut y): &mut (i32, i32)) {
    *x += 1;
    *y += 1;
}

fn main() {
    let mut pair = (10, 20);
    increment_tuple(&mut pair); // 传递 pair 的可变引用
    println!("pair: {:?}", pair); // 输出: pair: (11, 21)
}

2.4. 解构赋值

fn main() {
    let mut pair = (10, 20);
    let (ref mut x, ref mut y) = pair;
    *x += 1;
    *y += 1;
    println!("x: {}, y: {}", x, y); // 输出: x: 11, y: 21
    println!("{:?}", pair); // (11, 21)
}

七、总结

• *：解引用操作符，用于访问指针或引用指向的值的类型。
• &：借用操作符，用于创建不可变引用的类型，允许只读访问。
• mut：关键字，用于声明可变变量或参数的类型，允许其值被修改。
• &mut：借用操作符，用于创建可变引用的类型，允许读写访问。
• ref：模式匹配中的关键字，用于创建不可变引用的类型，避免所有权转移。
• ref mut：模式匹配中的关键字，用于创建可变引用的类型，允许修改引用的值。