rust编程基础

枚举

枚举就是在枚举中定义一些有名字和属性的值，然后可以建立变量来获取这些值。

枚举中的值同C++一样，也可以不用建立实例而直接利用，比如用来作为数组元素值。

枚举中可以定义结构体和元组

enum language{//只定义枚举的值c,cp,java,
}
fn main(){let inst_c=language::c;let cpp=language::cp;let Java=language::java;
}enum language{//为值添加元组属性c(String),cp(String),java(String),
}
fn main(){let inst_c=language::c;let cpp=language::cp;let Java=language::java;
}enum language{//为值添加元组属性,再给属性命名c(name:String,user:i32),cp(String),java(String),
}
fn main(){let inst_c=language::c;let cpp=language::cp;let Java=language::java;
}

let i = 0;
match i {0 => println!("zero"),_ => {},//_代表其他值
}

枚举中的值的属性可以输出吗

模式匹配

枚举值

同C++默认从0开始，往后加1：

 可以定义枚举值：

enum number{one=1,two,
}
fn main(){//println!("{}",number::zero as i32);println!("{}",number::one as i32);println!("{}",number::two as i32);
}

注意：如果用=给枚举值赋值了，那么只能是整形

如果使用等号赋值了，那么枚举其他成员值也要是整形，不能是元组或者结构体。

enum number{one=1,two(u8),
}
fn main(){
}

枚举赋值和值的获取

链接

模式匹配获取枚举值

//元组
enum number{one(f32),two,
}
fn main(){let n_one:number=number::one(1.1);if let number::one(a)=n_one{println!("{a}");}
}//结构体
enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(i32, i32, i32),
}fn main() {let msg = Message::Move{x: 1, y: 1};if let Message::Move{x: a, y: b} = msg {assert_eq!(a, b);} else {panic!("NEVER LET THIS RUN！");}
} 

利用数组的形式创建所有的枚举值

#[derive(Debug)]
enum Student{Name(String),Age(u8),Grade(f32),
}
fn main(){let s1:[Student;3]=[Student::Name(String::from("ZhangSan")),Student::Age(24),Student::Grade(149.5)];for i in s1{println!("{:?}",i);}
}

match和if let

注意：if let dosomething {}，let dosomething是一个整体，同if---else中的条件判断，不要认为let dosomething和后面的{}是一个整体。

fn main(){let sm=Some(10);if let Some(10)=sm{println!("{:?}",Some(1));}else if let Some(100)=sm{println!("{:?}",Some(1000));}else{println!("other Option");}
}

fn main(){let sm=Some(10);match sm{Some(10)=>{println!("{:?}",Some(10));},Some(100)=>{println!("{:?}",Some(1000));},_=>{println!("other Option");},}
}

option枚举

用来定义变量的值为某个确定值，或者可以为空。

enum Option{Some(T),//注意，是一个元组，不是函数None,
}

怎么比较Some中的值：

match和if let 中的some中的元组的变量可以获取的

fn main() {let mut v = vec![1, 2, 4, 8];println!("{}", match v.get(0) {Some(value) => value.to_string(),None => "None".to_string()});
}// if let
use std::collections::HashMap;fn main() {let mut map = HashMap::new();map.insert(1, "a");if let Some(x) = map.get_mut(&1) {*x = "b";}
}

OPtion存在的原因：

在 Rust 中所有的类型，编译器默认为它总是有一个有效的值。我们无需任何顾虑自信使用而无需做空值检查。只有当使用 Option（或者任何用到的类型）的时候需要担心可能没有值。

match匹配Option原理

fn main() {let x:Option=Some(32);match x{Some(a)=>println!("equal1"),None=>println!("Not equal"),}
}

 如果x不是空，那么match中的Some就可以获取x这个OPtion中的值，让后把这个值赋给a；

如果x是空，则获取不到值，就是None.

为什么a不能是一个常量字面值：

因为需要匹配，然后获取值。

result

成功就将值保存在Ok(T)元组的T中，失败将因为保存在Err(E)中

注意：T是成功返回数据的类型，E是错误时2，错误原因类型的数据，比如：

use std::num::ParseIntError;

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

fn main() {let x:i32=10000000;let y:u8=match x.try_into(){Ok(o)=>o,Err(e)=>{println!("{}",e.to_string());0},};println!("{y}");
}

result的运用

读文件，文件返回的类型

use std::num::ParseIntError;#[derive(PartialEq, Debug)]
enum ParsePosNonzeroError {Creation(CreationError),ParseInt(ParseIntError)
}impl ParsePosNonzeroError {fn from_creation(err: CreationError) -> ParsePosNonzeroError {ParsePosNonzeroError::Creation(err)}fn from_parseint(err:ParseIntError)->ParsePosNonzeroError{ParsePosNonzeroError::ParseInt(err)}
}fn parse_pos_nonzero(s: &str)-> Result
{let res:Result= s.parse();match res{Ok(x)=>match PositiveNonzeroInteger::new(x){Err(CreationError::Negative)=>Err(ParsePosNonzeroError::from_creation(CreationError::Negative)),Err(CreationError::Zero)=>Err(ParsePosNonzeroError::from_creation(CreationError::Zero)),Ok(PositiveNonzeroInteger(n))=>Ok(PositiveNonzeroInteger(n))},Err(s)=>Err(ParsePosNonzeroError::from_parseint(s))}
}#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result {match value {x if x < 0 => Err(CreationError::Negative),x if x == 0 => Err(CreationError::Zero),x => Ok(PositiveNonzeroInteger(x as u64))}}
}#[cfg(test)]
mod test {use super::*;#[test]fn test_parse_error() {assert!(matches!(parse_pos_nonzero("not a number"),Err(ParsePosNonzeroError::ParseInt(_))));}#[test]fn test_negative() {assert_eq!(parse_pos_nonzero("-555"),Err(ParsePosNonzeroError::Creation(CreationError::Negative)));}#[test]fn test_zero() {assert_eq!(parse_pos_nonzero("0"),Err(ParsePosNonzeroError::Creation(CreationError::Zero)));}#[test]fn test_positive() {let x = PositiveNonzeroInteger::new(42);assert!(x.is_ok());assert_eq!(parse_pos_nonzero("42"), Ok(x.unwrap()));}
}

结构体和枚举所有全属性

结构体

结构体不是剧本数据类型，不管内部成员是什么，都会move;

枚举

自定义枚举

自定义的枚举不管属性值是不是move类型，枚举都会move

Option

Some(T)

T是move类型，Option的变量移动。

T不是move类型，Option变量Copy。

Option会不会被move取决于它存储的数据类型

流程控制语句

if---else if----else

注意：条件没有小括号，{}包含代码块

rust没有三元比较运算符

{}不可省略

if--else作为表达式

就是if--else中会有返回值，那么返回值就是if或者else的返回类型。

fn main() {let condition = true;let number = if condition { 5 } else { 6 };println!("The value of number is: {number}");
}

fn main(){let x=get_num(100);println!("{x}");
}fn get_num(var:i32)->i32{if var>0 {println!("{var} is greater then 0.");return 43i32;}//报错
}//正确
fn main(){let x=get_num(100);println!("{x}");
}fn get_num(var:i32)->i32{if var>0 {println!("{var} is greater then 0.");return 43i32;}else{10i32}
}

如果使用if-else作为表达式，那么一定要注意，if分支和else分支的类型必须一致，否则就不能构成一个合法的表达式，会出现编译错误。如果else分支省略掉了，那么编译器会认为else分支的类型默认为()。

loop无线循环

在Rust中，使用loop表示一个无限死循环。

其中，我们可以使用continue和break控制执行流程。

break语句和continue语句还可以在多重循环中选择跳出到哪一层的循环。

生命周期标识符（循环标签）

我们可以在loop while for循环前面加上“生命周期标识符”。该标识符以单引号开头，冒号结尾，在内部的循环中可以使用break语句选择跳出到哪一层。

