Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Проверка ссылок с помощью времён жизни

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

Одна деталь, которую мы не обсуждали в разделе «Ссылки и заимствование» в главе 4, заключается в том, что каждая ссылка в Rust имеет время жизни, то есть область видимости, в пределах которой эта ссылка корректна. В большинстве случаев времена жизни неявны и выводятся, точно так же, как в большинстве случаев выводятся типы. Аннотировать типы требуется только тогда, когда возможны несколько типов. Аналогично, мы должны аннотировать времена жизни, когда времена жизни ссылок могут быть связаны несколькими разными способами. Rust требует аннотировать связи с помощью обобщённых параметров времени жизни, чтобы гарантировать, что фактические ссылки, используемые во время выполнения, определённо будут корректны.

Аннотация времён жизни — это даже не концепция, которая есть в большинстве других языков программирования, поэтому это будет казаться непривычным. Хотя мы не будем рассматривать времена жизни целиком в этой главе, мы обсудим распространённые способы, которыми можно столкнуться с синтаксисом времён жизни, чтобы привыкнуть к этой концепции.

Висячие ссылки

Главная цель времён жизни — предотвратить висячие ссылки, которые, если бы им было позволено существовать, заставили бы программу ссылаться на данные, отличные от данных, на которые она должна ссылаться. Рассмотрим программу в листинге 10-16, которая имеет внешнюю область видимости и внутреннюю область видимости.

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {r}");
}
Листинг 10-16: Попытка использовать ссылку, значение которой вышло из области видимости

Примечание: В примерах листингов 10-16, 10-17 и 10-23 переменные объявляются без начального значения, поэтому имя переменной существует во внешней области видимости. На первый взгляд это может показаться противоречащим тому, что в Rust нет нулевых значений. Однако если мы попытаемся использовать переменную до присвоения ей значения, мы получим ошибку времени компиляции, что показывает, что Rust действительно не допускает нулевые значения.

Внешняя область видимости объявляет переменную с именем r без начального значения, а внутренняя область видимости объявляет переменную с именем x с начальным значением 5. Внутри внутренней области видимости мы пытаемся присвоить r значение ссылки на x. Затем внутренняя область видимости заканчивается, и мы пытаемся вывести значение в r. Этот код не скомпилируется, потому что значение, на которое ссылается r, вышло из области видимости до того, как мы пытаемся его использовать. Вот сообщение об ошибке:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
 --> src/main.rs:6:13
  |
5 |         let x = 5;
  |             - binding `x` declared here
6 |         r = &x;
  |             ^^ borrowed value does not live long enough
7 |     }
  |     - `x` dropped here while still borrowed
8 |
9 |     println!("r: {r}");
  |                   - borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Сообщение об ошибке говорит, что переменная x «не живёт достаточно долго». Причина в том, что x выйдет из области видимости, когда внутренняя область видимости закончится на строке 7. Но r всё ещё корректна для внешней области видимости; поскольку её область видимости больше, мы говорим, что она «живёт дольше». Если бы Rust позволил этому коду работать, r ссылалась бы на память, которая была освобождена, когда x вышла из области видимости, и всё, что мы попытались бы сделать с r, не работало бы корректно. Итак, как Rust определяет, что этот код недопустим? Он использует проверку заимствований.

Проверка заимствований

Компилятор Rust имеет проверку заимствований, которая сравнивает области видимости, чтобы определить, корректны ли все заимствования. Листинг 10-17 показывает тот же код, что и листинг 10-16, но с аннотациями, показывающими времена жизни переменных.

fn main() {
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {r}");   //          |
}                         // ---------+
Листинг 10-17: Аннотации времён жизни r и x, обозначенных как 'a и 'b соответственно

Здесь мы аннотировали время жизни r как 'a, а время жизни x как 'b. Как видите, внутренний блок 'b намного меньше внешнего блока времени жизни 'a. Во время компиляции Rust сравнивает размер этих двух времён жизни и видит, что r имеет время жизни 'a, но что она ссылается на память со временем жизни 'b. Программа отклоняется, потому что 'b короче, чем 'a: объект ссылки не живёт так же долго, как ссылка.

