小编Her*_*tar的帖子

我正在拼凑一些东西，列出我的 Windows 盒子上的每个窗口，并且似乎（仅）对于我的一个窗口 GetWindowRect 返回一个具有非常负的 y 坐标的矩形。

可能的复杂情况：(1) 我有多个显示器，但 (1a) y 坐标非常负，约为 -24000，并且 (1b) 两个显示器上的其他窗口不显示此效果；(2) 我正在使用 VirtuaWin 虚拟桌面工具，但 (2a) 其他窗口，在多个不同的虚拟桌面和两台显示器上，不显示此效果；(3) 我使用 pywin32 模块在 Python 中完成所有这些工作。

相关窗口是 Windows 资源管理器窗口。它的大小或位置并不异常（至少从肉眼看来）。当前活动虚拟桌面上的资源管理器窗口不会显示此行为，但是当我在其他虚拟桌面上创建资源管理器窗口时，它们会显示相同的意外效果。

我运行的是 Windows XP 和 VirtuaWin 4.3 版本。

发生什么了？

我试图了解 Rust 的生命周期如何影响结构。附件是一个让我困惑的最小例子。

我想给一个结构体一个对象的引用，然后需要更改这个对象。由于借用对象时无法更改该对象，因此我认为必须在更改对象时删除引用。所以我的想法是将变量定义为一个选项，并在修改对象期间通过将其设置为 来删除引用None。对于不使用结构的示例，这似乎可行。但是，如果我现在将此引用放入结构中，它将不起作用。在我看来，借用检查器忽略了变量string不再被借用的事实。有没有办法仍然通过结构实现所需的行为？

这有效（链接到游乐场）：

fn main() {
    let mut string = "mutable string".to_string();
    let mut ref_to_string: Option<&str> = Some(&string);
    ref_to_string = None;
    string = "mutated string".to_string();
    ref_to_string = Some(&string);
}

但是，这不起作用链接到游乐场：

struct Foo<'a> {
    pub ref_data: Option<&'a str>,
}

fn main() {
    let mut string = "mutable string".to_string();
    let mut foo = Foo{ref_data: Some(&string)};
    foo.ref_data = None;
    string = "mutated string".to_string();
    foo.ref_data = Some(&string);
}

错误信息：

error[E0506]: cannot assign to …

在我的一个 Rust 项目中，我有一个多级枚举层次结构。这是一个简化版本（游乐场链接）：

enum Child {
    ChildA,
    ChildB,
}

enum Parent {
    ParentA(Child),
    ParentB,
}

enum GrandParent {
    GrandParentA(Parent),
    GrandParentB,
}

为了方便起见，我在每个级别与其之上的级别之间实现了转换器：

impl From<Child> for Parent {
    fn from(c: Child) -> Self {
        Parent::ParentA(c)
    }
}

impl From<Parent> for GrandParent {
    fn from(p: Parent) -> Self {
        GrandParent::GrandParentA(p)
    }
}

如果我想从 a 转换Child为 aParent我现在可以做

let c: Child = Child::ChildA;
let p: Parent = c.into();

但如果我想从 a 转换Child为 a Grandparent，我似乎无法将多个调用链接到into()： …

struct Haha {
    pub a: u32,
    pub b: Vec<u32>,
}

let example = Haha {
    a: 32,
    b: vec![1],
}; 
let new_a = example.a;
let new_b = example.b;

我的理解是：

1. new_a是 的副本，example.a所以example仍然拥有example.a。
2. new_bexample.b自从example.b搬家以来现在拥有。

example.aRust 是否因为具有特质而隐式复制Copy？由于example.b，它是一个Vec，不实现Copy特征，所以 的所有权example.b被移动而不是复制？

我的结构中有方法，它采用泛型类型T。该类型可能实现Debug特征，但我的结构不需要它。
我需要调试我的应用程序，并且能够打印它会非常有用。不幸的是，我不能这样做，因为该类型可能未实现Debug特征。我可以在我的结构定义中指定T: Debug，但我需要在很多地方添加它以便我的代码进行编译。println!()仅当类型实现此特征时才可以调用宏吗？

像这样的东西：

if argument.implements(Debug) {
    println!("{:?}", argument);
}

给定任何切片，例如：

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

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

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

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

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

我有以下代码，

impl<T: Debug + Into<String> + Clone> TryFrom<Vec<T>> for Positionals {
  type Error = &'static str;
  fn try_from(mut vec: Vec<T>) -> Result<Self, Self::Error> {
    let mystr: String = vec.get(0).unwrap().into();

该代码产生了这个错误，

error[E0277]: the trait bound `String: From<&T>` is not satisfied
  --> bin/seq.rs:21:43
   |
21 |         let mystr: String = vec.get(0).unwrap().into();
   |                                                 ^^^^ the trait `From<&T>` is not implemented for `String`
   |
   = note: required because of the requirements on the impl of `Into<String>` for `&T`
help: consider introducing a `where` bound, …

考虑这个Config包含结构向量的结构Host：

use serde::Deserialize;
use std::net::IpAddr;

#[derive(Debug, Deserialize)]
struct Config {
    name: String,
    hosts: Vec<Host>
}

#[derive(Debug, Deserialize)]
struct Host {
    addr: IpAddr,
    user: String,
}

使用派生实现，可以使用和Deserialize成功反序列化以下 JSON 和 YAML 配置文件：serde_jsonserde_yaml

{
  "name": "example",
  "hosts": [
    { "addr": "1.1.1.1", "user": "alice" },
    { "addr": "2.2.2.2", "user": "bob" }
  ]
}

---
name: example
hosts:
  - addr: 1.1.1.1
    user: alice
  - addr: 2.2.2.2
    user: bob

但是，我还希望能够Host从字符串反序列化结构。但是，重要的是我还可以从地图中反序列化它，并且理想情况下向量可以由两种格式组成。例如：

{
  "name": "example",
  "hosts": [
    "alice@1.1.1.1", …

这可能是一个愚蠢的问题，但我似乎无法解决这个问题。

我有这样的文件结构：

\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 src\n    \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 another.rs\n    \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 some_file.rs\n    \xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 main.rs\n

在 中some_file.rs，我想调用 中的函数main.rs。所以，我尝试在some_file.rs：

use crate::main\n\n\nfn some_func() {\n   // other code\n   \n   main::another_func_in_main();\n}\n

但编译器会抛出错误：

use of an undeclared crate or module `main`\n

我该如何解决这个问题？

我刚刚在 base64 crate 中发现了这段代码：

 buffer.resize(decoded_len_estimate, 0);

let bytes_written;
{
    let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
    bytes_written = decode_helper(input_bytes, num_chunks, config, buffer_slice)?;
}

buffer.truncate(starting_output_len + bytes_written);

请参阅https://github.com/marshallpierce/rust-base64/blob/b63975f0a3d2e724c611bf6cd7213ae6bcb065a3/src/decode.rs#L165-L169

使用这种声明变量 bytes_writing 的方式然后使用这个嵌套块的原因是什么？这解决了什么问题？为什么不直接使用这段代码：

 buffer.resize(decoded_len_estimate, 0);

let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
let bytes_written = decode_helper(input_bytes, num_chunks, config, buffer_slice)?  
buffer.truncate(starting_output_len + bytes_written);

有人可以帮我吗？