如何将新创建的结构体作为引用返回？

Question

作为学习 Rust 的练习，我决定实现一个位向量库，灵感来自于 std::vec::Vec ，用于提供方法。

我有以下代码：

extern crate num;

use std::cmp::Eq;
use std::ops::{BitAnd,BitOrAssign,Index,Shl};
use num::{One,Zero,Unsigned,NumCast};

pub trait BitStorage: Sized + 
    BitAnd<Self, Output = Self> + 
    BitOrAssign<Self> + 
    Shl<Self, Output = Self> + 
    Eq + Zero + One + Unsigned + NumCast + Copy {}

impl<S> BitStorage for S where S: Sized + 
    BitAnd<S, Output = S> + 
    BitOrAssign<S> + 
    Shl<S, Output = S> + 
    Eq + Zero + One + Unsigned + NumCast + Copy {}

pub struct BitVector<S: BitStorage> {
    data: Vec<S>,
    capacity: usize,
    storage_size: usize
}

impl<S: BitStorage> BitVector<S> {
    pub fn with_capacity(capacity: usize) -> BitVector<S> {
        let storage_size = std::mem::size_of::<S>() * 8;
        let len = (capacity / storage_size) + 1;
        BitVector { 
            data: vec![S::zero(); len],
            capacity: capacity,
            storage_size: storage_size
        }
    }

    pub fn get(&self, index: usize) -> Option<bool> {
        match self.index_in_bounds(index) {
            true => Some(self.get_unchecked(index)),
            false => None
        }
    }

    pub fn set(&mut self, index: usize, value: bool) {
        self.panic_index_bounds(index);
        let (data_index, remainder) = self.compute_data_index_and_remainder(index);
        let value = if value { S::one() } else { S::zero() };
        self.data[data_index] |= value << remainder;
    }

    pub fn capacity(&self) -> usize {
        self.capacity
    }

    pub fn split_at(&self, index: usize) -> (&BitVector<S>, &BitVector<S>) {
        self.panic_index_not_on_storage_bound(index);
        let data_index = self.compute_data_index(index);
        let (capacity_left, capacity_right) = self.compute_capacities(index);
        let (data_left, data_right) = self.data.split_at(data_index);

        let left = BitVector {
            data: data_left.to_vec(),
            capacity: capacity_left,
            storage_size: self.storage_size
        };
        let right = BitVector {
            data: data_right.to_vec(),
            capacity: capacity_right,
            storage_size: self.storage_size
        };
        (&left, &right)
    }

    pub fn split_at_mut(&mut self, index: usize) -> (&mut BitVector<S>, &mut BitVector<S>) {
        self.panic_index_not_on_storage_bound(index);
        let data_index = self.compute_data_index(index);
        let (capacity_left, capacity_right) = self.compute_capacities(index);
        let (data_left, data_right) = self.data.split_at_mut(data_index);

        let mut left = BitVector {
            data: data_left.to_vec(),
            capacity: capacity_left,
            storage_size: self.storage_size
        };
        let mut right = BitVector {
            data: data_right.to_vec(),
            capacity: capacity_right,
            storage_size: self.storage_size
        };
        (&mut left, &mut right)
    }

    #[inline]
    fn get_unchecked(&self, index: usize) -> bool {
        let (data_index, remainder) = self.compute_data_index_and_remainder(index);
        (self.data[data_index] & (S::one() << remainder)) != S::zero()
    }

    #[inline]
    fn compute_data_index_and_remainder(&self, index: usize) -> (usize, S) {
        let data_index = self.compute_data_index(index);
        let remainder = self.compute_data_remainder(index);
        (data_index, remainder)
    }

    #[inline]
    fn compute_data_index(&self, index: usize) -> usize {
        index / self.storage_size
    }

    #[inline]
    fn compute_data_remainder(&self, index: usize) -> S {
        let remainder = index % self.storage_size;
        // we know that remainder is always smaller or equal to the size that S can hold
        // for example if S = u8 then remainder <= 2^8 - 1
        let remainder: S = num::cast(remainder).unwrap();
        remainder
    }

    #[inline]
    fn compute_capacities(&self, index_to_split: usize) -> (usize, usize) {
        (index_to_split, self.capacity - index_to_split)
    }

    #[inline]
    fn index_in_bounds(&self, index: usize) -> bool {
        index < self.capacity
    }

    #[inline]
    fn panic_index_bounds(&self, index: usize) {
        if !self.index_in_bounds(index) {
            panic!("Index out of bounds. Length = {}, Index = {}", self.capacity, index);
        }
    }

    #[inline]
    fn panic_index_not_on_storage_bound(&self, index: usize) {
        if index % self.storage_size != 0 {
            panic!("Index not on storage bound. Storage size = {}, Index = {}", self.storage_size, index);
        }
    }
}

static TRUE: bool = true;
static FALSE: bool = false;

macro_rules! bool_ref {
    ($cond:expr) => (if $cond { &TRUE } else { &FALSE })
}

impl<S: BitStorage> Index<usize> for BitVector<S> {
    type Output = bool;

    fn index(&self, index: usize) -> &bool {
        self.panic_index_bounds(index);
        bool_ref!(self.get_unchecked(index))
    }
}

编译器错误出现在split_at和split_at_mut方法中：它们基本上告诉我，在这两种情况下，left和right的寿命不足以作为引用返回。我理解这一点，因为它们是在堆栈上创建的，然后我想将它们作为引用返回。

然而，我的设计受到std::vec::Vec的启发，您可以看到在SliceExt trait中它们的定义如下：

#[stable(feature = "core", since = "1.6.0")]
fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]);

#[stable(feature = "core", since = "1.6.0")]
fn split_at_mut(&mut self, mid: usize) -> (&mut [Self::Item], &mut [Self::Item]);