Листинг 10-18 исправляет код так, чтобы в нём не было висячей ссылки, и он компилируется без ошибок.

fn main() {
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {r}");   //   |       |
                          // --+       |
}                         // ----------+
Листинг 10-18: Корректная ссылка, потому что данные имеют большее время жизни, чем ссылка

Здесь x имеет время жизни 'b, которое в данном случае больше, чем 'a. Это означает, что r может ссылаться на x, потому что Rust знает, что ссылка в r будет всегда корректна, пока корректна x.

Теперь, когда вы знаете, где находятся времена жизни ссылок и как Rust анализирует времена жизни, чтобы гарантировать, что ссылки всегда будут корректны, давайте рассмотрим обобщённые времена жизни в параметрах и возвращаемых значениях функций.

Обобщённые времена жизни в функциях

Мы напишем функцию, которая возвращает более длинную из двух строковых срезов. Эта функция будет принимать два строковых среза и возвращать один строковый срез. После того как мы реализуем функцию longest, код в листинге 10-19 должен вывести The longest string is abcd.

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}
Листинг 10-19: Функция main, которая вызывает функцию longest для нахождения более длинного из двух строковых срезов

Обратите внимание, что мы хотим, чтобы функция принимала строковые срезы, то есть ссылки, а не строки, потому что мы не хотим, чтобы функция longest становилась владельцем своих параметров. Обратитесь к разделу «Строковые срезы как параметры» в главе 4 для дальнейшего обсуждения того, почему параметры, которые мы используем в листинге 10-19, — это те, которые нам нужны.

Если мы попытаемся реализовать функцию longest, как показано в листинге 10-20, она не скомпилируется.

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}
Листинг 10-20: Реализация функции longest, которая возвращает более длинный из двух строковых срезов, но пока не компилируется

Вместо этого мы получаем следующую ошибку, которая говорит о временах жизни:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0106]: missing lifetime specifier
 --> src/main.rs:9:33
  |
9 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
  |
9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  |           ++++     ++          ++          ++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Текст справки показывает, что возвращаемому типу нужен обобщённый параметр времени жизни, потому что Rust не может определить, ссылается ли возвращаемая ссылка на x или на y. На самом деле мы тоже этого не знаем, потому что блок if в теле этой функции возвращает ссылку на x, а блок else возвращает ссылку на y!

Когда мы определяем эту функцию, мы не знаем конкретные значения, которые будут переданы в эту функцию, поэтому мы не знаем, будет ли выполняться случай if или случай else. Мы также не знаем конкретные времена жизни ссылок, которые будут переданы, поэтому мы не можем посмотреть на области видимости, как мы делали в листингах 10-17 и 10-18, чтобы определить, будет ли возвращаемая ссылка всегда корректна. Проверка заимствований тоже не может это определить, потому что она не знает, как времена жизни x и y соотносятся со временем жизни возвращаемого значения. Чтобы исправить эту ошибку, мы добавим обобщённые параметры времени жизни, которые определяют связь между ссылками, чтобы проверка заимствований могла выполнить свой анализ.

Синтаксис аннотации времён жизни

Аннотации времён жизни не изменяют, как долго живут какие-либо из ссылок. Скорее, они описывают связи между временами жизни нескольких ссылок, не влияя на сами времена жизни. Точно так же, как функции могут принимать любой тип, когда сигнатура указывает обобщённый параметр типа, функции могут принимать ссылки с любым временем жизни, указав обобщённый параметр времени жизни.

