Rust中不依赖标准库实现mem::swap的问题求助

作为Rust新手，尝试不依赖标准库实现mem::swap时遇到了生命周期编译错误，代码和错误信息如下：

问题代码 #

fn swap<T: std::fmt::Display>(x: &mut T, y: &mut T) {
unsafe {
    // Give ourselves some scratch space to work with
    let mut t: &mut T = y;
    y = x;
    x = t;
    }
}
fn main() {
println!("Hello, world!");
let mut x = Box::new(5);
let mut y = Box::new(42);
let mut t = Box::new(0);
swap(&mut x, &mut y);
}

编译错误信息 #

error: lifetime may not live long enough
 --> src/main.rs:4:29
  |
1 | fn swap<T: std::fmt::Display>(x: &mut T, y: &mut T) {
  |                                  -          - let's call the lifetime of this reference `'2`
  |                                  |
  |                                  let's call the lifetime of this reference `'1`
...
4 |         let mut t: &mut T = y;
  |                             ^ assignment requires that `'2` must outlive `'1`
  |
help: consider introducing a named lifetime parameter
  |
1 | fn swap<'a, T: std::fmt::Display>(x: &'a mut T, y: &'a mut T) {
  |         +++                           ++            ++

1. 「lifetime may not live long enough」是什么意思？ #

Rust的生命周期是用来保证引用不会悬空的核心机制。在你的swap函数中，没有显式标注生命周期时，编译器会默认给x和y分配两个独立的生命周期'1和'2。

当你执行let mut t: &mut T = y;时，相当于把生命周期为'2的引用y赋值给t；后续又把x（生命周期'1）赋值给y，最后把t（绑定'2）赋值给x。这一系列操作要求'2的存活时间必须覆盖'1，但编译器无法确认这两个独立的生命周期是否满足这个约束，因此抛出错误。

本质上是：编译器无法保证交换后的引用在各自的有效生命周期内始终安全，因为两个参数的生命周期没有被绑定为同一个。

2. 正确且简单的实现方式 #

首先要明确：你当前的实现逻辑完全错误——你只是交换了函数内部的引用变量本身，而非引用指向的实际数据，根本达不到mem::swap的效果。

正确的实现需要操作引用指向的内存数据，这里必须用到不安全代码绕过Rust的借用检查（因为需要临时持有数据所有权）：

标准手动实现（对齐官方mem::swap逻辑） #

fn swap<T>(x: &mut T, y: &mut T) {
    unsafe {
        // 从x读取值，此时x暂时处于悬空状态（需手动保证后续安全）
        let temp = std::ptr::read(x);
        // 将y的值写入x
        std::ptr::write(x, std::ptr::read(y));
        // 将临时值写入y
        std::ptr::write(y, temp);
    }
}

fn main() {
    let mut x = Box::new(5);
    let mut y = Box::new(42);
    println!("交换前：x = {}, y = {}", x, y);
    swap(&mut x, &mut y);
    println!("交换后：x = {}, y = {}", x, y);
}

关键说明：

• std::ptr::read：从指针指向的内存读取值，不会触发类型的Drop逻辑，需手动确保后续不会重复释放内存
• std::ptr::write：将值写入指针指向的内存，同样不会触发原有值的Drop逻辑
• 整个逻辑包裹在unsafe块中，因为需要手动保证内存安全：x和y必须是有效的非空指针，且指向不同的内存位置（官方mem::swap也有此要求）
• 不需要给T添加std::fmt::Display约束，mem::swap对类型无任何 trait 要求，只要是可移动类型即可

更简洁的替代写法 #

如果你不想手动调用ptr::read和ptr::write，也可以用copy_nonoverlapping实现，本质逻辑一致：

fn swap<T>(x: &mut T, y: &mut T) {
    unsafe {
        let mut temp: T = std::mem::transmute(());
        // 复制x的值到temp
        std::ptr::copy_nonoverlapping(x, &mut temp as *mut T, 1);
        // 复制y的值到x
        std::ptr::copy_nonoverlapping(y, x, 1);
        // 复制temp的值到y
        std::ptr::copy_nonoverlapping(&temp as *const T, y, 1);
        // 避免temp被Drop（因为它的内存是通过transmute创建的）
        std::mem::forget(temp);
    }
}

不过这种写法可读性不如第一种，推荐使用ptr::read+ptr::write的版本。

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