一般来说，你试图完成的事情是不安全的，Rust 正确地阻止了你做你不应该做的事情。对于一个简单的例子为什么，考虑一个Vec<u8>. 如果向量具有一项且容量为一项，则向向量添加另一个值将导致重新分配和复制向量中的所有值，从而使对向量的任何引用无效。这将导致索引中的所有键都指向任意内存地址，从而导致不安全的行为。编译器会阻止这种情况。
在这种情况下，编译器不知道但程序员不知道的两条额外信息：
- 还有一个额外的间接性——
String是堆分配的，因此将指针移动到该堆分配并不是真正的问题。
String永远不会改变。如果是，那么它可能会重新分配，从而使引用地址无效。使用 aBox<[str]>而不是 aString将是通过类型系统强制执行此操作的一种方法。
在这种情况下，使用unsafe代码是可以的，只要您正确记录为什么它不是不安全的。
use std::collections::HashMap;
#[derive(Debug)]
struct Player {
name: String,
}
fn main() {
let names = ["alice", "bob", "clarice", "danny", "eustice", "frank"];
let mut players = Vec::new();
let mut index = HashMap::new();
for &name in &names {
let player = Player { name: name.into() };
let idx = players.len();
// I copied this code from Stack Overflow without reading the prose
// that describes why this unsafe block is actually safe
let stable_name: &str = unsafe { &*(player.name.as_str() as *const str) };
players.push(player);
index.insert(idx, stable_name);
}
for (k, v) in &index {
println!("{:?} -> {:?}", k, v);
}
for v in &players {
println!("{:?}", v);
}
}
但是，我的猜测是您不希望在您的main方法中使用此代码，而是希望从某个函数中返回它。这将是一个问题，因为您很快就会遇到为什么我不能在同一个结构中存储一个值和对该值的引用？.
老实说，有些代码风格不太适合 Rust 的限制。如果你遇到这些，你可以：
- 确定 Rust 不适合您或您的问题。
- 使用
unsafe代码，最好是经过彻底测试并且只公开一个安全的 API。
- 研究替代表示。
例如，我可能会重写代码以使索引成为键的主要所有者：
use std::collections::BTreeMap;
#[derive(Debug)]
struct Player<'a> {
name: &'a str,
data: &'a PlayerData,
}
#[derive(Debug)]
struct PlayerData {
hit_points: u8,
}
#[derive(Debug)]
struct Players(BTreeMap<String, PlayerData>);
impl Players {
fn new<I>(iter: I) -> Self
where
I: IntoIterator,
I::Item: Into<String>,
{
let players = iter
.into_iter()
.map(|name| (name.into(), PlayerData { hit_points: 100 }))
.collect();
Players(players)
}
fn get<'a>(&'a self, name: &'a str) -> Option<Player<'a>> {
self.0.get(name).map(|data| Player { name, data })
}
}
fn main() {
let names = ["alice", "bob", "clarice", "danny", "eustice", "frank"];
let players = Players::new(names.iter().copied());
for (k, v) in &players.0 {
println!("{:?} -> {:?}", k, v);
}
println!("{:?}", players.get("eustice"));
}
或者，如制作使用项目字段作为键的查找表的惯用方法是什么？，您可以包装您的类型并将其存储在一个集合容器中：
use std::collections::BTreeSet;
#[derive(Debug, PartialEq, Eq)]
struct Player {
name: String,
hit_points: u8,
}
#[derive(Debug, Eq)]
struct PlayerByName(Player);
impl PlayerByName {
fn key(&self) -> &str {
&self.0.name
}
}
impl PartialOrd for PlayerByName {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for PlayerByName {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
self.key().cmp(&other.key())
}
}
impl PartialEq for PlayerByName {
fn eq(&self, other: &Self) -> bool {
self.key() == other.key()
}
}
impl std::borrow::Borrow<str> for PlayerByName {
fn borrow(&self) -> &str {
self.key()
}
}
#[derive(Debug)]
struct Players(BTreeSet<PlayerByName>);
impl Players {
fn new<I>(iter: I) -> Self
where
I: IntoIterator,
I::Item: Into<String>,
{
let players = iter
.into_iter()
.map(|name| {
PlayerByName(Player {
name: name.into(),
hit_points: 100,
})
})
.collect();
Players(players)
}
fn get(&self, name: &str) -> Option<&Player> {
self.0.get(name).map(|pbn| &pbn.0)
}
}
fn main() {
let names = ["alice", "bob", "clarice", "danny", "eustice", "frank"];
let players = Players::new(names.iter().copied());
for player in &players.0 {
println!("{:?}", player.0);
}
println!("{:?}", players.get("eustice"));
}
不使用Rc或增加运行时间RefCell
在不执行分析的情况下猜测性能特征绝不是一个好主意。老实说，我不相信当一个值被克隆或删除时增加一个整数会导致明显的性能损失。如果问题需要索引和向量，那么我会寻求某种共享所有权。