首页 > 其他分享 >Rust 中 *、&、mut、&mut、ref、ref mut 的用法和区别

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

时间：2024-07-25 15:31:21浏览次数：16  
标签：mut let Rust println ref fn 引用

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

标签：mut,let,Rust,println,ref,fn,引用
From： https://www.cnblogs.com/risheng/p/18323252

相关文章

  • 详情 | GeoTrust OV通配符HTTPS证书申请流程
    GeoTrust是高端证书品牌，拥有强大的品牌背书。其SSL证书在全球范围内得到广泛认可，为企业的网络安全提供了有力保障。而GeoTrust的OV通配符证书更是众多企业的首选!选择一个合适的渠道进行申请购买择尤为重要！下面是GeoTrustOV通配符证书具体申请流程GeoTrustOV通配符......
  • selenium.webdriver.Firefox 与 FirefoxOptions().add_argument('--headless') 不返回
    我注意到Firefox中的无头选项会在后台运行Firefox，而不会附加任何窗口，而且我还没有找到一种方法可以在后台运行Firefox，同时仍保留Firefox窗口的hwnd能够使用。我开始使用pyvda来获取AppViewFirefox，但是pyvda.get_apps_by_z_order没有返回任......
  • rust 初探 -- 枚举和模式匹配
    rust初探–枚举和模式匹配定义枚举enumIpAddrKind{//将数据附加到枚举的变体中//-不需要额外使用struct//-每个变体可以拥有不同的类型以及关联的数据量V4(String),V6(String),}可以使用impl为枚举定义方法enumIpAddrKind{......
  • [POI2012] PRE-Prefixuffix 题解
    前言题目链接：洛谷。题意简述给出长为\(n\)的串\(\texttt{S}\)。求最大的\(l\)满足：\[2l\leqn\land\texttt{S}[1\ldotsl]\doteq\texttt{S}[n-l+1\ldotsn]\]其中\(\doteq\)表示循环相同。题目分析看到循环相同，套路化想到，两个字符串一定可以表示成\(\tex......
  • Rust——所有权
    前言所有权是Rust最独特的特性，对语言的其余部分有着深远的影响。它使Rust能够在不需要垃圾收集器的情况下保证内存安全，因此了解所有权的运作方式非常重要。在本章中，我们将讨论所有权以及几个相关功能：借用、切片以及Rust如何在内存中布局数据。内容什么是所有权所有权是......
  • rust poem sse
    Cargo.toml:[package]name="sse"version="0.1.0"edition="2021"[dependencies]futures-util="0.3.30"poem={version="3.0.3",features=["sse"]}tokio={version="1.39.1&quo......
  • 配置文件mybatis-plus: global-config: db-config: table-prefix: true
    具体来说，table-underline的含义是：当table-underline设置为true时：假设你有一个实体类名为UserInfo，那么MyBatis-Plus会默认去数据库中寻找名为user_info的表（即，驼峰命名法自动转换为下划线命名法）。同理，如果你的数据库表名是user_info，但你的实体类名是UserInfo，那么M......
  • 如何调试：断言错误：blk ref_locs 中的间隙
    我不知道如何解决这个似乎是随机发生的错误。我无法分享源代码，但如果有任何关于我可以采取哪些措施来防止此错误的想法，我将不胜感激。现在，我认为作为一种解决方法，我将捕获错误并重试...不确定这是否有效。就像上下文一样，我有一个生产者线程（显示问题的线程）填充数据帧以供消费者读......
  • golang channel 和 mutex 及原子操作 用于并发控制的性能对比
    场景：对同个数加10w次，看耗费时间，这里没有用benchmark测试，在意的请略过。以下是测试代码：packagemainimport( "fmt" "sync" "sync/atomic" "testing" "time")funcTestCount(t*testing.T){ varcntint varwgsync.WaitGroup num......
  • rust axum sse
    Cargo.toml:[package]name="sse"version="0.1.0"edition="2021"[dependencies]axum="0.7.5"axum-extra={version="0.9.3",features=["typed-header"]}eventsource-stream="0.2......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99