Структуры и трейты в Rust: ООП без классов

В Java/Python для объединения данных и методов используются классы. В Rust классов нет — вместо них структуры (struct) и трейты (trait).

Struct — структура данных

Аналогия: Анкета в школе. Поля: «Имя», «Возраст», «Класс». Структура — шаблон анкеты, экземпляр — конкретный ученик.

struct Student {
    name: String,
    age: u32,
    grade: String,
    gpa: f64,
}

fn main() {
    let s1 = Student {
        name: String::from("Алиса"),
        age: 12,
        grade: String::from("6А"),
        gpa: 4.8,
    };

    println!("{} из {}", s1.name, s1.grade);
    println!("Возраст: {}, Балл: {:.1}", s1.age, s1.gpa);

    // Изменяемый экземпляр
    let mut s2 = Student {
        name: String::from("Боря"),
        age: 13,
        grade: String::from("7Б"),
        gpa: 3.9,
    };
    s2.gpa = 4.2;

    // Создание из другого (..)
    let s3 = Student {
        name: String::from("Вера"),
        gpa: 4.5,
        ..s2   // остальные поля из s2
    };
    println!("Вера в классе {}", s3.grade);
}

impl — методы структуры

struct Rectangle { width: f64, height: f64 }

impl Rectangle {
    fn new(width: f64, height: f64) -> Self {
        Rectangle { width, height }
    }

    fn square(size: f64) -> Self {
        Rectangle { width: size, height: size }
    }

    fn area(&self) -> f64 { self.width * self.height }
    fn perimeter(&self) -> f64 { 2.0 * (self.width + self.height) }
    fn is_square(&self) -> bool {
        (self.width - self.height).abs() < 1e-10
    }

    fn scale(&mut self, factor: f64) {
        self.width *= factor;
        self.height *= factor;
    }

    fn can_contain(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let r = Rectangle::new(5.0, 3.0);
    println!("{}×{}: S={}, P={}", r.width, r.height, r.area(), r.perimeter());
    println!("Квадрат? {}", r.is_square());

    let mut r2 = Rectangle::new(3.0, 2.0);
    r2.scale(2.0);
    println!("После scale: {}×{}", r2.width, r2.height);
    println!("r содержит r2? {}", r.can_contain(&r2));
}

Трейты — интерфейсы в Rust

Аналогия: Должностная инструкция. «Учитель должен: объяснять, проверять, оценивать». Каждый учитель реализует по-своему.

trait Shape {
    fn area(&self) -> f64;
    fn perimeter(&self) -> f64;
    fn name(&self) -> &str;

    // Метод по умолчанию
    fn describe(&self) {
        println!("{}: S={:.2}, P={:.2}", self.name(), self.area(), self.perimeter());
    }
}

struct Circle { radius: f64 }
struct Square { side: f64 }

impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius * self.radius }
    fn perimeter(&self) -> f64 { 2.0 * std::f64::consts::PI * self.radius }
    fn name(&self) -> &str { "Круг" }
}

impl Shape for Square {
    fn area(&self) -> f64 { self.side * self.side }
    fn perimeter(&self) -> f64 { 4.0 * self.side }
    fn name(&self) -> &str { "Квадрат" }
}

fn main() {
    let c = Circle { radius: 5.0 };
    let s = Square { side: 4.0 };
    c.describe();
    s.describe();

    let shapes: Vec<&dyn Shape> = vec![&c, &s];
    let total: f64 = shapes.iter().map(|s| s.area()).sum();
    println!("Общая площадь: {:.2}", total);
}

derive — автоматическая генерация

#[derive(Debug, Clone, PartialEq)]
struct Point { x: f64, y: f64 }

impl Point {
    fn new(x: f64, y: f64) -> Self { Point { x, y } }
    fn distance(&self, other: &Point) -> f64 {
        let dx = self.x - other.x;
        let dy = self.y - other.y;
        (dx*dx + dy*dy).sqrt()
    }
}

fn main() {
    let p1 = Point::new(0.0, 0.0);
    let p2 = Point::new(3.0, 4.0);

    println!("p1 = {:?}", p1);    // Debug
    let p3 = p2.clone();          // Clone
    println!("p2 == p3: {}", p2 == p3);  // PartialEq
    println!("Расстояние: {}", p1.distance(&p2));
}

Enum и match

#[derive(Debug)]
enum Coin { Penny, Nickel, Dime, Quarter }

fn value(coin: &Coin) -> u32 {
    match coin {
        Coin::Penny   => 1,
        Coin::Nickel  => 5,
        Coin::Dime    => 10,
        Coin::Quarter => 25,
    }
}

enum Direction { North, South, East, West }

fn main() {
    let coin = Coin::Quarter;
    println!("{:?} = {} центов", coin, value(&coin));

    let dir = Direction::North;
    match dir {
        Direction::North => println!("↑ Север"),
        Direction::South => println!("↓ Юг"),
        Direction::East  => println!("→ Восток"),
        Direction::West  => println!("← Запад"),
    }
}

Option — почему в Rust нет null!

Тони Хоар, создавший null, назвал это своей «ошибкой в миллиард долларов». В Rust вместо null — Option: либо Some(x), либо None.

fn find_positive(nums: &[i32]) -> Option {
    for &n in nums {
        if n > 0 { return Some(n); }
    }
    None
}

fn divide(a: f64, b: f64) -> Option {
    if b == 0.0 { None } else { Some(a / b) }
}

fn main() {
    let nums = [-3, -1, 0, 5, 8];
    match find_positive(&nums) {
        Some(n) => println!("Первое положительное: {}", n),
        None    => println!("Положительных нет"),
    }

    println!("{:.4}", divide(10.0, 3.0).unwrap_or(0.0));

    if let Some(r) = divide(8.0, 2.0) {
        println!("8/2 = {}", r);
    }
}

