Как изменить поле структуры из метода в Rust?

Проблема: неизменяемая ссылка в методе

Вы столкнулись с одним из фундаментальных правил Rust: если метод принимает &self, то это неизменяемая ссылка на структуру. Через неё нельзя изменять поля — это нарушило бы гарантии безопасности. Даже если сама переменная counter объявлена как mut, это не даёт права изменять данные через неизменяемую ссылку.

Решение: используйте &mut self

Чтобы метод мог изменять поля структуры, он должен принимать изменяемую ссылку на себя — &mut self. Это явно говорит компилятору: "я собираюсь менять данные, и никто другой не должен иметь на них ссылок в этот момент". Вот исправленный код:

struct Counter {
    value: i32,
}

impl Counter {
    // Изменяем &self на &mut self
    fn increment(&mut self) {
        self.value += 1; // Теперь работает!
    }
}

fn main() {
    let mut counter = Counter { value: 0 };
    counter.increment(); // Вызов метода с &mut self
    println!("{}", counter.value); // Вывод: 1
}

Почему это важно?

• Безопасность: Rust гарантирует, что если у вас есть изменяемая ссылка (&mut), то никаких других ссылок на данные в этот момент не существует. Это предотвращает гонки данных и неопределённое поведение.
• Явность: Программист и компилятор точно знают, какие методы могут изменять состояние, а какие — нет. Это делает код предсказуемым.
• Производительность: Компилятор может оптимизировать код, зная, что изменяемая ссылка — единственный способ доступа к данным.

Что делать, если метод должен и читать, и изменять?

Если вам нужно и читать поле, и изменять его — используйте &mut self. Если метод только читает — оставляйте &self. Также можно комбинировать:

impl Counter {
    // Только чтение
    fn get_value(&self) -> i32 {
        self.value
    }
    
    // Изменение
    fn reset(&mut self) {
        self.value = 0;
    }
}

Распространённые ошибки

• Забыли mut для переменной: Даже с &mut self в методе, сама переменная должна быть объявлена как let mut counter, иначе вы не сможете вызвать метод, требующий изменяемую ссылку.
• Попытка изменить через &self: Компилятор сразу выдаст ошибку. Если вам нужно изменить поле внутри метода, который по логике должен быть "только для чтения", — пересмотрите дизайн. Возможно, стоит вынести изменение в отдельный метод.
• Одновременное изменение и чтение: Если у вас есть и &self, и &mut self методы, помните, что в одном скоупе нельзя одновременно вызывать их оба на одной переменной. Например:

let mut c = Counter { value: 0 };
let r = c.get_value(); // &self
c.increment();         // &mut self — ошибка! r всё ещё жив
println!("{}", r);

В этом случае нужно убедиться, что неизменяемая ссылка r "умирает" до вызова increment, или использовать c.get_value() напрямую.

Заключение

Чтобы изменить поле структуры из метода, всегда используйте &mut self в сигнатуре метода. Это не просто синтаксическое требование — это основа безопасности Rust. Привыкайте к этому правилу, и ваш код станет надёжным и понятным.

struct Counter {
    value: i32,
}

impl Counter {
    // Возвращает новый Counter с увеличенным значением
    fn increment(&self) -> Counter {
        Counter {
            value: self.value + 1,
        }
    }
}

fn main() {
    let counter = Counter { value: 0 };
    let counter = counter.increment(); // Создаём новую структуру
    println!("{}", counter.value); // Вывод: 1
}