1.控制流

//rust通过所有权机制来管理内存，编译器在编译就会根据所有权规则对内存的使用进行
//堆和栈
//编译的时候数据的类型大小是固定的，就是分配在栈上的
//编译的时候数据类型大小不固定，就是分配堆上的
fn main() {
    let x: i32 = 1;

    {
        let y: i32 = 1;
        println!("x = {}", x);
        println!("y = {}", y);
    }

    {
        let s1 = String::from("hello");
        //s1.push_str(" world");
        println!("s1 = {}", s1); //String类型离开作用域的时候会调用drop方法

        let s2 = s1; //浅拷贝 只是拷贝了指针， 数据并没有拷贝
        println!("s2= {}", s2);
        //println!("s1= {}", s1); //s1在被copy后会自动释放指针内存，所以会报错
        

        //clone 深拷贝数据
        let s3 = s2.clone();
        println!("s3= {}", s3);
        println!("s2= {}", s2);
    }

控制权

fn takes_ownership1(some_string: String){
    println!("{}", some_string);
}

fn takes_ownership2(some_string: String) -> String{
    println!("{}", some_string);
    some_string
}

fn makes_copy(i: i32) {
    println!("i = {}", i);
}

fn main() {
    let s = String::from("hello");
    //takes_ownership1(s); //s在调用函数后被drop，后续无法打印其值
    //println!("{}", s);
    let s2 = takes_ownership2(s);
    println!("{}", s2);

    let x = 5;
    makes_copy(x);
    println!("{}", x);
    println!("Hello, world!");
}

2.引用

//引用: 用法&,
//让我们创建一个指向值的应用，但是并不拥有它，因为不拥有这个值，所以，当引用离开其值指向的作用域后也不会被丢弃
fn calcute_length(s: &String) ->usize {
    s.len()
}

//借用:&mut 可以修改字符串，同时不会执行drop操作
fn modify_s(s: &mut String) {
    s.push_str(", world");
}

fn dangle() -> &String {
    let s = String::from("hello");
    &s
}

fn main() {
    let mut s1 = String::from("hello");
    
    //在任意给定时间，有了可变引用之后不能再有不可变引用
    let r1 = &s1;
    let r2 = &s1;
    println!("{}, {}", r1, r2);

    let r3 = &mut s1;
    r3.push_str(", world");
	//println!("{}, {}", r1, r2); 由于r3为 可变引用， r1,r2不能在这里使用，必须在r3之前使用
		
    //引用不能为空，dangle()中给s赋值结束后就drop了，最终返回了空指针，这是不合法的
    //let ref_s = dangle();
    //println!("{}", ref_s);
}

3.Slice

//1、字符串slice是String中一部分值的引用
//2、字面值就是slice
//3、其它类型slice
fn main() {
    let s = String::from("hello world");

    let h = &s[0..5]; 	//区间[0,5)
    let h = &s[0..=4]; 	//区间[0,4]
    let h = &s[..=4]; 	//区间[0,4]
    let h = &s[..5]; 	//区间[0,5)
    println!("h = {}", h);

    let w = &s[6..11];  //区间[6,11)
    let w = &s[6..=10]; //区间[6,10]
    let w = &s[6..];  	//区间[6,s.len())
    let w = &s[..]; 	//区间[0,s.len())
    println!("w = {}", w);

    //let ss = String::from("你好");
    //let w1 = &ss[0..1];

    let a = [1, 2, 3, 4];	
    let sss = &a[1..3];		//取a中[1,3)的元素
    println!("sss = {}", sss[0]);	//a[1]
    println!("sss = {}", sss[1]);	//a[2]
    println!("len = {}", sss.len());	//长度为2
}

4.智能指针

Box

fn main() {
    let text: String = "Hello CSDN".to_string();
    // 将字符串移动到堆上 
    let box_text: Box<String> = Box::new(text);
    // 此时原text已失效，因为所有权已经转移给box_text
    println!("{}", box_text);
}

Rc

use std::rc::Rc;
 
fn main() {
	//  Rc<T>提供了非独占、可共享的引用，它的内部维护了一个引用计数。当引用数量变为0时，会自动释放堆内存。
    let shared_data = Rc::new(66);
 
    // 创建指向同一数据的多个Rc实例
    let ref1 = Rc::clone(&shared_data);
    let ref2 = Rc::clone(&shared_data);
 
    println!("ref1: {}", ref1);
    println!("ref2: {}", ref2);
 
    // 当最后一个Rc实例超出作用域时，数据会被清理
}