Аннотации времён жизни имеют несколько необычный синтаксис: имена параметров времени жизни должны начинаться с апострофа (') и обычно пишутся строчными буквами и очень короткими, как обобщённые типы. Большинство людей используют имя 'a для первой аннотации времени жизни. Мы размещаем аннотации параметров времени жизни после & ссылки, используя пробел для отделения аннотации от типа ссылки.

Вот несколько примеров — ссылка на i32 без параметра времени жизни, ссылка на i32, которая имеет параметр времени жизни с именем 'a, и изменяемая ссылка на i32, которая также имеет время жизни 'a:

&i32        // ссылка
&'a i32     // ссылка с явным временем жизни
&'a mut i32 // изменяемая ссылка с явным временем жизни

Одна аннотация времени жизни сама по себе не имеет большого значения, потому что аннотации предназначены для того, чтобы сообщить Rust, как обобщённые параметры времени жизни нескольких ссылок соотносятся друг с другом. Давайте рассмотрим, как аннотации времён жизни соотносятся друг с другом в контексте функции longest.

В сигнатурах функций

Чтобы использовать аннотации времён жизни в сигнатурах функций, нам нужно объявить обобщённые параметры времени жизни внутри угловых скобок между именем функции и списком параметров, точно так же, как мы делали с обобщёнными параметрами типа.

Мы хотим, чтобы сигнатура выражала следующее ограничение: возвращаемая ссылка будет корректна до тех пор, пока корректны оба параметра. Это связь между временами жизни параметров и возвращаемого значения. Мы назовём время жизни 'a, а затем добавим его к каждой ссылке, как показано в листинге 10-21.

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
Листинг 10-21: Определение функции longest, в котором указано, что все ссылки в сигнатуре должны иметь одинаковое время жизни 'a

Этот код должен скомпилироваться и выдать желаемый результат при использовании с функцией main из листинга 10-19.

Сигнатура функции теперь сообщает Rust, что для некоторого времени жизни 'a функция принимает два параметра, оба из которых являются строковыми срезами, живущими как минимум столько же, сколько время жизни 'a. Сигнатура функции также сообщает Rust, что строковый срез, возвращаемый из функции, будет жить как минимум столько же, сколько время жизни 'a. На практике это означает, что время жизни ссылки, возвращаемой функцией longest, совпадает с меньшим из времён жизни значений, на которые ссылаются аргументы функции. Эти связи — то, что мы хотим, чтобы Rust использовал при анализе этого кода.

Помните, когда мы указываем параметры времени жизни в этой сигнатуре функции, мы не изменяем времена жизни каких-либо значений, переданных или возвращённых. Скорее, мы указываем, что проверка заимствований должна отклонять любые значения, которые не соответствуют этим ограничениям. Обратите внимание, что функции longest не нужно знать точно, как долго будут жить x и y, только то, что некоторая область видимости может быть подставлена вместо 'a, которая удовлетворит этой сигнатуре.

При аннотировании времён жизни в функциях аннотации размещаются в сигнатуре функции, а не в теле функции. Аннотации времён жизни становятся частью контракта функции, во многом как типы в сигнатуре. Наличие сигнатур функций, содержащих контракт времени жизни, означает, что анализ, выполняемый компилятором Rust, может быть проще. Если есть проблема с тем, как функция аннотирована или как она вызывается, ошибки компилятора могут указывать на ту часть нашего кода и ограничений более точно. Если бы вместо этого компилятор Rust делал больше выводов о том, какими мы предполагали связи времён жизни, компилятор мог бы только указать на использование нашего кода на много шагов дальше от причины проблемы.

Когда мы передаём конкретные ссылки в longest, конкретное время жизни, которое подставляется вместо 'a, — это часть области видимости x, которая пересекается с областью видимости y. Другими словами, обобщённое время жизни 'a получит конкретное время жизни, равное меньшему из времён жизни x и y. Поскольку мы аннотировали возвращаемую ссылку тем же параметром времени жизни 'a, возвращаемая ссылка также будет корректна в течение длины меньшего из времён жизни x и y.

Давайте посмотрим, как аннотации времён жизни ограничивают функцию longest, передавая ссылки с разными конкретными временами жизни. Листинг 10-22 — простой пример.

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("long string is long");

    {
        let string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is {result}");
    }
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
Листинг 10-22: Использование функции longest со ссылками на значения String, которые имеют разные конкретные времена жизни

В этом примере string1 корректна до конца внешней области видимости, string2 корректна до конца внутренней области видимости, а result ссылается на что-то, что корректно до конца внутренней области видимости. Запустите этот код, и вы увидите, что проверка заимствований одобряет его; он скомпилируется и выведет The longest string is long string is long.

Далее давайте попробуем пример, который показывает, что время жизни ссылки в result должно быть меньшим временем жизни из двух аргументов. Мы переместим объявление переменной result за пределы внутренней области видимости, но оставим присвоение значения переменной result внутри области видимости с string2. Затем мы переместим println!, который использует result, за пределы внутренней области видимости, после того как внутренняя область видимости закончится. Код в листинге 10-23 не скомпилируется.

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
    }
    println!("The longest string is {result}");
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
Листинг 10-23: Попытка использовать result после того, как string2 вышла из области видимости

