小编YLy*_*Lyu的帖子

我正在尝试用 Rust 解决一些 Leetcode 问题。然而，我在 LeetCode 的实现过程中遇到了一些困难TreeNode。

use std::cell::RefCell;
use std::rc::Rc;

// TreeNode data structure
#[derive(Debug, PartialEq, Eq)]
pub struct TreeNode {
    pub val: i32,
    pub left: Option<Rc<RefCell<TreeNode>>>,
    pub right: Option<Rc<RefCell<TreeNode>>>,
}

impl TreeNode {
    #[inline]
    pub fn new(val: i32) -> Self {
        TreeNode {
            val,
            left: None,
            right: None,
        }
    }
}

如果我想做一个中序遍历，如何解开 的TreeNode对象Option<Rc<RefCell<TreeNode>>>，访问它.val .left .right并将它们作为输入传递到递归函数中？

我努力了：

pub struct Solution;

impl Solution {
    pub fn inorder_traversal(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
        let …

fn main() {
    let _one = None.unwrap_or("one".to_string());
    let _two = None.unwrap_or_else(|| "two".to_string());
}

有什么特别的原因，人们应该更喜欢unwrap_or_else了unwrap_or？

我看到了unwrap_or热切的评论（以这个为例）。这是否意味着unwrap_or总是在程序执行之前评估中的值？并且只有在程序执行到该行时才调用中的FnOnce值unwrap_or_else？

示例代码：

use std::sync::atomic::{AtomicU32, Ordering};

#[derive(Debug)]
struct Token(u32);

impl Token {
    fn new() -> Self {
        static COUNTER: AtomicU32 = AtomicU32::new(1);
        let inner = COUNTER.fetch_add(1, Ordering::Relaxed);
        Token(inner)
    }
}

fn main() {
    let t1 = Token::new();
    let t2 = Token::new();
    let t3 = Token::new();
    println!("{:?}\n{:?}\n{:?}", t1, t2, t3);
}

当我运行上面显示的代码片段时，它会打印：

Token(1)
Token(2)
Token(3)

我在 Rust 参考中发现静态项的初始化是在编译时评估的。

我想知道当程序执行到初始化变量的行时，运行时到底发生了什么COUNTER。编译后的代码是什么样子的，以便它可以忽略初始化？

在Java中,我可以做到这一点.

int diff = 'Z' - 'A'; // 25

我在Rust中尝试了同样的方法:

fn main() {
    'Z' - 'A';
}

但编译器抱怨:

error[E0369]: binary operation `-` cannot be applied to type `char`
 --> src/main.rs:2:5
  |
2 |     'Z' - 'A';
  |     ^^^^^^^^^
  |
  = note: an implementation of `std::ops::Sub` might be missing for `char`

如何在Rust中执行等效操作？

我想从 stdin 读取一行并将其存储在字符串变量中，并将字符串值解析为 u32 整数值。read_line() 方法读取 2 个额外的 UTF-8 值，这会导致 parse 方法崩溃。

以下是我尝试删除回车符和换行符的内容：

use std::io;
use std::str;

fn main() {
    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(n) => {
            println!("{:?}", input.as_bytes());
            println!("{}", str::from_utf8(&input.as_bytes()[0..n-2]).unwrap());
        }
        Err(e) => {
            println!("{:?}", e);
        }
    }
}

在 Rust 中执行此操作最惯用的方法是什么？