小编Rod*_*igo的帖子

Cargo 功能允许条件编译，因此最终版本将仅包含可由最终用户过滤的特定功能组。

现在，根据库箱的复杂性，您可能会以形成依赖树的几个功能结束，例如：

[features]
banana = []
avocado = []
pineapple = ["avocado"]
orange = ["pineapple", "banana"]

很自然，除此之外cargo check|test --all-features，我会希望cargo check|test --features banana在每一项单独的功能上运行，以确保它们能够独立运行。目前，我正在使用一个粗略的 shell 脚本来完成此操作，并手动提供这些功能。如果我添加一个新功能但忘记将其添加到脚本中，我就会遇到麻烦。

FEATS=(banana avocado pineapple orange)

for FEAT in "${FEATS[@]}" ; do
    echo "$FEAT..."
    cargo check --features "$FEAT"
    #cargo test --features "$FEAT"
done

那么，是否有任何自动化方法可以cargo check|test --features banana逐一运行每个功能，然后报告已发现的警告/错误？

在窗口过程之外，我正在switch使用自执行 lambda编写语句，如下所示：

LRESULT 回调过程（HWND hWnd、UINT msg、WPARAM wp、LPARAM lp）
{
    开关（味精）
    {
        case WM_CREATE: return [&](WPARAM wp, LPARAM lp) {
            do_something(wp, lp);
            返回0；
        }(wp, lp);

        case WM_SIZE: return [&](HWND hWnd) {
            do_another_thing(hWnd);
            返回0；
        }(hWnd);
    }
    返回 DefWindowProc(hWnd, msg, wp, lp);
}

我相信编译器可以按照他们想要的方式自由地优化它，但一般来说，与不使用这些 lambdas 相比，编译器会为此添加很多样板代码吗？

编译器能否检测到多余的 lambdas 并删除它们？

假设我在模块中有一个 TypeScript 接口，还有一个返回该接口的初始化对象的函数：

export default interface Foo {
    name: string;
    surname: string;
    cars: number;
};

export function newFoo(): foo {
    return <Foo>{
        name: '',
        surname: '',
        cars: 0
    };
};

问题是我将所有字段都输入两次，这不仅很无聊，而且还容易出错。

我无法真正使用return <Foo>{};，因为有些对象是其他对象的成员，所以我会丢失属性并undefined弹出。

我可以在调用该属性时检查该属性是否存在，但由于该属性没有?，这意味着它是强制性的，因此它应该存在。

那么，上面的代码有没有更好的写法呢？

C++ 老手正在尝试 Rust 的第一步。我有一个包含 3 个文件的小项目：

主程序.rs

mod person;
use person::*;

fn main() {
    let mut pp = Person::new(); // Person struct used here
    pp.name = "Malcolm".to_string();
    println!("{}, {}, {}",
        pp.name, pp.place.street, pp.place.number);
}

人.rs

mod addr;
use addr::*;

pub struct Person {
    pub name: String,
    pub place: addr::Addr // Addr struct used here
}

impl Person {
    pub fn new() -> Self {
        Self {
            name: "John".to_string(),
            place: addr::Addr::new()
        }
    }
}

地址.rs

pub struct Addr { // won't …

在Windows中，当编译C++时，我可以指定/MT编译器选项来使用运行时库的静态版本，即。不动态链接到 MSVCRT。

既然没有这样的选项，Rust/Cargo 在这方面的表现如何？它是静态链接还是动态链接？

假设我在图书馆中有以下特征：

pub trait Foo {
    fn public_op(&self);
    fn internal_op(&self);
}

然后针对该库中的一堆结构实现此特征：

pub struct One {}

impl Foo for One {
    fn public_op(&self) {}
    fn internal_op(&self) {}
}

pub struct Two {}

impl Foo for Two {
    fn public_op(&self) {}
    fn internal_op(&self) {}
}

这个库中有一个接收特征类型的公共函数：

pub fn process(obj: &dyn Foo) {
    obj.public_op();
    obj.internal_op();
}

问题是，由于Foo特征在库中是公共的，因此该方法internal_op也是公共的......但实际上它应该具有pub(crate)可见性，因为它必须仅在库内部使用。

据我所知，一个特质的所有方法都是公共的，那么我该如何重新设计这个问题呢？

给定任何切片，例如：

let words = &["one", "one", "one", "two"];

如何知道所有元素是否相同？

更进一步，如果所有元素都相同，如何返回对第一个元素的引用？

本质上，我正在尝试编写一个如下函数：

fn are_all_elements_equal<T>(elems: &[T]) -> Option<&T> {
    // ... ?
}

我知道build.rs可以在程序编译开始之前执行任务，所以我可以准备任何我想要的东西。

如果编译完成后要执行一项任务（例如某种清理）怎么办？有什么办法可以做到这样的事情吗？

举一个简单的例子：在编译之前，我想出于某种原因将文件从 重命名foo.txt为abc.txt。然后在编译终止后我想将其重命名回foo.txt.

这是正确抛出普通 Win32 错误的方法，自动检索错误描述，而且效果非常好：

if (!SomeWinFunc()) {
  throw std::system_error(GetLastError(),
    std::system_category(),
    "SomeWinFunc crashed badly");
}

但是，我不确定如何处理 COM 错误，这些错误的检查方式如下：

HRESULT hr = comObj->SomeFunc();
if (FAILED(hr)) {
  throw std::system_error(hr, // <-- is it correct here?
    std::system_category(),
    "SomeFunc crashed right now");
}

传递HRESULTto是否正确system_error，或者还有其他方法可以从 COM 函数抛出异常？

这是我试图实现的 C++ 等价物：

std::vector<std::function<int(int)>> funcs;
funcs.emplace_back([](int n) -> int { return n + 1; });
int result = funcs[0](33);

如何在 Rust 中编写上面的代码？

以下代码有效：

pub struct Bar {
    pub name: String
}

macro_rules! printme {
    ($myclass: ident) => {
        let t = $myclass { name: "abc".to_owned() };
        println!("{}", t.name);
    }
}

fn main() {
    printme!(Bar);
}

但是，如果Bar在一个模块内，它将不起作用，错误是no rules expected the token ::：

mod foo {
    pub struct Bar {
        pub name: String
    }
}

macro_rules! printme {
    ($myclass: ident) => {
        let t = $myclass { name: "abc".to_owned() };
        println!("{}", t.name);
    }
}

fn main() {
    printme!(foo::Bar); // not …

我正在编写与 C API 通信的 Rust 代码，并且我需要某个结构来拥有固定的内存地址。到目前为止，我发现：

• Pin用于指针；
• pin_mut用于固定堆栈的宏；
• PhantomPinned，我不清楚。

如果我理解正确，PhantomPinned这将是最容易使用的：只需将其作为成员即可使我的结构自动具有固定的内存地址。它是否正确？

在 Go 中，我们可以在表达式的条件中声明变量if。该变量在作用域内有效if，在作用域外无效。例如：

func main() {
    if n := 4; n != 0 {
        fmt.Printf("%d is not zero", n)
    } else {
        fmt.Printf("%d is zero", n)
    }

    fmt.Printf("%d", n) // error, n doesn't exist here!
}

Rust 中有类似的语法吗？