fn main(){let mut x=0i32;'a:loop{let mut y:i32=0;'aa:loop{y+=1;if y>10 {x+=1;}if y>20{break 'aa;}}if x>10&&x<20 {println!("x={x}");continue 'a;}else if x>20 {println!("x={x}");break 'a;}}
}

while

loop比while好

for

for循环的主要用处是利用迭代器对包含同样类型的多个元素的容器执行遍历，如数组、链表、HashMap、HashSet等。

fn main(){let a=[1,2,3,4,5];for i in a{println!("{i}");}
}

for循环也会产生move

fn main(){let a=[String::from("I"),String::from("am"),String::from("a"),String::from("student")];for i in a{println!("{i}");}println!("{}",a[0]);
}

一般使用数组引用：

fn main(){let a=[String::from("I"),String::from("am"),String::from("a"),String::from("student")];for i in &a{println!("{i}");}println!("{}",a[0]);
}

或者将数组变为迭代器：

fn main(){let a=[String::from("I"),String::from("am"),String::from("a"),String::from("student")];for i in a.iter(){println!("{i}");}println!("{}",a[0]);
}

match模式匹配

模式匹配的格式

1，单个变量进行对应匹配；

2，使用|运算符匹配；

3，范围匹配：eg:  0..=5=>;

4，匹配守卫;

#![allow(unused)]
fn main() {
let num = Some(4);match num {Some(x) if x < 5 => println!("less than five: {}", x),Some(x) => println!("{}", x),None => (),
}
}

注意：不要为元组元素取名。

enum animal{bird(name:String,weight:i32)
}
元组元素没有名enum animal{bird(String,i32)
}

元组就用()匹配，结构体就用{}匹配，而且结构体还要指定匹配变量所属的成员，因为匹配的变量也是要定义的变量。

enum animal{bird(f64,u8),mammal{name:String,weight:f64}
}
fn main(){let animals=[animal::bird(10.0,2),animal::mammal{name:"tiger".to_string(),weight:100.0}];for ani in &animals{match ani{animal::bird(w,f)=>println!("bird has {} foods,it's weight is {}",f,w),animal::mammal{name:n,weight:w}=>println!("{} weighs in at {}kg",n,w)}}
}

模式匹配变量定义

右边的数据是什么类型，左边用于匹配的变量的也要定义出完整的类型，不能只定义变量：

结构体模式匹配

struct Point {x: i32,y: i32,
}fn main() {let p = Point { x: 0, y: 7 };//{a,b}=p    //类型不匹配let Point { x: a, y: b } = p;assert_eq!(0, a);assert_eq!(7, b);
}

元组模式匹配

fn main() {let cat = ("Furry McFurson", 3.5);let (name,age):(&str,f64) = cat;println!("{} is {} years old.", name, age);
}

注意类型的声明方式，和结构体不同，不再括号内。

数组的模式匹配（静态和动态）

fn array_and_vec() -> ([i32; 4], Vec) {let a = [10, 20, 30, 40]; // a plain arraylet v = vec![a[0],a[1],a[2],a[3]];// TODO: declare your vector here with the macro for vectors(a, v)
}#[cfg(test)]
mod tests {use super::*;#[test]fn test_array_and_vec_similarity() {let (a, v) = array_and_vec();assert_eq!(a, v[..]);}
}

枚举值比较

枚举值不能进行比较，但是：

Rust 标准库中提供了一个非常实用的宏：matches!，它可以将一个表达式跟模式进行匹配，然后返回匹配的结果 true or false。

enum MyEnum {Foo,Bar
}fn main() {let mut count = 0;let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];for e in v {if matches!(e,MyEnum::Foo) { // 修复错误，只能修改本行代码count += 1;}}assert_eq!(count, 2);
}

?模式匹配的注意事项

1，成功返回枚举中的值，失败就直接返回Err()或者None了，不要一位这个部分的代码还会继续执行；

2，因为?匹配有返回值，返回值不是Result或者Option或者为()的函数不能用?，比如main函数:

指针

trait--impl

Rust中Self（大写S）和self（小写s）都是关键字，大写S的是类型名，小写s的是变量名。

impl就是用来实现结构体的一些其他特征(trait)功能的，比如函数

格式：

impl 自定义的特征名 结构体名{}

函数参数用self,用来在函数内访问结构体的元素

self和Self的使用

先trait定义某些特征

再为某些类型（如结构体）实现（impl）这个特征

trait Property{fn area(self:Self)->f64;
}struct Circle{radius:f64
}
impl Property for Circle{fn area(self:Self)->f64{std::f64::consts::PI*self.radius*self.radius}
}
fn main(){let c:Circle=Circle{radius:10.0};println!("area={}",c.area());
}//2
trait Property{fn area(self:Self)->f64;
}struct Circle{radius:f64
}
impl Property for Circle{fn area(self)->f64{       //参数std::f64::consts::PI*self.radius*self.radius}
}
fn main(){let c:Circle=Circle{radius:10.0};println!("area={}",c.area());
}

使用impl 给某个类型定义某个特征时，只能定义特征中的函数，特征中没有的需要另外impl

trait Property{fn area(self:Self)->f64;
}struct Circle{radius:f64
}
impl Property for Circle{fn area(&self)->f64{std::f64::consts::PI*self.radius*self.radius}
//增加定义以下函数fn dis_play(t:&Self){println!("{}",t.radius);}
}

无需声明特性，直接impl内在方法

struct Circle{radius:f64
}
impl Circle{fn area(self)->f64{std::f64::consts::PI*self.radius*self.radius}
}
fn main(){let c:Circle=Circle{radius:10.0};println!("area={}",c.area());
}

为特性（trait）增加特性（trait）

特性可以声明的同时完成定义

pub trait Summary {fn summarize(&self) -> String {String::from("(Read more...)")}
}

静态方法

第一个参数不是self参数的方法称作“静态方法”。

静态方法的访问---类型名：：函数名

静态方法可以通过Type::FunctionName()的方式调用。需要注意的是，即便我们的第一个参数是Self相关类型，只要变量名字不是self，就不能使用小数点的语法调用函数。

特征作为参数

借用指针和借用

rust中的引用应该只称号为借用指针，因为借用指针本身不能自动获取值，除非输出。

fn main() {let mut x=100;let mut re:&mut i32=&mut x;println!("{}--{}--{}--{}",*re+1,*re-1,*re * *re,*re/20);match re{100=>println!("{re}"),_=>println!("None"),}
}

引用就是借用，借用就是引用。

但是rust中的称为借用指针更加准确

rust引用的本质

同C++,本质上也是一个指针

开辟地址--》保存变量地址

注意：rust中没有取地址的说法，&表示取变量的引用。

引用---借组--租房子案列

引用的类型

//引用和引用对象都是不可变的
fn main() {let str=String::from("come");let bw=&str;bw.push_str(" baby");//不可变println!("{str}");
}//引用mutable
fn main() {let mut str=String::from("come");let bw=&str;bw.push_str(" baby");//不可改变println!("{str}");
}//引用为mutable,引用对象也一定要是mutable
fn main() {let str=String::from("come");let bw=&mut str;bw.push_str(" baby");//可变println!("{str}");
}

可变引用与不可变引用相比除了权限不同以外，可变引用不允许多重引用，但不可变引用可以：

Rust 对可变引用的这种设计主要出于对并发状态下发生数据访问碰撞的考虑，在编译阶段就避免了这种事情的发生。

由于发生数据访问碰撞的必要条件之一是数据被至少一个使用者写且同时被至少一个其他使用者读或写，所以在一个值被可变引用引用时不允许再次被任何引用。

借用指针占16个字节

引用的对象

前mut是自己的权限，后mut是自己对引用对象的权限

fn main() {let mut str=String::from("come");let bw=&mut str;   //引用的对象不可以改变let mut str2=String::from("baby");bw=&mut str2;println!("{str}");
}fn main() {let mut str=String::from("come");let mut bw=&mut str;  //引用的对象可以改变let mut str2=String::from("baby");bw=&mut str2;println!("{str}");
}

悬空引用

引用对象的生命周期提前结束

rust引用和C++引用

1，rust引用传参，需要引用符。

2，rust引用，&在等号右侧。

借用对象被冻结

所谓的被冻结不是真的冻结，只是变量被引用之后，引用之后的的位置，引用和变量不能交替使用，只能使用一个。

fn main() {let mut x=1_i32;let _rf=&mut x;x=2i32;println!("{}",x);//运行成功
}fn main() {let mut x=1_i32;let _rf=&mut x;x=2i32;println!("{}",_rf);//运行失败
}

引用的规则

1，不能同时借用。

let mut x=100;
let re1=&mut x;
let re2=&mut x;

2，第一个借用，用完之后就可以第二个借用，之前的借用就释放了。

fn main(){let mut x=100;let re=&mut x;println!("1--{}",re);*re=200;println!("2--:{}",re);let re2=&mut x;println!("2--:{}",re);
}

3,不能跨过之后的引用去使用之前的引用，因为只要之后有引用出现，之前的就释放了。

//success
fn main() {let mut s = String::from("hello, ");let r1 = &mut s;let r2 = &mut s;// 在下面增加一行代码人为制造编译错误：cannot borrow `s` as mutable more than once at a time// 你不能同时使用 r1 和 r2r2.push_str("word");
}//failure
fn main() {let mut s = String::from("hello, ");let r1 = &mut s;let r2 = &mut s;// 在下面增加一行代码人为制造编译错误：cannot borrow `s` as mutable more than once at a time// 你不能同时使用 r1 和 r2r1.push_str("word");
}

可变借用和不可变借用的三条规则

1，不可变借用可多个；

2，可变借用只能连续一个；

3，可变借用和不可变借用不能同时出现；

4，发生借用之后，被借用对象不能马上修改，需进行其他操作之后才能修改；

fn main() {let mut x=100;let y=&x;println!("{y}");//第一次借用被使用之后就可以修改x=200;let y=&x;println!("{y}");println!("Hello, world!");
}fn main() {let mut x=100;let y=&x;println!("usdvc");x=200;let y=&x;println!("{y}");println!("Hello, world!");
}

ref

    // 赋值语句中左边的 `ref` 关键字等价于右边的 `&` 符号。let ref ref_c1 = c;let ref_c2 = &c;

ref关键字在想要直接利用变量生成引用变量的时候有用：

#[derive(Debug)]
struct Point {x: i32,y: i32,
}fn main() {let y: Option = Some(Point { x: 100, y: 200 });match y {Some(ref p) => println!("Co-ordinates are {},{} ", p.x, p.y),_ => println!("no match"),}println!("{:?}",y); // Fix without deleting this line.
}

宏

println!()

输出变量的两种方式：

1，println!("{}",var)

2，println!("{var}")

最简单的标准输出是使用println！宏来完成。请大家一定注意println后面的感叹号，它代表这是一个宏，而不是一个函数。

这里之所以使用宏，而不是函数，是因为标准输出宏可以完成编译期格式检查，更加安全。

打印变量地址：

fn main(){let x=100;let re=&x;println!("x addr:{:p}",re);println!("re addr:{:p}",&re);
}

rust内存

非法内存访问

在许多低级语言中，不会进行此类检查，并且当您提供不正确的索引时，可以访问无效内存。Rust 通过立即退出而不是允许内存访问并继续来保护您免受此类错误的侵害。

堆栈

哪些数据存储在堆中，哪些数据存储在栈中

默认情况下，长度较大的数据存放在堆中，且采用移动的方式进行数据交互。

"基本数据"类型的数据，不需要存储到堆中，仅在栈中的数据的"移动"方式是直接复制。

所有权----Rust内存管理方式

值的所有权

所有权--就是值在某一个时刻属于哪一个变量(指的是值的所有权)

Rust 使用第三种方法：内存通过所有权系统进行管理，该系统具有一组编译器检查的规则。如果违反任何规则，程序将无法编译。所有权的任何功能都不会减慢程序在运行时的速度。

所有权规则

在通过说明这些规则的示例时，请记住这些规则：

• Rust 中的每个值都有一个所有者。
• 一次只能有一个所有者。
• 当所有者超出范围时，该值将被删除。

一个变量----》一个地址--》一个值

fn main() {let mut str=String::from("baby.");let str1=str;//因为一个值只能属于一个变量，所以此时str的值被move到str1了println!("{}",str);
}fn main() {let mut str=String::from("baby.");let str1=str;//因为一个值只能属于一个变量，所以此时str的值被move到str1了str=str1;// 现在str1被move了println!("{}",str);
}fn main() {let mut str=String::from("baby.");let str1=str;//因为一个值只能属于一个变量，所以此时str的值被move到str1了println!("str1={}",str1);str=String::from("get again");println!("str={}",str);
}

注意：

虽然变量的值被Move了，但是变量还存在，以给它赋值继续使用。

如何实现值复制而不是move---clone()

需要手动调用clone()方法来完成

fn main() {let mut str=String::from("baby.");let str1=str.clone();println!("str1={}",str1);println!("str={}",str);
}

哪些会产生值的所有权移动

赋值语句、函数调用、函数返回等

 移动和复制

move-->剪切，粘贴

操作完成后，原来的数据就不存在了，被移动到了新的地方。

复制-->复制，粘贴

基本数据类型默认是copy,其他的默认是move

基本数据类型不会发送move

"基本数据"类型的数据，不需要存储到堆中，仅在栈中的数据的"移动"方式是直接复制，这不会花费更长的时间或更多的存储空间。"基本数据"类型有这些：

• 所有整数类型，例如 i32 、 u32 、 i64 等。
• 布尔类型 bool，值为 true 或 false 。
• 所有浮点类型，f32 和 f64。
• 字符类型 char。
• 仅包含以上类型数据的元组（Tuples）。

更多细节看---链接

变量的所有权

被当作函数返回值的变量所有权将会被移动出函数并返回到调用函数的地方，而不会直接被无效释放。

也就是返回的变量和接收的变量不仅含有相同值，还含有相同地址。

变量作为参数也是一样的道理。

fn get_str()->String{let str=String::from("get string");println!("{}",&str);str
}
fn main() {let mut str=get_str();let str1=str;//因为一个值只能属于一个变量，所以此时str的值和内存被move到str1了str=String::from("new String");//这里已经是重新分配内存给str,str的内存已经不是之前的内存了println!("str1={}",str1);println!("str={}",str);println!("str1={}",str1);
}

move只是相对于存储在栈上的复杂的数据类型来说，存储在栈上的简单数据类型没有move.

因为栈上的数据和内存操作都是有顺序的，不会产生内存泄漏之类的情况，而堆内存和数据没有访问原则，只要开辟了，就可以随机访问，rust为了解决安全问题，需要堆上的内存和数据进行move.

栈：

fn main(){let mut x=100;println!("{:p}",&x);x=get_back(x);println!("{:p}",&x);
}
fn get_back(x:i32)->i32{println!("{:p}",&x);x
}

数组的所有权

取决于数组中存储的数据的类型

move类型数据赋值和引用赋值

move类型数据赋值定会产生所有权move，但是如果利用引用给其他变量赋值呢。

fn main() {let s=String::from("baby");let s1=&s;//取s栈上的地址let ss=*s1;//注意，不是对s1解引用，而是对s1的值解引用，也就是将堆上的数据赋给ss
}

变量赋值：是将变量堆上的数据赋值，

变量的地址解引用赋值：变量的地址解引用所得的还是变量堆上的数据，还是把这个堆上的数据赋值。

如果不move，本质上都会产生两次析构。

结论：

move类型数据，无论变量赋值还是解引用赋值都会move。

而且rust编译器不允许使用move类型的引用解引用赋值。

以上代码结果：

结构体存储在哪里

结构体体变量也是变量，存储在栈上，只是它的内部成员存储在堆上。

struct User{name:String,age:u8,
}
fn main(){let mut u1:User=User{name:String::from("xiong"),age:30};println!("{:p}",&u1);u1=get_back(u1);println!("{:p}",&u1);
}
fn get_back(x:User)->User{println!("{:p}",&x);x
}

#[derive(Debug)]
struct User{name:String,age:u8,
}
fn main(){let mut u1:User=User{name:String::from("xiong"),age:30};println!("{:p}",&u1.name);u1=get_back(u1);println!("{:p}",&u1.name);
}
fn get_back(x:User)->User{println!("{:p}",&x.name);x
}

 结构体中成员地址也变了，说明move本质上是栈中数据的copy.

所谓的内存Move不是栈上的，而是堆上内存的所有权的移交

赋值和参数传递都会导致源对象失效，但是有一种特别情况----结构体部分成员移动，但是其他成员还可以被访问---》就是在结构体内部初始化：

#[derive(Debug)]
struct User{name:String,age:u8,
}
fn main(){let mut u1:User=User{name:String::from("xiong"),age:30};//println!("{:p}",&u1.name);//u1=get_back(u1);//println!("{:p}",&u1.name);let u2:User=User{..u1};//let u2:User=u1;println!("{}",u1.age);
}
fn get_back(x:User)->User{println!("{:p}",&x.name);x
}

move本质

所有的赋值，传参本质上都是复制，只是涉及堆数据和内存复制时，源对象会失效

mutable和immutable的使用

mut是用来修饰变量的，不是用来修饰类型的，不能单独加在类型的前面，只能配合&等这些符号。

fn main() {let mut vec0 = Vec::new();let mut vec1 = fill_vec(vec0.clone());// Do not change the following line!println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);vec1.push(88);println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}这样的mut修饰的类型是不允许的
fn fill_vec(vec:mut Vec) -> Vec {let mut vec = vec;vec.push(22);vec.push(44);vec.push(66);vec
}这样是可以的
fn fill_vec(mut vec:Vec) -> Vec {let mut vec = vec;vec.push(22);vec.push(44);vec.push(66);vec
}

rust的内存需要程序员管理吗

Rust的主要设计目标之一，是在不用自动垃圾回收机制的前提下避免产生segfault。

变量的生命周期

怎么让变量提前结束生命

参数类型一定要是T，而不是&T或者其他引用类型。函数体本身其实根本不重要，重要的是把变量的所有权move进入这个函数体中，函数调用结束的时候该变量的生命周期结束，变量的析构函数会自动调用，管理的内存空间也会自然释放。这个过程完全符合前面讲的生命周期、move语义，无须编译器做特殊处理。事实上，我们完全可以自己写一个类似的函数来实现同样的效果，只要保证参数传递是move语义即可。

自定义：

pub fn drop(_x:T){}fn main() {let num1:Num=Num(1);drop(num1);println!("exit");
}

下划线作为变量

如果你用下划线来绑定一个变量，那么这个变量会当场执行析构，而不是等到当前语句块结束的时候再执行。下划线是特殊符号，不是普通标识符。千万不要用下划线来绑定这个变量。

构造函数和析构函数

Rust中没有统一的“构造函数”这个语法，对象的构造是直接对每个成员进行初始化完成的，我们一般将对象的创建封装到普通静态函数中。

析构函数

use std::ops::Drop;struct Num(i32);
impl Drop for Num{fn drop(&mut self){println!("{}",self.0);}
}fn main() {let num1:Num=Num(1);{let num2:Num=Num(2);}println!("exit");
}

结束变量生命的方法：

标准库函数：std::mem::drop()函数，

标准库中特征中自动调用的函数：std::ops::Drop::drop()方法。

String

为什么字面值常量不可以修改，String类型却可以修改。

字面值直接存储在文件中，没有在堆上开辟内存。

String如何存储的

怎么输出String中的字符

切片或者chars()函数

怎么统计字符串的长度

一般：len()，len()是以字节计数字符数量。

汉字或者其他：（因为汉字使用UTF-8编码，每个字符3个字节）

let s = "hello你好";
let len = s.chars().count();

String函数

String和&str的转换

String-->&str:

1，&String就行，编译器自动转&String为&str

2，as_str()

fn main(){let mut ch=String::from("汉字");println!("{}",std::mem::size_of_val(ch.as_str()));
}

&str->String:

to_string()

String和&String都会自动转为&str

String创建的方法

1,
let s=String::from(""hello,word!);2,
fn main() {let mut s = String::new();s.push_str("hello");// some bytes, in a vectorlet v = vec![104, 101, 108, 108, 111];// Turn a bytes vector into a String// We know these bytes are valid, so we'll use `unwrap()`.let s1 = String::from_utf8(v).unwrap();assert_eq!(s, s1);println!("Success!")
}3,
fn main() {let story = String::from("Rust By Practice");// Prevent automatically dropping the String's datalet mut story = mem::ManuallyDrop::new(story);let ptr = story.as_mut_ptr();let len = story.len();let capacity = story.capacity();// story has nineteen bytesassert_eq!(16, len);// We can re-build a String out of ptr, len, and capacity. This is all// unsafe because we are responsible for making sure the components are// valid:let s = unsafe { String::from_raw_parts(ptr, len, capacity) };assert_eq!(*story, s);println!("Success!")
}

字符和字符串

字符是unicode编码---4个字节。

字符串UTF-8编码---1...4个字节。

字符串索引

切片和get()

pub fn capitalize_first(input: &str) -> String {let mut c = input.chars();match c.next() {None => String::new(),Some(first) => {let mut result=first.to_uppercase().to_string();if let Some(input)=input.get(1..) {result.push_str(input);}result}}
}

切片

就是部分引用

引用没有所有权，所以切片也没有

变量被引用(切片)的时候，暂时不能使用。

fn main(){let mut s=String::from("slice");let slice_s=&s[..3];s.push_str(" is slice");//切片之后，使用变量，不可println!("{}",slice_s);
}

切片之后进行其他操作之后，变量才可以使用。

fn main(){let mut s=String::from("slice");let slice_s=&s[..3];println!("{}",slice_s);//其他操作s.push_str(" is slice");println!("{s}");
}

for j in 0..v.len(){println!("{}",v[j]);}for i in 0..5{}

字符串切片

    let ch=String::from("汉字");let re=&ch[..3];println!("{re}");字符串切片索引以字节为单位

数组切片：

    let a=['汉','字'];//let a_re=&a[0..3];let a_re:&[char]=&a[..1];println!("{:?}",a_re);数组切片索引以下标为单位

切片数据存储位置

切片变量本质上一个指针，存储在栈上，指向堆上或者栈上的数据

切片的实质

let arr = [1, 2, 3, 4, 5];

let s3: &[i32] = &arr[1..3];

建立一个指针s3，指向一个数组，这个数组存储i32类型数据。

包，板条箱，模块

cargo new 项目工程名

什么是包：

每一个文件都是独立的二进制包，

包(文件)的存储形式

以树的形式存储

树根--main.rs和lib.rs

模块

外部模块就是文件名

引用外部模块

mod 文件名；

模块的引用不能在模块定义的内部引用

mod my{pub mod B;//这样找不到
} 
fn main(){my::B::get_mod_name();
}

模块引用的位置同样没有要求

fn main(){B::get_mod_name();
}
mod B;

模块包含子模块

src包含B.rs,C.rs

B模块包含C模块

模块引用的路径

main文件引用同级目录下的模块--》可行

 其他文件引用同级目录模块--------》不可行

需创建与本模块同名的目录，让后把子模块放入这个同名目录中

（自己的子模块要放入自己的目录中）

（要求在src下创建B目录，把子模块加入B目录中，或者在B目录中再创建C目录，把代码加入mod.rs模块中。）

main文件引用非同级目录下模块---》不可行

 src就是crate模块的目录，

自己的子模块需要放入自己的目录中

模块pub

Rust 出于安全的考虑，默认情况下，所有的类型都是私有化的，包括函数、方法、结构体、枚举、常量，是的，就连模块本身也是私有化的。

1，文件的第一级模块对本文件public，第二级之后的private;

2，父模块完全无法访问子模块中的私有项，但是子模块却可以访问父模块；

3，父模块可以访问子模块的共有项；

mod Father{//pub use Son::son_name as s_name;pub use self::Son::son_name as s_name;mod Son{pub fn son_name(){println!("My name is sun");}}
}
fn main() {Father::s_name();
}

4，同结构体一样，模块pub，不代表模块内的成员就pub，如果需要外部访问，也需要pub;

5，枚举只要枚举名pub,成员就pub；

6，文件的第一级mod也属于本文件mod的子mod,也可以通过super引用文件内的其他数据类型和函数。

pub enum Command {Uppercase,Trim,Append(usize),
}mod my_module {use super::Command;
}

文件存储原理分析

箱（Crate）

"箱"是二进制程序文件或者库文件，存在于"包"中。【crate就是文件】

"箱"是树状结构的，它的树根是编译器开始运行时编译的源文件所编译的程序。

注意："二进制程序文件"不一定是"二进制可执行文件"，只能确定是是包含目标机器语言的文件，文件格式随编译环境的不同而不同。

包（Package）

当我们使用 Cargo 执行 new 命令创建 Rust 工程时，工程目录下会建立一个 Cargo.toml 文件。工程的实质就是一个包，包必须由一个 Cargo.toml 文件来管理，该文件描述了包的基本信息以及依赖项。

一个包最多包含一个库"箱"，可以包含任意数量的二进制"箱"，但是至少包含一个"箱"（不管是库还是二进制"箱"）。

当使用 cargo new 命令创建完包之后，src 目录下会生成一个 main.rs 源文件，Cargo 默认这个文件为二进制箱的根，编译之后的二进制箱将与包名相同。

为什么main可以引用同级目录模块，不可以引用其他目录模块？
 

当调用模块的函数时，需要指定完整的路径。

use 指定路径

路径可以采用两种形式：

• 绝对路径从板条箱根目录crate开始，方法是使用板条箱名称（对于来自外部板条箱的代码）或文字（对于当前板条箱中的代码）。
• 相对路径从当前模块开始，并在当前模块中使用 、 或标识符。self super

绝对路径和相对路径后跟一个或多个标识符，以双冒号 :: 分隔。

exp:

绝对：use carte::mod1::mod2::结构体名/函数名/枚举名/*;

相对：use 【默认当前模块(省略)下的】mod1::mod2::结构体名/函数名/枚举名/*;

为什么use可以用crate开头，表示绝对路径

一个文件就是一个模块，而main.rs和lib.rs是文件树根。

main.rs或者lib.rs所形成的模块就是crate,也就是crate这个模块就是根模块。

super

super前面可以使用use，也可以不使用

//B.rs
mod external{pub mod B_name{pub fn get_name(){println!("I am external B");}}
}pub use external::B_name;//main.rs
mod B;
fn main(){B::B_name::get_name();
}

use引入的模块的类型

1，std

2，我们自定义的模块

3，第三方模块 

4，从其他注册服务引入依赖包

详情连接

use使用外部包-----如同c++导入头文件

引入再导出

use crate::front_of_house::hosting;-----在本文件属于私有；

pub use crate::front_of_house::hosting;----到处，变为公有

修改rust下载源

cd ~/.cargo

创建config文件

粘贴一下源：

[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
replace-with = 'ustc'
[source.ustc]
# registry = "https://mirrors.ustc.edu.cn/crates.io-index"
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"
[http]
check-revoke = false

  保存

cargo buiild

use嵌套

use std::{f64::consts::PI,io::{Read,Write}};
fn main(){}

use枚举

利用use声明使用枚举中的值之后，就可以直接利用值进行实例定义，而不需要枚举枚举名。

#[derive(Debug)]
enum book
{nature,education,science,
}
use book::{nature,education,science};
fn main(){let na:book=nature;let ed:book=education;let sc:book=science;println!("{:?}",na);println!("{:?}",ed);println!("{:?}",sc);
}

use引入函数，使用函数名就可以，不用加()

use可以引用模块，特征，函数，枚举，结构体等等

 权限

 mod中struct和enum

struct为pub,成员还是private,

enum为pub,成员值就也是pub

泛型

泛型参数可以有多个：

// 修改以下结构体让代码工作
struct Point {x: T,y: W
}fn main() {// 不要修改这行代码！let p = Point{x: 5, y : "hello".to_string()};
}

数组作为参数

fn main(){let a=[1,2,3,4,5];display(&a);
}
fn display(arr:&[i32]){for i in arr{println!("{i}");}
}

数组地址(引用)和数组名作为参数

链接

泛型参数隐式和显示指定

// 填空
struct A;          // 具体的类型 `A`.
struct S(A);       // 具体的类型 `S`.
struct SGen(T); // 泛型 `SGen`.fn reg_fn(_s: S) {}fn gen_spec_t(_s: SGen) {}fn gen_spec_i32(_s: SGen) {}fn generic(_s: SGen) {}fn main() {// 使用非泛型函数reg_fn(S(A));          // 具体的类型gen_spec_t(SGen(A));   // 隐式地指定类型参数  `A`.gen_spec_i32(SGen(32)); // 隐式地指定类型参数`i32`.// 显式地指定类型参数 `char`generic::(SGen('c'));// 隐式地指定类型参数 `char`.generic(SGen('c'));
}

use std::ops::Add;
// 实现下面的泛型函数 sum
fn sum>(x:T,y:T)->T{x+y
}fn main() {assert_eq!(5, sum(2i8, 3i8));assert_eq!(50, sum(20, 30));assert_eq!(2.46, sum(1.23, 1.23));
}

fn main(){let a:[i32;5]=[1,2,3,4,5];display(a);
}
fn display(arr:[T;N]){for i in 0..N{println!("{}",arr[i]);}
}

fn print_array(arr:[T;N]) {println!("{:?}", arr);
}
fn main() {let arr = [1, 2, 3];print_array(arr);let arr = ["hello", "world"];print_array(arr);
}

struct Point {x: T,y: U,
}impl Point {fn mixup(self, other: Point) -> Point {Point {x: self.x,y: other.y,}}
}fn main() {let p1 = Point { x: 5, y: 10 };let p2 = Point { x: "Hello", y: '中'};let p3 = p1.mixup(p2);assert_eq!(p3.x, 5);assert_eq!(p3.y, '中');
}

// 修复错误，让代码工作
struct Point {x: T,y: T,
}impl Point {//这里的方法用来处理i32类型参数的fn distance_from_origin(&self) -> f32 {(self.x.powi(2) + self.y.powi(2)).sqrt()}
}fn main() {let p = Point{x: 5, y: 10};println!("{}",p.distance_from_origin())
}

fn main(){let arr=[1,2,3,4,5];let result=get_largest(&arr);println!("{}",result);
}pub fn get_largest(arr:&[T])->T{let mut largest=arr[0];for &i in arr.iter(){if i>largest{largest=i;}}largest
}1，arr:&[T]---数组地址(引用)作为参数，传递数组首地址，迭代的时候往后迭代某一个元素的地址
2，let mut largest=arr[0]---rust编译器想要move，但是arr是引用，不能Move,所以我们特征约束为T的
类型为实现了Copy特性的类型.
3,
for &i in arr.iter(){}
for i in arr.iter(){}
for &i in arr{}
for i in arr{}
3-1-1,arr是引用，则for i in arr{}中i是&T类型
3-1-2，for &i in arr{}中i是T类型
3-2-1，arr.iter()同arr

fn main(){let arr=["I".to_string(),"am".to_string(),"a".to_string(),"student".to_string()];let result=get_largest(&arr);println!("{}",result);
}//实现1
pub fn get_largest(arr:&[String])->String{let mut largest=arr[0].clone();for i in arr.iter(){if i.len()>largest.len(){largest=i.clone();}}largest
}
//
pub fn get_largest(arr:&[String])->String{let mut largest=arr[0].clone();for i in arr.iter(){if (*i).len()>largest.len(){largest=(*i).to_string().clone();}}largest
}1,*i.len()---.的优先级高，所以先计算.；
2，i是String类型的引用，解引用后获得的值变为&str了

fn main(){let arr=["I".to_string(),"am".to_string(),"a".to_string(),"student".to_string()];let re:&String=&arr[0];let lf=(*re).to_string();println!("{}",lf);println!("{}",arr[0]);
}

trait Add{pub fn add(&self)->T{self.x+self.y}
}

pub trait GetAdd{fn add(&self)->i32;fn get_name(&self){println!("babay");}
}
pub trait GetMultiple{fn multiple(&self)->i32;
}struct Point{x:i32,y:i32
}struct Ractangle{lenght:i32,width:i32
}
impl GetAdd for Point{fn add(&self)->i32{self.x+self.y}
}
impl GetMultiple for Point{fn multiple(&self)->i32{self.x*self.y}
}
impl GetAdd for Ractangle{fn add(&self)->i32{self.lenght+self.width}
}
impl GetMultiple for Ractangle{fn multiple(&self)->i32{self.width*self.width}
}fn main(){let p1:Point=Point{x:1,y:2};let r1:Ractangle=Ractangle{lenght:100,width:200};display_add(&p1);display_add(&r1);let p2:Point=Point{x:2,y:3};get_distance(&p1,&p2);
}pub fn display_add(arg:&impl GetAdd){println!("Point_add={}",arg.add());
}//特征参数，使用结构体成员
pub fn get_distance(p1:&impl GetAdd,p2:&impl GetAdd){println!("The distance between p1 to p2 is {}",((p1.x-p2.x).powi(2)+(p1.y-p2.y).powi(2)).sqrt());
}

use std::ops::Add;
fn add>(a:T,b:T)->T{a+b
}fn main() {assert_eq!(5, add(2u8, 3u8));assert_eq!(6.0, add(1.0, 5.0));println!("Success!")
}

#[derive(Debug)]
struct Point> { //限制类型T必须实现了Add特征，否则无法进行+操作。x: T,y: T,
}impl> Add for Point {type Output = Point;fn add(self, p: Point) -> Point {Point{x: self.x + p.x,y: self.y + p.y,}}
}

use std::ops::Mul;// 实现 fn multiply 方法
// 如上所述，`+` 需要 `T` 类型实现 `std::ops::Add` 特征
// 那么, `*` 运算符需要实现什么特征呢? 你可以在这里找到答案: https://doc.rust-lang.org/core/ops/
fn multiply>(a:T,b:T)->T{a*b
}fn main() {assert_eq!(6, multiply(2u8, 3u8));assert_eq!(5.0, multiply(1.0, 5.0));println!("Success!")
}

use std::ops;struct Foo;
struct Bar;
#[derive(PartialEq,Debug)]
struct FooBar;
#[derive(PartialEq,Debug)]
struct BarFoo;// 下面的代码实现了自定义类型的相加： Foo + Bar = FooBar
impl ops::Add for Bar {type Output = FooBar;fn add(self, _rhs: Foo) -> FooBar {FooBar}
}impl ops::Sub for Foo {type Output = BarFoo;fn sub(self, _rhs: Bar) -> BarFoo {BarFoo}
}fn main() {assert_eq!(Foo + Bar, FooBar);assert_eq!(Foo - Bar, BarFoo);println!("Success!")
}我们要实现的是Foo这个对象的+，—；
符号之前的是符号的对象，符号之后的是符号对象相加的对象；
所以对符号进行特征约束实现的应该是Foo,而不是Bar
符号之前的对象不是随便的，它代表实现了这个符号特征的对象。assert_eq!();要进行相等比较和Debug,对于结构体，枚举，需要derive实现相等特征和Debug特征：
#[derive(PartialEq,Debug)]

use std::ops::Mul;
#[derive(PartialEq,Debug)]
struct Point>{x:T,y:T
}impl> Mul> for Point{type Output=Point;fn mul(self,p:Point)->Point{Point{x:self.x*p.x,y:self.y*p.y}}
}
fn main() {let p1:Point=Point{x:1,y:2};let p2:Point=Point{x:10,y:20};let p3:Point=p1*p2;println!("{:?}",p3);println!("Success!")
}

fn main() {assert_eq!(sum(1, 2), 3);assert_eq!(sum(1.0, 2.0), 3.0);
}fn sum>(x: T, y: T) -> T {x + y
}fn main() {assert_eq!(sum(1, 2), 3);assert_eq!(sum(1.0, 2.0), 3.0);
}fn sum(x: T, y: T) -> T
whereT: std::ops::Add
,
{x + y
}

trait Dis {fn display(&self);
}#[derive(Debug)]
struct Number{n:i32
}impl Dis for Number{fn display(&self){println!("{}",self.n);}}
#[derive(Debug)]
struct Name{n:String
}impl Dis for Name{fn display(&self){println!("{}",self.n);}
}fn dis_info(inst:Box<&dyn Dis>){inst.display();
}
fn dis_info1(inst:&dyn Dis){inst.display();
}fn main() {let num:Number=Number{n:100};let nam:Name=Name{n:"lili".to_string()};dis_info(Box::new(&num));dis_info1(&num);dis_info(Box::new(&nam));dis_info1(&nam);
}

#[derive(Debug,PartialEq)]
struct Animal{name:String,habitat:String,weight:f32
}
fn main() {let sparrow:Animal=Animal{name:String::from("sparrow"),habitat:String::from("sky"),weight:0.25};let parrot:Animal=Animal{name:String::from("parrow"),habitat:"sky".to_string(),weight:0.75};if sparrow==parrot{println!("was same animal");}else {println!("was not same animal");}
}

#[derive(Debug,PartialEq)]
enum Animal{Bird,Fish,Mammal,
}
fn main() {let sparrow:Animal=Animal::Bird;let parrot:Animal=Animal::Bird;let _tiger:Animal=Animal::Mammal;if sparrow==parrot{println!("All was {:?}",sparrow);}
}

#[derive(Debug,PartialEq,PartialOrd)]
struct Animal{name:String,habitat:String,weight:f32
}
fn main() {let sparrow1:Animal=Animal{name:String::from("sparrow"),habitat:String::from("sky"),weight:0.25};let sparrow2:Animal=Animal{name:String::from("sparrow"),habitat:String::from("sky"),weight:0.5};if sparrow1>sparrow2{println!("sparrow1 is more weight");}else if sparrow1

trait Summary {fn summarize(&self) -> String;
}#[derive(Debug)]
struct Post {title: String,author: String,content: String,
}impl Summary for Post {fn summarize(&self) -> String {format!("The author of post {} is {}", self.title, self.author)}
}#[derive(Debug)]
struct Weibo {username: String,content: String,
}impl Summary for Weibo {fn summarize(&self) -> String {format!("{} published a weibo {}", self.username, self.content)}
}
fn main() {let post = Post {title: "Popular Rust".to_string(),author: "Sunface".to_string(),content: "Rust is awesome!".to_string(),};let weibo = Weibo {username: "sunface".to_string(),content: "Weibo seems to be worse than Tweet".to_string(),};summary(&post);summary(&weibo);println!("{:?}", post);println!("{:?}", weibo);
}fn summary(su:&impl Summary){println!("{}",su.summarize());
}

struct Sheep {}
struct Cow {}trait Animal {fn noise(&self) -> String;
}impl Animal for Sheep {fn noise(&self) -> String {"baaaaah!".to_string()}
}impl Animal for Cow {fn noise(&self) -> String {"moooooo!".to_string()}
}// Returns some struct that implements Animal, but we don't know which one at compile time.
// FIX the erros here, you can make a fake random, or you can use trait object
fn random_animal(random_number: f64) -> Box {if random_number < 0.5 {Box::new(Sheep {})} else {Box::new(Cow{})}
}fn main() {let random_number = 0.234;let animal = random_animal(random_number);println!("You've randomly chosen an animal, and it says {}", animal.noise());
}

impl AppendBar for Vec{fn append_bar(mut self)->Self{/*let mut s:Vec=self;s.push("Bar".to_string());s*/self.push("Bar".to_string());self}
}fn is_vec_pop_eq_bar() {let mut foo = vec![String::from("Foo")].append_bar();assert_eq!(foo.pop().unwrap(), String::from("Bar"));assert_eq!(foo.pop().unwrap(), String::from("Foo"));}

let mut v2 = Vec::new();
v2.extend([1, 2, 3]);

fn main() {let mut v:Vec=vec![1,2,3,4,5];for i in &mut v{*i=*i+1;}println!("{:?}",v);
}

fn main() {let arr=[1,2,3,4,5];let mut v:Vec=arr.into();let slice=&mut v[1..4];slice[0]=100;println!("{:?}",v);
}

fn main() {let arr=[1,2,3,4,5];let mut v:Vec=arr.into();let refe=&mut v;(*refe).push(100);println!("{:?}",v);
}

1,创建之前clone()
fn main() {let vec0 = Vec::new();let mut vec1 = fill_vec(vec0.clone());// Do not change the following line!println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);vec1.push(88);println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}clone原数组的数据，然后将之转为mutable
fn fill_vec(vec: Vec) -> Vec {let mut ve = vec;//这里产生所有权的移交ve.push(22);ve.push(44);ve.push(66);ve
}为什么vec不可变,给ve之后却可变呢：
属性是和变量有关，和值无关2,创建之后clone()
fn main() {let mut vec0 = Vec::new();let mut vec1 = fill_vec(&mut vec0);// Do not change the following line!println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);vec1.push(88);println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}fn fill_vec(vec: &mut Vec) -> Vec {let mut ve = vec;ve.push(22);ve.push(44);ve.push(66);(*ve).clone()
}

map.entry("color").or_insert("red");

use std::collections::HashMap;
fn main() {let mut map=HashMap::new();let text="This is a very nice girl.";for word in text.split_whitespace(){let count=map.entry(word).or_insert(0);*count +=1;}println!("{}",map["This"]);
}

use std::collections::HashMap;
fn main() {let mut map=HashMap::new();map.insert("red".to_string(),100);match map.get("red"){Some(t)=>println!("{}",*t),//t就是一个&i32_=>println!("Nothing")}
}

use std::collections::HashMap;
fn main() {let mut map=HashMap::new();map.insert("red".to_string(),100);map.insert("yellow".to_string(),200);map.insert("blue".to_string(),300);for (key,value) in &map{println!("{}--{}",*key,*value);}
}use std::collections::HashMap;
fn main() {let mut map=HashMap::new();map.insert("red".to_string(),100);map.insert("yellow".to_string(),200);map.insert("blue".to_string(),300);for KV in &map{println!("{}--{}",KV.0,KV.1);}
}

use std::collections::HashMap;
fn main() {let mut map=HashMap::new();let text="This is a very nice girl.";for word in text.split_whitespace(){let count=map.entry(word).or_insert(0);*count +=1;}println!("{:?}",map);
}

let mut scores = HashMap::new();scores.insert("Sunface", 98);scores.insert("Daniel", 95);scores.insert("Ashley", 69);scores.insert("Katie", 58);// get returns a Option<&V>let score = scores.get("Sunface");assert_eq!(score, Some(&98));

use std::collections::HashMap;
fn main() {let mut map: HashMap = HashMap::with_capacity(100);map.insert(1, 2);map.insert(3, 4);// 事实上，虽然我们使用了 100 容量来初始化，但是 map 的容量很可能会比 100 更多assert!(map.capacity() >= 100);// 对容量进行收缩，你提供的值仅仅是一个允许的最小值，实际上，Rust 会根据当前存储的数据量进行自动设置，当然，这个值会尽量靠近你提供的值，同时还可能会预留一些调整空间map.shrink_to(50);assert!(map.capacity() >= 50);// 让 Rust  自行调整到一个合适的值，剩余策略同上map.shrink_to_fit();assert!(map.capacity() >= 2);println!("Success!")
}

let numbers: Vec<_> = (0..100u32).collect();

use std::collections::HashMap;
fn main() {let mut map=HashMap::new();for i in 0..10{map.insert(i,i.to_string()+"str");}for i in map.iter(){println!("{:?}",i);}
}

pub trait GetAdd{fn add(&self)->i32;fn get_name(&self){println!("babay");}
}
pub trait GetMultiple{fn multiple(&self)->i32;
}pub struct Point{pub x:i32,pub y:i32
}struct Ractangle{lenght:i32,width:i32
}
impl GetAdd for Point{fn add(&self)->i32{self.x+self.y}
}
impl GetMultiple for Point{fn multiple(&self)->i32{self.x*self.y}
}
impl GetAdd for Ractangle{fn add(&self)->i32{self.lenght+self.width}
}
impl GetMultiple for Ractangle{fn multiple(&self)->i32{self.width*self.width}
}fn main(){let p1:Point=Point{x:1,y:2};let r1:Ractangle=Ractangle{lenght:100,width:200};display_add(&p1);display_add(&r1);let p2:Point=Point{x:2,y:3};get_distance(&p1,&p2);
}pub fn display_add(arg:&impl GetAdd){println!("Point_add={}",arg.add());
}pub fn get_distance(p1:&Point,p2:&Point){println!("The distance between p1 to p2 is {}",(((p1.x-p2.x).pow(2)+(p1.y-p2.y).pow(2))as f64).sqrt());
}

fn main() {let arr=[1,2,3,4,5];let _v:Vec=arr.into();let x=100;let _y:f64=x.into();let s="ssss";let _s1:String=s.into();
}

use std::collections::HashMap;
fn main() {let mut map=HashMap::new();let text="This is a very nice girl.";for word in text.split_whitespace(){let count=map.entry(word).or_insert(0);*count +=1;}println!("{:?}",map);
}

fn main() {let s="come baby";println!("{:^20.4}",s);let num=123456.123456;println!("{:^20.3}",num);
}
//符号可以连用

fn main() {let num=1;println!("number is {:10}",num);
}
//从当前位置往后占位10位，右对齐

fn main() {let x=1;let y=2;let z=3;println!("{:5}",x);//指定宽度位5println!("{:5$}",x);//指定使用下标为5的值为宽度println!("{2:5$}+{1:4$}={0:3$}",z,y,x,2,3,4);println!("{:len$}",100+200,len=10);let s="come baby";println!("{:020}",s);let num=100;println!("{:020}",num);println!("{:+020}",num);//输出+号
}

fn main() {let s="come baby";println!("{:20}",s);let num=100;println!("{:20}",num);
}

fn main() {let s="come baby";//左对齐println!("{:*<20}",s);//右对齐println!("{:*>20}",s);//居中println!("{:*^20}",s);let num=100;println!("{:-<20}",num);println!("{:->20}",num);println!("{:-^20}",num);
}

fn main() {let s="come baby";println!("{:p}",&s);println!("{:p}",s.as_ptr());
}   

fn main() {let s=r"come \*baby";println!("{}",s);
}

fn add_data(s:&mut String)->&mut String{//s的生命周期被赋给了输出的引用s.push_str("add");s
}
fn main(){let mut s=String::from("old data");let re=add_data(&mut s);//注意&mutprintln!("{}",re);
}//这个时候编译器不知道使用哪一个的生命周期赋给返回的引用。
fn main() {let mut s=String::from("come baby");let mut ss=String::from("hello");let re:&String=add_str(&mut s,&mut ss);println!("{}",re);
}
fn add_str(s1:&mut String,s2:&mut String)->&String{s1.push_str(s2);s1
}//指定，让编译器知道就可以
fn main() {let mut s=String::from("come baby");let mut ss=String::from("hello");let re:&String=add_str(&mut s,&mut ss);println!("{}",re);
}
fn add_str<'a>(s1:&'a mut String,s2:&mut String)->&'a String{s1.push_str(s2);s1
}

fn bigger(x1:&i32,x2:&i32)->&i32{if x1>x2{x1}else {x2}
}
fn main() {let r;{let x1=1;let x2=2;r=bigger(&x1,&x2);}//括号有没有都会报错println!("{} is moer bigger.",r);
}

fn bigger<'a>(x1:&'a i32,x2:&'a i32)->&'a i32{if x1>x2{x1}else {x2}
}
fn main() {let r;//{let x1=1;let x2=2;r=bigger(&x1,&x2);//}println!("{} is moer bigger.",r);
}//error
fn bigger<'a>(x1:&'a i32,x2:&'a i32)->&'a i32{if x1>x2{x1}else {x2}
}
fn main() {let r;{let x1=1;let x2=2;r=bigger(&x1,&x2);}//两个参数的生命周期到这结束println!("{} is moer bigger.",r);//返回的引用的生命周期到这，比两个参数都大
}

fn bigger1(x1:i32,x2:i32)->i32{if x1>x2{x1}else{x2}
}
fn main() {let r;{let x1=1;let x2=2;r=bigger1(x1,x2);}println!("{} is moer bigger.",r);
}

fn bigger(x1:i32,x2:&i32)->i32{if x1>*x2{1}else {2}
}
fn main() {let r;{let x1=1;let x2=2;r=bigger(x1,&x2);}println!("{} is moer bigger.",r);
}

fn bigger<'a>(x1:i32,x2:&'a i32)->&'a i32{let num=100;let n=111;if x1>*x2{&n}else {&num}
}
fn main() {let r;{let x1=1;let x2=2;r=bigger(x1,&x2);}println!("{} is moer bigger.",r);
}

fn bigger<'a>(x1:i32,x2:&'a i32)->i32{let num=100;let n=111;if x1>*x2{n}else {num}
}
fn main() {let r;{let x1=1;let x2=2;r=bigger(x1,&x2);}println!("{} is moer bigger.",r);
}

