let mut test1 = Test::new("test1");
    test1.init();
    let mut test2 = Test::new("test2");
    test2.init();
    println!("a: {}, b: {}, {:?}", test1.a(), test1.b(), test1.b);
    test1.a = "hello".to_string();
    println!("a: {}, b: {}, {:?}", test1.a(), test1.b(), test1.b);
}

a: test1, b: test1, 0x7f3d249d96a0
a: hello, b: hello, 0x7f3d249d96a0

为什么这里改了a，b也变了呢

let mut test1 = Test::new("test1");
    test1.init();
    let mut test2 = Test::new("test2");
    test2.init();
    println!("{:?}", &test1.a as *const String);
    println!("{:?}", &test1.a[..] as *const str);
    println!("{:?}", test1.a.as_ptr());
    println!(
        "a: {}, {:?}, {:?}, b: {}, {:?}",
        test1.a(),
        &test1.a as *const String,
        test1.a.as_ptr(),
        test1.b(),
        test1.b
    );
    std::mem::swap(&mut test1, &mut test2);
    println!(
        "a: {}, {:?}, {:?}, b: {}, {:?}",
        test1.a(),
        &test1.a as *const String,
        test1.a.as_ptr(),
        test1.b(),
        test1.b
    );

0x7f9f221fe570
0x7f9f1c000c30
0x7f9f1c000c30
a: test1, 0x7f9f221fe570, 0x7f9f1c000c30, b: test1, 0x7f9f221fe570
a: test2, 0x7f9f221fe570, 0x7f9f1c000c50, b: test1, 0x7f9f221fe590

问下各位大佬，为什么 const String 指针在内存交换前后都没变化，而const str就确实发生了交换

同问，为什么*const String在swap之后并没有改变，是否是因为*const String的存储位置不一样？

&test1.a 表示栈上的地址，test1.a.as_ptr() 还有test1.a[..]表示堆上的内容了。
test本身存储在栈上，test1.a的地址当然一直没有变，但是它的内容变了。指向了新的堆上的内容。
std::mem::swap的实现去看一看。它只交换两个参数（指针）直接指向的确定大小（类型可能是动态大小，但是类型的控制结构（那个胖指针）的大小是一定的，因为它可以被放在栈上。）的内容。而不去管这个直接指向的内容里面有没有指针。有没有指针，这个内部用到了unsafe的函数都是安全的。很有意思。

swap交换的是指针所指向的值，因此指针本身的值肯定不会变：https://doc.rust-lang.org/stable/std/mem/fn.swap.html
Swaps the values at two mutable locations, without deinitializing either one.

你可能是考虑太多了，就mem::swap而言就是把Test1的数据拷贝到Test2的地址，Test2的数据拷贝到了Test1的地址。

图

&test1 == 0x1001;      // test1地址是0x1001
&test1.a == 0x1002;   // test1.a地址是0x1002
test1.a == 0x1111 -> "test1" // test1.a的值是地址0x1111，地址0x1111存储着字符串“test1”
&test1.b == 0x1003;   // test.b的地址是0x1003
test.b == &test.a == 0x1002; //test.b的值是0x1002，也就是test.a的地址

确实，rust中swap是值拷贝，内存地址不变，仅仅是拷贝后的值发生变化，其中0x1002一直是变量a的地址，0x1003一直是指针变量b地址

1. 0x1002地址的值从0x2222（0x2222保存值是test2）
2. 0x1003地址的值变形为0x2002，0x2002现在保存值0x1111（0x1111保存值是test1）

在堆和栈上没什么区别，Pin做的就是利用编译器规则尽量保证你没有手段移动内存。换句话说，只要你写的代码足够unsafe，Pin跟没有一样:)。

#![feature(box_syntax)]
use core::pin::Pin;
use core::marker::PhantomPinned;

#[derive(Debug)]
struct Test{
    x: i32,
    _marker: PhantomPinned,
}

impl Test{
    fn new(x:i32) -> Self {
        Test{x, _marker:PhantomPinned}
    }
}

fn main() {
    // 裸指针
    let p0 = Box::leak(box Test::new(0));
    let mut p1 = box Test::new(1);
    // 绕过借用规则从裸指针构造Pin
    let p2 = unsafe {
       Pin::new_unchecked( &mut *core::ptr::addr_of_mut!( *p0 ) )
    };
    // 由于没有shadow掉p0，我们现在拥有了p0所指内存的两个可变指针
    // Ok！交换p0和p1，p2所Pin的内存也随之改变
    std::mem::swap(p0, &mut p1);
    // 1，0，1
    println!("{:?}, {:?}, {:?}", p0 , p1, p2);
    
    // Bad！编译器阻止了我们使用p2的可变引用
    //std::mem::swap(p2.get_mut(), &mut p1);
    //println!("{:?}, {:?}", p0 , p1);
    
    // Ok！我们向编译器声明要使用unsafe，交换成功
    unsafe {
      std::mem::swap(p2.get_unchecked_mut(), &mut p1);
    }
    // 0，1
    println!("{:?}, {:?}", p0 , p1); 
}

