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 govern3govern(); // 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 govern3govern(); // 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<T, E> 的函数，// 其中 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=2println!("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());}