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

Question

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

这是板条箱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）住在同一个箱子。但是，在另一个包中定义的功能Engine::run返回其中一个对象（r）时，比较返回false。
• 当我将测试功能放入lib.rs时，测试正确通过。
• 该问题可以通过定义struct Engine { intval: Object }来解决，但我仍然对为什么感兴趣。

Answer 1

何时是“指针”而不是“指针”？当它是一个胖指针。 Object是一个特征，这意味着&Object是特征对象。特征对象由两个机器指针组成：一个用于具体数据，另一个用于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) 

事实证明，（至少在锈病1.22.1）每个码生成单元创建一个单独的虚函数表！这解释了为什么它在全部在同一个模块中时工作。如果这是一个错误，则有active discussion。

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

---

由于Francis Gagné said：

您可以更改as *const _到as *const _ as *const()打开脂肪指针变成一个普通的指针，如果你只关心价值的地址。