为什么用 == 比较两个看似相等的指针会返回 false？

Question

我想测试Rc<Trait> 类型的两个对象是否包含具体类型的相同实例，因此我比较了指向Rc 内部对象的指针是否相等。如果所有代码都驻留在同一个 crate 中，它似乎可以正常工作，但在涉及多个 crate 时会失败。

在 Rust 1.17 中添加了函数 Rc::ptr_eq，从 Rust 1.31 开始，该函数与此问题中使用的手动指针比较表现出相同的跨板条箱问题。

这是crate mcve(src/lib.rs)的实现：

use std::rc::Rc;

pub trait ObjectInterface {}

pub type Object = Rc<ObjectInterface>;

pub type IntObject = Rc<i32>;

impl ObjectInterface for i32 {}

/// Test if two Objects refer to the same instance
pub fn is_same(left: &Object, right: &Object) -> bool {
    let a = left.as_ref() as *const _;
    let b = right.as_ref() as *const _;
    let r = a == b;
    println!("comparing: {:p} == {:p} -> {}", a, b, r);
    r
}

pub struct Engine {
    pub intval: IntObject,
}

impl Engine {
    pub fn new() -> Engine {
        Engine {
            intval: Rc::new(42),
        }
    }

    pub fn run(&mut self) -> Object {
        return self.intval.clone();
    }
}

我使用以下代码 (tests/testcases.rs) 测试实现：

extern crate mcve;

use mcve::{is_same, Engine, Object};

#[test]
fn compare() {
    let mut engine = Engine::new();

    let a: Object = engine.intval.clone();
    let b = a.clone();
    assert!(is_same(&a, &b));

    let r = engine.run();
    assert!(is_same(&r, &a));
}

在以下输出中运行测试结果：

comparing: 0x7fcc5720d070 == 0x7fcc5720d070 -> true
comparing: 0x7fcc5720d070 == 0x7fcc5720d070 -> false
thread 'compare' panicked at 'assertion failed: is_same(&r, &a)'

比较运算符==怎么可能返回false，尽管指针看起来是一样的？

一些观察：

• 当两个对象（a 和 b）位于同一个 crate 中时，比较返回 true。但是，当其中一个对象 (r) 由另一个 crate 中定义的函数 Engine::run 返回时，比较会返回 false。
• 当我将测试函数放入lib.rs 时，测试正确通过。
• 可以通过定义struct Engine { intval: Object } 来解决问题，但我仍然对为什么感兴趣。

Answer 1

什么时候“指针”不是“指针”？当它是一个 胖指针。 ObjectInterface 是一个特征，这意味着&dyn ObjectInterface 是一个特征对象。特征对象由两个机器指针组成：一个用于具体数据，一个用于vtable，一组具体值的特征的具体实现。这种双指针称为胖指针。

使用 nightly 编译器和std::raw::TraitObject，您可以看到差异：

#![feature(raw)]

use std::{mem, raw};

pub fn is_same(left: &Object, right: &Object) -> bool {
    let a = left.as_ref() as *const _;
    let b = right.as_ref() as *const _;
    let r = a == b;
    println!("comparing: {:p} == {:p} -> {}", a, b, r);

    let raw_object_a: raw::TraitObject = unsafe { mem::transmute(left.as_ref()) };
    let raw_object_b: raw::TraitObject = unsafe { mem::transmute(right.as_ref()) };
    println!(
        "really comparing: ({:p}, {:p}) == ({:p}, {:p})",
        raw_object_a.data, raw_object_a.vtable,
        raw_object_b.data, raw_object_b.vtable,
    );

    r
}

comparing: 0x101c0e010 == 0x101c0e010 -> true
really comparing: (0x101c0e010, 0x1016753e8) == (0x101c0e010, 0x1016753e8)
comparing: 0x101c0e010 == 0x101c0e010 -> false
really comparing: (0x101c0e010, 0x101676758) == (0x101c0e010, 0x1016753e8)

事实证明（至少在 Rust 1.22.1 中）每个 代码生成单元 创建一个单独的 vtable！这解释了为什么它在同一个模块中时有效。 active discussion 是否是错误。

当您使用 #[inline] 注释 new 和 run 函数时，消费者将使用该 vtable。

---

作为Francis Gagné said:

如果您只关心值的地址，您可以将as *const _ 更改为as *const _ as *const () 以将胖指针变为常规指针。

这可以使用std::ptr::eq 简洁地表达：

use std::ptr;

pub fn is_same(left: &Object, right: &Object) -> bool {
    let r = ptr::eq(left.as_ref(), right.as_ref());
    println!("comparing: {:p} == {:p} -> {}", left, right, r);
    r
}