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：模式匹配中的關鍵字，用於建立可變引用的型別，允許修改引用的值。