rust std

目录

一，std基本数据结构

1，std::option

2，std::result

二，std容器

1，vector

三，std算法

1，排序

2，二分

（1）vector二分

（2）自定义二分

---

rust std 文档

一，std基本数据结构

1，std::option

（1）定义

pub enum Option {
    None,
    Some(T),
}

这是一个枚举值，要么等于None，要么等于泛型Some

（2）is_some、is_none

	let x:Option=Some(2);
	assert_eq!(x.is_some(),true);
	assert_eq!(x.is_none(),false);
	let x:Option=None;
	assert_eq!(x.is_some(),false);
	assert_eq!(x.is_none(),true);

（3）is_some_and

	let x:Option=Some(2);
	assert_eq!(x.is_some_and(|x| x>1),true);

2，std::result

（1）定义

pub enum Result {
    Ok(T),
    Err(E),
}

这也是个枚举值，要么是等于Option型的OK，要么是等于Option型的Err

2个模板类型可以一样也可以不一样。

（2）is_ok、is_err

	let x:Result=Ok(1);
	assert_eq!(x.is_ok(),true);
	assert_eq!(x.is_err(),false);
	let x:Result=Err("456");
	assert_eq!(x.is_ok(),false);
	assert_eq!(x.is_err(),true);

str类型要带取址符。

（3）is_ok_and、is_err_and

	let x:Result=Ok(1);
    assert_eq!(x.is_ok_and(|x| x==1),true);
	assert_eq!(x.is_err(),false);
	let x:Result=Err("456");
	assert_eq!(x.is_ok(),false);
	assert_eq!(x.is_err_and(|x| x=="456"),true);

（4）ok、err

这里又把result当成结构体，用ok、err取出2个成员值，但至少有一个成员是None值。

	let x:Result=Ok(1);
    assert_eq!(x.ok(),Some(1));
	assert_eq!(x.err(),None);
	let x:Result=Err("456");
	assert_eq!(x.ok(),None);
	assert_eq!(x.err(),Some("456"));

二，std容器

1，vector

fn main() {
	let mut nums=vec![1,2,4,3];
	println!("{}",nums.len());
}

三，std算法

1，排序

（1）vector排序

fn main() {
	let mut nums=vec![1,2,4,3];
	nums.sort();
	println!("{}",nums[3]);
}

vector的默认排序，从小到大排序，输出4

2，二分

（1）vector二分

fn search(nums: &Vec, target:i32)->i32{
    let res = nums.binary_search(&target);
    match res{
        Ok(x)=>x as i32,
        _=>-1
    }
}
fn main() {
    let nums =vec![1,2,4,5];
    println!("{}",search(&nums,1));
	println!("{}",search(&nums,4));
	println!("{}",search(&nums,7));
}

输出：

0
2
-1

（2）自定义二分

trait Solution{
    fn find(&self,low:i32,high:i32)-> i32;
    fn check_value(&self,x:i32)->bool;
}
struct SearchData{
    target:i32
}
impl Solution for SearchData{
    fn find(&self, low:i32,high:i32)-> i32{
        let mut low = low;
        let mut high = high;
        if self.check_value(high) == false{
            return high+1;
        }
        if self.check_value(low) == true{
            return low;
        }
        while high - low > 1 {
            let mid = (high + low)/2;
            if self.check_value(mid) == true{
                high = mid;
            }
            else {
                low = mid;
            }
        }
        return high;
    }
    fn check_value(&self,x:i32)->bool{
        if x*x*x>self.target{
            return true;
        }
        return false;
    }
}
fn main() {
    let x=SearchData{target:100};
    println!("{}",x.find(0,50));
}

输出5，即5是满足x*x*x>target的最小值。