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

Question

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

这是crate Rc::ptr_eq(mcve)的实现:

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();
    }
}

我使用以下代码(src/lib.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)'

虽然指针似乎是相同的,但比较运算符如何tests/testcases.rs返回==呢？

一些观察:

• false当两个对象(true和a)都位于同一个包中时,将返回比较.但是,b当false函数返回其中一个对象()时,将返回比较,该函数r在另一个包中定义.
• 当我将测试功能放入内部时,测试正确通过Engine::run.
• 问题可以通过定义来解决lib.rs,但我仍然对其原因感兴趣.

Answer 1

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

使用夜间编译器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!这解释了为什么它在同一个模块中都有效.有积极的讨论.如果这是一个错误或没有.

当你注释new和消费者的run功能#[inline]将使用该vtable.

正如FrancisGagné所说:

如果只关心值的地址,可以更改as *const _为as *const _ as *const ()将胖指针转换为常规指针.