let mut list: Vec<&str> = Vec::new(); 
    let str1 = "ssf".to_string();
    list.push(str1.as_str());
    let str2: String = "ccc".to_string();
    list.push(str2.as_str());
    println!("{:?}", list);

let mut list: Vec<&str> = Vec::new(); 
    list.push("aaa");
    {
        let str2: String = "ccc".to_string();
        list.push(str2.as_str());  // flag0
    }
    println!("{:?}", list);  // flag1

let mut list: Vec<&str> = Vec::new(); 
    list.push("aaa");
    let str2: String = String::new();
    list.push(str2.as_str());
    println!("{:?}", list);

#[derive(Debug)]
struct Kkk<'a, 'b> {
　　// 这里不是说pro1是'a的，它只是一个引用/借用/指针（引用作为结构属性和部分特殊的函数【比如longest这类】必须有生命周期标志）
　　// 这个是说pro1这个引用指向的空间是一个String对象空间，然后这个对象空间的生命周期是'a
    pro1: &'a String,
    pro2: &'b i32,
}
------------------------
{
        let sse = 3;
        let mut k = Kkk {pro1: &"sss".to_string(), pro2: &sse};
        println!("{:?}", k);
        {
            let ssk = 4;
            k.pro2 = &ssk;
            println!("{:?}", k);
        }
        //println!("{:?}", k);  // flag1
        //println!("{:?}", k.pro1); // flag2
    }

static mut KKK: String = String::new();

fn main() {
    unsafe {
        KKK = "ss".to_string();
        test(&KKK);
        /*let kkk = "ss".to_string();
        test(&kkk);*/
    }
}

const fn confn() -> i32 {
    8
}

fn test(a: &'static String) {
    println!("{}, {}", a, confn())
}

fn main() {
    test2("aaa")
}

const fn confn() -> i32 {
    8
}

fn test2(a: &'static str) {  // 是指a这个 str类型的借用（指针）指向的str类型空间是static的【不能被RAII释放的堆空间，无法被解引用，能被解引用的指针（借用）都是指向的可以被RAII的空间】
    println!("{}, {}", a, confn())
}

fn main() {
    test();
}

struct Kkk {
    pro1: i32
}

fn test() {
　　// 这里可以打印{:p}来输出k指向的地址，然后多次调用test()可以发现都是指向的一个地址，说明确实是静态局部变量；
    let k = &Kkk{pro1: 8};  // 这里如果换成&mut Kkk{pro1:8};则报错了，因为这种生成的是局部变量，而非mut的生成的是static的局部绑定变量，所以没有内存泄漏，因为下次调用这个方法用的k指向的对象还是上一次调用这个方法产生的
    test2(k);
    /*let k2 = Kkk{pro1: 8};
    test2(&k2);*/
}

fn test2(a: &'static Kkk) {
    println!("{}", a.pro1)
}

let tmp1 = Kkk {pro1:8};
let kk = &tmp1;
/*
好吧，这里的生成代码的方式和是否有mut有关，let k = &Kkk{pro1: 8};这种方式生成的是static tmp1 = Kkk {pro1:8};【tmp1只读，而且也没有产生内存泄漏，这个就和C++的方法里的static变量是一样的】
而如果是let k = &mut Kkk{pro1:8};这种方式则是生成的是let mut tmp1 = Kkk {pro1:8};
*/

let bbb = "sfjlk";  // 这个字符串字面量类型是&str，即这个字符串实际上是保存在不能被RAII释放的堆空间里的（应该有类似享元模式的str优化）
// ，然后获取这个str的地址（对该str对象借用）赋值给bbb，因此不能用*"sss"，因为static 对象无法被move【可以move的都是能被释放的】

fn test3(a: &'static str) {
    println!("{}$$$", a);
}

fn main() {
    let bbb = "sfjkl";
　　// 这里可以写成&bbb或&&bbb都是一样的，因为会被自动解引用为bbb，但是closure捕获的变量是不会自动解引用的，因为本身就没有需要转换为什么类型
    test3(bbb);
}

