Obj-C 中的 DisguisedPtr

Preface · 序
DisguisedPtr<T> 是 Apple 开源代码中的一个结构体类型，其使用于诸多 Obj-C 运行时组件中，比如 weak、@synchronized 等。

// objc-private.h

// DisguisedPtr<T> acts like pointer type T*, except the
// stored value is disguised to hide it from tools like `leaks`.
// nil is disguised as itself so zero-filled memory works as expected,
// which means 0x80..00 is also disguised as itself but we don't care.
// Note that weak_entry_t knows about this encoding.
//
// DisguisedPtr<T> 的行为类似于指针类型 T* 一样，唯一的不同在于存储的值是伪装的，以避免被 leaks 等工具发现。
// nil 被伪装成了自己，所以零填充的内存可以像预期的那样工作，这意味着 0x80...00 也被伪装成了自己，但我们并不在意。
// 注意，weak_entry_t 也使用了该编码。

template <typename T>
class DisguisedPtr {
    // _uintptr_t.h:
    // typedef unsigned long uintptr_t;
    // uintptr_t 表示能够存储指针地址的无符号整数类型（不同操作系统可能存在不同）
    uintptr_t value;

    static uintptr_t disguise(T* ptr) {
        // 将指针指向的地址转换为 unsigned long，并取负
        return -(uintptr_t)ptr;
    }

    static T* undisguise(uintptr_t val) {
        // 转换回指针指向的地址
        return (T*)-val;
    }

 public:
    // 无参构造方法
    DisguisedPtr() { }
    
    // 指针构造（value = disguise(ptr)）
    DisguisedPtr(T* ptr)
        : value(disguise(ptr)) { }
    
    // 使用 DisguisedPtr 类型构造（value = ptr.value）
    DisguisedPtr(const DisguisedPtr<T>& ptr)
        : value(ptr.value) { }

    // 实现 = 运算符，右操作数类型为 T*
    DisguisedPtr<T>& operator = (T* rhs) {
        value = disguise(rhs);
        return *this;
    }
    
    // 实现 = 运算符，右操作数类型为 DisguisedPtr<T>
    DisguisedPtr<T>& operator = (const DisguisedPtr<T>& rhs) {
        value = rhs.value;
        return *this;
    }

    operator T* () const {
        // Foo *someFoo = disguisedFooPtr;
        return undisguise(value);
    }
    T* operator -> () const {
        // disguisedFooPtr->bar
        return undisguise(value);
    }
    T& operator * () const {
        // *disguisedFooPtr
        return *undisguise(value);
    }
    T& operator [] (size_t i) const {
        // &disguisedFooPtr[0]
        return undisguise(value)[i];
    }

    // pointer arithmetic operators omitted
    // because we don't currently use them anywhere
    // 省略了指针运算符，因为我们目前没有在任何地方使用它们
};

// fixme type id is weird and not identical to objc_object*
static inline bool operator == (DisguisedPtr<objc_object> lhs, id rhs) {
    return lhs == (objc_object *)rhs;
}
static inline bool operator != (DisguisedPtr<objc_object> lhs, id rhs) {
    return lhs != (objc_object *)rhs;
}

// main.mm

#import <Foundation/Foundation.h>
#import "objc-private.h"

class Foo {
public:
    int bar;
    double baz;
};

int main(int argc, const char * argv[]) {
    // 创建对象
    Foo foo;
    foo.bar = 1;
    foo.baz = 3.14;
    
    // 指针 fooPtr 指向 foo（即 fooPtr 存储了 foo 的内存地址）
    Foo *fooPtr = &foo;
    
    // 构造 DisguisedPtr
    DisguisedPtr<Foo> disguisedFooPtr = DisguisedPtr<Foo>(fooPtr);
    
    Foo *someFoo = disguisedFooPtr; // => operator T* ()
    NSLog(@"%d", someFoo->bar);     // 1
    
    disguisedFooPtr->bar = 10;            // => T* operator -> ()
    NSLog(@"%d", disguisedFooPtr->bar);   // 10
    
    NSLog(@"%d", (*disguisedFooPtr).bar); // 10 => T& operator * ()
    
    NSLog(@"%p", &disguisedFooPtr[0]);    // 0x16fdff320 => T& operator * ()
    NSLog(@"%p", &disguisedFooPtr[1]);    // 0x16fdff330 => T& operator * ()
    
    return 0; // BREAKPOINT 🔴
}

// OUTPUT:
// 1
// 10
// 10
// 0x16fdff320
// 0x16fdff330

// LLDB:
// (lldb) memory read 0x16fdff320
// 0x16fdff320: 0a 00 00 00 00 00 00 00 1f 85 eb 51 b8 1e 09 40  ...........Q...@
// 0x16fdff330: 88 f3 df 6f 01 00 00 00 01 00 00 00 00 00 00 00  ...o............
// (lldb) memory read 0x16fdff330
// 0x16fdff330: 88 f3 df 6f 01 00 00 00 01 00 00 00 00 00 00 00  ...o............
// 0x16fdff340: 60 f3 df 6f 01 00 00 00 50 d4 26 89 01 00 00 00  `..o....P.&.....