如何在Rust中实现无拷贝且可禁用后续访问的高效字符串构建器？

我想要编写一个用于构建大型字符串（如HTML）的类型，要求返回字符串时无需进行拷贝或克隆，同时实现一个unwrap函数，调用该函数后能阻止对构建器的后续访问。

现有实现代码如下：

mod test {
    use std::cell::RefCell;

    struct StringBuilder {
        buffer: RefCell<String>,
    }

    impl StringBuilder {
        pub fn new() -> Self {
            Self { buffer: RefCell::new(String::with_capacity(8000)) }
        }

        pub fn append(self: &Self, s: &str) -> &Self {
            self.buffer.borrow_mut().push_str(s);
            self
        }

        pub fn unwrap(self: &Self) -> String {
            self.buffer.borrow().clone()
        }
    }

    #[test]
    pub fn test() {
        let sb = StringBuilder::new();
        sb.append("a").append("b");
        let s = sb.unwrap();
        println!("{s}");
    }
}

但这个实现的unwrap方法需要克隆字符串，性能不佳。我曾尝试让unwrap接收&mut Self而非&Self，想借此阻止后续对构建器的引用，但可变引用会立即超出作用域，达不到预期效果。

解决方案：利用所有权转移实现无拷贝+访问限制 #

通过让unwrap获取构建器的所有权，既能直接转移内部字符串的所有权（无需拷贝），又能让原构建器变量失效，从编译层面阻止后续访问。修改后的代码如下：

mod test {
    struct StringBuilder {
        buffer: String,
    }

    impl StringBuilder {
        pub fn new() -> Self {
            Self { buffer: String::with_capacity(8000) }
        }

        // 用可变引用实现链式append，符合Rust所有权规则
        pub fn append(&mut self, s: &str) -> &mut Self {
            self.buffer.push_str(s);
            self
        }

        // 接收Self所有权，调用后原变量失效
        pub fn unwrap(mut self) -> String {
            // 取出内部String，留下空字符串（无额外开销）
            std::mem::take(&mut self.buffer)
        }
    }

    #[test]
    pub fn test() {
        let mut sb = StringBuilder::new();
        sb.append("a").append("b");
        let s = sb.unwrap();
        println!("{s}");
        
        // 以下代码会编译报错，因为sb的所有权已被转移
        // sb.append("c");
    }
}

方案说明： #

• 移除RefCell：不需要内部可变性，改用&mut self进行修改，更符合Rust的安全规范，同时避免了RefCell的运行时开销。
• 所有权转移的unwrap：unwrap(self)会将构建器的所有权转移到方法内部，原变量sb在调用后会被标记为已移动，编译器会直接阻止后续对它的任何操作，完美实现访问限制。
• 无拷贝获取字符串：使用std::mem::take将内部的String取出，仅留下一个空的String（空字符串不占用堆内存），整个过程没有任何字符串拷贝，性能拉满。

内容的提问来源于stack exchange，提问作者bikeman868