rust基础语法知识

清疚 2022-12-31 10:28 276阅读 0赞

### 文章目录 ###

*  一. slice
 *  二. 引用& /借用&mut /悬垂引用 return &s
 *  三. 所有权
 *  四. 结构体 struct /impl
 *  五. 枚举
 *  六. option类型
 *  七. vector类型

# 一. slice #

fn slice_test() { 
    	let s = String::from("hello world");
    	// let h = &s[0..5];
    	// let h = &s[0..=4]; // 0开始占4个位
    	// let h = &s[..=4]; // 不写表示从头
    	let h = &s[..5]; // 不写表示从头
    	let w = &s[6..11]; // 不写表示从头
    	println!("{}//{}//{}", s,h,w);
    
    	let s1 = "hh"; //不可变引用, &"hh"
    
    	let a = [1,2,3,4];
    	let a1 = &a[0..1];
    }

# 二. 引用& /借用&mut /悬垂引用 return &s #

// 引用 &,创建指向值得引用, 但是并不拥有它, 因为不拥有, 当引用离开, 其值指向的作用域不会被丢弃
    fn calculation(s: &String) -> usize { 
    	s.len()
    }
    
    // 借用 &mut, 
    fn modify(s: &mut String) { 
    	s.push_str(", world");
    }
    
    // 悬垂引用, 不可, 返回的是野指针
    fn dangle() -> &String { 
    	let s = String::from("hello");
    	&s //引用不拥有这个对象, 离开后, 对象销毁, 引用返回的指针成了野指针
    }
    
    // 任意给定时间, 要么只能有一个可变引用, 要么多个不可变引用,
    // 有了可变引用, 就不能再用不可变引用
    
    fn main() { 
    	let mut s2 = String::from("hello");	
    
    	let s = &s2;
    	let len = calculation(s);
    	println!("长度是: {:?}", len);
    
    	modify(&mut s2); //借用
    	println!("{:?}", s2);
    
    	let ms = &mut s2; //借用
    	modify(ms); //借用
    	// println!("s = {:?}", s); // 借用之后就不能在使用引用的变量了
    	println!("ms = {:?}", ms);
    	println!("s2 = {:?}", s2);
    
    
    	let r1 = &s2;
    	let r2 = &s2;
    	let r3 = &mut s2;
    	println!("r1 = {:?}", r1);
    	println!("r2 = {:?}", r2);
    	println!("r3 = {:?}", r3); //借用之后就不能在使用引用了, 因为借用会修改本身的值, 引用就不清楚改啥了
    }

# 三. 所有权 #

// 所有权
    fn takes_ownership(some_string:String){ 
    	println!("{:?}", some_string);
    }
    
    
    fn make_copy(i: i32){ 
    	println!("{:?}", i);
    }
    
    fn main() { 
    	let s = String::from("hello"); // 类定义的数据都new到了堆栈里面, 所以s在堆里面
    	takes_ownership(s); // s给了这个函数后, s无法使用
    	// println!("{:?}", s); //err 已经离开了作用域
    
    	let x =5;
    	make_copy(x);
    	println!("{:?}", x);  // x分配到栈上的, 所以可以继续使用, 因为引用时是直接copy
    }

# 四. 结构体 struct /impl #

fn struc_test() { 
    	// slice_test()
    	// 1. 定义结构体
    	#[derive(Debug)]
    	struct User { 
    		name: String,
    		count: String,
    		nonce: u64,
    		active: bool,
    	}
    
    	// 2. 创建
    	let xm = User{ 
    		name: String::from("xiaoming"),
    		count:String::from("99999"),
    		nonce:10000,
    		active:true,
    	};
    	// 3. 修改结构体字段
    	let mut xh = User{ 
    		name: String::from("xiaohuang"),
    		count:String::from("99999"),
    		nonce:10000,
    		active:true,
    	};
    	xh.nonce = 20000;
    
    	// 4. 参数字段简写
    	let name = String::from("xiaoxiao");
    	let count = String::from("8979079");
    	// let xx1 = User{ 
    	// name:name,
    	// count:count,
    	// nonce:123,
    	// active:false,
    	// };
    	let xx2 = User{ 
    		name,
    		count,
    		nonce:123,
    		active:false,
    	};
    	// 5. 从其他结构体创建实例
    	let user2 = User{ 
    		name:String::from("user2"),
    		..xx2
    	}; 
    	println!("{:#?}", user2);
    	// println!("{:?}", xx2); //err 因为user2已经将xx2消耗了
    	// 
    	// 6. 元组结构体
    	// 字段没有名字, 圆括号
    	#[derive(Debug)]
    	struct Point(i32, i32);
    	let a = Point(1,2);
    	let b = Point(2,34);
    	println!("{:?}", a); 
    	println!("{:?}", a.0);
    	
    
    	// 7. 没有任何字段的类单元结构体
    	#[derive(Debug)]
    	struct A{ };
    
    	// 8. 打印结构体
    	println!("{:?}", a); //中间加#表示打印结构性
    }
    
    #[derive(Debug)]
    struct Dog { 
    	name: String,
    	weight: f32,
    	height:f32,
    }
    
    //实现类里面的方法
    impl Dog {   // 每个结构体都可以有多个impl, 每个impl都是对应类的方法
    	fn get_name(&self) -> &str{ 
    		&(self.name[..])
    	}
    	fn get_weight(&self) -> f32{ 
    		self.weight
    	}
    	fn get_height(&self) -> f32{ 
    		self.height
    	}
    
    	fn show(){ 
    		println!("{:?}", "我是你爸爸");
    	}
    	fn show2(&self){ 
    		println!("{:?}", "我是你爸爸");
    	}
    }
    
    fn main() { 
    	// struc_test();
    	let dog = Dog{ 
    		name: String::from("wangcai"),
    		weight:43.5,
    		height:33.6,
    	};
    	println!("{:#?}", dog);
    	println!("{:#?}", dog.get_weight()); //结构体方法
    	Dog::show(); //这是类的通用方法
    	dog.show2(); //这是旺财的方法
    }

