Rust 为什么您可以借用可变引用，但仍然同时使用这两种引用？ [衍生博客] 结构矩形{ 宽度：u32， 身高：u32， } fn干线{ 设mutr=Rect{width:30，height:30}； 设b=&mut r； 设c:&Rect=b； println！{：？}，{：？}，b，c； }

在代码中，b是可变借用的，c是不可变借用的，所以这不应该编译，但编译和运行时没有任何错误

这不应该被编译

为什么?？是的，b可变地借用r。但是c不可变地借用了b，所以现在b是不可变地借用的，你不能使它变异

如果您试图分配给b的任何字段，那么编译器将立即抛出一个错误

设mutr=Rect{width:30，height:30}； 设b=&mut r； 设c:&Rect=b； //这项作业将失败，因为“b”是a //可变引用，但它是不可变借用的。 b、 宽度=40； 普林顿！{：？}，{：？}，b，c； 该示例与同时删除b的示例相同。即使r是可变的，你仍然不能变异r

设mutr=Rect{width:30，height:30}； 设c:&Rect=&r； //由于同样的原因，此任务将失败， //`r`是可变的引用，但它是不可变的借用。 r、 宽度=40； 普林顿！{：？}，{：？}，r，c； 这不应该被编译

为什么?？是的，b可变地借用r。但是c不可变地借用了b，所以现在b是不可变地借用的，你不能使它变异

如果您试图分配给b的任何字段，那么编译器将立即抛出一个错误

设mutr=Rect{width:30，height:30}； 设b=&mut r； 设c:&Rect=b； //这项作业将失败，因为“b”是a //可变引用，但它是不可变借用的。 b、 宽度=40； 普林顿！{：？}，{：？}，b，c； 该示例与同时删除b的示例相同。即使r是可变的，你仍然不能变异r

设mutr=Rect{width:30，height:30}； 设c:&Rect=&r； //由于同样的原因，此任务将失败， //`r`是可变的引用，但它是不可变的借用。 r、 宽度=40； 普林顿！{：？}，{：？}，r，c；

---

让我们简化并简化您的示例：

fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； println！{：？}，{：？}，b，c； } 我认为困惑的根源在于普林恩！宏看起来像一个常规函数调用，但实际上不是。如果我们换掉println！具有常规函数的宏：

fn funcformat:&str，b:&muti32，c:&i32{} fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； func{：？}，{：？}，b，c； } 然后我们得到预期的编译器错误：

错误[E0502]：无法将“*b”作为可变项借用，因为它也是作为不可变项借用的 ->src/main.rs:7:5 | 6 |设c:&i32=&b； |-此处发生不可变借用 7 | func{：？}，{：？}，b，c； | --^^^^^^^^^^^^^^^^^^^ | | |可变借用发生在这里 |不可变借阅稍后由调用使用 现在的问题是为什么println！在func失败的地方工作。让我们仔细看看PrimtLn！通过扩展它：

fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； { ：：std:：io:：_print:：core:：fmt:：Arguments:：new_v1 &[，\n]， &匹配&b，&c{//在这里再次借用b&c arg0，arg1=>[ ：：core:：fmt:：ArgumentV1:：newarg0，：：core:：fmt:：Debug:：fmt， ：：core:：fmt:：ArgumentV1:：newarg1，：：core:：fmt:：Debug:：fmt， ], }, ; }; } 普林顿！在其参数前面加上前缀（&F），因此如果我们修改func以执行相同的操作：

fn funcformat:&str，b:&muti32，c:&i32{} fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； 函数{：？}，{：？}，&b，&c； } 它现在可以编译了

---

那么我们在这里学到了什么？如果我们可变借用一些数据，然后从可变借用中不可变借用，然后不可变借用可变借用和可变借用的不可变重新借用，那么就没有违反Rust的所有权规则，因为不可变借词都是从同一个原始可变借词中借来的，当不可变借词处于活动状态时，该可变借词不会发生变异。

让我们简化并取消您的示例：

fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； println！{：？}，{：？}，b，c； } 我认为困惑的根源在于普林恩！宏看起来像一个常规函数调用，但实际上不是。如果我们换掉println！具有常规函数的宏：

fn funcformat:&str，b:&muti32，c:&i32{} fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； func{：？}，{：？}，b，c； } 然后我们得到预期的编译器错误：

错误[E0502]：无法将“*b”作为可变项借用，因为它也是作为不可变项借用的 ->src/main.rs:7:5 | 6 |设c:&i32=&b； |-此处发生不可变借用 7 | func{：？}，{：？}，b，c； | --^^^^^^^^^^^^^^ ^^^^^ | | |可变借用发生在这里 |不可变借阅稍后由调用使用 现在的问题是为什么println！在func失败的地方工作。让我们仔细看看PrimtLn！通过扩展它：

fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； { ：：std:：io:：_print:：core:：fmt:：Arguments:：new_v1 &[，\n]， &匹配&b，&c{//在这里再次借用b&c arg0，arg1=>[ ：：core:：fmt:：ArgumentV1:：newarg0，：：core:：fmt:：Debug:：fmt， ：：core:：fmt:：ArgumentV1:：newarg1，：：core:：fmt:：Debug:：fmt， ], }, ; }; } 普林顿！在其参数前面加上前缀（&F），因此如果我们修改func以执行相同的操作：

fn funcformat:&str，b:&muti32，c:&i32{} fn干线{ 设mut a:i32=1； 设b:&muti32=&muta； 设c:&i32=&b； 函数{：？}，{：？}，&b，&c； } 它现在可以编译了

---

那么我们在这里学到了什么？如果我们可变借用一些数据，然后从可变借用中不可变借用，然后不可变借用可变借用和可变借用的不可变重新借用，那么就没有违反Rust的所有权规则，因为不可变借词都是从相同的原始可变借词中借来的，当不可变借词存在时，该原始可变借词没有被变异。

对可变引用的不可变引用-代码中没有这样的东西。简化的示例让我困惑了一秒钟，因为它不是问题中代码的简化版本。如果println！没有使用不可变的引用。因此，将func定义为不接受2&i32更容易混淆，并且稍微使其听起来像是宏与函数的关系@SebastianRedl请详细说明。@vallentin我更新了我的答案，希望能让它更清楚。如果我们更换println！带有普通函数的宏仍然建议println/宏是特殊的。实际上，如果是fn funca:&i32，b:&i32，则行为将是相同的。比如println！{：？}，{：？}，&mut a，&a；也会失败。对可变引用的不可变引用-代码中没有这样的东西。简化的示例让我感到困惑，因为它不是问题中代码的简化版本。如果println！没有使用不可变的引用。因此，将func定义为不接受2&i32更容易混淆，并且稍微使其听起来像是宏与函数的关系@SebastianRedl请详细说明。@vallentin我更新了我的答案，希望能让它更清楚。如果我们更换println！带有普通函数的宏仍然建议println/宏是特殊的。实际上，如果是fn funca:&i32，b:&i32，则行为将是相同的。比如println！{：？}，{：？}，&mut a，&a；也会失败。