Когда мы пытаемся скомпилировать этот код, мы получаем эту ошибку:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `string2` does not live long enough
 --> src/main.rs:6:44
  |
5 |         let string2 = String::from("xyz");
  |             ------- binding `string2` declared here
6 |         result = longest(string1.as_str(), string2.as_str());
  |                                            ^^^^^^^ borrowed value does not live long enough
7 |     }
  |     - `string2` dropped here while still borrowed
8 |     println!("The longest string is {result}");
  |                                      ------ borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Ошибка показывает, что для того, чтобы result была корректна для оператора println!, string2 должна была бы быть корректна до конца внешней области видимости. Rust знает это, потому что мы аннотировали времена жизни параметров функции и возвращаемого значения, используя один и тот же параметр времени жизни 'a.

Как люди, мы можем взглянуть на этот код и увидеть, что string1 длиннее, чем string2, и, следовательно, result будет содержать ссылку на string1. Поскольку string1 ещё не вышла из области видимости, ссылка на string1 будет по-прежнему корректна для оператора println!. Однако компилятор не может увидеть, что ссылка корректна в этом случае. Мы сообщили Rust, что время жизни ссылки, возвращаемой функцией longest, совпадает с меньшим из времён жизни переданных ссылок. Следовательно, проверка заимствований запрещает код в листинге 10-23 как потенциально содержащий некорректную ссылку.

Попробуйте разработать больше экспериментов, варьируя значения и времена жизни ссылок, передаваемых в функцию longest, и то, как используется возвращаемая ссылка. Сформулируйте гипотезы о том, пройдут ли ваши эксперименты проверку заимствований, прежде чем компилировать; затем проверьте, правы ли вы!

Связи

Способ, которым нужно указывать параметры времени жизни, зависит от того, что делает ваша функция. Например, если бы мы изменили реализацию функции longest, чтобы всегда возвращать первый параметр, а не самый длинный строковый срез, нам не нужно было бы указывать время жизни для параметра y. Следующий код скомпилируется:

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("abcd");
    let string2 = "efghijklmnopqrstuvwxyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest<'a>(x: &'a str, y: &str) -> &'a str {
    x
}

Мы указали параметр времени жизни 'a для параметра x и возвращаемого типа, но не для параметра y, потому что время жизни y не имеет никакой связи со временем жизни x или возвращаемого значения.

Когда функция возвращает ссылку, параметр времени жизни для возвращаемого типа должен совпадать с параметром времени жизни для одного из параметров. Если возвращаемая ссылка не ссылается на один из параметров, она должна ссылаться на значение, созданное внутри этой функции. Однако это была бы висячая ссылка, потому что значение выйдет из области видимости в конце функции. Рассмотрим эту попытку реализации функции longest, которая не будет компилироваться:

Имя файла: src/main.rs
fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest<'a>(x: &str, y: &str) -> &'a str {
    let result = String::from("really long string");
    result.as_str()
}

Здесь, хотя мы указали параметр времени жизни 'a для возвращаемого типа, эта реализация не скомпилируется, потому что время жизни возвращаемого значения вообще не связано со временем жизни параметров. Вот сообщение об ошибке, которое мы получаем:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0515]: cannot return value referencing local variable `result`
  --> src/main.rs:11:5
   |