Result — безопасная обработка ошибок

fn parse(s: &str) -> Result {
    s.trim().parse::().map_err(|e| format!("Ошибка: {}", e))
}

fn main() {
    for input in ["42", "  -7  ", "abc"] {
        match parse(input) {
            Ok(n)  => println!("✅ '{input}' = {}", n * 2),
            Err(e) => println!("❌ {}", e),
        }
    }

    let n = parse("21").map(|n| n * 2);
    println!("{:?}", n);  // Ok(42)
}

Практика: библиотека фигур

trait Drawable {
    fn draw(&self);
    fn area(&self) -> f64;
}

struct Canvas { items: Vec> }

impl Canvas {
    fn new() -> Self { Canvas { items: Vec::new() } }
    fn add(&mut self, d: Box) { self.items.push(d); }
    fn total_area(&self) -> f64 { self.items.iter().map(|d| d.area()).sum() }
    fn render(&self) {
        println!("=== Canvas ({} фигур) ===", self.items.len());
        for item in &self.items { item.draw(); }
        println!("Общая площадь: {:.2}", self.total_area());
    }
}

struct Circ { r: f64 }
struct Rect { w: f64, h: f64 }

impl Drawable for Circ {
    fn draw(&self) { println!("  ⭕ r={:.1} S={:.2}", self.r, self.area()); }
    fn area(&self) -> f64 { std::f64::consts::PI * self.r * self.r }
}

impl Drawable for Rect {
    fn draw(&self) { println!("  ▭ {}×{} S={:.2}", self.w, self.h, self.area()); }
    fn area(&self) -> f64 { self.w * self.h }
}

fn main() {
    let mut c = Canvas::new();
    c.add(Box::new(Circ { r: 5.0 }));
    c.add(Box::new(Rect { w: 8.0, h: 6.0 }));
    c.add(Box::new(Circ { r: 3.0 }));
    c.render();
}

Итого

Struct: именованные поля. impl Struct { fn new() -> Self {...} fn method(&self) {...} }. Трейты: интерфейс (набор методов). derive: автогенерация Debug, Clone, PartialEq и других. Enum: набор именованных вариантов с данными. Option<T>: Some(x) или None — замена null. Result<T, E>: Ok(x) или Err(e) — обработка ошибок.

Дополнительные примеры для практики

Программирование — это навык, который улучшается только с практикой. Вот несколько задач для самостоятельной работы:

Задача 1: Числовые паттерны

fn main() {
    // Выведи пирамиду из звёздочек
    for i in 1..=5 {
        for _ in 0..i { print!("* "); }
        println!();
    }

    // Числа Фибоначчи итеративно (быстрее рекурсии)
    let mut a = 0u64;
    let mut b = 1u64;
    print!("Фибоначчи: ");
    for _ in 0..15 {
        print!("{} ", a);
        let c = a + b;
        a = b;
        b = c;
    }
    println!();

    // Простые числа через решето Эратосфена
    let n = 50usize;
    let mut is_prime = vec![true; n + 1];
    is_prime[0] = false;
    is_prime[1] = false;
    let mut i = 2;
    while i * i <= n {
        if is_prime[i] {
            let mut j = i * i;
            while j <= n {
                is_prime[j] = false;
                j += i;
            }
        }
        i += 1;
    }
    print!("Простые до {}: ", n);
    for k in 2..=n {
        if is_prime[k] { print!("{} ", k); }
    }
    println!();
}

Задача 2: Работа с данными

fn main() {
    let data = vec![
        ("Алиса", 85.0f64),
        ("Боря",  72.0),
        ("Вера",  91.0),
        ("Гриша", 68.0),
        ("Даша",  95.0),
    ];

    // Сортировка по убыванию
    let mut sorted = data.clone();
    sorted.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    println!("Топ учеников:");
    for (i, (name, score)) in sorted.iter().enumerate() {
        let medal = match i { 0 => "🥇", 1 => "🥈", 2 => "🥉", _ => "  " };
        println!("{} {} — {:.1}", medal, name, score);
    }

    let avg = data.iter().map(|(_, s)| s).sum::() / data.len() as f64;
    let above: Vec<_> = data.iter().filter(|(_, s)| *s > avg).collect();

    println!("
Средний балл: {:.2}", avg);
    println!("Выше среднего: {}", above.len());
}

Разбор типичных задач

// Палиндром
fn is_palindrome(s: &str) -> bool {
    let chars: Vec = s.chars().collect();
    let n = chars.len();
    for i in 0..n/2 {
        if chars[i] != chars[n-1-i] { return false; }
    }
    true
}

// FizzBuzz
fn fizzbuzz(n: u32) -> String {
    match (n % 3, n % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        _      => n.to_string(),
    }
}

// Подсчёт слов в тексте
fn word_frequencies(text: &str) -> std::collections::HashMap<&str, usize> {
    let mut freq = std::collections::HashMap::new();
    for word in text.split_whitespace() {
        *freq.entry(word).or_insert(0) += 1;
    }
    freq
}

fn main() {
    println!("'racecar' палиндром? {}", is_palindrome("racecar"));
    println!("'hello' палиндром? {}", is_palindrome("hello"));

    for n in 1..=20 { print!("{} ", fizzbuzz(n)); }
    println!();

    let text = "rust rust код код код программирование";
    let freq = word_frequencies(text);
    let mut pairs: Vec<_> = freq.iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(a.1));
    for (word, count) in pairs {
        println!("'{}': {}", word, count);
    }
}