相关疑难解决方法(0)

为什么都是&[u8]和&[u8; 3]确定在这个例子吗？

fn main() {
    let x: &[u8] = &[1u8, 2, 3];
    println!("{:?}", x);

    let y: &[u8; 3] = &[1u8, 2, 3];
    println!("{:?}", y);
}

&[T; n]可以胁迫的事实&[T]是使它们可以容忍的方面. - 克里斯摩根

为什么可以&[T; n]胁迫&[T]？在其他条件下,这种强制发生了吗？

引用这本书（强调我的），

当使用特征时，用具体类型参数填充的泛型类型参数也是如此：具体类型成为实现该特征的类型的一部分。当通过使用特征对象而忘记类型时，就无法知道用什么类型填充泛型类型参数。

我无法理解其中的道理。对于具体示例，请考虑以下内容

pub trait Echoer {
    fn echo<T>(&self, v: T) -> T;
}

pub struct Foo { }

impl Echoer for Foo {
    fn echo<T>(&self, v: T) -> T {
        println!("v = {}", v);
        return v;
    }
}

pub fn passthrough<T>(e: Box<dyn Echoer>, v: T) {
    return e.echo(v);
}

fn main() {
    let foo = Foo { };
    passthrough(foo, 42);
}

结果当然是报错

$ cargo run
   Compiling gui v0.1.0 (/tmp/gui)
error[E0038]: the trait `Echoer` cannot be made into …

我已经看到一些带有这样的模式的D3代码用于追加元素:

var circles = svg.selectAll(null)
    .data(data)
    .enter()
    .append("circle");

我真的没有得到这个片段.为何选择null？

我理解D3的方式,如果有人附加圈子,它应该是:

var circles = svg.selectAll("circle")
    .data(data)
    .enter()
    .append("circle");

同样,如果要添加HTML段落,它应该是:

var circles = svg.selectAll("p")
    .data(data)
    .enter()
    .append("p");

对于类来说也是如此:如果一个是用类附加元素foo,那么它应该是selectAll(".foo").

但是,selectAll(null) 确实有效!元素得到追加.

那么,那是什么意思null呢？我在这里错过了什么？

^{注意:这是一个自我回答的问题,试图提供一个主题的"规范"问答,这个问题已被许多先前的问题所触及,而不是由API解释.以下大部分答案来自我在已灭绝的StackOverflow文档中编写的示例.}

我有一个盒装数组的结构,我想使用这个数组并将其插入到一个向量中.

我目前的方法是将数组转换为向量,但相应的库函数似乎不像我预期的那样工作.

let foo = Box::new([1, 2, 3, 4]);
let bar = foo.into_vec();

编译器错误状态

没有为当前范围中的into_vec类型命名的方法Box<[_; 4]>

我发现这里的规格看起来像

fn into_vec(self: Box<[T]>) -> Vec<T>
Converts self into a vector without clones or allocation.

......但我不太确定如何应用它.有什么建议？

我看到一些代码如下所示：

fn test <'a> (&'a mut &'a str) {}

我知道 'a 是一生，而 & 是引用。

但是我很难理解双重引用 && 。

根据我的理解，引用是一个指针，那么 && 是指向另一个指针还是其他指针的指针？

在下面的代码中，不可能从对实现相同特征的动态大小类型的引用中获得对特征对象的引用。为什么会这样呢？究竟是什么区别&dyn Trait和&(?Sized + Trait)我是否可以使用这两种调用方法特质？

实现的类型FooTraitContainerTrait可能例如具有type Contained = dyn FooTrait或type Contained = T在哪里T实现的具体类型FooTrait。在这两种情况下，都很难获得&dyn FooTrait。我想不出另一种情况，这是行不通的。为什么在通用情况下这不可能FooTraitContainerTrait？

trait FooTrait {
    fn foo(&self) -> f64;
}

///

trait FooTraitContainerTrait {
    type Contained: ?Sized + FooTrait;
    fn get_ref(&self) -> &Self::Contained;
}

///

fn foo_dyn(dyn_some_foo: &dyn FooTrait) -> f64 {
    dyn_some_foo.foo()
}

fn foo_generic<T: ?Sized + FooTrait>(some_foo: &T) -> f64 {
    some_foo.foo()
}

///

fn foo_on_container<C: FooTraitContainerTrait>(containing_a_foo: &C) -> …

我不明白切片和参考之间的区别。&String和 和有&str什么区别？我在网上读到一些东西，说引用是一个细指针，切片是一个胖指针，但我不知道，似乎无法找到这两个的意思。我知道切片可以强制转换为引用，但它是如何做到的？Deref特质是什么？

有一个问题：切片是否有任何额外的数据，例如字符串末尾的零或字符串开头的字符串大小？

在此代码中：

use std::collections::HashMap;

fn main()
{
  let mut hashmap : HashMap< &'static str, &'static str > = HashMap::new();
  hashmap.insert( "EUR", "Euro" );
  hashmap.insert( "USD", "US Dollar" );
  hashmap.insert( "CHF", "Swiss Francs" );

  let usd = hashmap.get( "EUR" );
  if let Some( usd ) = usd
  {
    println!( "usd : {}", usd );
  }
  // < usd : US Dollar
}

HashMap 的键和值let mut hashmap : HashMap< &'static str, &'static str >可以具有任意长度。正确的？我不明白程序如何知道US Dollar长度/大小为 9？切片是否有任何额外的数据，例如字符串末尾的零或字符串开头的字符串大小？

游乐场就在这里 …

我一直在学习 Rust 中的引用，发现很难理解引用到底是如何存储在堆栈中的。

考虑下面的程序：

fn main() {
    let name = String::from("Somu");
    let name_ref = &name;
}

现在，如何在堆栈帧中为这两个变量分配内存？

|--------------------|
| name     | 0x1fcd  |
|--------------------|
| name_ref | ?       |
|--------------------|

因此，由于String存储在堆中，因此我们有堆的地址，其中字符串“Somu”作为变量的值出现name。

现在，name_ref是对 的引用name。用 Rust 术语来说，name_ref借用 指向的值name。

那么，什么 get 作为 的值存储在堆栈帧中呢name_ref？

• 包含字符串的堆内存的地址？
• name堆栈中的地址？

或者是其他东西？

有人可以用这个概念丰富我吗？

提前致谢

我Rc用于对实现特征的对象进行动态调度。然后我需要内部可变性，所以我改为RefCell. 我认为这RefCell只是Rc内部可变性的一个，但它不会接受我的 trait 对象。

use std::cell::RefCell;
use std::rc::Rc;

trait Test {}

struct A;

impl Test for A {}

fn main() {
    // This works:
    let x: Rc<dyn Test> = Rc::new(A);
    
    // But this not:
    // let x: RefCell<dyn Test> = RefCell::new(A);
}

错误：

error[E0308]: mismatched types
  --> src/main.rs:18:32
   |
18 |     let x: RefCell<dyn Test> = RefCell::new(A);
   |            -----------------   ^^^^^^^^^^^^^^^ expected trait object `dyn Test`, found struct `A`
   |            |
   |            expected …