//1
struct Num{n:&i32
}fn main(){let i=100;let n:Num=Num{n:&i};println!("{}",n.n);
}//2
struct Mystr<'a>{s:&'a str
}
fn main() {let s=String::from("come baby");let re=Mystr{s:s.as_str()};println!("{}",re.s);
}
代码分析：
&str是存储在栈上的，as_str时，获取字符串地址存放入结构体的s中      

struct Num<'a>{n:&'a i32
}fn main(){let i=100;let n:Num=Num{n:&i};println!("{}",n.n);
}

fn main() {let x=1;let y=2;let _z=get_str(&x,&y);
}
fn get_str<'a,'b:'a>(x:&'a i32,y:&'b i32)->&'a i32{if *x>*y{x}else {y}
}

use std::fmt::Display;
fn main() {let x="str1";let y="str2";let _z=get_str(&x,&y,100);println!("{_z}");
}
fn get_str<'a,'b:'a,T:Display>(x:&'a str,y:&'b str,w:T)->&'a str{println!("{w}");if *x>*y{x}else {y}
}

#![allow(unused)]
fn main() {
struct Cacher
whereT: Fn(u32) -> u32,
{query: T,value: Option,
}
}T是一种类型，类型是用来定义变量的；
T类型特征约束为实现了闭包特征，所以T定义的变量就是闭包变量，利用这个变量
就可以调用闭包函数

