Rust 如何构建Rc<；str>；或Rc<；[T] >；？

我想创建一个

Rc

，因为我想减少遵循访问

Rc

所需的两个指针的间接性。我需要使用

Rc

，因为我确实拥有共同的所有权。我详细介绍了有关字符串类型的更具体问题

Rc:

error[E0277]：不满足特征绑定'str:std:：marker:：Sized'
-->src/main.rs:5:22
|
5 |设b:Rc=Rc:：new（*a）；
|^^^`str`在编译时没有已知的常量大小
|
=help:trait`std:：marker:：Sized`未为`str实现`
=注意：`::new所需`

很明显，为了创建一个

Rc

，我需要复制整个字符串：

RcBox

本身就是一个未大小化的类型，将字符串本身存储在弱指针和强指针旁边-上面的原始代码甚至没有意义

我被告知不能实例化这样的类型，而是用一个大小为

T

的

Rc

实例化一个

Rc

，然后强制它为一个未大小的类型。给出的示例用于存储trait对象：首先创建

Rc

，然后强制执行

Rc

。但这也没有意义：两者都不起作用（而且你不能从

&str

或

String

强制到

str

。

创建

Rc

可以通过强制和

从固定大小的数组强制转换来完成，例如，强制可以按如下方式完成：

use std::rc::Rc;

fn main() {
    let x: Rc<[i32; 4]> = Rc::new([1, 2, 3, 4]);

    let y: Rc<[i32]> = x;

    println!("{:?}", y);
}

擦除意味着
RcRef
s可以来自多个不同的源，例如
RcRef
也可以来自字符串文本

注意。在撰写本文时，使用
RcRef
进行擦除需要夜间编译器，并且取决于
owning\u ref
的
nightly
功能：

[dependencies]
owning_ref = { version = "0.1", features = ["nightly"] }

从Rust 1.21.0开始，按照的要求，现在可以创建
Rc
或
Arc
：

use std::rc::Rc;
use std::sync::Arc;

fn main() {
    let a: &str = "hello world";
    let b: Rc<str> = Rc::from(a);
    println!("{}", b);

    // or equivalently:
    let b: Rc<str> = a.into();
    println!("{}", b);

    // we can also do this for Arc,
    let a: &str = "hello world";
    let b: Arc<str> = Arc::from(a);
    println!("{}", b);
}

使用std:：rc:：rc；
使用std:：sync:：Arc；
fn main（）{
让a:&str=“你好，世界”；
设b:Rc=Rc:：from（a）；
println！（“{}”，b）；
//或相当于：
设b:Rc=a.into（）；
println！（“{}”，b）；
//我们也可以为Arc这样做，
让a:&str=“你好，世界”；
设b:Arc=Arc:：from（a）；
println！（“{}”，b）；
}

（）

请参阅和。
，因为访问
Rc
需要以下两个指针（另外，我需要
Rc
，因为我确实拥有共享所有权）。我详细介绍了关于字符串类型的更多具体问题。我的暂定定义
Rc
也需要一个非大小的类型
Utf16Str
（它的布局与
Rc
相同）。另请参见。因此，当编译时[t]的长度未知时，无法创建
Rc
，对吗？（但这是为什么？堆中没有分配
Rc
吗？因为它是一个胖指针，它已经“知道”它的大小）是的，
Rc
不能通过动态长度的强制构造。然而，这个概念完全有道理，唯一的阻塞问题是没有好的方法来构造一个。另外，访问
RcRef
中的
String
是否需要以下两个指针？（整个问题是，
Rc
有一个指向
String
的指针，该指针指向字符串的开头…）。我不知道是否只有一个指向
字符串的指针。Re:“这个概念完全有意义”-这是否意味着除了
Rc
，
Rc
（和其他未分级类型）可以在未来版本的Rust上工作？@darque适用于某些未分级类型，如traits。这是Rust 1.1 IIRC的新版本。
extern crate owning_ref;
use owning_ref::RcRef;
use std::rc::Rc;

fn main() {
    let some_string = "foo".to_owned();

    let val: RcRef<String> = RcRef::new(Rc::new(some_string));

    let borrowed: RcRef<String, str> = val.map(|s| &**s);

    let erased: RcRef<owning_ref::Erased, str> = borrowed.erase_owner();
}

[dependencies]
owning_ref = { version = "0.1", features = ["nightly"] }

use std::rc::Rc;
use std::sync::Arc;

fn main() {
    let a: &str = "hello world";
    let b: Rc<str> = Rc::from(a);
    println!("{}", b);

    // or equivalently:
    let b: Rc<str> = a.into();
    println!("{}", b);

    // we can also do this for Arc,
    let a: &str = "hello world";
    let b: Arc<str> = Arc::from(a);
    println!("{}", b);
}