我认为这是为了方便终端用户而做的，因为他们更愿意处理引用而不是盒子。

我认为我可以通过将返回的位向量放入Box<_>中来修复我的错误，但有没有一种方法可以返回创建的结构体作为引用？

额外的问题：如果我返回(BitVector<S>, BitVector<S>)，它确实起作用，那么这样做的缺点是什么？为什么SliceExt特质不能这样做？

- skiwi

---

请提供一个 [MCVE]。 - Shepmaster

@Shepmaster，我认为无法缩短代码并仍然保留问题的精神，即它是一个位向量以及它如何与std::vec::Vec和SliceExt特质相关。 - skiwi

get、set和capacity函数是无关紧要的。请删除参数和泛型类型。最终结果请参考此链接。 - Shepmaster

Answer 1

如何将一个新创建的结构体作为引用返回？

你不可以这样做。没有办法绕过这一点；这是不可能的。就像你所说的，如果它在栈上声明，那么该值将被丢弃，并且任何引用都将失效。

那么是什么让Vec不同呢？

Vec 是 slice(&[T]) 的所有权对应物。虽然 Vec 有指向数据开头的指针、计数和容量，但是 slice 只有指针和计数。两者都保证所有数据是连续的。在伪 Rust 中，它们看起来像这样：

struct Vec<T> {
    data: *mut T,
    size: usize,
    capacity: usize,
}

struct Slice<'a, T> {
    data: *mut T,
    size: usize,
}

Vec::split_at 可以返回切片，因为它本质上 "包含" 一个切片。它不是创建一个东西并返回一个对它的引用，而只是指针和计数的复制。

如果您创建一个借用类型作为您拥有的数据类型的副本，则可以返回它。例如：

struct BitVector {
    data: Vec<u8>,
    capacity: usize,
    storage_size: usize
}

struct BitSlice<'a> {
    data: &'a [u8],
    storage_size: usize,
}

impl BitVector {
    fn with_capacity(capacity: usize) -> BitVector {
        let storage_size = std::mem::size_of::<u8>() * 8;
        let len = (capacity / storage_size) + 1;
        BitVector { 
            data: vec![0; len],
            capacity: capacity,
            storage_size: storage_size
        }
    }

    fn split_at<'a>(&'a self) -> (BitSlice<'a>, BitSlice<'a>) {
        let (data_left, data_right) = self.data.split_at(0);
        let left = BitSlice {
            data: data_left,
            storage_size: self.storage_size
        };
        let right = BitSlice {
            data: data_right,
            storage_size: self.storage_size
        };
        (left, right)
    }
}

fn main() {}

为了遵循 Vec 的主题，您可能需要将 Deref 和 DerefMut 应用到 BitSlice 上，然后在 BitSlice 上实现所有非容量更改方法。

我想这是为了终端用户的方便，因为他们更愿意处理引用而不是盒子。

使用时，引用和盒子应该是透明的。主要原因是性能。 Box 是在堆上分配的。

我想我可以通过将返回的位向量放入 Box<_> 中来修复我的错误。

这不是一个好主意。您已经通过 Vec 进行了堆分配，将其打包会引入另一个间接和额外的堆使用。

如果我返回 (BitVector<S>, BitVector<S>)，这样做有什么缺点？ 为什么 SliceExt 特征没有这样做？

是的，在这里，您正在返回堆分配的结构。返回这些没有缺点，只是执行分配的缺点。这就是为什么 SliceExt 没有这样做的原因。

这是否也直接转换为 split_at_mut 变体？

是的。

struct BitSliceMut<'a> {
    data: &'a mut [u8],
    storage_size: usize,
}

fn split_at_mut<'a>(&'a mut self) -> (BitSliceMut<'a>, BitSliceMut<'a>) {
    let (data_left, data_right) = self.data.split_at_mut (0);
    let left = BitSliceMut {
        data: data_left,
        storage_size: self.storage_size
    };
    let right = BitSliceMut {
        data: data_right,
        storage_size: self.storage_size
    };
    (left, right)
}

这有助于指出&T和&mut T是不同的类型，行为也不同。

不允许给出(mut BitSlice<'a>, mut BitSlice<'a>作为返回类型。

返回mut T没有意义：变量名前后的mut有什么区别？。对于BitSliceMut，可变性是包含类型(&mut [u8])的一个方面。

- Shepmaster

---

这是否也直接翻译成split_at_mut变体？因为这似乎是最有趣的情况，但是不允许将(mut BitSlice<'a>, mut BitSlice<'a>)作为返回类型。 - skiwi

@skiwi添加了更多内容。 - Shepmaster

我想我现在开始理解了，感谢您的解释。所以这真的是我能得到的最好的吗？因为切片不可行，因为这个结构表示一个位向量，不能表示为切片（因为即使bool也使用u8作为支持）。 - skiwi

尝试实现这个并失败后，我得出了以下（希望是暂时的）结论：无法实现Deref和DerefMut特性，因为你最终仍然会尝试创建一个BitSlice或BitSliceMut，而返回对栈上某个东西的引用是行不通的。 - skiwi

Answer 2

为什么标准库可以通过引用返回的答案是，它不在堆栈上分配任何东西。它返回对已分配内存的引用，该内存存在足够长的时间。

因此，您基本上有两种选择：

- 如果在堆栈上分配内存，则必须将其作为值返回。这包括Box<_>场景。您将Box（其中包含指向堆分配内存的指针）作为值返回。 - 如果不在堆栈上分配内存，则可以返回对结果的引用，该结果已经存在于内存中。

在 Rust 中，按值返回是有效的，因为该值被移动而不是复制。

- JDemler