Pointers 对向量的引用仍然作为向量打印？

愚蠢的n00b试图学习一点关于生锈的知识。这是我的节目：

fn main() {
    let v = vec![1, 2, 3];
    println!("{:?}", v);
    println!("{:?}", &v);
}

产出：

[1, 2, 3]
[1, 2, 3]

和

的要点是什么？我有点期待它打印一个内存地址

---

我最初是被这个抛出的，看起来他们正在循环引用。我的猜测是Rust有一些魔力并检测到它是一个向量的内存地址？

魔力在于格式化程序而不是编译器。例如，见：

fn take_val<T>(a:Vec<T> ) {}
fn take_ref<T>(b:&Vec<T>) {}

fn main() {
    let v = vec![1, 2, 3];
    take_val(&v);
    take_ref(&v);

}

fn take_val（a:Vec）{
fn取_ref（b:&Vec）{}
fn main（）{
设v=vec！[1,2,3]；
取值（&v）；
取参考值（&v）；
}

失败，出现以下错误：

<anon>:6:14: 6:16 error: mismatched types:
 expected `collections::vec::Vec<_>`,
    found `&collections::vec::Vec<_>`
(expected struct `collections::vec::Vec`,
    found &-ptr) [E0308]
<anon>:6     take_val(&v);

：6:14:6:16错误：不匹配的类型：
应为“collections:：vec:：vec`，
找到`&集合：：vec：：vec`
（应为结构`collections:：vec:：vec`，
找到和-ptr）[E0308]
：6取值（&v）；

这表明这是因为格式化程序不想显示引用和值之间的差异。在旧版本的Rust中，如果我的记忆正确，a

&v

将显示为

&[1,2,3]

&

在锈蚀中有特殊的含义。它不仅仅是一个引用，它是一个注释，该值被借用到一个或多个函数/方法

这个&的意义是什么

正如您所猜测的，

&

引用对象。然而，有一种方法只是打印出引用的对象。之所以这样做是因为Rust倾向于选择值相等而不是引用相等：

impl结果{$tr:：fmt（&**self，f）}
}

如果要打印内存地址，可以使用

{:p}

：

let v = vec![1,2,3];
println!("{:p}", &v);

看起来他们在循环引用

foo中i的

语法sugar调用
进入
foo
上的\u迭代器
，并且有一个函数返回迭代器中项目的迭代器引用：

fn-into\u-iter（self）->slice:：IterThanks。我阅读了关于迭代器的部分，看到了&v中I的
将I作为v的每个元素的引用。for循环发挥了神奇的作用，它可以计算出我希望引用iterable的每个元素，而不是试图遍历指针。“是这样吗？”斯佩格我补充了一部分。基本上，
for i in foo
使用
到迭代器
，并且有一个
&Vec
特性的实现，它委托给
Vec:：iter
<代码>向量：：iter
返回一个迭代器，该迭代器生成对向量中每个项的引用。