Rust的入门篇(中)

Rust的入门篇(中)

这是接上面一篇rust入门篇(上)文章

22. 包管理一

mod nation {
    pub mod government {
        pub fn govern() {}
    }

    mod congress {
        pub fn legislate() {}
    }
   
    mod court {
        fn judicial() {
            super::congress::legislate();
        }
    }
}

fn main() {
    nation::government::govern();
}

23. 包管理二

mod back_of_house{
    pub struct Breakfast{
        pub toast: String,
        seasonal_fruit: String,
    }
    impl Breakfast{
        pub fn summer(toast: &str)->Breakfast{
            Breakfast { 
                toast: String::from(toast), 
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant(){
    let mut meal = back_of_house::Breakfast::summer("Rye");
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);
}


fn main() {
    eat_at_restaurant();
    
}

24. 包管理三

use std::fs::Permissions;

mod SomeModule{
    pub enum Person{
        King {
            name: String
        },
        Queen
    }
}



fn main() {
    let person = SomeModule::Person::King { 
        name: String::from("Blue") 
    };

    match person {
        SomeModule::Person::King { name } =>{
            println!("{}", name);
        }
        _=>{}
    }
    // Blue
}

25. 包管理四 导入包

second_modules.rs

pub fn message()->String{
    String::from("this is the 2nd module")
}

main.rs

// 学习如何导入一个外来的模块
mod second_module;

fn main(){
    println!("This is the main module");
    println!("{}", second_module::message())
}
// This is the main module
// this is the 2nd module

27. 使用use关键字引入包内的函数

mod nation{
    pub mod government{
        pub fn govern(){
            println!("hello world");
        }
    }
}

// use关键字的使用
use crate::nation::government::govern;

fn main(){
    govern();
}

28. 泛型编程一

模板编程

fn max<T>(array: &[T]) -> T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i] > array[max_index] {
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}

fn main(){
    let a = [2, 4, 6, 3, 1];
    println!("max={}", max(&a));

}

28. use as

mod nation{
    pub mod government{
        pub fn govern(){println!("nation govern")}
    }
    pub fn govern(){println!("govern")}
}

use crate::nation::government::govern as nation_govern;
use crate::nation::govern;

fn main(){
    nation_govern(); // nation govern3
    govern(); // govern

}

29. use-pub

mod nation{
    pub mod government{
        pub fn govern(){println!("nation govern")}
    }
    pub use government::govern;
}

use crate::nation::government::govern as nation_govern;
use crate::nation::govern;

fn main(){
    nation_govern(); // nation govern3
    govern(); // govern

}

30. 第三方库

use std::f64::consts::PI;

fn main(){
    println!("{}", (PI*3.0/2.0).sin());

}

31. exception1

fn main(){
    // panic!("error occured");
    println!("hello, rust");


}

32. exception2

use std::fs::File;

// 异常处理1
fn main(){
    let f = File::open("hello.txt");
    match f{
        Ok(file) => {
            println!("File opened successfully.");
        }
        Err(err)=>{
            println!("Failed to open file.");
        }
    }

}

33. exception3

use std::fs::File;

// 异常处理2
fn main(){
    let f = File::open("hello.txt");
    if let Ok(file) = f{
        println!("File opened succefully")
    } else {
        println!("fail to open.");
    }

}

34. exception4

use std::fs::File;


fn main(){
    // 可恢复错误按不可恢复错误处理

    // 不发送错误信息
    // let f1 = File::open("hello.txt").unwrap();

    // 发送错误信息
    // let f2 = File::open("hello.txt").expect("Failed to open");
    
    // 啥也没做，不知道是否错误
    let f2 = File::open("hello.txt");


}

35. exception5

// 异常的传递


fn f(i:i32)->Result<i32, bool>{
    if i>=0 {
        Ok(i)
    }
    else {
        Err(false)
    }
}

fn g(i:i32)->Result<i32, bool>{
    // ? 符的实际作用是将 Result 类非异常的值直接取出，如果有异常就将异
    // 常 Result 返回出去。所以，? 符仅用于返回值类型为 Result 的函数，
    // 其中 E 类型必须和 ? 所处理的 Result 的 E 类型一致
    let t = f(i)?;
    Ok(t)
}


fn main(){
    let r = g(10000);
    if let Ok(v) = r{
        println!("Ok: g(10000) = {}", v);
    } else {
        println!("Err");
    }

}

36. exception6

use std::io;
use std::io::Read;
use std::fs::File;

// 读取文件，并捕获文件不存在的异常
fn read_text_from_file(path: &str) -> Result<String, io::Error> {
    let mut f = File::open(path)?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

fn main() {
    let str_file = read_text_from_file("d://hello.txt");
    match str_file {
        Ok(s) => println!("{}", s),
        Err(e) => {
                // kind 方法
                match e.kind(){
                    io::ErrorKind::NotFound=>{
                        println!("no such file");
                    },
                    _=>{
                        println!("cannot read file.");
                    }
                }
        }
    }
}

37. 泛型编程1

// 非泛型的情况，传入的数据类型只能是i32
fn max(array:&[i32])->i32{
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len(){
        if array[i] > array[max_index]{
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}


fn main(){
    let a = [2, 4, 6, 3, 1];
    println!("max={}", max(&a));

}

38. 泛型编程2

// 枚举+泛型编程
struct Point<T>{
    x: T,
    y: T
}


fn main(){
    let p1 = Point {x:1, y:2};
    let p2 = Point {x: 1.0, y: 2.0};
    
    // p1.x=1, p1.y=2
    println!("p1.x={}, p1.y={}",  p1.x, p1.y);

    // 下面错误的，不能使用2个不同的类型
    // let p3 = Point {x: 1, y: 2.0};

}

39. 泛型编程3

// 枚举+泛型编程
struct Point<T1, T2>{
    x: T1,
    y: T2
}


fn main(){

    // 使用2个不同的类型
    let p3 = Point {x: 1, y: 2.0};
    println!("p3.x={}, p3.y={}",  p3.x, p3.y);

}

40. 泛型编程4

在结构体定义泛型方法

struct Point<T>{
    x: T,
    y: T
}

// 结构体与枚举类定义泛型方法
impl<T> Point<T>  {
    fn x(&self)->&T{
        &self.x
    }
}

fn main(){
    let p = Point{x:1, y:2};
    println!("p.x = {}", p.x());

}

41. 泛型编程5

特性trait的定义与实施

trait Descriptive {
    fn describe(&self)->String{
        String::from("[Object]")
    }
}

struct Person{
    name: String,
    age: u8
}

impl Descriptive for Person {
    fn describe(&self)->String {
        format!("{} {}", self.name, self.age)
    }
}


fn main(){
    let cali = Person{
        name: String::from("Cali"),
        age: 24
    };
    println!("{}", cali.describe());
}

42. 泛型编程6

// 特性（trait）概念接近于 Java 中的接口（Interface），但两者不完全相同。特性与接
// 口相同的地方在于它们都是一种行为规范，可以用于标识哪些类有哪些方法。
trait Descriptive {
    fn describe(&self)->String{
        String::from("[Object]")
    }
}

struct Person{
    name: String,
    age: u8
}

impl Descriptive for Person {
    fn describe(&self)->String {
        format!("{} {}", self.name, self.age)
    }
}


fn main(){
    let cali = Person{
        name: String::from("Cali"),
        age: 24
    };
    println!("{}", cali.describe());
}

43. 泛型编程7

综合例子

// 特性例子简介

// 定义特性
trait Comparable {
    fn compare(&self, object: &Self)->i8;    
}

// 实现特性 并 绑定到 f64类型下
impl Comparable for f64 {
    fn compare(&self, object: &f64)->i8{
        if &self > &object{1}
        else if &self == &object{0}
        else {-1}
    }
}

fn max<T: Comparable>(array: &[T])->&T{
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len(){
        if array[i].compare(&array[max_index])>0{
            max_index = i;
        }
        i += 1;
    }
    &array[max_index]
}



fn main(){
    // 默认arr的类型是[f64; 5]
    let arr = [1.0, 3.0, 5.0, 4.0, 2.0];
    println!("maximum of arr is {}", max(&arr));
}

44. 泛型编程8

特征做为返回值出现

// 特性作为返回值
trait Descriptive {
    fn describe(&self)->String{
        String::from("[Object]")
    }
}

impl Descriptive for Person {
    fn describe(&self)->String {
        format!("{} {}", self.name, self.age)
    }
}

struct Person{
    name: String,
    age: u8
}

// 特征作为返回值出现
fn person() -> impl Descriptive {
    Person {
        name: String::from("Cali"),
        age: 24
    }
}

fn main(){
    let p = person();
    println!("{}", p.describe());

}