/*
而且这里将bbb换成：

let uuks = String::new();
let bbu = uuks.as_str();
里的bbu则编译不通过提示bbu存活时间不够长，说明不是编译器“智能”的发现bbb虽然非static但是确实要比test3更长存活所以也通过了，而是bbb就是static的；【宏参数则要求必须是字面量，static的变量都不行，宏比较特殊就不考虑那么多了】
*/

【这里再换个概念对个人理解更好，就是rust closure不能理解为捕获一个变量，而应该理解为在closure里产生一个地址空间的引用/指针（某种意义上也叫变量的引用），如果这个地址空间是static的则可以不用move，否则必须move（这个时候就不要非得用生命周期标志来理解了
，按人的思维理解反而更好，即f: 'static是指f里捕获的变量【捕获的对象空间（i32的也是一种对象）】必须是static的【不被释放的堆空间】，然后closure会自动获取其（这个空间）借用）
，因此这里没有move时bbb对象所在的空间是栈空间，是会消亡的，因此不是static，一下子就理解了，如果非得生搬硬套生命周期标志就很蛋疼（也可以理解，就要把它展开为let bbb_tmp = &bbb）】
let bbb = "sfjlk";  // 换成这个可以：static bbb: &str = "sfjlk";，这个时候调用者函数结束也不会释放bbb变量【但是如果换成static mut则又不行，因为这里可能存在并发问题（可以用unsafe解决，不过最好加锁）】
    thread::spawn(|| {
        println!("{}####", bbb);
    }).join();
// 这里如果用了move个人认为是编译器产生了魔法，即在closure最上面（即println上面）隐式的添加一个代码let bbb = 外部bbb的值【一个地址】;，这个是在运行到这里时执行的，编译期间应该没法知道bbb的值是多少吧

    for v in 1..=2 {
        test8();
    }
}

fn test8() {
    static mut m: i32 = 0;
    unsafe {
        println!("{}", m);
        m += 1;
    }
}

这里输出两次分别是0和1可以知道static局部变量的用处函数结束后不会释放m变量，因此m变量其实是在堆里的一个i32变量，只不过可见性是test8函数里，因此这里其实捕获的不是局部变量而是全局变量了【和C++一样】

fn main() {
    static bbb: &str = "sfjlk";
    thread::spawn(|| {
        println!("{}####", bbb);
    }).join();
}

struct TestStruct(i32);
trait Hello: Sized {
    fn say_hello(&self) {  // 默认trait实现
        println!("hello");
    }
}
impl Hello for TestStruct{}

fn test1<T: Hello + 'static + Sized>(t: &T) {
    t.say_hello();
}

fn test2() {
    let x = TestStruct(666);
    test1(&x);
}

fn main(){
    test2();
}

struct TestStruct<'a>(&'a i32);
trait Hello: Sized {
    fn say_hello(&self) {
        println!("hello");
    }
}

impl<'a> Hello for TestStruct<'a>{}

fn test1<T: Hello + 'static + Sized>(t: &T) {
    t.say_hello();
}

fn test2() {
    let y = 666;
    let x = TestStruct(&y);  // 这种不行，【因为y不是static（注意不是说字面量就是static的，所以之前的那个字面量写到程序元数据里所以是static的理解是错误的，static就是因为指向的空间是不会被RAII的堆空间）】
    test1(&x);
}

fn main(){
    test2();
}

struct TestStruct<'a>(&'a i32);
trait Hello: Sized {
    fn say_hello(&self) {
        println!("hello");
    }
}

impl<'a> Hello for TestStruct<'a>{}

fn test1<T: Hello + 'static + Sized>(t: &T) {
    t.say_hello();
}

fn test2() {
    //let y = 666;
    let x = TestStruct(&666);  // 改动点
    test1(&x);
}

fn main(){
    test2();
}