База знаний (цифровой суверенитет)
База знаний (цифровой суверенитет)

  • Rust - варианты простого калькулятора

    Язык Rust
    1 5 13
    A
    951
    0
    A

    1. Простейший калькулятор (сложение без ввода)

    fn main() {
    println!("--- Простейший калькулятор (сложение, без ввода) ---");
    
    let num1 = 25.3;
    let num2 = 75.0;
    let result = num1 + num2;
    println!("Результат: {} + {} = {}", num1, num2, result);
}
    0
  • A
    951
    0
    A

    2. Простейший калькулятор (минималистичный вариант со вводом)

    use std::io;

fn read_number(prompt: &str) -> f64 {
    println!("{}", prompt);

    let mut input = String::new();

    io::stdin().read_line(&mut input).unwrap();

    input.trim().parse().unwrap()
}

fn main() {
    let a = read_number("Введите первое число:");
    let b = read_number("Введите второе число:");

    println!("Результат: {}", a + b);
}
    0
  • A
    951
    0
    A

    3. Простейший калькулятор (сложение со вводом)

    use std::io;

fn main() {
    println!("--- Простой калькулятор (сложение) ---");

    println!("Введите первое число:");
    let mut input1 = String::new();
    io::stdin().read_line(&mut input1).expect("Ошибка чтения");
    let num1: f64 = input1.trim().parse().expect("Это не число");

    println!("Введите второе число:");
    let mut input2 = String::new();
    io::stdin().read_line(&mut input2).expect("Ошибка чтения");
    let num2: f64 = input2.trim().parse().expect("Это не число");

    let result = num1 + num2;
    println!("Результат: {} + {} = {}", num1, num2, result);
}
    0
  • A
    951
    0
    A

    4. Простейший калькулятор (сложение со вводом и функция)

    use std::io;

fn read_number(prompt: &str) -> f64 {
    println!("{}", prompt);

    let mut input = String::new();

    io::stdin()
        .read_line(&mut input)
        .expect("Ошибка чтения");

    input
        .trim()
        .parse()
        .expect("Это не число")
}

fn main() {
    println!("--- Простой калькулятор (сложение) ---");

    let num1 = read_number("Введите первое число:");
    let num2 = read_number("Введите второе число:");

    let result = num1 + num2;

    println!("Результат: {} + {} = {}", num1, num2, result);
}
    0
  • A
    951
    0
    A

    5. Простой калькулятор (полностью)

    use std::io;

fn main() {
    println!("=== Простой калькулятор на Rust ===");
    println!("Для выхода введите 'q' или оставьте строку пустой\n");

    loop {
        // Читаем первое число
        let num1 = match read_number("Введите первое число (или q для выхода):") {
            Some(n) => n,
            None => break,
        };

        // Читаем оператор
        let operator = read_operator();

        // Читаем второе число
        let num2 = match read_number("Введите второе число:") {
            Some(n) => n,
            None => continue,
        };

        // Выполняем вычисление
        match calculate(num1, &operator, num2) {
            Ok(result) => {
                println!("Результат: {} {} {} = {:.4}", num1, operator, num2, result);
            }
            Err(msg) => println!("Ошибка: {}", msg),
        }

        // Исправленная строка-разделитель
        println!("{}", "─".repeat(40));
    }

    println!("До свидания! 👋");
}

// ====================== ФУНКЦИИ ======================

fn read_number(prompt: &str) -> Option<f64> {
    loop {
        println!("{}", prompt);
        let mut input = String::new();
        
        if io::stdin().read_line(&mut input).is_err() {
            println!("Ошибка чтения ввода!");
            continue;
        }

        let input = input.trim();

        if input.eq_ignore_ascii_case("q") || input.is_empty() {
            return None;
        }

        match input.parse::<f64>() {
            Ok(num) => return Some(num),
            Err(_) => println!("Ошибка: введите корректное число!"),
        }
    }
}

fn read_operator() -> String {
    loop {
        println!("Введите оператор (+, -, *, /):");
        let mut input = String::new();

        if io::stdin().read_line(&mut input).is_err() {
            continue;
        }

        let op = input.trim();

        if matches!(op, "+" | "-" | "*" | "/") {
            return op.to_string();
        } else {
            println!("Ошибка: допустимы только +, -, *, /");
        }
    }
}

fn calculate(a: f64, op: &str, b: f64) -> Result<f64, String> {
    match op {
        "+" => Ok(a + b),
        "-" => Ok(a - b),
        "*" => Ok(a * b),
        "/" => {
            if b == 0.0 {
                Err("Деление на ноль!".to_string())
            } else {
                Ok(a / b)
            }
        }
        _ => Err("Неизвестный оператор".to_string()),
    }
}
    0