【Rust学习日志】2024.01.29

[Irissssaa]

所有权和借用

所有权

•   fn main() {
        // 使用尽可能多的方法来通过编译
        let x = String::from("hello, world");
        let y = x;
        println!("{},{}",x,y);
    }
    
    法1
    fn main(){
        let x = "hello,world";
        let y = x;
        println!("{},{}",x,y);
    }
    
    法2
    fn main(){
        let x = String::from("hello,world");
        let y = x.clone();
        println!("{},{}",x,y);
    }

•   fn main() {
        let x = Box::new(5);
        
        let ...      // 完成该行代码，不要修改其它行！
        
        *y = 4;
        
        assert_eq!(*x, 5);
    }
    
    例1
    fn main() {
        let x = Box::new(5);
        
        let mut y = x;
        
        *y = 4;
        
        assert_eq!(*y, 4);
    }//这是正确的
    
    例2
    fn main() {
        let x = Box::new(5);
        
        let mut y = x.clone();
        
        *y = 4;
        
        assert_eq!(*x, 5);//原因是第27行通过clone创建了一个新的指针并克隆了x的值，所以y与x并未指向同一地址
    }
    
    例3
    fn main() {
        let x = Box::new(5);
        
        let mut y = x;
        
        *y = 4;
        
        assert_eq!(*x, 4);
    }//该代码会报错，原因是在第38行进行了所有权转移，x失效了

•   //在这里我将解释一下String类型和Box<u8>类型的一个重要区别
    fn main() {
       let t = (String::from("hello"), Box::new(18));
        
       let (s1,s2) = t;
    
       println!("{:?}, {:?}, {:?}", s1, s2, t); 
     // -> "hello", 18,报错（t已经失效）
    }
    
    fn main() {
       let t = (String::from("hello"), String::from("world"));
    
       let (s1,s2) = t;
    
       println!("{:?}, {:?}, {:?}", s1, s2, t); 
     // -> "hello", "world", ("hello", "world")
    }
    //两个代码的区别就在于元组中的元素类型不同这里的知识点就是在rust中，对于String类型来说，当它被赋值给另一个变量、作为函数参数传递或者作为结构体成员时，它的所有权都会发生转移。但是，如果在解构结构体时，结构体中的元素类型实现了 Copy trait，那么在解构时就不会涉及所有权的转移。而Box<u8>类型在赋值、传递参数或者解构 Box<u8> 类型时，均会涉及所有权的转移。这就是两者的区别。

引用与借用

• 引用与借用的功效都一样，借用使用&关键字，引用使用ref关键字。借用的对象是必须存在的，引用的对象可以是虚拟的，后期附上对象。

  我们可以这样看，借用表示借来某个东西，这个东西是有主人的，而引用类似于我们保留了网上某篇文章的链接，这个链接指向的内容可能是不存在的并且将来可以修改链接的内容。但是实际情况中不必区分两者概念

• 值得注意的是在 Rust 中，打印引用时不需要使用 * 解引用操作符，因为 Rust 的标准库已经为常见类型实现了 Display trait，使得可以直接打印引用指向的数据。无论你是否使用 * 解引用操作符，println!("{}, {}", r1, r2) 都会正确地打印出 r1 和 r2 引用的字符串内容。

• 此处这里的引用就是借用，总的来说，借用规则如下

  1. 同一时刻，对于同一内容，只能拥有要么一个可变引用，要么任意多个不可变引用
  2. 引用必须总是有效

   fn main() {
       let reference_to_nothing = dangle();
   }
   
   fn dangle() -> &String {
       let s = String::from("hello");
   
       &s
   }//会报错，原因是发生了无效引用
   
   //仔细看看 dangle 代码的每一步到底发生了什么：
   fn dangle() -> &String { // dangle 返回一个字符串的引用
   
       let s = String::from("hello"); // s 是一个新字符串
   
       &s // 返回字符串 s 的引用
   } // 这里 s 离开作用域并被丢弃。其内存被释放。
     // 危险！
   
   //其中一个很好的解决方法是直接返回 String：
   fn no_dangle() -> String {
       let s = String::from("hello");
   
       s
   }

•   fn main() {
        let c = '中';
        let r1 = &c;
        let ref r2 = c;
    
        assert_eq!(*r1, *r2);
        
        // 判断两个内存地址的字符串是否相等
        assert_eq!(get_addr(r1),get_addr(r2));
    }
    
    // 获取传入引用的内存地址的字符串形式
    fn get_addr(r: &char) -> String {
        format!("{:p}", r)
    }

  在给定的代码中，let ref r2 = c; 和 let r1 = &c; 的作用是相同的，它们都创建了对变量 c 的引用。这两种方式都可以用来创建引用，但是 ref 更多地用于模式匹配中，而 & 更多地用于普通的引用创建。

  另外，关于内存地址的比较，由于 r1 和 r2 都是对同一个变量 c 的引用，所以它们指向的内存地址是相同的。因此，assert_eq!(get_addr(r1), get_addr(r2)); 这行代码会通过断言，因为它们的内存地址是相等的。

•   fn main() {
        let mut x = 100;
        let y = &mut x;
        *y += 100;
        let z = &mut x;
        *z += 1000;
        assert_eq!(x, 1200);
    }
    
    fn main() {
        let mut x = 100;
        let y = &mut x;
        let z = &mut x;
        *y +=100;
        *z += 1000;
        assert_eq!(x, 1200);
    }
    /*在 Rust 中，对同一个变量同时存在多个可变引用是不允许的，这是 Rust 的借用规则所限制的。在第一个示例中，由于 y 和 z 的作用域没有重叠，它们分别持有了对 x 的独立可变引用，因此代码能够编译并运行。
    
    而在第二个示例中，虽然 y 和 z 的作用域也没有重叠，但是在后续的代码中将同时使用 *y += 100; 和 *z += 1000; 来修改同一个变量 x。这违反了 Rust 的借用规则，因为在同一时间只能有一个可变引用，而将 y 和 z 分开赋值并不改变它们指向的是同一个变量的事实。*/