11 |     result.as_str()
   |     ------^^^^^^^^^
   |     |
   |     returns a value referencing data owned by the current function
   |     `result` is borrowed here

For more information about this error, try `rustc --explain E0515`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Проблема в том, что result выходит из области видимости и очищается в конце функции longest. Мы также пытаемся вернуть ссылку на result из функции. Невозможно указать параметры времени жизни, которые изменили бы висячую ссылку, и Rust не позволит нам создать висячую ссылку. В этом случае лучшим исправлением было бы вернуть тип с владением, а не ссылку, чтобы вызывающая функция затем отвечала за очистку значения.

В конечном итоге синтаксис времён жизни связан с соединением времён жизни различных параметров и возвращаемых значений функций. Как только они соединены, у Rust есть достаточно информации, чтобы разрешать безопасные операции с памятью и запрещать операции, которые создали бы висячие указатели или иным образом нарушили безопасность памяти.

В определениях структур

До сих пор все структуры, которые мы определяли, хранят типы с владением. Мы можем определять структуры для хранения ссылок, но в этом случае нам нужно было бы добавить аннотацию времени жизни к каждой ссылке в определении структуры. Листинг 10-24 показывает структуру с именем ImportantExcerpt, которая хранит строковый срез.

Имя файла: src/main.rs
struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}
Листинг 10-24: Структура, которая хранит ссылку и требует аннотации времени жизни

Эта структура имеет единственное поле part, которое хранит строковый срез, то есть ссылку. Как и с обобщёнными типами данных, мы объявляем имя обобщённого параметра времени жизни внутри угловых скобок после имени структуры, чтобы мы могли использовать параметр времени жизни в теле определения структуры. Эта аннотация означает, что экземпляр ImportantExcerpt не может пережить ссылку, которую он хранит в своём поле part.

Функция main здесь создаёт экземпляр структуры ImportantExcerpt, который хранит ссылку на первое предложение String, принадлежащей переменной novel. Данные в novel существуют до того, как экземпляр ImportantExcerpt будет создан. Кроме того, novel не выходит из области видимости до тех пор, пока ImportantExcerpt не выйдет из области видимости, поэтому ссылка в экземпляре ImportantExcerpt корректна.

Выведение времён жизни

Вы узнали, что каждая ссылка имеет время жизни и что нужно указывать параметры времени жизни для функций или структур, использующих ссылки. Однако у нас была функция в листинге 4-9, снова показанная в листинге 10-25, которая скомпилировалась без аннотаций времён жизни.

Имя файла: src/lib.rs
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // first_word работает со срезами `String`
    let word = first_word(&my_string[..]);

    let my_string_literal = "hello world";

    // first_word работает со срезами строковых литералов
    let word = first_word(&my_string_literal[..]);

    // Поскольку строковые литералы *и есть* срезы строк,
    // это тоже работает, без синтаксиса среза!
    let word = first_word(my_string_literal);
}
Листинг 10-25: Функция, которую мы определили в листинге 4-9, которая скомпилировалась без аннотаций времён жизни, хотя параметр и возвращаемый тип являются ссылками

Причина, по которой эта функция компилируется без аннотаций времён жизни, историческая: в ранних версиях (до 1.0) Rust этот код не скомпилировался бы, потому что каждая ссылка нуждалась в явном времени жизни. В то время сигнатура функции была бы записана так:

fn first_word<'a>(s: &'a str) -> &'a str {

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

Этот фрагмент истории Rust актуален, потому что возможно, что больше детерминированных шаблонов появится и будет добавлено в компилятор. В будущем может потребоваться ещё меньше аннотаций времён жизни.

Шаблоны, запрограммированные в анализ ссылок Rust, называются правилами выведения времён жизни. Это не правила, которым должны следовать программисты; они представляют собой набор конкретных случаев, которые компилятор будет рассматривать, и если ваш код соответствует этим случаям, вам не нужно писать времена жизни явно.

