Этот пост посвящается всем тем, кого смущает необходимость использовать to_string(), чтобы заставить программы компилироваться. И я надеюсь пролить немного света на вопрос о том, почему в Rust два строковых типа String и &str.
Функции, которые принимают строки
Я хочу обсудить, как создавать интерфейсы, которые принимают строки. Я большой фанат гипермедии и увлечён созданием лёгких в использовании интерфейсов. Начнём с метода, который принимает String. Наш поиск приведёт нас к типу std::string::String, что для начала совсем не плохо.
fn print_me(msg: String) {
println!("сообщение: {}", msg);
}
fn main() {
let message = "привет, мир";
print_me(message);
}
Получаем ошибку компиляции:
expected `collections::string::String`,
found `&'static str`
Получается, что строковый литерал типа &str не совместим с типом String. Нам нужно поменять тип переменной message на String, чтобы компиляция удалась: let message = "привет, мир".to_string();. Так заработает, но это всё равно что использовать clone() для починки ошибок владения-наследования. Вот три причины, чтобы поменять тип аргумента print_me на &str:
- Символ
&обозначает ссылочный тип, то есть мы даём переменную взаймы. Когдаprint_meзаканчивает работу с переменной, право владения возвращается к её изначальному владельцу. Если у нас нет хорошей причины, для передачи владения переменнойmessageв нашу функцию, нам следует использовать заимствование. - Использование ссылки более эффективно. Использование
Stringдляmessageозначает, что программа должна скопировать значение. При использовании ссылки, такой как&str, копирования не происходит. - Тип
Stringможет волшебным образом превращаться в&strс использованием типажаDerefи приведения типов. Пример позволит понять этот момент намного лучше.
Пример приведения с разыменованием
В этом примере строки создаются четырьмя разными способами, и все они работают с функцией print_me. Основной момент, благодаря которому всё это работает, — передача значений по ссылке. Вместо того, чтобы передавать владеющую строку owned_string как String, мы передаём её как указатель &String. Когда компилятор видит, что &String передаётся в функцию, которая принимает &str, он приводит &String к &str. Точно такая же конверсия используется при использовании строк с обычным и атомарным счётчиком ссылок. Переменная string уже является ссылкой, поэтому нет необходимости использовать & при вызове print_me(string). Обладая этим знанием, нам больше не нужно постоянно вызывать .to_string() по нашему коду.
fn print_me(msg: &str) {
println!("msg = {}", msg);
}
fn main() {
let string = "привет, мир";
print_me(string);
let owned_string = "привет, мир".to_string(); // или String::from_str("привет, мир")
print_me(&owned_string);
let counted_string = std::rc::Rc::new("привет, мир".to_string());
print_me(&counted_string);
let atomically_counted_string = std::sync::Arc::new("привет, мир".to_string());
print_me(&atomically_counted_string);
}
Вы так же можете использовать приведение с разыменованием с другими типами, такими как вектор Vec. Всё таки String — это просто вектор восьмибайтных символов. Про приведение с разыменованием (англ.) можно подробнее почитать в книге «Язык программирования Rust» (англ.).
Использование структур
На данный момент мы должны уже быть свободны от лишних вызовов to_string(). Однако, у нас могут возникнуть некоторые проблемы при использовании структур. Используя имеющиеся знания, мы могли бы создать такую структуру:
struct Person {
name: &str,
}
fn main() {
let _person = Person { name: "Herman" };
}
Мы получим такую ошибку:
<anon>:2:11: 2:15 error: missing lifetime specifier [E0106]
<anon>:2 name: &str,
Rust пытается удостовериться, что Person не может пережить ссылку на name. Если Person переживёт name, то есть риск падения программы. Основная цель Rust — не допустить этого. Давайте заставим этот код компилироваться. Нам понадобится указать время жизни (англ.), или область видимости, так, чтобы Rust смог нам обеспечить безопасность. Обычно время жизни называют так: 'a. Я не знаю, откуда пошла такая традиция, но мы ей последуем.
struct Person {
name: &'a str,'
}
fn main() {
let _person = Person { name: "Herman" };
}
При попытке скомпилировать получим такую ошибку:
<anon>:2:12: 2:14 error: use of undeclared lifetime name `'a` [E0261]
<anon>:2 name: &'a str,
Давайте поразмыслим. Мы знаем, что хотим как-то донести до компилятора Rust мысль, что структура Person не должна пережить поле name. Так что нам нужно объявить время жизни структуры Person. Недолгие поиски приводят нас к синтаксису для объявления времени жизни: <'a>.
struct Person<'a> {
name: &'a str,
}
fn main() {
let _person = Person { name: "Herman" };
}
Это компилируется! Обычно мы реализуем на структурах некоторые методы. Давайте добавим к нашему классу Person метод greet.
struct Person<'a> {
name: &'a str,
}
impl Person {
fn greet(&self) {
println!("Привет, меня зовут {}", self.name);
}
}
fn main() {
let person = Person { name: "Herman" };
person.greet();
}
Теперь мы получим такую ошибку:
<anon>:5:6: 5:12 error: wrong number of lifetime parameters: expected 1, found 0 [E0107]
<anon>:5 impl Person {
У нашей структуры Person есть параметр времени жизни, так что наша реализация должны тоже его иметь. Давайте объявим время жизни 'a в реализации Person вот так: impl Person<'a> {. Увы, теперь мы получим такую странную ошибку компиляции:
<anon>:5:13: 5:15 error: use of undeclared lifetime name `'a` [E0261]
<anon>:5 impl Person<'a> {
Чтобы нам объявить время жизни, нам нужно указать время жизни сразу после impl вот так: impl<'a> Person {. Компилируем снова, получаем ошибку:
<anon>:5:10: 5:16 error: wrong number of lifetime parameters: expected 1, found 0 [E0107]
<anon>:5 impl<'a> Person {
Уже понятнее. Давайте добавим параметр времени жизни в описании структуры Person её в реализации вот так: impl<'a> Person<'a> {. Теперь программа cкомпилируется. Вот полный рабочий код:
struct Person<'a> {
name: &'a str,
}
impl<'a> Person<'a> {
fn greet(&self) {
println!("Привет, меня зовут {}", self.name);
}
}
fn main() {
let person = Person { name: "Herman" };
person.greet();
}
String или &str в структурах
Теперь возникает вопрос: когда стоит использовать String, а когда &str в структурах? Другими словами, когда следует использовать ссылку на другой тип в структуре? Нам следует использовать ссылки, если наша структура не требует владения переменной. Смысл может быть немного размыт, так что я использую несколько правил, для ответа на этот вопрос.
- Нужно ли использовать переменную вне структуры? Вот немного надуманный пример:
struct Person {
name: String,
}
impl Person {
fn greet(&self) {
println!("Привет, меня зовут {}", self.name);
}
}
fn main() {
let name = String::from_str("Herman");
let person = Person { name: name };
person.greet();
println!("Меня зовут {}", name); // move error
}
Здесь мне стоит использовать ссылку, так как мне нужно будет использовать переменную до помещения в структуру. Пример из реальной жизни — rustc_serialize. Структуре Encoder не нужно владеть переменной writer, которая реализует типаж std::fmt::Write, поэтому используется только заимствование. На самом деле String реализует Write. В этом примере при использовании функции encode переменная типа String передаётся в Encoder и затем возвращается обратно в encode.
- Мой тип большой? Если тип большой, то передача по ссылке позволит сберечь память. Помните, передача по ссылке не приводит к копированию переменных. Представьте буфер типа
Stringс большим количеством данных. Его копирование при каждой передаче в другую функцию может значительно замедлить программу.
Теперь мы может создать функцию, которая принимает строки в виде &str, String или даже со счётчиком ссылок. Мы так же можем создавать структуры, которые содержат ссылки. Время жизни структуры связано с содержащимися в ней ссылками, так что структура не может пережить переменные, на которые она ссылается, и тем самым привести к ошибкам в программе. А ещё теперь у нас есть базовое понимание того, когда стоит использовать ссылки внутри структур, а когда нет.
По поводу 'static
Думаю, что стоит обратить внимание на ещё один момент. Мы можем использовать статическое время жизни 'static (как в первом примере), чтобы заставить наш пример скомпилироваться, но я бы не советовал так делать:
struct Person {
name: &'static str,
}
impl Person {
fn greet(&self) {
println!("Привет, меня зовут {}", self.name);
}
}
fn main() {
let person = Person { name: "Herman" };
person.greet();
}
Статическое время жизни 'static валидно на протяжении всей жизни программы. Вы вряд ли захотите, чтобы Person или name жили так долго. (Например статические строковые литералы, вкомпилированные в саму программу, обладают типом &'static str, то есть живут на протяжении всей жизни программы — прим. перев.)
Что ещё почитать
- Создание функции на Rust, которая принимает
Stringили&str(оригинал) - Создание функций в Rust, которые возвращают
&strилиString(готовится к переводу)
Автор: kstep
