Этот пост посвящается всем тем, кого смущает необходимость использовать 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!("Hello, my name is {}", 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!("My name is {}", 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!("Hello, my name is {}", self.name); } } fn main() { let person = Person { name: "Herman" }; person.greet(); } Статическое время жизни 'static валидно на протяжении жизни всей программы. Вы вряд ли захотите, чтобы Person или name жили так долго. (Например статические строковые литералы, вкомпилированные в саму программу, обладают типов &'static str, то есть живут на протяжении жизни всей программы — прим. перев.)
Что ещё почитать
- Создание функции на Rust, которая принимает
Stringили&str(оригинал) - Создание функций в Rust, которые возвращают
&strилиString(готовится к переводу)
ссылка на оригинал статьи http://habrahabr.ru/post/274485/
Добавить комментарий