Пример программы, использующей структуры
Чтобы понять, когда может понадобиться использовать структуры, напишем программу, которая вычисляет площадь прямоугольника. Мы начнём с использования отдельных переменных, а затем будем рефакторить программу до тех пор, пока не начнём использовать структуры.
Создадим новый бинарный проект с помощью Cargo под названием rectangles, который будет принимать ширину и высоту прямоугольника, заданные в пикселях, и вычислять площадь прямоугольника. Листинг 5-8 показывает короткую программу с одним из способов сделать это в файле src/main.rs нашего проекта.
fn main() {
let width1 = 30;
let height1 = 50;
println!(
"The area of the rectangle is {} square pixels.",
area(width1, height1)
);
}
fn area(width: u32, height: u32) -> u32 {
width * height
}
Теперь запустим эту программу с помощью cargo run:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.
Этот код успешно вычисляет площадь прямоугольника, вызывая функцию area с каждым измерением, но можно сделать больше, чтобы сделать код ясным и читаемым.
Проблема этого кода очевидна в сигнатуре area:
fn main() {
let width1 = 30;
let height1 = 50;
println!(
"The area of the rectangle is {} square pixels.",
area(width1, height1)
);
}
fn area(width: u32, height: u32) -> u32 {
width * height
}
Функция area должна вычислять площадь одного прямоугольника, но написанная нами функция имеет два параметра, и нигде в нашей программе не ясно, что параметры связаны. Было бы более читаемым и управляемым объединить ширину и высоту вместе. Мы уже обсуждали один способ сделать это в разделе «Тип кортеж» главы 3: используя кортежи.
Рефакторинг с помощью кортежей
Листинг 5-9 показывает другую версию нашей программы, использующую кортежи.
fn main() {
let rect1 = (30, 50);
println!(
"The area of the rectangle is {} square pixels.",
area(rect1)
);
}
fn area(dimensions: (u32, u32)) -> u32 {
dimensions.0 * dimensions.1
}
В одном смысле эта программа лучше. Кортежи позволяют добавить немного структуры, и теперь мы передаём только один аргумент. Но в другом смысле эта версия менее ясна: кортежи не именуют свои элементы, поэтому приходится индексировать части кортежа, что делает вычисление менее очевидным.
Перепутать ширину и высоту не имело бы значения для вычисления площади, но если мы хотим нарисовать прямоугольник на экране, это было бы важно! Нам пришлось бы помнить, что width — это индекс кортежа 0, а height — индекс кортежа 1. Это было бы ещё сложнее для кого-то другого, кто попытался бы разобраться и запомнить, если бы он использовал наш код. Поскольку мы не передали смысл наших данных в коде, теперь легче внести ошибки.
Рефакторинг с помощью структур
Мы используем структуры, чтобы добавить смысл, помечая данные. Мы можем преобразовать кортеж, который используем, в структуру с именем для целого, а также с именами для частей, как показано в листинге 5-10.
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!(
"The area of the rectangle is {} square pixels.",
area(&rect1)
);
}
fn area(rectangle: &Rectangle) -> u32 {
rectangle.width * rectangle.height
}
RectangleЗдесь мы определили структуру и назвали её Rectangle. Внутри фигурных скобок мы определили поля как width и height, оба типа u32. Затем в main мы создали конкретный экземпляр Rectangle с шириной 30 и высотой 50.
Наша функция area теперь определена с одним параметром, который мы назвали rectangle, тип которого — неизменяемое заимствование экземпляра структуры Rectangle. Как упоминалось в главе 4, мы хотим заимствовать структуру, а не брать её во владение. Таким образом, main сохраняет своё владение и может продолжать использовать rect1, и именно поэтому мы используем & в сигнатуре функции и в месте вызова функции.
Функция area обращается к полям width и height экземпляра Rectangle (обратите внимание, что доступ к полям заимствованного экземпляра структуры не перемещает значения полей, поэтому вы часто видите заимствования структур). Наша сигнатура функции для area теперь говорит именно то, что мы имеем в виду: вычислить площадь Rectangle, используя его поля width и height. Это передаёт, что ширина и высота связаны друг с другом, и даёт описательные имена значениям вместо использования значений индексов кортежа 0 и 1. Это победа в ясности.
Добавление функциональности с помощью производных трейтов
Было бы полезно иметь возможность печатать экземпляр Rectangle во время отладки нашей программы и видеть значения всех его полей. Листинг 5-11 пытается использовать макрос println!, как мы использовали в предыдущих главах. Однако это не сработает.
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!("rect1 is {rect1}");
}
RectangleКогда мы компилируем этот код, мы получаем ошибку с основным сообщением:
error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`
Макрос println! может выполнять много видов форматирования, и по умолчанию фигурные скобки говорят println! использовать форматирование, известное как Display: вывод, предназначенный для непосредственного потребления конечным пользователем. Примитивные типы, которые мы видели до сих пор, реализуют Display по умолчанию, потому что есть только один способ, которым вы хотели бы показать 1 или любой другой примитивный тип пользователю. Но со структурами способ, которым println! должен форматировать вывод, менее ясен, потому что есть больше возможностей отображения: нужны ли запятые или нет? Хотите ли вы напечатать фигурные скобки? Должны ли быть показаны все поля? Из-за этой неоднозначности Rust не пытается угадать, что мы хотим, и структуры не имеют предоставленной реализации Display для использования с println! и заполнителем {}.
Если мы продолжим читать ошибки, мы найдём эту полезную заметку:
help: the trait `std::fmt::Display` is not implemented for `Rectangle`
--> src/main.rs:1:1
Давайте попробуем! Вызов макроса println! теперь будет выглядеть так: println!("rect1 is {rect1:?}");. Размещение спецификатора :? внутри фигурных скобок говорит println!, что мы хотим использовать формат вывода под названием Debug. Трейт Debug позволяет нам печатать нашу структуру способом, полезным для разработчиков, чтобы мы могли видеть её значение во время отладки нашего кода.
Скомпилируйте код с этим изменением. Чёрт! Мы всё ещё получаем ошибку:
error[E0277]: `Rectangle` doesn't implement `Debug`
Но опять же, компилятор даёт нам полезную заметку:
| required by this formatting parameter
|
Rust действительно включает функциональность для печати отладочной информации, но мы должны явно включить её, чтобы сделать эту функциональность доступной для нашей структуры. Для этого мы добавляем внешний атрибут #[derive(Debug)] непосредственно перед определением структуры, как показано в листинге 5-12.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!("rect1 is {rect1:?}");
}
Debug и печать экземпляра Rectangle с использованием отладочного форматированияТеперь, когда мы запускаем программу, мы не получим никаких ошибок, и мы увидим следующий вывод:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }
Отлично! Это не самый красивый вывод, но он показывает значения всех полей для этого экземпляра, что определённо помогло бы при отладке. Когда у нас есть более крупные структуры, полезно иметь вывод, который немного легче читать; в таких случаях мы можем использовать {:#?} вместо {:?} в строке println!. В этом примере использование стиля {:#?} выведет следующее:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/rectangles`
rect1 is Rectangle {
width: 30,
height: 50,
}
Другой способ напечатать значение с использованием формата Debug — использовать макрос dbg!, который принимает владение выражением (в отличие от println!, который принимает ссылку), печатает имя файла и номер строки, где происходит вызов макроса dbg! в вашем коде, вместе с результирующим значением этого выражения, и возвращает владение значением.
Примечание: Вызов макроса dbg! печатает в стандартный поток консоли ошибок (stderr), в отличие от println!, который печатает в стандартный поток консоли вывода (stdout). Мы поговорим больше о stderr и stdout в разделе «Перенаправление ошибок в стандартный поток ошибок» главы 12.
Вот пример, где нас интересует значение, которое присваивается полю width, а также значение всей структуры в rect1:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let scale = 2;
let rect1 = Rectangle {
width: dbg!(30 * scale),
height: 50,
};
dbg!(&rect1);
}
Мы можем поместить dbg! вокруг выражения 30 * scale и, поскольку dbg! возвращает владение значением выражения, поле width получит то же значение, как если бы у нас не было вызова dbg! там. Мы не хотим, чтобы dbg! брал владение rect1, поэтому мы используем ссылку на rect1 в следующем вызове. Вот как выглядит вывод этого примера:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
Running `target/debug/rectangles`
[src/main.rs:10:16] 30 * scale = 60
[src/main.rs:14:5] &rect1 = Rectangle {
width: 60,
height: 50,
}
Мы видим, что первый фрагмент вывода пришёл из src/main.rs, строка 10, где мы отлаживаем выражение 30 * scale, и его результирующее значение равно 60 (форматирование Debug, реализованное для целых чисел, заключается в печати только их значения). Вызов dbg! в строке 14 файла src/main.rs выводит значение &rect1, которое является структурой Rectangle. Этот вывод использует красивое форматирование Debug типа Rectangle. Макрос dbg! может быть действительно полезен, когда вы пытаетесь понять, что делает ваш код!
В дополнение к трейту Debug, Rust предоставил ряд трейтов для использования с атрибутом derive, которые могут добавить полезное поведение нашим пользовательским типам. Эти трейты и их поведение перечислены в Приложении C. Мы рассмотрим, как реализовать эти трейты с пользовательским поведением, а также как создавать свои собственные трейты в главе 10. Существует также много атрибутов, помимо derive; для получения дополнительной информации см. раздел «Атрибуты» справочника Rust.
Наша функция area очень специфична: она вычисляет только площадь прямоугольников. Было бы полезно связать это поведение более тесно с нашей структурой Rectangle, потому что оно не будет работать с любым другим типом. Давайте посмотрим, как мы можем продолжить рефакторинг этого кода, превратив функцию area в метод area, определённый для нашего типа Rectangle.