Rust 文件

从文件读取数据，转换成a+b形式的表达式，并计算结果。

 

use std::fs::File;
use std::io::prelude::*;
use std::vec::Vec;
use std::char;

fn main() {
    let filename = "D:\\Rust\\data\\data1.txt";
    let mut file = File::open(filename).expect("file not found");
    let mut contents = String::new();
    file.read_to_string(&mut contents).expect("something went wrong reading the file");

    let mut a: u32 = 0;
    let mut b: u32 = 0;
    let mut sign_index: usize = 0;
    let mut expressions: Vec<char> = Vec::new();
    let mut left_number: Vec<u32> = Vec::new();
    let mut right_number: Vec<u32> = Vec::new();
    for ch in contents.chars() {
        expressions.push(ch);
    }

    for i in 0..expressions.len() {
        if !expressions[i].is_digit(10) {
            sign_index = i;
            break;
        }
    }

    for i in 0..sign_index {
        if expressions[i].is_digit(10) {
            left_number.push(expressions[i].to_digit(10).unwrap());
        }
    }

    for i in sign_index + 1..expressions.len() {
        if expressions[i].is_digit(10) {
            right_number.push(expressions[i].to_digit(10).unwrap());
        }
    }

    for i in 1..left_number.len() + 1 {
        a += left_number[i - 1] * pow(10, (left_number.len() - i) as u32);
    }

    for i in 1..right_number.len() + 1 {
        b += right_number[i - 1] * pow(10, (right_number.len() - i) as u32);
    }

    let sum = add(a, b);
    println!("{} + {} = {}", a, b, sum);

    let mut file = File::create("D:\\Rust\\data\\foo.txt").expect("Failed to create file.");
    file.write(contents.as_bytes()).expect("Failed to write file.");
    file.write(b"=").expect("Failed to write file.");
    file.write(get_string_from_integer(sum).as_bytes()).expect("Failed to write file.");
}

fn add(a: u32, b: u32) -> u32 {
    return a + b;
}

fn pow(a: u32, b: u32) -> u32 {
    let mut result: u32 = 1;
    if b == 0 {
        result
    } else if b == 1 {
        result = a;
        result
    } else {
        let mut i: u32 = 0;
        for i in 0..b {
            result *= a;
        }
        result
    }
}

fn get_string_from_integer(number: u32) -> String {
    let mut string = String::new();
    let bits = get_bits_of_number(number);
    let mut i = (bits - 1) as i32;
    loop {
        if i < 0 {
            break;
        }
        string.push(char::from_digit(get_digit_from_integer(number, i as u32), 10).unwrap());
        i = i - 1;
    }
    string
}

fn get_digit_from_integer(number: u32, bit: u32) -> u32 {
    number % pow(10, bit + 1) / pow(10, bit)
}

fn get_bits_of_number(number: u32) -> u32 {
    let mut bits: u32 = 0;
    while number / pow(10, bits) > 0 {
        bits = bits + 1;
    }
    bits
}