如何检查两个引用变量是否借用了同一个对象？

Question

我有一个结构体，所有内容都是只读引用，例如：

struct Pt { x : f32, y : f32, }
struct Tr<'a> { a : &'a Pt }

我想为Tr实现impl Eq，以测试底层a引用是否完全相同的Pt：

let trBase1 = Pt::new(0.0, 0.0);
let trBase2 = Pt::new(0.0, 0.0);
assert!(trBase1 == trBase2);        // ok.
let tr1 = Tr::new(&trBase1);
let tr2 = Tr::new(&trBase2);
let tr3 = Tr::new(&trBase1);
assert!(tr1 == tr3);                // ok.
assert!(tr1.a == te2.a);            // ok. Using Eq for Pt that compare values.
assert!(tr1 != tr2);                // panicked! Not intended.

现在我有了。

impl<'a> PartialEq for Tr<'a> {
    fn eq(&self, v : &Tr<'a>) -> bool {
        // self.a == v.a // doesn't work.
    }
}

我应该写些什么？

- karatoga

Answer 1

你可以使用 std::ptr::eq 函数来比较两个指针的地址。如果将引用（&T 或者 &mut T）传给该函数，它们会自动转换为底层指针（*const T）。当然，一个可变引用和另一个引用有相同的地址是没有意义的，因为可变引用总是独占引用，但仍然可以被强制转换为 *const T。

// This derive will use the equality of the underlying fields
#[derive(PartialEq)]
struct Pt {
    x: f32,
    y: f32,
}

impl Pt {
    fn new(x: f32, y: f32) -> Self {
        Self { x, y }
    }
}

struct Tr<'a> {
    a: &'a Pt,
}

impl<'a> Tr<'a> {
    fn new(a: &'a Pt) -> Self {
        Self { a }
    }
}

// Here we use std::ptr::eq to compare the *addresses* of `self.a` and `other.a`
impl<'a> PartialEq for Tr<'a> {
    fn eq(&self, other: &Tr<'a>) -> bool {
        std::ptr::eq(self.a, other.a)
    }
}

fn main() {
    let tr_base1 = Pt::new(0.0, 0.0);
    let tr_base2 = Pt::new(0.0, 0.0);
    assert!(tr_base1 == tr_base2);

    let tr1 = Tr::new(&tr_base1);
    let tr2 = Tr::new(&tr_base2);
    let tr3 = Tr::new(&tr_base1);

    assert!(tr1 == tr3);
    assert!(tr1.a == tr2.a);
    assert!(tr1 != tr2);
}

（示例代码网址链接）

- SCappella

Answer 2

将引用转换为原始指针并进行比较。最初的回答保留了HTML标签。

impl<'a> PartialEq for Tr<'a> {
    fn eq(&self, v: &Tr<'a>) -> bool {
        self.a as *const _ == v.a as *const _
    }
}

- Francis Gagné

---

太酷了！谢谢。对于我的情况，我必须将&ref作为*const_处理。 - zertyz