Почему нельзя хранить значение и ссылку на него в одной структуре в Rust?

Почему Rust запрещает такое хранение?

Проблема в том, что когда вы перемещаете text в поле data структуры, память, на которую указывает ссылка first, может быть перемещена (изменён адрес). Rust гарантирует безопасность памяти на этапе компиляции, поэтому он не позволяет ссылкам "висеть" (dangling references). В вашем примере first ссылается на старый адрес text, который после перемещения становится недействительным.

Даже если вы создаёте ссылку после перемещения, как в этом коде:

let s = MyStruct { data: text, first_char: &text[..1] }; // Ошибка!

Компилятор всё равно выдаст ошибку, потому что text уже перемещён в s.data — вы не можете одновременно заимствовать text (через &text[..1]) и перемещать его.

Три решения проблемы

1. Использование индекса вместо ссылки

Самый простой способ — хранить не ссылку, а индекс, который указывает на нужную часть данных:

struct MyStruct {
    data: String,
    first_char_index: usize, // храним позицию
}

impl MyStruct {
    fn first_char(&self) -> &str {
        &self.data[..self.first_char_index]
    }
}

fn main() {
    let s = MyStruct {
        data: String::from("Hello"),
        first_char_index: 1, // первый символ — срез от 0 до 1
    };
    println!("{}", s.first_char()); // "H"
}

Плюсы: просто, безопасно, не требует времён жизни. Минусы: нужно следить за актуальностью индекса при изменении данных.

2. Использование умных указателей (Rc/RefCell)

Если вам обязательно нужна ссылка, используйте подсчёт ссылок и внутреннюю изменяемость:

use std::rc::Rc;
use std::cell::RefCell;

struct MyStruct {
    data: Rc<RefCell<String>>,
    first_char: String, // копия первого символа
}

fn main() {
    let text = Rc::new(RefCell::new(String::from("Hello")));
    let first = text.borrow()[..1].to_string();
    let s = MyStruct { data: text, first_char: first };
    println!("{}", s.first_char); // "H"
}

Плюсы: гибкость, можно менять данные через RefCell. Минусы: оверхед, потеря гарантий времени жизни на этапе компиляции (ошибки могут быть в runtime).

3. Самый правильный — спроектировать иначе

Чаще всего такая структура — признак плохого дизайна. Вместо того чтобы хранить ссылку внутри, сделайте методы, которые её вычисляют:

struct MyStruct {
    data: String,
}

impl MyStruct {
    fn first_char(&self) -> &str {
        &self.data[..1]
    }
}

fn main() {
    let s = MyStruct { data: String::from("Hello") };
    println!("{}", s.first_char()); // "H"
}

Плюсы: никаких проблем с временами жизни, чистый код. Минусы: нужно вызывать метод каждый раз, но это дешево.

Почему это не антипаттерн, а фича?

Запрет на хранение ссылки и значения вместе — это сознательное решение разработчиков Rust. Оно предотвращает целый класс багов с висячими указателями, которые в C++ приводят к крашам и уязвимостям. Вместо того чтобы бороться с компилятором, примите его правила — и ваш код станет безопасным и предсказуемым.

struct MyStruct {
    data: Box<String>, // храним в куче, адрес стабилен
    first_char: *const str, // сырой указатель
}

impl MyStruct {
    fn new(s: String) -> Self {
        let data = Box::new(s);
        let first_char = &(*data)[..1] as *const str;
        MyStruct { data, first_char }
    }

    fn first_char(&self) -> &str {
        unsafe { &*self.first_char }
    }
}

fn main() {
    let s = MyStruct::new("Hello".to_string());
    println!("{}", s.first_char());
}