在"if let Some(ref mut x) = option“和"if let Some(x) = option.as_mut()”中匹配可变选项引用有什么区别？
在"if let Some(ref mut x) = option"和"if let Some(x) = option.as_mut()"中匹配可变选项引用有以下区别：
- 语法形式不同：第一个示例使用的是模式匹配的方式，而第二个示例使用的是Option类型的方法
as_mut()返回一个可变引用。 - 可变性：第一个示例中，使用
ref mut x可以创建一个可变引用，使得在匹配成功时，可以通过该引用修改被匹配的值。而第二个示例中，x是一个普通变量，如果需要修改被匹配的值，需要使用as_mut()方法返回的可变引用。 - 匹配方式：第一个示例中，匹配的是
Some(ref mut x)，即匹配Some中的值，并创建一个可变引用x。而第二个示例中，使用Some(x)匹配Some中的值，直接取得该值的所有权。
综上所述，两者的区别在于匹配方式和可变性。第一个示例适用于需要在匹配成功后修改被匹配值的情况，而第二个示例更适用于需要获取被匹配值所有权的情况。
对于这个问题，腾讯云并没有直接相关的产品或产品介绍链接地址。
相关·内容
1回答
如何访问选项中的向量，而不必在第一次访问时将其移动？
fn maybe_push(v_option: Option<&mut Vec<usize>>) -> usize {
let mut c = 0;
if let Some(v) = v_option {
for i in 0..10 {
v.push(i);
c += i;
}
} else {
for i in 0..10 {
c += i;
浏览 2提问于2016-11-17得票数 2
回答已采纳
我有一个Option<&mut T>，希望多次访问包含的引用，如下所示：
fn f(a: Option<&mut i32>) {
if let Some(x) = a {
*x = 6;
}
// ...
if let Some(x) = a {
*x = 7;
}
}
fn main() {
let mut x = 5;
f(Some(&mut x));
}
这不起作用，因为if let Some(x) = a将引用值从选项中移出，而第二个if let S
浏览 1提问于2017-02-18得票数 9
回答已采纳
我实现了一些基本的链接列表操作：
use std::mem;
//Generic List
struct LinkedList<T> {
head: Option<Box<Node<T>>>,
}
struct Node<T> {
element: T,
next: Option<Box<Node<T>>>,
}
//List functions
impl<T> LinkedList<T> {
//Create empty list
浏览 2提问于2017-01-23得票数 0
回答已采纳
我有一个函数返回一个结果<&‘a ~Foo，BarErr>，我可以使用以下方法访问该函数：
match x.borrow() {
Ok(ref foo) => println!("Found {}", foo.value),
Err(Nope) => println!("Bleh")
}
然而，我发现我现在处于一个更复杂的情况，我想借用一个可变的引用，这样我就可以调用它上的函数：
match x.borrow() {
Ok(ref foo) => { foo.inc(); trace!("Found {}
浏览 3提问于2014-03-10得票数 3
回答已采纳
1回答
我有一个两个大小写的枚举：
#[derive(Debug)]
pub enum Enum {
Str(String),
Fields { len: u32, opt: Option<String> },
}
use Enum::*;
我想就地更新我的枚举，具体取决于它的值。这在一开始是可行的：
pub fn update(x: &mut Enum) {
match x {
&mut Str(ref mut s) => { s.push('k'); }
&mut Fields {
浏览 0提问于2018-01-12得票数 1
1回答
我创建了一个处理有向图的：将节点链接(引用计数)到零或其他一个节点(就像链接列表中的那样，但在有向图中，节点可以由多个节点链接)。
我试图使用我的库创建一个具有当前节点的列表：
struct ListWithPointer<'a> {
pub nodes: DigraphNodeRef<String>,
pub current_node: Option<&'a mut DigraphNodeRef<String>>,
}
current_node指向列表中的链接。
现在，我试图将当前节点移动到列表的下一个元
浏览 6提问于2022-02-01得票数 -1
我对Rust很陌生，我想知道是否有一种自然的方式来编写下面的内容，同时在元组上进行模式匹配。
我有一个树状结构，包括key、value、left和right成员。我希望创建一个看起来类似于
fn insert(&mut self, k: K, v: V) -> Option<V> {
match (k.cmp(self.k.borrow()), &mut self.left, &mut self.right) {
(Ordering::Less, &mut None, _) => { self.left = Som
浏览 3提问于2015-04-30得票数 2
回答已采纳
2回答
我很难理解如何修改Mutex中的选项。
当没有选择的时候，它可以正常工作
let mut my_int = Arc::new(Mutex::new(5));
let my_int_clone = Arc::clone(&my_int);
thread::spawn(move || {
let mut my_int = my_int_clone.lock().unwrap();
*my_int += 1;
}).join();
let my_int_clone_print = Arc::clone(&my_int);
println!("Value: {}&
浏览 3提问于2020-06-07得票数 3
回答已采纳
学习一些生锈编程(Leetcode Q3)。
得到了错误：
cannot borrow `result` as immutable because it is also borrowed as mutable
immutable borrow occurs hererustcE0502
solution.rs(42, 23): mutable borrow occurs here
solution.rs(44, 13): mutable borrow later used here
我可以将程序从if result.is_none() {更改为if current.is_none() {，这样
浏览 9提问于2022-04-14得票数 0
回答已采纳
因此，我试图在Rust中实现一个链接列表，以便更好地理解语言，下面是我想出的。
use std::rc::Rc;
use std::fmt::Debug;
struct Node<T>
where
T: Debug,
{
value: T,
next: Option<Rc<Box<Node<T>>>>,
}
pub struct LinkedList<T>
where
T: Debug,
{
start: Option<Rc<Box<Node<T>&g
浏览 5提问于2022-12-03得票数 0
回答已采纳
1回答
有任何选项可以从Option<&mut Foo>中提取可变引用吗？我发现的只有as_ref()，它提取了一个不变的引用。
浏览 1提问于2021-10-18得票数 1
回答已采纳
2回答
我想解决锈蚀()中的一个leetcode问题。我的解决方案使用两个指针查找要删除的Node：
#[derive(PartialEq, Eq, Debug)]
pub struct ListNode {
pub val: i32,
pub next: Option<Box<ListNode>>,
}
impl ListNode {
#[inline]
fn new(val: i32) -> Self {
ListNode { next: None, val }
}
}
// two-pointer slid
浏览 3提问于2019-01-17得票数 9
回答已采纳
我试图理解以下代码失败的原因：
fn main() {
let mut a = 10;
let mut b = 20;
let mut c = 30;
let p = vec![&mut a, &mut b, &mut c]; // works with [&a, &b, &c]
for &x in &p { // works with 'x' instead of of '&x'
println!("{}", x);
浏览 0提问于2018-03-07得票数 1
回答已采纳
我尝试将匹配结果发送到函数Foo，但匹配结果的类型为Some()
如何将其作为参数发送到Foo函数？
struct Person {
name: Option<String>,
lastname: Option<String>,
}
fn Foo(x: Option<String>) {
println!("{:?}", x);
}
fn main() {
let name = "Steve".to_string();
let lastname = "Alvarez"
浏览 0提问于2020-02-18得票数 0
我正在实现一个二进制搜索树。完整的代码。
type Link<K, V> = Option<Box<Node<K, V>>>;
struct Node<K, V> {
key: K,
val: V,
left: Link<K, V>,
right: Link<K, V>,
n: usize, // nodes in subtree rooted here
}
pub struct BST<K, V> {
root: Link<K, V>,
浏览 6提问于2021-12-22得票数 0
回答已采纳
该代码编译：
struct BufRef<'a> {
buf: &'a [u8],
}
struct Foo<'a> {
buf_ref: BufRef<'a>,
}
impl<'a> Iterator for Foo<'a> {
type Item = &'a [u8];
fn next(&mut self) -> Option<Self::Item> {
let result =
浏览 0提问于2019-09-08得票数 7
回答已采纳
试图了解什么是错误的
fn set_inpt_port_values1(&mut self, input_port_values: HashMap<u8, u8>) {
if let Some(mut io_handler) = self.io_handler {
io_handler.set_input_ports_values(input_port_values);
}
}
获取
cannot move out of `self.io_handler.0` which is behind a mutable referencerustcE0
浏览 2提问于2021-07-11得票数 0
回答已采纳
2回答
这是一个Thing
struct Thing(i32);
impl Thing {
pub fn increment_self(&mut self) {
self.0 += 1;
println!("incremented: {}", self.0);
}
}
下面是一个函数，它尝试变异Thing并返回true或false，这取决于Thing是否可用：
fn try_increment(handle: Option<&mut Thing>) -> bool {
if let Some(t
浏览 2提问于2019-02-26得票数 1
回答已采纳
我想为整数索引序列实现一个。为了提高效率，重要的是通过索引序列(而不是某种映射)将节点的子节点与节点关联。为了说明基本思想，下面是Ruby中的一个实现：
require 'virtus'
class TrieNode
include Virtus.model
attribute :terminal, Boolean, default: false
attribute :children, Array, default: []
def add(i, vec)
if i == vec.length
terminal = true
浏览 4提问于2016-04-30得票数 0
回答已采纳
1回答
我试图通过使用静态变量的C回调来提供闭包。我能够使用Fn类型，但我希望通过FnMut使其工作，为库的用户提供更多的功能。
我现在拥有的是：
lazy_static! {
static ref CALLBACK: Mutex<RefCell<Box<FnMut(Result<&str>) + Send>>> = Mutex::new(RefCell::new(Box::new(|_|())));
}
fn wrap_cb<F: Fn(Result<&str>)>(f: Option<F>
浏览 0提问于2018-03-01得票数 3
回答已采纳
3回答
我试着去了解锈蚀中的生命是如何影响结构的。附件是一个很小的例子，让我感到困惑。
我想给一个结构一个对对象的引用，然后有必要修改这个对象。由于不可能在借来时更改对象，所以我认为必须在更改对象时删除引用。因此，我的想法是将变量定义为一个选项，并通过将其设置为None来删除对象修改过程中的引用。对于不使用Struct的示例来说，这似乎是可行的。但是，如果我现在把这个引用放到一个结构中，它就不能工作了。在我看来，借用检查器忽略了变量string不再被借用的事实。是否仍有一种方法可以通过结构实现预期的行为？
此工作()：
fn main() {
let mut string = "mut
浏览 2提问于2021-10-12得票数 5
回答已采纳
我正试图为类型为Vec<Vec<(K, V)>>的向量创建一个可变迭代器。
迭代器代码：
pub struct IterMut<'a, K: 'a, V: 'a> {
iter: &'a mut Vec<Vec<(K, V)>>,
ix: usize,
inner_ix: usize,
}
impl<'a, K, V> Iterator for IterMut<'a, K, V> {
type Item = (&&
浏览 4提问于2017-02-24得票数 3
回答已采纳
1回答
当我试图实现一个迭代器来产生链表元素的可变引用时，我偶然发现了一个奇怪的问题。
这可以很好地工作：
impl<'a, T> Iterator<&'a T> for LinkedListIterator<'a, T>{
fn next(&mut self) -> Option<&'a T> {
match self.current {
&Cell(ref x, ref xs) => {self.current = &*
浏览 3提问于2014-01-08得票数 5
1回答
我试图在&[u8]的可变缓冲区上迭代，每当有--时，删除所有字节，直到遇到'\n'为止。
我尝试过这种方法，它产生了一个我无法解决的错误。
fn remove_comments_in_place<'a>(buffer: &'a mut [u8]) {
#[derive(PartialEq)]
enum Mode {
COMMENT,
CODE,
}
let mut mode = Mode::CODE;
let mut iter = buffer.iter_mut(
浏览 3提问于2018-01-03得票数 1
回答已采纳
我在试图确定所有权规则。我想：
从切片的可变引用开始
对它的内容做一些修改
将切片引用缩减为子片的引用，并重复。
以下是我的尝试：
pub fn example() {
// Make a mutable slice
let mut v = [0, 1, 2, 3];
// Make a mutable reference to said slice
let mut v_ref = &mut v[..];
while v_ref.len() > 1 {
// Involves some edits -
浏览 0提问于2018-08-26得票数 0
回答已采纳
考虑一下这个玩具代码：
struct X {
x: usize,
times_accessed: usize,
}
impl X {
fn get(&mut self) -> usize {
self.times_accessed = self.times_accessed + 1;
self.x
}
}
struct Y {
y: usize,
max_access: usize,
option_x: Option<X>,
}
impl Y {
fn get_x(&
浏览 1提问于2017-12-03得票数 0
回答已采纳
我正在为一个C库编写一个Rust包装器，在这样做的同时，我试图利用中提到的“可空指针优化”，但是我找不到像他们描述的那样将Option<&T>转换为*const T和Option<&mut T>到*mut T的好方法。
我真正想要的是能够调用Some(&foo) as *const _。不幸的是，这不起作用，所以我能想到的下一个最好的事情就是Option<T>上的一个特性，它使我能够调用Some(&foo).as_ptr()。以下代码是该特性的有效定义和实现：
use std::ptr;
trait AsPtr<T&g
浏览 10提问于2016-03-09得票数 6
回答已采纳
背景 考虑一个玩具问题，在这个问题中，我有一个表示链表节点的Node结构，并且我想创建一个用1到9之间的值构建列表的函数。以下代码按预期工作： struct Node {
val: i32,
next: Option<Box<Node>>,
}
fn build_list() -> Option<Box<Node>> {
let mut head = None;
let mut tail = &mut head;
for n in 1..10 {
*tail = Some(
浏览 40提问于2020-07-13得票数 10
回答已采纳
1回答
我想要创建一个可更改的迭代器来控制修改，为此，我创建了一个名为FitnessIterMut的结构，用于impl Iterator特性。next()方法提供了一个结构，当修改完成时，它可以对容器本身执行操作。(这是做这种事的好办法吗?)
pub struct FitnessModifier<'a, T: 'a> {
wheel: &'a mut RouletteWheel<T>,
value: &'a mut (f32, T)
}
impl<'a, T> FitnessModifier&
浏览 2提问于2016-05-21得票数 3
回答已采纳
fn main () {
let x: &Option<_> = &Some(90);
match x {
// no ref
&Some(y) => {
print!("{}", y);
},
&None => {
},
}
match x {
// ref
&Some(ref y) => {
浏览 15提问于2020-06-28得票数 0
回答已采纳
如何从Option中提取引用并将其传递回调用者的特定生命周期？
具体地说，我想从一个包含Box<Foo>的Bar中借用一个对Option<Box<Foo>>的引用。我以为我能做到：
impl Bar {
fn borrow(&mut self) -> Result<&Box<Foo>, BarErr> {
match self.data {
Some(e) => Ok(&e),
None => Err(BarErr::No
浏览 0提问于2014-03-09得票数 51
回答已采纳
我试图迭代地导航递归数据结构，以便在某个位置插入元素。据我有限的理解，这意味着对结构的根进行可变的引用，并将其依次替换为对其追随者的引用：
type Link = Option<Box<Node>>;
struct Node {
next: Link
}
struct Recursive {
root: Link
}
impl Recursive {
fn back(&mut self) -> &mut Link {
let mut anchor = &mut self.root;
浏览 0提问于2016-06-23得票数 26
回答已采纳
我正在编写一个函数，它从单链列表中移除最后一个节点：
#[derive(PartialEq, Eq, Debug)]
struct Node<T> {
value: T,
next: Option<Box<Self>>,
}
以下是我的递归版本：
fn remove_last_node_recursive<T>(node_ref: &mut Option<Box<Node<T>>>) {
let next_ref = &mut node_ref.as_mut().unwr
浏览 0提问于2019-08-25得票数 1
回答已采纳
因此，我遇到了，展示了如何在锈蚀中创建“不可移动”类型--因为编译器将对象视为其整个生命周期中的借来的，因此防止了移动。
use std::cell::Cell;
use std::marker;
struct Unmovable<'a> {
lock: Cell<marker::ContravariantLifetime<'a>>,
marker: marker::NoCopy
}
impl<'a> Unmovable<'a> {
fn new() -> Unmova
浏览 2提问于2015-02-06得票数 10
回答已采纳
我有Input结构，它包含ref to Data结构实例。此Data结构包含要重写的字段，并希望在其他函数之间共享。当我试图从某个地方修改Data实例的某些字段时，我得到了一个错误，如：
不能分配给data.value1，它位于&引用后面
这是我的密码：
struct Data {
value1: Option<i32>,
value2: Option<String>,
value3: Option<Vec<u8>>,
}
impl Data {
pub fn new() -> Self {
浏览 2提问于2022-05-31得票数 0
回答已采纳
我正在尝试更新树结构的一个节点。随机选择要更新的节点。要使用库采样算法对树中的节点进行采样，我必须遍历这些节点，因此我尝试为我的Node枚举创建一个Iterator。
问题是，一方面，我必须将子节点的引用存储在堆栈或队列中，但另一方面，我必须返回父节点的可变引用。Rust不允许对一个值进行多个可变引用，也不允许将不可变引用转换为可变引用。
有没有一种方法可以遍历可变树？或者，是否有另一种方法可以随机获取对树中节点的可变引用？
这是我的代码。
#![feature(box_syntax, box_patterns)]
extern crate rand;
// Simple binary tr
浏览 28提问于2018-03-02得票数 3
回答已采纳
我已经在Rust中创建了一个数据结构，我想为它创建迭代器。不可变的迭代器非常简单。我目前有这个，它工作得很好：
// This is a mock of the "real" EdgeIndexes class as
// the one in my real program is somewhat complex, but
// of identical type
struct EdgeIndexes;
impl Iterator for EdgeIndexes {
type Item = usize;
fn next(&mut self) -&g
浏览 26提问于2014-09-09得票数 41
回答已采纳
1回答
我正在努力学习Rust，我觉得自己就像一个假人在前进的每一步。
我读了一本关于在“锈”中制作列表的教程。我正在尝试应用这些知识来实现一个简单的BST。
不过，代码看上去很恐怖。对如何改进它有什么建议吗？
pub struct Tree<T: Ord> {
root: Link<T>,
}
type Link<T> = Option<Box<Node<T>>>;
pub struct Node<T:Ord> {
elem: T,
left: Link<T>,
rig
浏览 0提问于2019-11-08得票数 3
回答已采纳
我想在铁锈里建立一个不相交的数据结构。有关守则是：
pub struct Set<'a, T: 'a> {
rank: u32,
value: T,
parent: Option<&'a mut Set<'a, T>>,
}
impl<'a, T> Set<'a, T> {
pub fn find(&'a mut self) -> &'a mut Set<'a, T> {
浏览 3提问于2015-01-28得票数 6
我有以下代码片段，它实现了某种类型的发射器结构：
type Callback<'a> = Option<&'a mut dyn FnMut()>;
struct Emitter<'a> {
cb: Callback<'a>
}
impl<'a> Emitter<'a> {
fn emit(&mut self) {
if self.cb.is_some() {
let f = self.cb.unwrap();
f(
浏览 2提问于2021-08-26得票数 2
回答已采纳
1回答
use std::collections::HashMap;
#[derive(Clone, Hash, Eq, PartialEq)]
struct HeavyCloneKey;
struct Map<V> {
map : HashMap<HeavyCloneKey, V>
}
impl<V> Map<V> {
pub fn get_mut(&mut self, key: &HeavyCloneKey) -> Option<&mut V> {
if let Som
浏览 1提问于2021-04-26得票数 0
以下代码无法编译：
struct Things {
things: Vec<usize>
}
struct ThingsIterMut<'a> {
contents: &'a mut Vec<usize>,
indices: std::slice::Iter<'a, usize>
}
impl<'a> Iterator for ThingsIterMut<'a> {
type Item = &'a mut usize;
浏览 1提问于2021-02-23得票数 0
我想从头到尾实现一个链接列表。基本思想是将新元素添加到列表的末尾，要求程序循环到最后一个元素来追加。
我意识到有一个LinkedList类型作为标准库的一部分，但是为了教育目的，我正在尝试实现这个类型。
我还看了锈蚀教程，但这并不是我真正想要的，因为它实现了堆栈，在开始时放置了新的元素。
我提出的代码如下：
#[derive(Debug)]
struct Node {
value: i32,
next: Option<Box<Node>>,
}
struct LinkList {
head: Option<Box<Node>&
浏览 0提问于2019-11-10得票数 3
回答已采纳
如果我有一个绑定到结构的不可变变量，Rust通常不会允许我改变结构的字段或拥有的子结构的字段。
但是，如果字段是可变引用，Rust 将允许我在绑定不可变的情况下对引用对象进行变异。
为什么这是允许的？它不符合铁锈的不变性的正常规则吗？
铁锈不会允许我通过一个不变的引用来做同样的事情，所以一个不变的引用与一个不可变的绑定有不同的行为。
代码示例：
struct Bar {
val: i32,
}
struct Foo<'a> {
val: i32,
bar: Bar,
val_ref: &'a mut i32,
}
fn m
浏览 0提问于2018-05-01得票数 15
回答已采纳
我试图在Rust中实现一个二进制搜索树，但在插入元素时遇到了问题。在Rust中做这件事的惯用方法是什么？
下面是我的实现：
use std::cmp::Ordering;
pub struct BinarySearchTree {
root: OptNode,
size: u32,
}
type OptNode = Option<Box<Node>>;
struct Node {
key: i32,
left: OptNode,
right: OptNode,
}
impl BinarySearchTree {
p
浏览 4提问于2016-06-27得票数 5
我正在实现一个类似堆栈的结构，其中该结构包含对切片的可变引用。 struct StackLike<'a, X> {
data: &'a mut [X],
} 我希望能够从堆栈中弹出最后一个元素，例如： impl<'a, X> StackLike<'a, X> {
pub fn pop(&mut self) -> Option<&'a X> {
if self.data.is_empty() {
return None;
浏览 17提问于2020-04-15得票数 6
回答已采纳
我正在编写一个链接列表，其中存在连接前一个节点的弱引用。
use std::cell::{Ref, RefCell, RefMut};
use std::rc::{Rc, Weak};
pub struct List<T> {
head: NextLink<T>,
tail: PrevLink<T>,
}
type NextLink<T> = Option<Rc<RefCell<Node<T>>>>;
type PrevLink<T> = Weak<RefCel
浏览 3提问于2020-09-02得票数 3
回答已采纳
3回答
我需要在树中找到值最大的节点，假设子节点的值总是大于所属节点的值，然后进行修改：
#[derive(Debug)]
struct Node {
val: usize,
nodes: Vec<Node>,
}
fn find_max(node: &mut Node, val: usize) -> Option<&mut Node> {
if node.val < val {
return None;
}
let mut max_val = node.val;
let mut ma
浏览 0提问于2017-10-24得票数 0
在下面的代码中，我期望编译器抱怨使用移动值: xref on hello函数自以来的第二次调用。编译器不会引发任何这样的错误。我在这里错过了什么？
fn main() {
let mut x: String = "Developer".to_string();
let x_ref: &mut String = &mut x;
hello(x_ref);
hello(x_ref);
}
fn hello(a: &mut String) {
println!("Hello {}", a);
}
浏览 1提问于2021-04-28得票数 3
我正在通过读“这本书”来自学生锈。当我在做这个链接中的第一个练习：时，我发现使用for循环来纠正类型是非常困难的。我最终通过尝试和错误获得了代码，但是我真的很困惑它是如何工作的。
在这里，我简化了我遇到的一些问题，并将我的问题放在了行内。我尝试了尽可能多的变化，但我认为主要的困惑是：
loop1和loop2的区别(我相信3和4，5和6是相似的)
loop1和loop2中的内联问题
loop3_bad有什么问题？
fn main() {
// using mut because it is needed in the original code
浏览 7提问于2022-06-29得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