非常感谢～

我学习 Pin 的出发点是理解为何在 tokio 中 future 需要调用 tokio::pin 的本质原因是什么。

我再消化消化，感觉有点像课堂教学哈，老师讲台上讲的飞起，但是下面的同学们却没有理解这个理论（Pin）为什么可以应用到特定的实践场景（tokio）中：）

Test的例子确实会带来这种思考：Pin做的事情好像只是报错、并没有解决什么问题。
我起初也有一样的疑问，我看了下最上方Rustln的回答后，结合我个人的思考：
Pin做的事情，就是制定一个编译器规则，让你在使用自引用类型的时候给予帮助/提示，防止你写出异常的代码。

我也是，刚开始理解“固定”这个词以为是真的是固定住，直到了看到：https://cfsamson.github.io/books-futures-explained/5_pin.html#practical-rules-for-pinning 的第三条：Pinning does nothing special with memory allocation like putting it into some "read only" memory or anything fancy. It only uses the type system to prevent certain operations on this value.

确实，我理解Pin的目的是 防止 在T是!unpin的时候，安全获得Pin<P>里面，T的所有权和可变引用。那么T自然就是不可以移动的了。但是Pin本身是一个指针，只是包装了一下P，所以它是可以移动的。Pin的目的是把一个移动就会出错的结构，变成移动它的指针，这样就不会出错。
在swap的例子，就是获得自引用结构的可变引用导致出错了。
在栈的错误例子里面，就是Pin并没有获得T的所有权，导致T被它的所有者随意改了，Pin并没有发挥到它的作用。

讲清楚这个问题，其实需要讲解为啥有时候Future需要!Unpin，有时候又需要Unpin。
很可惜目前俺也没办法完整的给出答案，只能粗略的根据个人理解回答下，有些框架的Future实现不涉及到自引用，有些框架的Future又涉及到自引用。

道法自然，不用拘泥于形式，搞清楚原理就行。至于怎么用，真正用的时候再来查就行了。

那是你将
std::mem::swap放在了俩次打印之前
原文是在俩次之间

这个终于说清楚了。。。

说的对，有一个小问题，Pin中的值实现Unpin trait 的时候可以safe的获得可变引用。

仍然可以移动 只要你写的足够unsafe
#788 (comment)

我觉得 再直白点 就是rust总得给你提供一种 保证指针指向的值不能被改动的 机制吧？那否则就剩下了所有的指针指向的对象 都可以被改变 这一种case，只有这一种倒也不是不行 那也可以在不希望被改动的情况下 自己保证写代码的时候不去改他 但这不就留下了隐患，那就是这种保证变成了纯代码层面的，而rust只是在为那些 明确知道自己的内容不希望被改变的case 加了一层 编译层面的保障，使得代码更加的安全 我觉得rust做的对！

我好像又悟了 不确定对不对 分享出来大家也可以一起探讨，所谓语言中的某种特性 其实都是围绕功能设计的，一个语言特性难理解，比如vtable也好 Pin也好 所谓的Future也好，难理解的原因其实还是现实场景中的为什么需要这个功能难理解；以Pin为例，他难理解是因为本身他也可有可无，你指向的内容如果允许被改变，那就不需要Pin，甚至不能被改变，你不从编译的角度保证，你从代码的角度保证，也行；只是rust提供Pin出来 从编译层面 更严格的提供了不可改变的 能力而已；我相信其实所有的科目都是这样的，为什么要方向盘，这个很好理解，因为开车我总要控制方向吧，所以由于场景大家都耳熟能详 都好理解，因此汽车上存在方向盘，也就好理解了，Pin其实也就是“汽车”上面，一个起到某个作用的实现而已，和一个方向盘没什么区别；其他的 哪怕做一个项目，其中的一个功能 一个开关，他好不好理解，也是看他针对要解决的那个场景 好不好理解而已；我甚至觉得换一个学科，也都是这样的，经济学那么多名词，工具 我觉得也就是一种对于 现实场景的抽象解决 而存在的一些东西而已。

没看出有什么问题 指针又不归rust管

啊？你的意思是你改了 data，想让 rData 也跟着改？这肯定不会跟着改啊