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

Question

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

在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呢？

一些观察：

• 当两个对象（true和a）都在同一个箱子中时，比较会返回b。但是，当其中一个对象（false）由函数r返回时，比较返回Engine::run，该函数在另一个包中定义。
• 当我将测试函数放在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。

当您使用new注释run和#[inline]函数时，消费者将使用该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
}