Arithmetische Operationen in Rust

Что это и зачем?

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

В Rust, как и в любом другом языке программирования, есть специальные символы для сложения, вычитания, умножения и деления. Они работают почти как на обычном калькуляторе, но с некоторыми особенностями. Зачем это нужно? Без арифметики невозможно написать ни одну программу: от простого калькулятора до сложной игры или приложения для банка.

Давай разберёмся, как это работает в Rust!

Синтаксис и примеры кода

В Rust арифметические операции выглядят очень просто. Вот основные символы:

• + — сложение
• - — вычитание
• * — умножение
• / — деление
• % — остаток от деления (показывает, сколько останется, если разделить число нацело)

Давай посмотрим на примеры. Представь, что мы пишем программу для подсчёта карманных денег.

// Пример 1: Сложение
let money_monday = 100;  // В понедельник дали 100 рублей
let money_tuesday = 150; // Во вторник дали 150 рублей
let total = money_monday + money_tuesday; // Складываем
println!("Всего денег: {}", total); // Выведет: Всего денег: 250

В этом примере мы создали две переменные (money_monday и money_tuesday), записали в них числа, а потом сложили их с помощью +. Результат сохранили в переменную total и вывели на экран.

// Пример 2: Вычитание
let pizza_slices = 8;    // У нас 8 кусочков пиццы
let eaten = 3;           // Съели 3 кусочка
let remaining = pizza_slices - eaten; // Вычитаем
println!("Осталось кусочков: {}", remaining); // Выведет: Осталось кусочков: 5

Здесь мы отняли от общего количества кусочков те, что съели. Всё как в жизни!

// Пример 3: Умножение
let friends = 4;         // 4 друга
let candies_per_friend = 5; // Каждому по 5 конфет
let total_candies = friends * candies_per_friend; // Умножаем
println!("Всего нужно конфет: {}", total_candies); // Выведет: Всего нужно конфет: 20

Умножение помогает, когда нужно посчитать общее количество одинаковых предметов. Если у каждого друга по 5 конфет, а друзей 4, то всего конфет 4 × 5 = 20.

// Пример 4: Деление
let total_apples = 10;   // 10 яблок
let children = 3;        // 3 детей
let apples_per_child = total_apples / children; // Делим
println!("Каждому ребёнку по {} яблок", apples_per_child); // Выведет: Каждому ребёнку по 3 яблок

Обрати внимание: 10 разделить на 3 — это 3 с остатком. Но Rust при делении целых чисел отбрасывает дробную часть! Поэтому результат — 3, а не 3.333... Если нужно получить точный результат, нужно использовать числа с плавающей точкой (о них позже).

// Пример 5: Остаток от деления
let total_apples = 10;
let children = 3;
let remainder = total_apples % children; // Остаток от деления
println!("Останется яблок: {}", remainder); // Выведет: Останется яблок: 1

Оператор % показывает, сколько останется, если разделить число нацело. 10 ÷ 3 = 3 (целых) и 1 в остатке. Это очень полезно, например, чтобы узнать, чётное число или нет.

Сравнение с Python

Если ты уже пробовал Python, то заметишь, что арифметика в Rust очень похожа. Но есть важные отличия.

В Python деление целых чисел даёт дробный результат:

# Python
print(10 / 3)  # Выведет: 3.3333333333333335

В Rust то же самое деление даст целое число (3), если оба числа целые. Чтобы получить дробный результат, нужно явно указать, что числа дробные:

// Rust
let a: f64 = 10.0; // f64 — это дробное число
let b: f64 = 3.0;
println!("{}", a / b); // Выведет: 3.3333333333333335

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

// Rust — так нельзя!
let x = 5;
let y = 2.5;
// let z = x + y; // Ошибка! Разные типы

// Правильно:
let z = x as f64 + y; // Преобразуем x в дробное число
println!("{}", z); // Выведет: 7.5

В Python такое смешивание работает автоматически:

# Python
x = 5
y = 2.5
print(x + y)  # Выведет: 7.5

Rust строже относится к типам данных, но это помогает избежать ошибок.

Типичные ошибки новичков

Вот самые частые ошибки, которые допускают начинающие программисты на Rust:

1. Деление на ноль. Если попробовать разделить число на 0, программа упадёт с ошибкой. Всегда проверяй, что делитель не равен нулю.
2. Забыл про остаток. Новички часто думают, что 10 / 3 = 3.333, но в Rust для целых чисел это 3. Если нужен остаток, используй %.
3. Смешивание типов. Нельзя складывать целое число с дробным без преобразования. Rust скажет: "Эй, типы разные!". Используй as для преобразования.
4. Переполнение. Если число слишком большое для своего типа, может произойти переполнение. Например, если в u8 (число от 0 до 255) попытаться записать 256, будет ошибка или неожиданный результат.
5. Порядок операций. Как в математике, умножение и деление выполняются раньше сложения и вычитания. Если хочешь изменить порядок, используй скобки: (2 + 3) * 4.

Вот пример неправильного кода, который часто пишут новички:

// Ошибка: деление на ноль
let a = 10;
let b = 0;
// let result = a / b; // Программа упадёт!

// Ошибка: смешивание типов
let x = 5;
let y = 2.5;
// let z = x + y; // Ошибка компиляции

// Правильный вариант:
let z = x as f64 + y;
println!("{}", z);

Итог

Арифметические операции — это основа программирования. В Rust они работают почти как в обычной математике, но с некоторыми правилами:

• Используй +, -, *, /, % для базовых операций.
• Помни, что деление целых чисел даёт целый результат.
• Не смешивай целые и дробные числа без преобразования.
• Избегай деления на ноль.
• Используй скобки для управления порядком операций.

Попробуй написать свою первую программу с арифметикой! Например, калькулятор для подсчёта баллов в игре или для расчёта времени на домашнее задание. Чем больше практикуешься, тем быстрее запомнишь все правила.

Удачи в изучении Rust! Это мощный язык, и арифметика — только начало твоего пути.