24.内存操作Copy-Move-Clone.rs

布满荆棘的人生 2022-11-06 05:51 93阅读 0赞

/*
    详细请看:
    https://zhuanlan.zhihu.com/p/21730929
    https://zhuanlan.zhihu.com/p/184907190
    
    Clone VS Copy VS Move
    首先看一下这个两个trait的关系:
    pub trait Sized {
        // Empty.
    }
    pub trait Clone: Sized {
        fn clone(&self) -> Self;
        fn clone_from(&mut self, source: &Self){}
    }
    
    在编译器眼里，它们与其它的 trait 不一样。这几个 trait 内部都没有方法，它们的唯一任务是，给类型打一个“标记”，表明它符合某种约定，这些约定会影响编译器的静态检查以及代码生成
    pub trait Copy: Clone {
        // Empty.
    }
    
    
    */
    
    fn test_1() {
        //不实现任何特性也可以直接复制
        struct TestCopy0 {
            data: i32,
        }
        let t1: TestCopy0 = TestCopy0 { data: 12 };
        let t2 = t1;
    
        //Copy trait 是给编译器用的，告诉编译器这个类型默认采用 copy 语义，而不是 move 语义。
        //一旦一个类型实现了 Copy trait，那么它在变量绑定、函数参数传递、函数返回值传递等场景下，它都是 copy 语义，而不再是默认的 move 语义
        //并不是所有的类型都可以实现Copy trait。Rust规定，对于自定义类型，只有所有的成员都实现了 Copy trait，这个类型才有资格实现 Copy trait
        //常见的数字类型、bool类型、共享借用指针&，都是具有 Copy 属性的类型。而 Box、Vec、可写借用指针&mut 等类型都是不具备 Copy 属性的类型
    
        //#[derive(Copy)] -- the trait `Clone` is not implemented for `TestCopy`.要实现copy必须同时实现clone
        #[derive(Debug, Copy, Clone)]
        struct TestCopy {
            data: i32,
        }
    
        let t1: TestCopy = TestCopy { data: 12 };
        let t2 = t1; //实现与不实现copy，这一行应该有很大差别
        println!("{:?}", t1); //不实现copy,经过上面的赋值操作再次使用t1会编译不过.value borrowed here after move
    
        // 为了能让#[derive(Copy, Clone)]正常工作，结构体或枚举的所有成员自身必须是Copy类型。例如，下面这样就无法正常工作:
        // #[derive(Copy, Clone)]
        // struct Numbers {
        //     nums: Vec<i32>,
        // }
    
        ///------------------------------------------Clone----------------------------------------------------
        //Clone trait 是给程序员用的，我们必须手动调用clone方法，它才能发挥作用。
        #[derive(Debug, Clone)]
        struct TestCopy2 {
            data: i32,
        }
        let t1: TestCopy2 = TestCopy2 { data: 12 };
        let t2 = t1.clone(); //不实现Clone的特性不可以调用clone函数
        println!("{:?}", t1);
    
        //基础类型系统帮他们实现了Clone的特性
        let t1 = 3;
        let t2 = t1.clone();
    
        let t1 = (1, "1", 1.1);
        let t2 = t1.clone();
    
        //Clone trait 里面的 clone 方法究竟会执行什么操作，则是取决于程序员自己写的逻辑。
        #[derive(Debug)]
        struct TestCopy3 {
            data: i32,
        }
        impl Clone for TestCopy3 {
            fn clone(&self) -> Self {
                let t = TestCopy3 {
                    data: self.data + 100000,
                };
                t
            }
            fn clone_from(&mut self, source: &Self) {
                *self = source.clone()
            }
        }
        let t1: TestCopy3 = TestCopy3 { data: 12 };
        let t2 = t1.clone(); //不实现Clone的特性不可以调用clone函数
        println!("{:?}", t2);
    
    }
    
    fn test_2() {
        let v: Vec<i32> = Vec::new();
        //这就是move,转移所有权的，用来控制变量所有权.移动之后之前的值就会失效了
        let v1 = v; //v1 is the new owner
                    //println!("{:?}", v);
    
        let v: i32 = 42;
        let v1 = v;
        println!("v is {}", v); //compiles fine, no error!
                                //像这样没有拥有其他资源的类型且可以被逐位拷贝(bitwise copy)的类型被称为Copy类型。它们实现了Copy marker trait[2]。所有的基本类型，像整数，浮点数和字符都是Copy类型
    }
    
    fn main() {
        test_1();
        test_2();
    }