Rust笔记

Rust笔记

---

Rust基本概念

• 在rust中变量默认是不可变的，如果需要定义可变变量需要使用关键字mut进行声明

  fn main() {
      let a = 10; //a变量是一个不可变变量
      let mut b = 10; //b变量是一个可变变量
      println!("{}",b);
      println!("{}", a);
  }
  

• 禁止试改不可变变量的值

  let a = 10;
  a = 45; //error :试图修改不可变变量的值
  

• 常量

  • 常量类似于不可变变量，但是不可变变量可以通过使用mut关键字使变量可变，而常量永远不可变并且不可使用mut关键字修饰常量。

    const MAX_INT:i32 = 100;
    println!("{}", MAX_INT);
    

• 变量隐藏

  • 我们可以定义一个与之前变量重名的新变量， 而新变量会 隐藏 之前的变量。 Rustacean
    们称之为第一个变量被第二个 隐藏 了， 这意味着使用这个变量时会看到第二个值。 可以用相同变量名称来隐藏它自己，
    以及重复使用 let 关键字来多次隐藏

    fn main(){
        let a = 10;
        {{{{println!("{}", a);}}}}
        {  let a = 13;
           println!("{}", a); 
            {
                {
                    let mut a = 34;
                    {
                        println!("{}", a);
                        a = 60;
                        {
                            println!("{}", a);
                        }
                    }
                }
            }
        }
        println!("{}", a);
    }
  

  重复使用let去隐藏变量实质上是重新定义同名变量，此时变量的作用域发生改变，第一定义的同名变量作用域为第一定义变量的位置开始到第二次定义同名变量位置结束。例如：

  fn main()
  {
      let a = 10;
      println!("{}", a);
      let a:String = "hello";
      println("{}", a);
  }
  

Rust 数据类型

标量类型

复合类型

• 元组类型：元组是一个将多个其他类型的值组合成复合类型

  元组定义：

  fn main()
  {
      let tup:(i32, u32, u64) = (45, 89, 90);
  }
  

  为了从元组中获取单个的值， 可以使用模式匹配
  （pattern matching） 来解构（destructure） 元组 :

  fn main()
  {
      let tup:(i32, u64, i64) = (12, 56, -89);
      let(x, y, z) = tup; //元组解构
      println!("{}", x);
      println!("{}", y);
      println!("{}", z);
  }
  

  使用点号（ . ） 后跟值的索引来直接访问

  fn main()
  {
      let tup:(i32, u32, u64) = (45, 89, 90);
      println!("{}", tup.0);
      println!("{}", tup.1);
      println!("{}", tup.2);
  }
  

• 数组：数组是一个将多个相同类型的值组合成复合类型

数组定义

fn main()
{
   let a = [1, 2, 3, 4];
}

fn main()
{
       let a:[i32;5] = [0;5];
       for i in (0..5)
       {
           println!("{}",a[i]);
       }
}

​

Rust函数

函数定义

关键字+函数名+()+函数体

fn main()
{
    deplay();
}

fn deplay()
{
    println!("hello world");
}

Rust 不关心函数定义于何处， 只要它们被定义了。

fn main()
{
    deplay();
    
    fn deplay()
	{
   		 println!("hello world");
	}
}

c语言禁止在任意函数体内定义函数，而rust可以这样操作。

函数参数

函数也可以被定义为拥有 参数（parameters）的 ， 它们是作为函数签名一部分的特殊变量。

fn main()
{
    println!("{}", add(23, 56));
}
fn add(x:i32, y:u32) ->i32
{
    x+y as i32
}

函数体

由一系列语句和可选的表达式组成的语句块，语句和可选表达式总时被花括号包围

fn main() -> i32
{
    println!("hello world"); //函数调用语句
    0 //可选表达式
}

语句与表达式

语句： 语句（Statements） 是执行一些操作但不返回值的指令。

表达式： 表达式（Expressions） 计算并产生一个值。

使用 let 关键字创建变量并绑定一个值是一个语句。

fn main()
{
    let x = let y = 6;
}

let y = 6 语句并不返回值， 所以并没有 x 可以绑定的值。 这与其他语言不同， 例如 C 和 Ruby， 它们的赋值语句返回所赋的值。 在这些语言中， 可以这么写 x = y = 6 这样 x 和 y 的值都是 6 ； 这在 Rust 中可不行。

函数调用是一个表达式。 宏调用是一个表达式。 我们用来创建新作用域的大括号（代码
块） ， {} ， 也是一个表达式

fn main() {
	let x = 5;
	let y = {
		let x = 3;
		x + 1
	};
	println!("The value of y is: {}", y);
    
    let a = add(3, 6);
    let b = println!("{}", a);
    println!("{:?}", b);
}

fn add (x:i32, y:i32) -> i32
{
    x + y
}

函数返回值

格式：

fn main () -> i32
{
    
}

控制流

if表达式

fn main()
{
    let num = 90;
    if num == 90 {
        println!("Yes");
    } else {
        println!("NO");
    }
}

值得注意的是if条件表达式必须是 boolea 类型，有别于C语言只要是非零值即是真。

fn main()
{
    let num = 90;
    if num == 90 {
        println!("Yes");
    } else {
        println!("NO");
    }
}

使用 else if 实现多重条件

可以将 else if 表达式与 if 和 else 组合来实现多重条件。

fn main() {
    let number = 6;
    if number % 4 == 0 {
    	println!("number is divisible by 4");
    } else if number % 3 == 0 {
    	println!("number is divisible by 3");
    } else if number % 2 == 0 {
    	println!("number is divisible by 2");
    } else {
    	println!("number is not divisible by 4, 3, or 2");
    }
}

在 let 语句中使用 if

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

if 的每个分支的可能的返回值都必须是相同类型 ,如果它们的类型不匹配， 如下面这个例子， 则会出现一个错误：

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

} else {
	6
};
println!("The value of number is: {}", number);

}

if 的每个分支的可能的返回值都必须是相同类型  ,如果它们的类型不匹配， 如下面这个例子， 则会出现一个错误：  

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