Правила выведения не обеспечивают полный вывод. Если после применения правил Rust остаётся неоднозначность в отношении того, какие времена жизни имеют ссылки, компилятор не будет угадывать, каким должно быть время жизни оставшихся ссылок. Вместо угадывания компилятор выдаст ошибку, которую можно устранить, добавив аннотации времён жизни.

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

Компилятор использует три правила, чтобы определить времена жизни ссылок, когда нет явных аннотаций. Первое правило применяется к входным временам жизни, а второе и третье правила применяются к выходным временам жизни. Если компилятор доходит до конца трёх правил, и всё ещё есть ссылки, для которых он не может определить времена жизни, компилятор остановится с ошибкой. Эти правила применяются к определениям fn, а также к блокам impl.

Первое правило состоит в том, что компилятор назначает параметр времени жизни каждому параметру, который является ссылкой. Другими словами, функция с одним параметром получает один параметр времени жизни: fn foo<'a>(x: &'a i32); функция с двумя параметрами получает два отдельных параметра времени жизни: fn foo<'a, 'b>(x: &'a i32, y: &'b i32); и так далее.

Второе правило состоит в том, что если есть ровно один входной параметр времени жизни, это время жизни назначается всем выходным параметрам времени жизни: fn foo<'a>(x: &'a i32) -> &'a i32.

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

Давайте представим, что мы — компилятор. Мы применим эти правила, чтобы определить времена жизни ссылок в сигнатуре функции first_word из листинга 10-25. Сигнатура начинается без каких-либо времён жизни, связанных со ссылками:

fn first_word(s: &str) -> &str {

Затем компилятор применяет первое правило, которое указывает, что каждый параметр получает своё собственное время жизни. Мы назовём его 'a, как обычно, так что теперь сигнатура такова:

fn first_word<'a>(s: &'a str) -> &str {

Второе правило применяется, потому что есть ровно одно входное время жизни. Второе правило указывает, что время жизни единственного входного параметра назначается выходному времени жизни, так что сигнатура теперь такова:

fn first_word<'a>(s: &'a str) -> &'a str {

Теперь все ссылки в этой сигнатуре функции имеют времена жизни, и компилятор может продолжить свой анализ, не требуя от программиста аннотировать времена жизни в этой сигнатуре функции.

Давайте посмотрим на другой пример, на этот раз используя функцию longest, у которой не было параметров времени жизни, когда мы начали работать с ней в листинге 10-20:

