2023-11-Rust

学习方案：Rust程序设计指南

1、变量和可变性

声明变量：let 变量、const 常量

rust 默认变量一旦声明，就不可变(immutable)。当想改变 加 mut（mutable） 。

const 不允许用mut ，只能声明常量，单词全部大写下划线连接。

let特点：

可多次声明，多次声明隐蔽性、默认不可变。

mut 和隐蔽的区别：

隐蔽实际创建一个新的变量，可以改变值得类型，并复用变量名。而mut 修改值时不能转换值得类型

2、rust类型

标量 scalar：

rust有四种标量类型：整数、浮点型、bool、字符型

整型：长度为 8-128bit、arch（isize、usize）、有符号 ixxx 、无符号u***

有符号和无符号代表数字是否可为负值（有符号数）、

或永远为正（无符号数）、

isize和usize 类型依赖运行程序的计算机架构，64系统为64,32系统为32

rust 默认使用 i32 。

整形溢出：

debug模式：程序panic

release模式：二进制补码，超过最大值绕会最小值

浮点型： f32  f64 默认 f64 。32单精度，64双精度。

字符类型 char：

单引号 声明char 字面量

双引号声明 字符串字面量

复合类型 compound：

rust有两个原生的复合类型：tuple 、array  

tuple 元祖：一旦声明，长度不可变。每个位置类型可不同，可以结构，可以使用点访问索引  

数组：长度固定，类型一致， 

声明12个长度 类型为i32的数组：let x :[i32;12]=[]

创建x个值为y的数组 let arr = [x;y];

访问元素：【index】，索引超出数组时panic

函数：

函数名变量名 snake case 风格；小写下划线分割，函数签名提供参数类型。

语句和表达式

语句：不返回值，

表达式：计算产生一个值

表达式可以用变量接收，语句不能用变量接收。

rust 函数也是语句

2、所有权

及scope 作用域：

栈：

堆：

Sting：

指针：0x1111

长度：当前String使用多少字节内存，

容量：String从分配器总共获取多少字节内容。 

栈：出作用域自动调用 drop函数

堆：存在指针拷贝。可能存在重复drop，二次释放【bug】造成内存污染，安全隐患。

解决：指针拷贝后，rust认为指针一不再有效，

 let str = String::from("hello world");
    let str1 = str;
    println!("str is {str}")

【 str  value borrowed here  after move  】

js： 深拷贝、浅拷贝。

rust： move 移动

rust 深拷贝的方式 clone，重新拷贝了一份堆中数据。

【js 和 rust 关于堆数据多次引用的关系区别】：

js：多个指针指向同一个堆中数据

rust：当多个指针指向同一个堆中数据，只有最后一个指针有效，之前的全部失效，无法访问

包括 函数的实参传递。

fn test2(){
  let str = String::from("hello world");
    test3(str);
    println!("str is {str}") // str value borrowed after move
}
 
fn test3(str:String){
 
   
}

rust变量：栈中copy 

 let x = 111;
    let y = x;
    println!("x is {x}")  //111

弊端：不获取所有权就无法对堆数据进行访问，引出：

【reference  引用 &】

引用与指针：

引用确保指向某个堆数据的有效指针。

移动：

引用：

fn test2(){
  let str = String::from("hello world");
    test3(&str);
    println!("str is {str}") // hello world
}
 
fn test3(str:&String){
 
   
}

tip：

函数使用引用值作为参数，无需交换所有权，因为未曾拥有过。

将创建一个引用的行为成为借用【borrowing】，使用权而不是拥有权和处置权。

所以无法修改借用来的变量：

  fn test3(str:&String){
     str.push_str("8888") ;
  }
// error:  cannot borrow `*str` as mutable, as it is behind a `&` reference

引用同变量一样，默认不允许修改。

引出： 可变引用：

fn test2(){
  let str = String::from("hello world");
    test3(&mut str);
    println!("str is {str}") // hello world
}
 
fn test3(str:&mut String){
 
   
}

限制：

只能对同一个变量使用一次可变引用，因为无法清除以哪个结果为准，数据在运行时难以追踪，类式：同时append和remove同一个dom。

【数据竞争】：多个指针同时访问并异步同一数据源

在同时使用可变与不可变引用是也是类式的规则。

let str = String::from("hello world");
    let str1 = &str;
    let str2 = &mut str1; // cannot borrow `str1` as mutable, as it is not declared as mutable

一个引用的作用域从声明的地方一直持续到最后一次使用为止，如果最后一个使用不可变引用发生在可变引用之前，那么是可以的：

 let mut str = String::from("hello world");
    let str1 = &str;
    let str2 = &mut str;//error:cannot borrow `str` as mutable because it is also borrowed as immutable
    println!("str1 is {str1}");
     let str2 = &mut str;//ok