相关疑难解决方法(0)

作为学习Rust的简单练习,我决定实现一个简单的二进制搜索:

pub fn binary_search(arr: &[i32], key: i32) -> usize {
    let min: usize = 0;
    let max: usize = arr.len();
    while max >= min {
        let mid: usize = (max - min) / 2 as usize;
        if key == arr[mid] {
            mid as usize
        }

        if key < arr[mid] {
            min = mid + 1;
            continue;
        }

        max = mid - 1;
    }
    -1 as usize
}

#[cfg(test)]
mod tests {

    use super::binary_search;

    #[test]
    fn binary_search_works() {
        let arr: [i32; …

我正在阅读《Rust 编程语言》一书，我偶然发现了一个简单的表达式：

let guess: u32 = match guess.trim().parse() {
    Ok(num) => num,
    Err(_) => continue,
};

它的手臂如何match处理不同的表情？例如，第一个臂将简单地“返回”，num以便将其分配给，guess但在第二个臂中，表达式只是continue。如何match处理它并且不“分配”continue而是guess执行它？整个赋值表达式本身会发生什么？它是否从调用堆栈中删除（如果这是正确的术语）？

取自current_dir文档的代码片段：

use std::env;

fn main() -> std::io::Result<()> {
    let path = env::current_dir()?;
    println!("The current directory is {}", path.display());
    Ok(())
}

我注意到只有在 之后添加分号Ok(())，程序才不会编译并出现以下错误：

error[E0308]: mismatched types
expected enum `std::result::Result`, found `()`

这是为什么？

我想遍历Options的列表。如果其中之一有值，我想返回一个错误。这是一个人为的例子：

fn test(options: &[Option<u8>]) -> Result<(), &u8> {
    for option in options {
        match option {
            None => (),
            Some(value) => {
                // do some stuff here, so I can't just go
                // Some(value) => return Err(value),
                return Err(value); // this semicolon is optional
            }
        }
    }

    Ok(())
}

添加另一个分号会导致错误，但删除分号不会。

为什么 return 语句后面的分号是可选的？

在惯用的 Rust 中应该使用哪种形式：分号还是没有分号？两者都被编译器接受并且似乎产生相同的结果。

摘自Rust 书的第 3.5 章：

我们使用break带有 value的关键字counter * 2。在循环之后，我们使用分号结束为 赋值的语句result。

加上代码片段：

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

我明白这是如何工作的以及为什么结果是 20，但我注意到如果我删除包含break关键字的行上的分号，程序是等效的。

为什么在这种情况下分号是可选的？

我是 Rust 编程新手。我想用递归实现合并排序。这是我的代码：

fn merge(a: &mut Vec<u32>, b: &mut Vec<u32>) -> Vec<u32> {
    let mut temp: Vec<u32> = Vec::new();

    println!("The digit is {}", a[0]);
    while a.len() > 0 && b.len() > 0 {
        if a[0] > b[0] {
            temp.push(a[0]);
            a.pop();
        } else {
            temp.push(b[0]);
            b.pop();
        }
    }

    while a.len() > 0 {
        temp.push(a[0]);
        a.pop();
    }

    while b.len() > 0 {
        temp.push(b[0]);
        b.pop();
    }

    temp
}

fn merge_sort(v: &mut Vec<u32>) -> Vec<u32> {
    println!("The divided vector is: {:?}", v);
    let n …

我遇到了以下两种方式：

#[derive(Debug)]
struct InputList(i32, i32, i32, i32);
#[derive(Debug)]
struct OutputList(i32, i32, i32, i32);

// Option 1
fn foo(input_list: InputList) -> OutputList {
    return OutputList(input_list.0, input_list.1, input_list.2, input_list.3);
}

// Option 2
fn bar(input_list: InputList) -> OutputList {
    OutputList(input_list.0, input_list.1, input_list.2, input_list.3)
}

fn main() {
    let input_list1 = InputList(1, 2, 3, 4);
    let input_list2 = InputList(6, 7, 8, 9);

    println!("foo() invocation output: {:?}", foo(input_list1));
    println!("bar() invocation output: {:?}", bar(input_list2));
}

只有这两种选择吗？