Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ? для отображения этой справки

Нажмите Esc, чтобы скрыть эту справку

Методы

Методы похожи на функции: они объявляются с помощью ключевого слова fn и имени, могут иметь параметры и возвращаемое значение, и содержат код, который выполняется, когда метод вызывается откуда-либо. В отличие от функций, методы определяются в контексте структуры (или перечисления, или трейт-объекта, которые рассматриваются в главе 6 и главе 18 соответственно), и их первый параметр всегда — self, который представляет экземпляр структуры, для которого вызывается метод.

Синтаксис методов

Изменим функцию area, которая принимает экземпляр Rectangle в качестве параметра, и вместо неё сделаем метод area, определённый на структуре Rectangle, как показано в листинге 5-13.

Имя файла: src/main.rs
#[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()
    );
}
Листинг 5-13: Определение метода 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:

Имя файла: src/main.rs
#[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.

Имя файла: src/main.rs
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));
}
Листинг 5-14: Использование ещё не написанного метода 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.

Имя файла: src/main.rs
#[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));
}
Листинг 5-15: Реализация метода 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));
}
Листинг 5-16: Переписывание листинга 5-15 с использованием нескольких блоков impl

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

Итоги

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

Но структуры — не единственный способ создавать пользовательские типы: обратимся к возможности перечислений в Rust, чтобы добавить ещё один инструмент в ваш арсенал.