稍微写过一点rust的人就知道，和别的大多数语言不同，rust默认的赋值语义是move，其他语言例如golang，默认的语义是copy，例如

    1. type Hello struct {
    2.     Name: string,
    3. }
    5. h := Hello {
    6.     Name: "hello",
    7. }
    8. h_copy := h

    h_copy 是 h的copy，而rust不同

    1. struct Hello {
    2.     int_field: i32,
    3.     string_field: String,
    4. }
    6. let a = Hello {
    7.    int_field: 1,
    8.    string_field: String::from("hello"),
    9. };
    11. let b = a;

    这时候我们说 a move 到了b, 几乎所有的书以及文档都告诉你，这时候 Hello的ownership转移到了b上，a “不复存在”，那到底move做了什么？为了搞清楚这个，我写了2段测试代码

    1. fn move_vec() {
    3.     let mut a = vec![1,3,4];
    5.     let ptr_a = &mut a as *mut Vec<i32>;
    6.     println!("ptr_a {:?}", ptr_a);
    8.     let mut b = a;
    9.     let ptr_b = &mut b as *mut Vec<i32>;
    10.     println!("ptr_b {:?}", ptr_b);
    12.     b.push(5);
    13.     b.push(6);
    14.     b.push(7);
    15.     b.push(8);
    17.     println!("ref_b {:?}", &b);
    19.     unsafe{
    20.         let a = &*ptr_a;
    21.         println!("ref_a {:?}", &a);
    22.     }
    23. }
    25. 输出为
    26. ptr_a 0x7ffee3f839b0
    27. ptr_b 0x7ffee3f83a18
    28. ref_b [1, 3, 4, 5, 6, 7, 8]
    29. ref_a [1, 3, 4]

    可以看到，当 b = a 后，a和b的指针地址发生了变化，我们指到vec实际上是一个fat pointer，一个指向back array的指针，以及2个字段，一个保存长度，一个保存capacity，所以当move发生后，这个fatpointer实际上发生了copy，指向backarray的指针没有变，当b发生修改后，capacity以及len都变大了，但原始vec没有变。

    1. [derive(Debug)]
    2. struct Hello {
    3.     int_field: i32,
    4.     string_field: String,
    5. }
    7. fn move_struct() {
    8.     let mut a = Hello {
    9.         int_field: 1,
    10.         string_field: String::from("hello"),
    11.     };
    13.     let ptr_a = &mut a as *mut Hello;
    14.     println!("ptr_a {:?}", ptr_a);
    15.     let mut b = a;
    16.     let ptr_b = &mut b as *mut Hello;
    17.     println!("ptr_b {:?}", ptr_b);
    18.     b.int_field = 2;
    19.     b.string_field = String::from("world");
    21.     println!("ref_b {:?}", &b);
    22.     unsafe{
    23.         let a = &*ptr_a;
    24.         println!("ref_a {:?}", &a);
    25.     }
    27. }
    28. 输出
    29. ptr_a 0x7ffee6d76950
    30. ptr_b 0x7ffee6d769d8
    31. ref_b Hello { int_field: 2, string_field: "world" }
    32. ref_a Hello { int_field: 1, string_field: "hello" }

    Hello在栈上分配，当发生move后，可以看到b是a的copy，这时候a和b完全没有关系了，a”不再存在”只是对于编译器而言，然而当你通过unsafe去访问a的裸指针时，你任然可以访问到它，但是必须通过unsafe，rust不再保证安全性

    所以rust中，move实际上就是一次memcpy，对于被move的变量而言，只是告诉编译器你不可以再访问它了。