小编ide*_*n42的帖子

如果已知选项变量为非None,则通常可以写入:

let var = option_var.unwrap();

在我碰到的一个案例中,这引起了一个关于搬出借来的上下文的错误.

if let Some(var) = option_var { ... }

(因为它允许Some(ref mut var) = option_var也很方便).

这是有效的,但在这种情况下,我不希望这是一个if声明.写入let Some(var) = option_var;失败,错误"模式None未覆盖".

要明确这个问题不是借用的背景.

可以在let Some(var) = option;语法的情况下使用,其中据了解,这是不是None？解决" None未覆盖模式"警告？或者这只是在if声明之外不支持？

使用一个简单的递归宏，如下例所示，通常采用第一个参数，然后将其余参数通通。

macro_rules! count_tts {
    () => {0usize};
    ($_head:tt $($tail:tt)*) => {1usize + count_tts!($($tail)*)};
}

有没有办法递归地采用最后一个参数？

这使得可以：

• 反向处理参数。
• 考虑所有先前的论点（例如计算它们，请参阅相关问题）

像($($head:tt)* $tail:tt)......但这不起作用。

给定以下ifeq语句，如何压缩它以便可以在一个ifeq块中处理字符串检查？

OS:=$(shell uname -s)

ifeq ($(OS), Linux)
    foo
endif
ifeq ($(OS), Darwin)
    bar
endif
ifeq ($(OS), FreeBSD)
    bar
endif
ifeq ($(OS), NetBSD)
    bar
endif

我已经研究过类似的问答，但不确定它如何完全适用于这个问题。

像这样的东西：

ifeq ($(OS), Linux)
    foo
endif
ifeq ($(OS) in (Darwin, FreeBSD, NetBSD))  # <- something like this
    bar
endif

在 C 语言中，我习惯于：

if (ELEM(value, a, b, c)) { ... }

这是一个具有可变数量参数的宏，以避免输入

if (value == a || value == b || value == c) { ... }

C 示例可以在与 C 一起使用的 Varargs `ELEM` 宏中看到。

这在 Rust 中可能吗？我认为它会使用match. 如果是这样，如何使用可变参数来实现这一目标？

在Rust中填充结构向量的好方法是:

• 大小是动态的,但在初始化时已知.
• 不首先将内存初始化为虚拟值.
• 不重新分配内存作为填充.
• 在此示例中,始终初始化向量的所有成员.
  (符合Rusts保证没有未定义的行为).

理想情况下

• 不索引检查每个索引访问
  (因为在声明向量时大小是已知的,这应该是可能的).
• 不需要unsafe
  (不确定这是否合理,但编译器_could_检测到所有值始终被填充,允许在不安全的块中使用此类逻辑).

C等价物是:

struct MyStruct *create_mystruct(const uint n) {
    struct MyStruct *vector = malloc(sizeof(*vector) * n);
    for (uint i = 0; i < n; i++) {
        /* any kind of initialization */
        initialize_mystruct(&vector[i], i);
    }
    return vector;
}

我正在移植一些C代码,它在一个简单的循环中填充一个数组,所以我想知道是否有一种乡村方式来执行这样一个零或至少最小开销的常见任务？

如果此代码的Rust版本通常需要一些额外的检查,那么最近的等价物是什么？

使用向量作为堆栈时(存储被推送和弹出的状态).

while stack.len() != 0 {
    let state = stack.pop().unwrap();
    // ... optionally push other states onto the stack.
}

在Rust中有一个不那么冗长的方法吗？

我正在寻找一些在空间中使用2D和3D点或方向的小型库
(矢量/矩阵感中的矢量,而不是Rust的Vec).

Rust不会在这里施加规则,所以你可以创建一个浮点元组,或者一个struct带有x, y, z成员的新元组.或单个data: [f64; 3]成员.

我想定义一个类型,而不是在这里使用的原因[f64; 3],就是这样我就可以宣布方法,例如length,normalized也Add,Sub运营商.

什么是宣布小型2D-3D固定大小数据类型的良好基础？

请注意,虽然有很好的现有库,但我想编写自己的库,因为它只需要一些基本操作,我想了解内部发生的事情.

是否可以编写一个宏来将表达式扩展为多个索引参数,这些参数可以传递给函数或另一个宏？

看到这个简单的自包含示例.
目的是unpack3扩大v到v[0], v[1], v[2].

macro_rules! elem {
    ($val:expr, $($var:expr), *) => {
        $($val == $var) || *
    }
}

// attempt to expand an array.
macro_rules! unpack3 {
    ($v:expr) => {
        $v[0], $v[1], $v[2]
    }
}

fn main() {
    let a = 2;
    let vars = [0, 1, 3];
    // works!
    if elem!(a, vars[0], vars[1], vars[2]) {
        println!("Found!");
    }
    // fails!
    if elem!(a, unpack3!(vars)) {
        println!("Found!");
    }
}

第二个例子失败了,是否有可能使这个工作？

可能的解决方案包括:

• 改变宏语法的使用.
• 使用元组,然后扩展到参数.
• 重新安排表达式以解决宏约束. …

基于以下示例,可以在Rust中使用链式方法调用编写构建模式,该方法调用通过值或通过引用传递(使用生命周期说明符)

• 是否可以创建一个宏来实现构建器模式方法？
• 如何重载"新"方法？(回答)
• https://github.com/rust-unofficial/patterns/blob/master/patterns/builder.md

Rust中的构建器模式可能如下所示:

 ui::Button::new()
    .label("Test")
    .align(Align::Center)
    .build();

在写作惯用的Rust时,有一种强烈的偏好吗？

有没有一个很好的例子,如何在Rust中写这个？

如果你不能使用稳定编译器的不稳定模块,Rust如何编译它std？例如,std::Vec使用alloc::raw_vec,一个不稳定的功能.

将十六进制字符串转换为浮点数的最直接方法是什么？（不使用第 3 方板条箱）。

Rust 是否提供了一些与 Python 相同的功能？ struct.unpack('!f', bytes.fromhex('41973333'))

请参阅Python和Java 的此问题，提及以供参考。

假设我们有一个变量(在用于其预期目的之后)永远不应该被访问.

(就Rust而言,这样做可能是有效的,但其内容在应用程序的上下文中在逻辑上不再有效).

例如,在Python中,您可以简单地执行以下操作:

del myvar;

有没有办法禁止将来访问函数体中声明的变量或作为参数传递的引用？

请注意,通常可以使用范围,但这不适用于函数参数.