如何修复Rust中结构体方法调用引发的所有权移动错误？

这个问题的核心是Rust的所有权规则：Screen的handle_input和print_input方法都接收self（值传递），调用这类方法时，实例的所有权会被转移给方法，原变量就无法再次使用。

下面是三种可行的修复方案：

方案一：使用引用作为方法接收者（推荐） #

如果方法不需要获取Screen实例的所有权，只是执行逻辑或读取内部数据，把方法的接收者从self改为&self（不可变引用）即可。这样调用方法时只会借用实例，不会转移所有权：

#[derive(Debug)]
pub enum Input {
    Text(String),
    None,
    Exit,
}

#[derive(Debug)]
pub enum InputError {
    NotUTF8(Vec<u8>),
    EmptyString,
    IoError(std::io::Error),
}

struct Screen {
    stdout: Vec<u8>,
}

impl Screen {
    fn new(stdout: Vec<u8>) -> Self {
        Screen { stdout }
    }

    // 改为不可变引用接收者
    fn print_input(&self, input: Input) {
        match input {
            Input::Text(text) => println!("{}", &text),
            Input::None => println!("None"),
            Input::Exit => println!("Exit"),
        }
    }

    // 改为不可变引用接收者
    fn handle_input(&self, prompt: Option<String>) -> Result<Input, InputError> {
        match prompt {
            Some(_) => {
                let input = get_input()?;
                Ok(input)
            }
            None => Ok(Input::None),
        }
    }
}

fn get_input() -> Result<Input, InputError> {
    Ok(Input::Text("Text".to_owned()))
}

fn main() {
    let screen = Screen::new(Vec::new());
    let prompt = Some("Prompt".to_string());
    let input = screen.handle_input(prompt).unwrap();

    // 原screen实例仍可正常使用
    screen.print_input(input);
}

如果方法需要修改Screen的内部字段（比如操作stdout），则改用&mut self作为接收者，同时在main中声明mut let screen = ...。

方案二：为Screen实现Clone trait #

如果业务逻辑确实需要转移所有权，可以给Screen派生Clone trait，调用方法时传递克隆后的实例，保留原实例的所有权：

#[derive(Debug, Clone)]
pub enum Input {
    Text(String),
    None,
    Exit,
}

#[derive(Debug)]
pub enum InputError {
    NotUTF8(Vec<u8>),
    EmptyString,
    IoError(std::io::Error),
}

#[derive(Debug, Clone)] // 派生Clone trait
struct Screen {
    stdout: Vec<u8>,
}

// 其他impl代码与原代码一致...

fn main() {
    let screen = Screen::new(Vec::new());
    let prompt = Some("Prompt".to_string());
    // 传递克隆的实例，原screen所有权保留
    let input = screen.clone().handle_input(prompt).unwrap();

    screen.print_input(input);
}

这种方式会产生额外的内存开销，适合结构体较小、克隆成本低的场景。

方案三：让方法返回Self（适合必须消费self的场景） #

如果方法必须消费self（比如要取出内部资源处理），可以让方法返回处理后的Self实例，重新获取所有权继续操作：

impl Screen {
    // 修改为返回(Self, Input)的Result
    fn handle_input(mut self, prompt: Option<String>) -> Result<(Self, Input), InputError> {
        match prompt {
            Some(_) => {
                let input = get_input()?;
                Ok((self, input))
            }
            None => Ok((self, Input::None)),
        }
    }

    // 消费self后返回实例
    fn print_input(mut self, input: Input) -> Self {
        match input {
            Input::Text(text) => println!("{}", &text),
            Input::None => println!("None"),
            Input::Exit => println!("Exit"),
        }
        self
    }
}

fn main() {
    let mut screen = Screen::new(Vec::new());
    let prompt = Some("Prompt".to_string());
    // 获取返回的实例和输入结果
    let (screen_after_handle, input) = screen.handle_input(prompt).unwrap();
    // 使用返回的实例继续调用方法
    let _ = screen_after_handle.print_input(input);
}

这种方式代码相对繁琐，仅在必须消费self的场景下使用。

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