fn main() {let arr=[1,2,3,4];for i in arr{}//隐式for i in arr.into_iter(){}//显示
}

fn main(){let mut values = vec![1, 2, 3];let mut iter=values.into_iter();if let Some(v)=iter.next(){println!("{}",v);}//输出1if let Some(v)=iter.next(){println!("{}",v);}//输出2
}

use std::rc::Rc;
use std::cell::RefCell;
fn main(){let a=Rc::new(RefCell::new("Come here".to_string()));let b=Rc::clone(&a);let c=b.clone();let mut s=(*c).borrow_mut();s.push_str(" baby");println!("{:?}",s);//println!("{:?}",b);//println!("{:?}",c);
}use std::rc::Rc;
use std::cell::RefCell;
fn main(){let a=Rc::new(RefCell::new(100));let b=Rc::clone(&a);let c=b.clone();let mut s=(*c).borrow_mut();*s=200;println!("{}",s);//println!("{:?}",b);//println!("{:?}",c);
}

fn main(){let x=123;let pt:*const i32=std::ptr::null();println!("{:?}",pt);
}

fn main(){let x=123;let pt:*const i32;pt=&x;if pt.is_null(){println!("is null");}else{unsafe{println!("is not null,pt={:?}",pt);}}
}

use std::thread;
use std::time::Duration;
fn main() {let handle=thread::spawn(get_thread);thread::sleep(Duration::from_millis(500));
}
fn get_thread(){for i in 0..10{println!("thread {} was spawned",i);thread::sleep(Duration::from_millis(1));}
}

