在 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：模式匹配中的关键字，用于创建可变引用的类型，允许修改引用的值。