fn longest(x: &str, y: &str) -> &str {

Давайте применим первое правило: каждый параметр получает своё собственное время жизни. На этот раз у нас два параметра вместо одного, поэтому у нас два времени жизни:

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {

Вы можете видеть, что второе правило не применяется, потому что есть более одного входного времени жизни. Третье правило тоже не применяется, потому что longest — это функция, а не метод, поэтому ни один из параметров не является self. Пройдя через все три правила, мы всё ещё не определили, каково время жизни возвращаемого типа. Именно поэтому мы получили ошибку при попытке скомпилировать код в листинге 10-20: компилятор прошёл через правила выведения времён жизни, но всё ещё не смог определить все времена жизни ссылок в сигнатуре.

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

В определениях методов

Когда мы реализуем методы для структуры с временами жизни, мы используем тот же синтаксис, что и для обобщённых параметров типа, как показано в листинге 10-11. То, где мы объявляем и используем параметры времени жизни, зависит от того, связаны ли они с полями структуры или параметрами метода и возвращаемыми значениями.

Имена времён жизни для полей структуры всегда нужно объявлять после ключевого слова impl, а затем использовать после имени структуры, потому что эти времена жизни являются частью типа структуры.

В сигнатурах методов внутри блока impl ссылки могут быть связаны со временем жизни ссылок в полях структуры, или они могут быть независимыми. Кроме того, правила выведения времён жизни часто делают так, что аннотации времён жизни не нужны в сигнатурах методов. Давайте рассмотрим несколько примеров с использованием структуры с именем ImportantExcerpt, которую мы определили в листинге 10-24.

Сначала мы используем метод с именем level, единственный параметр которого — ссылка на self, а возвращаемое значение — i32, который не является ссылкой ни на что:

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {announcement}");
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

Объявление параметра времени жизни после impl и его использование после имени типа требуются, но из-за первого правила выведения нам не требуется аннотировать время жизни ссылки на self.

Вот пример, где применяется третье правило выведения времён жизни:

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {announcement}");
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

Здесь два входных времени жизни, поэтому Rust применяет первое правило выведения времён жизни и даёт и &self, и announcement свои собственные времена жизни. Затем, поскольку один из параметров — &self, возвращаемый тип получает время жизни &self, и все времена жизни учтены.

Время жизни 'static

Одно особое время жизни, которое нужно обсудить, — это 'static, которое обозначает, что затронутая ссылка может жить в течение всего времени работы программы. Все строковые литералы имеют время жизни 'static, что можно аннотировать так:

#![allow(unused)]
fn main() {
let s: &'static str = "I have a static lifetime.";
}

Текст этой строки хранится непосредственно в двоичном файле программы, который всегда доступен. Следовательно, время жизни всех строковых литералов — 'static.

Вы можете увидеть в сообщениях об ошибках предложения использовать время жизни 'static. Но прежде чем указывать 'static в качестве времени жизни для ссылки, подумайте, действительно ли ссылка, которая у вас есть, живёт в течение всего времени жизни вашей программы и хотите ли вы этого. В большинстве случаев сообщение об ошибке, предлагающее время жизни 'static, является результатом попытки создать висячую ссылку или несоответствия доступных времён жизни. В таких случаях решение заключается в исправлении этих проблем, а не в указании времени жизни 'static.

Обобщённые параметры типа, ограничения трейтов и времена жизни

Давайте кратко рассмотрим синтаксис указания обобщённых параметров типа, ограничений трейтов и времён жизни — всё в одной функции!

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest_with_an_announcement(
        string1.as_str(),
        string2,
        "Today is someone's birthday!",
    );
    println!("The longest string is {result}");
}

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: Display,
{
    println!("Announcement! {ann}");
    if x.len() > y.len() { x } else { y }
}

Это функция longest из листинга 10-21, которая возвращает более длинный из двух строковых срезов. Но теперь у неё есть дополнительный параметр с именем ann обобщённого типа T, который может быть заполнен любым типом, реализующим трейт Display, как указано в предложении where. Этот дополнительный параметр будет выведен с помощью {}, поэтому необходимо ограничение трейта Display. Поскольку времена жизни являются разновидностью обобщений, объявления параметра времени жизни 'a и обобщённого параметра типа T идут в одном списке внутри угловых скобок после имени функции.

Итоги

В этой главе мы рассмотрели многое! Теперь, когда вы знаете об обобщённых параметрах типа, трейтах и ограничениях трейтов, а также об обобщённых параметрах времени жизни, вы готовы писать код без повторений, работающий во многих разных ситуациях. Обобщённые параметры типа позволяют применять код к разным типам. Трейты и ограничения трейтов гарантируют, что даже несмотря на то, что типы обобщённые, у них будет поведение, необходимое коду. Вы узнали, как использовать аннотации времён жизни, чтобы гарантировать, что этот гибкий код не будет содержать висячих ссылок. И весь этот анализ происходит во время компиляции, что не влияет на производительность во время выполнения!

Хотите верьте, хотите нет, но по темам, которые мы обсудили в этой главе, можно узнать гораздо больше: глава 18 рассматривает трейт-объекты, которые являются ещё одним способом использования трейтов. Также существуют более сложные сценарии, связанные с аннотациями времён жизни, которые вам понадобятся только в очень продвинутых случаях; для них вам следует прочитать Справочник по Rust. Но далее вы узнаете, как писать тесты на Rust, чтобы можно было убедиться, что ваш код работает так, как должен.