use std::thread;
use std::time::Duration;
fn main() {let handle=thread::spawn(||{for i in 0..10{println!("thread {} was spawned",i);thread::sleep(Duration::from_millis(1));}});thread::sleep(Duration::from_millis(500));
}

use std::thread;
use std::sync::{Arc,Mutex};
fn main() {let m_arc=Arc::new(Mutex::new(0));let mut v_handle:Vec<_>=Vec::new();for _ in 0..10{let t_arc=Arc::clone(&m_arc);let handle=thread::spawn(move||{let mut m_val=t_arc.lock().unwrap();*m_val+=1;});v_handle.push(handle);}for handle in v_handle.iter_mut(){handle.join().unwrap();//不可行}println!("{:?}",v_handle[0]);println!("{:?}",m_arc);
}

use std::thread;
use std::sync::{Arc,Barrier};
const NUM_THREAD:i32=20;
fn main() {let mut v:Vec<_>=Vec::new();let t_barrier=Arc::new(Barrier::new(NUM_THREAD.try_into().unwrap()));for i in 0..NUM_THREAD{let b=t_barrier.clone();let handle=thread::spawn(move||{println!("{} wait here",i);b.wait();println!("I get out");});v.push(handle);}//thread::sleep(Duration::from_millis(500));for handle in v{handle.join().unwrap();}
}

use std::thread;
use std::sync::Once;
static mut VAL:usize=0;
static INIT:Once=Once::new();
fn main() {let handle1=thread::spawn(||{INIT.call_once(||{unsafe{VAL=1;}})});let handle2=thread::spawn(||{INIT.call_once(||{unsafe{VAL=2;}})});handle1.join().unwrap();handle2.join().unwrap();println!("{}",unsafe{VAL});
}
1，主线程要等待，要不然主线程就会退出
2，static定义的变量，使用时必须在unsafe内

use std::thread;
use std::sync::mpsc;
fn main() {let (sx,rx)=mpsc::channel();let handle1=thread::spawn(move||{sx.send("I send infomation for you").unwrap();});let handle2=thread::spawn(move||{println!("I am sin :{}",rx.recv().unwrap());});handle1.join().unwrap();handle2.join().unwrap();
}
1，send发送什么类型数据，recv返回的就是什么类型的数据

use std::thread;
use std::sync::mpsc;
use std::time::Duration;
fn main() {let (sx,rx)=mpsc::channel();let handle1=thread::spawn(move||{let v:Vec<_>=vec!["I".to_string(),"send".to_string(),"info".to_string(),"you".to_string()];for info in v{sx.send(info).unwrap();thread::sleep(Duration::from_secs(1));}});let handle2=thread::spawn(move||{for info in rx{print!("{}",info);}println!("\n");});handle1.join().unwrap();handle2.join().unwrap();
}
1，为什么不能发送String类型--move,编译器不允许；
2，for循环直接迭代数组，Copy数组的数据返回就行；不要再去使用循环下标，
再通过数组下标直接访问数组数据，这会涉及所有权；
3，for循环迭代数组，Copy数组的值---next(value)4，接收者就是迭代器，迭代获取的值就是接收的数据

use std::thread;
use std::sync::mpsc;
use std::time::Duration;
fn main() {let (tx,rx)=mpsc::channel();let tx1=tx.clone();let handle1=thread::spawn(move||{let v:Vec<_>=vec!["I".to_string(),"am".to_string(),"send1".to_string()];for info in v{tx.send(info).unwrap();thread::sleep(Duration::from_secs(1));}});let handle3=thread::spawn(move||{let v:Vec<_>=vec!["I".to_string(),"am".to_string(),"send2".to_string()];for info in v{tx1.send(info).unwrap();thread::sleep(Duration::from_secs(1));}});let handle2=thread::spawn(move||{for info in rx{print!("{}",info);}println!("");});handle1.join().unwrap();handle2.join().unwrap();handle3.join().unwrap();
}

use std::thread;
use std::sync::mpsc::{self,Sender,Receiver};
use std::time::Duration;
enum Student{Name(String),Age(i32)
}
fn main() {let (tx,rx):(Sender,Receiver)=mpsc::channel();let handle1=thread::spawn(move||{let v:Vec<_>=vec![Student::Name("XiaoMei".to_string()),Student::Age(22)];for info in v{tx.send(info).unwrap();thread::sleep(Duration::from_secs(1));}});let handle2=thread::spawn(move||{for info in rx{match info{Student::Name(n)=>print!("{n} is "),Student::Age(a)=>println!("{a}")}}});handle1.join().unwrap();handle2.join().unwrap();
}
1，如何防止move问题出现------for循环直接迭代数组
2，

use std::sync::Mutex;fn main() {let data = Mutex::new(0);let d1 = data.lock();let d2 = data.lock();
} // d1锁在此处释放
一个还不能释放，一个就尝试获取

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！