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

Почему нельзя вернуть ссылку на локальную переменную?

В Rust действуют строгие правила владения и заимствования. Когда вы создаёте переменную внутри функции (например, let data = String::from(...)), она располагается на стеке. При выходе из функции эта память освобождается. Если бы компилятор разрешил вернуть ссылку на неё, то после возврата из функции ссылка указывала бы на уже освобождённую память — это классический висячий указатель (dangling pointer). Rust предотвращает такие ситуации на этапе компиляции.

Вот как это выглядит в памяти:

fn get_data() -> &str {   // обещаем вернуть ссылку
    let data = String::from("Hello"); // data живёт только внутри функции
    &data                             // пытаемся отдать ссылку на data
}                                     // data уничтожается, ссылка становится недействительной

Правильные решения

Есть три основных подхода, в зависимости от вашей задачи:

• Вернуть владение (String) — самый простой и идиоматичный способ.
• Принять ссылку на внешнюю память — если данные уже где-то существуют.
• Использовать умные указатели — для сложных сценариев с разделяемым владением.

Решение 1: Возвращаем String

Просто верните владение строкой. Вызывающая сторона получит String, а если ей нужен &str, она может взять ссылку от неё:

fn get_data() -> String {
    let data = String::from("Hello, world!");
    data // перемещаем владение наружу
}

fn main() {
    let s = get_data();
    let slice: &str = &s; // теперь можно получить ссылку
    process_data(slice);  // передаём срез в другие функции
}

Это работает, потому что String — владеющий тип. Он не уничтожается при выходе из функции, а передаётся вызывающему коду.

Решение 2: Принимаем буфер извне

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

fn get_data_into(buffer: &mut String) -> &str {
    buffer.clear();
    buffer.push_str("Hello, world!");
    &buffer[..] // возвращаем срез на переданный буфер
}

fn main() {
    let mut my_buffer = String::new();
    let slice = get_data_into(&mut my_buffer);
    println!("{}", slice); // "Hello, world!"
}

Здесь время жизни ссылки совпадает с временем жизни my_buffer, поэтому всё безопасно.

Решение 3: Используем Cow (Clone-on-Write)

Для случаев, когда функция может вернуть либо ссылку на существующие данные, либо создать новые:

use std::borrow::Cow;

fn process(input: &str) -> Cow<str> {
    if input.starts_with("Hello") {
        Cow::Borrowed(input) // возвращаем ссылку без копирования
    } else {
        Cow::Owned(format!("Hello, {}", input)) // создаём новую строку
    }
}

fn main() {
    let result = process("World");
    println!("{}", result); // "Hello, World"
}

Что делать, если очень нужна ссылка?

Если вы пишете библиотечную функцию, которая должна возвращать &str по условию, используйте трейт ToOwned или Cow. Но в 95% случаев достаточно просто вернуть String. Rust явно разделяет владение и заимствование — это одна из ключевых фич языка, обеспечивающая безопасность памяти без сборщика мусора.

fn get_data() -> &'static str {
    "Hello, world!" // строковый литерал имеет тип &'static str
}

fn get_data() -> &'static str {
    let s = String::from("Hello");
    Box::leak(s.into_boxed_str()) // "утекает" память, живёт вечно
}