Методы
Методы похожи на функции: они объявляются с помощью ключевого слова fn и
имени, могут иметь параметры и возвращаемое значение, и содержат код,
который выполняется, когда метод вызывается откуда-либо. В отличие от функций,
методы определяются в контексте структуры (или перечисления, или трейт-объекта,
которые рассматриваются в главе 6 и главе
18 соответственно), и их первый параметр
всегда — self, который представляет экземпляр структуры, для которого
вызывается метод.
Синтаксис методов
Изменим функцию area, которая принимает экземпляр Rectangle в качестве параметра,
и вместо неё сделаем метод area, определённый на структуре Rectangle, как показано
в листинге 5-13.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!(
"The area of the rectangle is {} square pixels.",
rect1.area()
);
}
area на структуре RectangleЧтобы определить функцию в контексте Rectangle, мы начинаем блок impl
(реализации) для Rectangle. Всё внутри этого блока impl
будет связано с типом Rectangle. Затем мы перемещаем функцию area
внутрь фигурных скобок impl и меняем первый (в данном случае единственный)
параметр на self в сигнатуре и везде в теле. В
main, где мы вызывали функцию area и передавали rect1 в качестве аргумента,
мы можем вместо этого использовать синтаксис методов, чтобы вызвать метод area на экземпляре Rectangle.
Синтаксис методов ставится после экземпляра: мы добавляем точку, за которой следует
имя метода, круглые скобки и любые аргументы.
В сигнатуре area мы используем &self вместо rectangle: &Rectangle.
&self на самом деле сокращение для self: &Self. Внутри блока impl
тип Self является псевдонимом для типа, к которому относится блок impl. Методы должны
иметь параметр с именем self типа Self в качестве первого параметра, поэтому Rust
позволяет сократить это, указав только имя self на месте первого параметра.
Обратите внимание, что по-прежнему нужно использовать & перед сокращением self, чтобы
указать, что этот метод заимствует экземпляр Self, так же как мы делали в
rectangle: &Rectangle. Методы могут брать владение self, заимствовать self
неизменяемо, как мы сделали здесь, или заимствовать self изменяемо, как и любой
другой параметр.
Мы выбрали &self здесь по той же причине, по которой использовали &Rectangle в функциональной
версии: мы не хотим брать владение и просто хотим прочитать данные в
структуре, а не записывать в них. Если бы мы хотели изменить экземпляр, на котором
вызван метод, как часть того, что делает метод, мы бы использовали &mut self в
качестве первого параметра. Метод, который берёт владение экземпляром,
используя просто self в качестве первого параметра, встречается редко; этот приём обычно
применяется, когда метод преобразует self во что-то другое, и нужно
запретить вызывающей стороне использовать исходный экземпляр после преобразования.
Основная причина использовать методы вместо функций, помимо
предоставления синтаксиса методов и отсутствия необходимости повторять тип self в каждой
сигнатуре метода, — это организация. Мы поместили всё, что можно сделать
с экземпляром типа, в один блок impl, а не заставляем будущих пользователей
нашего кода искать возможности Rectangle в разных местах
предоставляемой нами библиотеки.
Обратите внимание, что можно дать методу то же имя, что и одному из полей структуры.
Например, можно определить на Rectangle метод, который также называется
width:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn width(&self) -> bool {
self.width > 0
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
if rect1.width() {
println!("The rectangle has a nonzero width; it is {}", rect1.width);
}
}
Здесь мы решили сделать так, чтобы метод width возвращал true, если значение в
поле width экземпляра больше 0, и false, если значение равно
0: мы можем использовать поле внутри метода с тем же именем для любых целей. В
main, когда мы ставим круглые скобки после rect1.width, Rust понимает, что имеется в виду
метод width. Когда мы не используем круглые скобки, Rust понимает, что имеется в виду поле
width.
Часто, но не всегда, когда мы даём методу то же имя, что и полю, мы хотим, чтобы он только возвращал значение поля и ничего больше не делал. Такие методы называются геттерами, и Rust не реализует их автоматически для полей структур, как это делают некоторые другие языки. Геттеры полезны тем, что можно сделать поле приватным, а метод публичным и таким образом обеспечить доступ только для чтения к этому полю как часть публичного API типа. Мы обсудим, что такое публичное и приватное и как обозначить поле или метод как публичный или приватный, в главе 7.
Где оператор ->?
В C и C++ для вызова методов используются два разных оператора: .
используется, если метод вызывается непосредственно на объекте, а -> —
если метод вызывается на указателе на объект и нужно сначала разыменовать
указатель. Другими словами, если object — указатель,
object->something() аналогично (*object).something().
В Rust нет эквивалента оператора ->; вместо этого в Rust есть
возможность, называемая автоматическим заимствованием и разыменованием. Вызов методов —
одно из немногих мест в Rust с таким поведением.
Вот как это работает: когда метод вызывается с помощью object.something(), Rust
автоматически добавляет &, &mut или *, чтобы object соответствовал
сигнатуре метода. Другими словами, следующие вызовы эквивалентны:
#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Point {
x: f64,
y: f64,
}
impl Point {
fn distance(&self, other: &Point) -> f64 {
let x_squared = f64::powi(other.x - self.x, 2);
let y_squared = f64::powi(other.y - self.y, 2);
f64::sqrt(x_squared + y_squared)
}
}
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 5.0, y: 6.5 };
p1.distance(&p2);
(&p1).distance(&p2);
}
Первый вариант выглядит намного чище. Это поведение автоматического заимствования работает
потому, что методы имеют явного получателя — тип self. Зная
получателя и имя метода, Rust может точно определить, читает ли метод
(&self), изменяет (&mut self) или потребляет (self). Тот факт,
что Rust делает заимствование для получателей методов неявным, — важная часть
того, что делает владение эргономичным на практике.
Методы с несколькими параметрами
Попрактикуемся в использовании методов, реализовав второй метод на структуре Rectangle.
На этот раз мы хотим, чтобы экземпляр Rectangle принимал другой экземпляр
Rectangle и возвращал true, если второй Rectangle может полностью поместиться
внутри self (первого Rectangle); в противном случае он должен вернуть false.
То есть, после того как мы определим метод can_hold, мы хотим иметь возможность написать
программу, показанную в листинге 5-14.
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
can_holdОжидаемый вывод будет выглядеть следующим образом, поскольку оба размера
rect2 меньше размеров rect1, но rect3 шире, чем
rect1:
Can rect1 hold rect2? true
Can rect1 hold rect3? false
Мы знаем, что хотим определить метод, поэтому он будет внутри блока impl Rectangle.
Имя метода будет can_hold, и он будет принимать неизменяемое заимствование
другого Rectangle в качестве параметра. Мы можем определить тип
параметра, посмотрев на код, который вызывает метод:
rect1.can_hold(&rect2) передаёт &rect2, что является неизменяемым заимствованием
rect2, экземпляра Rectangle. Это имеет смысл, потому что нам нужно только
читать rect2 (а не записывать, что означало бы необходимость изменяемого заимствования),
и мы хотим, чтобы main сохранял владение rect2, чтобы можно было использовать его снова
после вызова метода can_hold. Возвращаемое значение can_hold будет
логическим, а реализация проверит, больше ли ширина и высота
self, чем ширина и высота другого Rectangle,
соответственно. Добавим новый метод can_hold в блок impl из
листинга 5-13, как показано в листинге 5-15.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
can_hold на Rectangle, принимающего другой экземпляр Rectangle в качестве параметраКогда мы запустим этот код с функцией main из листинга 5-14, мы получим
желаемый вывод. Методы могут принимать несколько параметров, которые добавляются в
сигнатуру после параметра self, и эти параметры работают так же, как
параметры в функциях.
Ассоциированные функции
Все функции, определённые внутри блока impl, называются ассоциированными функциями,
потому что они связаны с типом, указанным после impl. Можно определять
ассоциированные функции, у которых нет self в качестве первого параметра (и которые, таким образом,
не являются методами), потому что им не нужен экземпляр типа для работы.
Мы уже использовали одну такую функцию: функцию String::from, которая
определена на типе String.
Ассоциированные функции, которые не являются методами, часто используются для конструкторов, которые
возвращают новый экземпляр структуры. Их часто называют new, но
new не является специальным именем и не встроено в язык. Например, мы
могли бы предоставить ассоциированную функцию с именем square, которая имела бы
один параметр размера и использовала бы его как ширину и высоту, что делает
создание квадратного Rectangle проще, чем указание одного и того же
значения дважды:
Имя файла: src/main.rs
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn square(size: u32) -> Self {
Self {
width: size,
height: size,
}
}
}
fn main() {
let sq = Rectangle::square(3);
}
Ключевые слова Self в возвращаемом типе и в теле функции являются
псевдонимами для типа, который указан после ключевого слова impl, в данном случае
это Rectangle.
Чтобы вызвать эту ассоциированную функцию, мы используем синтаксис :: с именем структуры;
let sq = Rectangle::square(3); — пример. Эта функция находится в пространстве имён
структуры: синтаксис :: используется как для ассоциированных функций, так и для
пространств имён, создаваемых модулями. Мы обсудим модули в главе
7.
Несколько блоков impl
Каждая структура может иметь несколько блоков impl. Например, листинг
5-15 эквивалентен коду, показанному в листинге 5-16, в котором каждый метод находится в
своём собственном блоке impl.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
implЗдесь нет причины разделять эти методы на несколько блоков impl,
но это допустимый синтаксис. Мы увидим случай, в котором несколько блоков impl
полезны, в главе 10, где обсуждаются обобщённые типы и трейты.
Итоги
Структуры позволяют создавать пользовательские типы, которые имеют смысл для вашей предметной области.
Используя структуры, можно держать связанные части данных соединёнными друг с другом
и давать имя каждой части, чтобы сделать код понятным. В блоках impl можно определять
функции, связанные с вашим типом, а методы — это разновидность
ассоциированных функций, которые позволяют задать поведение, присущее экземплярам ваших
структур.
Но структуры — не единственный способ создавать пользовательские типы: обратимся к возможности перечислений в Rust, чтобы добавить ещё один инструмент в ваш арсенал.