小编all*_*y87的帖子

据我了解，可变性并未反映在变量类型签名中。例如，这两个引用具有相同的类型签名&i32：

let ref_foo : &i32 = &foo;
let mut ref_bar : &i32 = &bar;

为什么会这样？这似乎是一个非常重大的疏忽。我的意思是，即使是 C/C++ 也更const明确地做到了这一点，有两个来表示我们有一个const指向const数据的指针：

const int * const ptr_foo = &foo;
const int * ptr_bar = &bar;

有没有更好的方法来思考这个问题？

我使用相机校准获得了相机内部矩阵和失真参数.

我想,焦距的单位是像素.

然后,我如何计算视野(沿y)？

这个公式对吗？

double fov_y = 2*atan(height/2/fy)*180/CV_PI;

我将它用于参数

gluPerspective()

是否有可能（合乎逻辑？）将包含未来的结果转换为解决结果的未来？

以下功能有点损坏，但希望能让我想要实现的目标更加清晰：

use std::future::Future;

fn transpose<T,U,E>(result: Result<T,E>) -> impl Future<Output = Result<U, E>>
   where T: Future<Output = Result<U,E>> /* not sure if this is the correct trait bound */ {
   match result {
      Ok(inner) => /* a future that eventually resolves to a Result<U, E> */
      Err(error) => /* a future that immediately resolves to a Result<U, E>::Err(error) */
   }
}

给出一些上下文：在async从传递给 的闭包中调用函数后，我发现自己需要这样做Result::map，所以也许这是我的第一个错误。

变量sinprint_struct是指堆上还是堆栈上的数据？

struct Structure {
    x: f64,
    y: u32,
    /* Use a box, so that Structure isn't copy */
    z: Box<char>,
}

fn main() {
    let my_struct_boxed = Box::new(Structure {
        x: 2.0,
        y: 325,
        z: Box::new('b'),
    });
    let my_struct_unboxed = *my_struct_boxed;
    print_struct(my_struct_unboxed);
}

fn print_struct(s: Structure) {
    println!("{} {} {}", s.x, s.y, s.z);
}

据我了解，let my_struct_unboxed = *my_struct_boxed;将所有权从 box 转移到my_struct_unboxed，然后转移s到函数中print_struct。

实际数据会发生什么？最初它是通过调用从堆栈复制到堆上的Box::new(...)，但是数据是否在某些时候是如何移动或复制回堆栈的？如果是这样，如何？什么时候被drop调用？什么时候s超出范围？

我正在尝试使用配方为 RPi 构建一个控制台映像core-image-base，但在我的配置中的某个地方，我似乎打开了一些开关，使构建的配方数量增加了大约 1000 个，其中包括许多感觉不像的东西属于控制台图像（libx11、gnome-desktop-testing等）

我试图找出为什么这些食谱被包含在我的构建中。到目前为止，我的方法是运行以下命令：

# Generate a massive dot file with all the dependencies in it
bitbake -g core-image-base

# grep through that file to find out what is bringing in
# gnome-desktop-testing.
cat task-depends.dot | grep -i gnome-desktop-testing | grep -vi do_package_write_rpm

我do_package_write_rpm从匹配中删除了，因为一切似乎都与它匹配。这留下了以下内容：

"core-image-base.do_build" -> "gnome-desktop-testing.do_build"
"core-image-base.do_rootfs" -> "gnome-desktop-testing.do_package_qa"
"core-image-base.do_rootfs" -> "gnome-desktop-testing.do_packagedata"
"core-image-base.do_rootfs" -> "gnome-desktop-testing.do_populate_lic"
"glib-2.0.do_package_qa" -> "gnome-desktop-testing.do_packagedata"
(followed by many dependencies between the tasks of the gnome-desktop-testing recipe) …

假设我有几个本地声明的对象,我想使用基于范围的语法进行迭代.这看起来效果很好,但是,似乎要将本地对象放入initializer_list,执行复制.对于像这样的对象来说这是个坏消息std::shared_ptr(据我所知),增加引用计数是一个原子操作.我认为可以避免的唯一方法是使用原始指针.

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptrInt1 = std::make_shared<int>(1);
    std::shared_ptr<int> ptrInt2 = std::make_shared<int>(2);
    /* in this loop, ptrInt1 and ptrInt2 are copied before they are binded
       to ptrInt, this is ugly since the reference counter needs to temporarily
       increased */
    for(const std::shared_ptr<int>& ptrInt : {ptrInt1, ptrInt2}) {
        std::cerr << *ptrInt << std::endl;
    }
    /* this solution works, but it feels somewhat ugly having to convert my smart
       pointers to raw pointers to avoid the copying, …

据我所知，辩驳的模式只能在测试match，if let和while let表达。为了说明我想做什么，请考虑=>在以下上下文中使用match 语句中的语法：

let val = get_optional_value();
if val => Some(inner) {
    do_something(inner);
}

我可以使用if let语句，但更有用的上下文是简短的闭包：

get_optional_value()
    .filter(|iv| iv => InnerVariant::VariantA)
    .and_then(/* ... */)

据我所知，使用模式匹配实现这一目标的唯一解决方案是：

get_optional_value()
    .filter(|iv| {
        if let InnerVariant::VariantA = iv {
            true
        } else {
            false
        }
    })
    .and_then(/* ... */)

有一个类似的问题没有得到回答，但评论确实指出使用?运算符解决了 的相关极端情况std::result::Result。

假设我定义并实例化了一个枚举，如下所示：

enum MyEnum {
    EmptyVariant,
    TupleVariant(u8),
    StructVariant {
        key: u8,
        value: char,
    }
}

let instance = MyEnum::StructVariant{key: 8, value: 'a'};

是否可以在不解构的情况下匹配此变体？例如，不要这样做：

if let MyEnum::StructVariant{key, value} = instance {
    eprintln!("key, value = {}, {}", key, value);
}

我宁愿写这样的东西：

if let MyEnum::StructVariant{VARIANT_MEMBERS} = instance {
    eprintln!("key, value = {}, {}", VARIANT_MEMBERS.key, VARIANT_MEMBERS.value);
}

在此示例中，写出结构体变体的成员是良性的，但在变体具有许多成员的情况下，会使代码难以阅读。

在Sendtrait的文档中，有一个很好的例子说明了 Rc 之类的东西不是这样的Send，因为在两个不同的线程中克隆/删除会导致引用计数不同步。

然而，不太清楚的是，为什么在 a 中的Send一个await点上持有对非类型的绑定async fn会导致生成的未来也是非类型Send。当编译器在异步手册的变通方法一章中过于保守时，我能够找到变通方法，但它并没有回答我在这里提出的问题。

也许有人可以举例说明为什么在 a 中有一个非Send类型是Future可以的，但将它放在anawait上却不是？