前言
学习rust的前提如下：
（1）先把Rust环境装好
（2）把VScode中关于Rust的插件装好
\;\\\;\\\;
目录
- 前言
- 先写一个程序看看
- Rust的基础
- mut可变变量
- let重定义覆盖变量
- 基本数据类型
- 复合类型（）和 [ ]
- 数组
- 字符串&str
- 字符串String
- Rust的Misc
- if
- 循环while和loop和for
- 枚举与结构体
- match
- 所有权
先写一个程序看看
新建一个hello.rs文件
fn main(){
println!("hola,mundo!");
let a=12;
println!("{} is {}","a",a);
let b=1;
println!("{0}={0},{1}={1}",a,b); //如果注释这行，那么b没有被使用，就会报错！（够安全吧）
println!("{{}},}},{{"); //只有括号
let _c=-2;
let _=-3;
}
在VScode中的终端中编译hello.rs生成hello.pdb和hello.exe两个文件，然后再运行hello.exe文件。如果是在windows的console窗口中，就直接输入hello就行了。
注：如果单独输入{，}会出错！！！
没有使用的变量会报错，但是加个下划线做前缀（let _b=1;），表示这个变量特殊处理，不使用也不会报错了！
\;\\\;\\\;
Rust的基础
mut可变变量
普通定义的变量（let a=1;）默认是不可变的，所以不能再赋值（a=2;）—— 改成可变的（let mut a=1;）
fn main(){
let mut a=1;
a=2; //有警告，表示在打印之前被覆盖了！
println!("a={}",a);
}
上面出现warning的原因也是因为变量没有使用，在赋值和定义之间，原本的（变量，值）没有被使用！
- 把变量a都改成_a就没有警告了！
\;\\\;
let重定义覆盖变量
fn main(){
let a=1;
let a=false;
println!("a={}",a);
}
\;\\\;
基本数据类型
fn main(){
let a:f32 = 3.14159;println!("a={}",a);
let a:f64 = 3.14159;println!("a={}",a);
let a:bool=true;println!("a={}",a);
let a:i8 = 12;println!("a={}",a);
let a:u8 = 0b0000_1101;println!("a={}",a);
let a:i16 = 12;println!("a={}",a);
let a:u16 = 0xd;println!("a={}",a);
let a:i32 = 1_24;println!("a={}",a);
let a:u32 = 0xd;println!("a={}",a);
let a:i64 = 12;println!("a={}",a);
let a:u64 = 0xd;println!("a={}",a);
let a:i128 = 12;println!("a={}",a);
let a:u128 = 0xd;println!("a={}",a);
let a:isize = 12;println!("a={}",a);
let a:usize = 0xd;println!("a={}",a);
}
\;\\\;
复合类型（）和 [ ]
类型转换用as i64这种形式
复合类型的使用可以用 .0 .1 .2这种形式
fn main(){
let x0=12u32;
let x1=89;
let x2=x0;
let a:(i64,i64,i64) = (x0 as i64,x1,x2 as i64); //复合类型
let (y0,mut y1,y2)=a;
y1=-1;
println!("y0={},y1={},y2={}",a.0,a.1,a.2);
}
\;\\\;
数组
fn main(){
let a:[i64;6]=[0,1,2,3,4,5];
println!("first={},last={}",a[0],a[a.len()-1]);
}
\;\\\;
字符串&str
Rust字符串类似C语言中的指针
这里的&str不是String，那个是结构体，变量是私有的，只能通过接口去使用它。
简单来说&str是固定长度的数组，而String是动态数组！
fn main(){
let a: &str = "hello,word";
let a="hola,mundo";
let b: &str = a;
println!("{}",b);
}
fn main() {
let a:&str = "Dog";
let b:String = "Cat".to_string();
say(a);
say(&b); //传递引用
println!("a={}",a);
println!("&a={}",&a);
println!("b={}",b);
println!("&b={}",&b);
}
fn say(name: &str) {
println!("Hello, {}!", name);
}
\;\\\;
字符串String
fn main() {
let a = String::from("i think of you a lot");
let b = a.replace("you","the one"); //前面的替换成后面的
println!("a={}",a);
println!("b={}",b);
}
\;\\\;\\\;
Rust的Misc
if
fn main(){
let a=100;
let mut b=0;
//b钳制在0到62之间
if a<0{
b=0;
}
else if a<50{
b+=a;
}
else if a<75{
b=50 + (a-50)/2;
}
else{
b=62;
}
let c = if b>50 { 1} else {-1};
println!("a={},b={},c={}",a,b,c);
}
\;\\\;
循环while和loop和for
fn main(){
let mut a=100;
while a<0 {
a-=1;
}
loop{
let mut b=a;
if b==100{
break;
}
b+=1;
}
for i in -1..10 {
a+=i;
}
println!("a={}",a);
}
\;\\\;
枚举与结构体
使用 #[derive()] 属性时，Rust 编译器会自动生成实现特定 traits 所需的代码，从而简化了手动编写这些代码的过程
#[derive(Debug)]
enum Person {
Student,
Teacher,
Staff,
}
#[derive(Debug)]
struct Master{
Dog:i32,
Fish:i32,
Cat:i32,
}
fn main() {
let a = Person::Teacher;
let b = Master{
Dog:7,
Fish:-7,
Cat:0
};
println!("{:?}", a);
println!("{:#?}",b);
}
match
#[derive(Debug)]
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let a = Coin::Dime;
println!("{}",test(a));
}
fn test(a : Coin)-> i64{
match a{
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter => 25,
}
}
\;\\\;\\\;
所有权
let a=1;
let b=a;
基本数据赋值时，标识符的值会被拷贝一份。
let a = String::from("hello");
let b = a;
字符串赋值时，标识符的值被拷贝，但是实际的字符串还是同一个。因为字符串多了一层，它的标识符的值只是实际字符串的地址而已！
let b = a.clone(); //这样才能真的拷贝一份
\;\\\;
fn main(){
let mut a=1;
println!("[main]a={}",a);
test(&mut a);
println!("[main]a={}",a);
}
fn test(a:&mut i64){ //传入地址
*a=2; //数据被修改了
println!("[test]a={}",a);
}
fn main(){
let a=String::from("hola");
println!("[main]a={}",a);
test(&a);
println!("[main]a={}",a);
}
fn test(a:&String){
println!("[test]a={}",a);
}
\;\\\;\\\;