# 五. 枚举 #

//1. 类似于C语言的方式
    #[derive(Debug)]
    enum IpAddKind { 
    	V4,
    	V6,
    }
    
    #[derive(Debug)]
    struct IpAddr { 
    	kind: IpAddKind,
    	address:String,
    }
    //2. rust语言定义方式
    #[derive(Debug)]
    enum IpAddr2 { 
    	V4(String),
    	V6(String),
    }
    
    //3. 可以是不同类型
    #[derive(Debug)]
    enum IpAddr3 { 
    	V4(u8,u8,u8,u8),
    	V6(String),
    }
    
    
    
    //4. 经典用法
    #[derive(Debug)]
    enum Message { 
    	Quit,
    	Move{ x:i32, y:i32},
    	Write(String),
    	Change(i32,i32,i32),
    }
    // 等同于下面的结构体
    // struct QuitMessage;
    // struct MoveMessage{ 
    // x:i32,
    // y:i32
    // };
    // struct WriteMessage(String);
    // struct ChangeMessage(i32,i32,i32);
    
    //5. 枚举类型的方法以及match
    impl Message { 
    	fn prin(&self) { 
    		match *self { 
    			Message::Quit => println!("{:?}", "Quit"),
    			Message::Move{ x,y} => println!("x={:?},y={:?}", x,y),
    			Message::Change(a,b,c) => println!("{:?},{:?},{:?}", a,b,c),
    			_ => println!("{:?}", "write")
    			// Message::Write(&s) => println!("{:?}", s);
    		}
    	}
    }
    
    
    fn enum_test() { 
    	let i = IpAddr{ 
    	kind:IpAddKind::V4,
    	address: String::from("127.0.0.1")
    	};
    
    	let i1 = IpAddr2::V4(String::from("127.0.0.1"));
    	println!("{:?}", i1);
    
    	let i3 = IpAddr3::V4(127,0,0,1);
    	let i4 = IpAddr3::V6(String::from("127,0,0,1"));
    	println!("{:?}, {:?}", i3, i4);
    
    	let quit = Message::Quit;
    	quit.prin();
    	let mo = Message::Move{ x:10, y:250};
    	mo.prin();
    	let change = Message::Change(1,2,3);
    	change.prin();
    
    }
    
    fn main() { 
    	enum_test();
    	
    }

# 六. option类型 #

// 1. Option是标准库定义的枚举, 形式:
    // enum Option<T>{ 
    // Some(T),
    // None
    // }
    
    
    fn plus_one(x: Option<i32>) -> Option<i32> { 
    	match x { 
    		None => None,
    		Some(x) => Some(x+1),
    	}
    }
    
    
    fn main() { 
    	// 2. 使用方法
    	let some_number = Some(5);
    	let some_string = Some(String::from("a string"));
    	let absent_number:Option<i32> = None;
    	let x:i32 =5;
    	let y:Option<i32> = Some(15);
    	let mut temp = 0;
    	match y { 
    		Some(i) => { temp = i;},
    		None => { println!("{:?}", "do noting");},
    	}
    	let sum = x+temp;
    	println!("sum = {:?}", sum);
    
    	let result = plus_one(y);
    	match result { 
    		Some(i) => println!("{:?}", i),
    		None => println!("{:?}", "none"),
    	}
    	
    	// 这样做就不需要使用match匹配了
    	if let Some(value) = plus_one(y){  
    		println!("value = {:?}", value);
    	} else{ 
    		println!("{:?}", "none");
    	}
    }

# 七. vector类型 #

fn main() { 
    	// 1. 创建空vector
    	let mut v:Vec<i32> = Vec::new();
    	v.push(1);
    	// 2. 创建包含初始值
    	let v = vec![1,2,3];
    
    	// 3. 丢弃 统统会被丢弃
    	{ 
    		let v1 = vec![2,3,4,5];
    	} // 离开作用域就丢弃了
    	
    	// 4. 读取元素
    	let one:&i32 = &v[0];
    	println!("one = {:?}", *one);
    
    	match v.get(1) {  //推荐方法使用get
    		Some(value) => println!(" v.get(1) {:?}", value),
    		None => println!("{:?}", "none"),
    	}
    
    	// 5. 更新
    	let mut v2:Vec<i32> = Vec::new();
    	v2.push(1);
    	v2.push(2);
    	v2.push(3);
    	v2.push(4);
    
    	// 6. 遍历
    	// 不可变遍历
    	for i in &v2{ 
    		println!("{:?}", i);
    	}
    	// 可变遍历
    	for i in &mut v2 { 
    		*i += 1; //*表示使用这个值
    		println!("{:?}", i);
    	}
    
    
    	
    	// 7. 使用枚举
    	#[derive(Debug)]
    	enum Context { 
    		Text(String),
    		Float(f32),
    		Int(i32),
    	};
    	let c  = vec![
    	Context::Text(String::from("your")),
    	Context::Int(-1),
    	Context::Float(3.1415926)];
    
    	println!("{:?}", c);
    
    	// 8. 补充
    	let mut v = vec![1,2,3,4,5];
    	let first = &v[0]; //不可变引用
    	v.push(6); //使用了可变引用, 在之后就不能使用不可变使用了
    	// println!("first = {:?}", first); //err 不可变引用后使用可变引用就报错
    }