齐卫鹏的博客

static const CGFloat kTabBarHeight      = 44.0;
static const CGFloat kStatusBarHeight   = 20.0;
static const CGFloat kTableContentInset = 200;

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        void (^simpleBlock)(void) = ^{
            NSLog(@"This is a block.");
        };
        
        simpleBlock();
    }
    return 0;
}

void (*simpleBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

((void (*)(__block_impl *))((__block_impl *)simpleBlock)->FuncPtr)((__block_impl *)simpleBlock); // 可以看到 Block 的调用最终其实就是去找它的实现 `__block_impl` 中的函数指针 `FuncPtr`，最终就是一个函数调用

// 代表 Block 对象
struct __main_block_impl_0 {
  struct __block_impl impl; // 实现
  struct __main_block_desc_0* Desc; // 内存管理
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock; // 代表这是一个栈区 Block
    impl.Flags = flags;
    impl.FuncPtr = fp; // 将 __main_block_func_0 作为 Block 具体的实现函数
    Desc = desc;
  } // 构造函数
};

// Block 的实现
struct __block_impl {
  void *isa; // 表明 Block 是一个对象
  int Flags;
  int Reserved;
  void *FuncPtr; // 函数指针，指向具体实现
};

// Block 的实现函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_q4_jm3g73557p74v3ncp13gq3l00000gn_T_main_455ba4_mi_0);
        }

// 包含 Block 的内存管理        
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int anInteger = 5; // 增加一个临时变量
        
        void (^simpleBlock)(void) = ^{
            NSLog(@"Integer is %d", anInteger); // Block 中使用这个临时变量。
        };
        
        anInteger = 10; // 修改临时变量
        
        simpleBlock(); // 执行后打印结果为 5
    }
    return 0;
}

int anInteger = 5;

void (*simpleBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, anInteger)); // 增加了 anInteger 作为参数

anInteger = 10;

((void (*)(__block_impl *))((__block_impl *)simpleBlock)->FuncPtr)((__block_impl *)simpleBlock);

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int anInteger; // 增加了捕获的变量作为成员变量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _anInteger, int flags=0) : anInteger(_anInteger) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  // 增加了一句从 __main_block_impl_0 中获取捕获的变量的步骤，最终函数执行使用的也是捕获后的变量，而不是之前的临时变量
  int anInteger = __cself->anInteger; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_q4_jm3g73557p74v3ncp13gq3l00000gn_T_main_62f6c8_mi_0, anInteger);
        }

#import <Foundation/Foundation.h>

int num1 = 10;
static int num2 = 20;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        static int num3 = 30;
        int num4 = 40;
        
        __unsafe_unretained id obj1 = nil;
        __strong id obj2 = nil;
        
        void (^simpleBlock)(void) = ^{
            NSLog(@"全局变量%d", num1);
            NSLog(@"静态全局变量%d", num2);
            NSLog(@"静态局部变量 %d", num3);
            NSLog(@"局部变量 %d", num4);
            NSLog(@"对象1 %@", obj1);
            NSLog(@"对象2 %@", obj2);
        };
        
        simpleBlock();
    }
    return 0;
}

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        __block int anInteger = 5; // 加上 __block 修饰符
        
        void (^simpleBlock)(void) = ^{
            NSLog(@"Integer is %d", anInteger);
        };
        
        anInteger = 10;
        
        simpleBlock(); // 加上 __block 修饰符后，打印结果变成了 10
    }
    return 0;
}

// 针对 anInteger 变量专门创建了一个结构体
struct __Block_byref_anInteger_0 {
  void *__isa; // 拥有 isa
__Block_byref_anInteger_0 *__forwarding; // 转发指针，栈区 Block 在 copy 之前都是指向自己
 int __flags;
 int __size;
 int anInteger; // 这里存储变量的值
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_anInteger_0 *anInteger; // by ref // 之前是直接捕获，现在变成了一个结构体指针
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_anInteger_0 *_anInteger, int flags=0) : anInteger(_anInteger->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_anInteger_0 *anInteger = __cself->anInteger; // bound by ref

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_q4_jm3g73557p74v3ncp13gq3l00000gn_T_main_5fc99a_mi_0, (anInteger->__forwarding->anInteger));
        }

// 通过字符串获取到这个类然后生成一个实例。
Class cls = objc_getClass("Person");
Person *p = [cls new];
[p hello];

NSLog(@"%s", class_getName([Person class]));

unsigned int outCount = 0;
Ivar *ivarList = class_copyIvarList([Person class], &outCount);

for (NSUInteger i = 0; i < outCount; i++) {
    Ivar ivar = ivarList[i];
    NSLog(@"%s", ivar_getName(ivar));
    NSLog(@"%s", ivar_getTypeEncoding(ivar));
}

/*
 _name
 @"NSString"
 _age
 q
 */

unsigned int outCount = 0;
objc_property_t *propertyList = class_copyPropertyList([Person class], &outCount);

for (NSUInteger i = 0; i < outCount; i++) {
    objc_property_t p = propertyList[i];
    NSLog(@"%s", property_getName(p));
    NSLog(@"%s", property_getAttributes(p));
}

/*
 name
 T@"NSString",C,N,V_name
 age
 Tq,N,V_age
 */

unsigned int outCount = 0;
Method *methodList = class_copyMethodList([Person class], &outCount);
 
NSMutableDictionary *dict = [NSMutableDictionary dictionary];
for (NSUInteger i = 0; i < outCount; i++) {
    Method method = methodList[i];
    SEL sel = method_getName(method);
    dict[NSStringFromSelector(sel)] = [NSString stringWithUTF8String:method_getTypeEncoding(method)];
}
NSLog(@"%@", dict);

/*
 {
 ".cxx_destruct" = "v16@0:8";
    age = "q16@0:8";
    "helloTo:" = "v24@0:8@16";
    name = "@16@0:8";
    "setAge:" = "v24@0:8q16";
    "setName:" = "v24@0:8@16";
    walk = "v16@0:8";
 }
 */

__unsafe_unretained Protocol **protocolList = class_copyProtocolList([Person class], &outCount);

// 给类分配空间
Class Game = objc_allocateClassPair([NSObject class], "Game", 0);

// 添加变量
BOOL isAdded = class_addIvar(Game, "name", sizeof(NSString *), log2(sizeof(NSString *)), @encode(NSString *));

// 注册类
objc_registerClassPair(Game);

if (isAdded) {
    id game = [[Game alloc] init];
    [game setValue:@"mario" forKey:@"name"];
    NSLog(@"%@", game);
    NSLog(@"%@", [game valueForKey:@"name"]);
}

// <Game: 0x1006aaba0>
// mario

// 获取方法
Method method = class_getInstanceMethod([Person class], @selector(hello));
// 获取方法实现
IMP methodIMP = method_getImplementation(method);
// 获取方法类型（即返回值、参数类型）
const char *types = method_getTypeEncoding(method);

class_addMethod([Animal class], @selector(hi), methodIMP, types);

Animal *a = [Animal new];
[a hi];

Method method1 = class_getInstanceMethod([Person class], @selector(hello));

Method method2 = class_getInstanceMethod([Person class], @selector(walk));

method_exchangeImplementations(method1, method2);

Person *p = [Person new];
[p hello];
[p walk];

// Walk!
// Hello!

// message.h

OBJC_EXPORT id _Nullable
objc_msgSend(id _Nullable self, SEL _Nonnull op, ...)
    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);

Person *olivia = [[Person alloc] init];
[olivia sayHi];

// NSObject.h

+ (BOOL)resolveClassMethod:(SEL)sel OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
+ (BOOL)resolveInstanceMethod:(SEL)sel OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

void playIMP(id self, SEL _cmd) {
    NSLog(@"Game Start!");
}

void playWithTypeIMP(id self, SEL _cmd, GameType type) {
    switch (type) {
        case GameTypeOne:
            NSLog(@"Game Type One Start!");
            break;
        case GameTypeTwo:
            NSLog(@"Game Type Two Start!");
            break;
        case GameTypeThree:
            NSLog(@"Game Type Three Start!");
            break;
        default:
            break;
    }
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(play)) {
        class_addMethod(self, sel, (IMP)playIMP, "v@:");
        return YES;
    } else if (sel == @selector(playWith:)) {
        class_addMethod(self, sel, (IMP)playWithTypeIMP, "v@:i");
        return YES;
    }
    
    return [super resolveInstanceMethod:sel];
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
    
    if (aSelector == @selector(play)) {
        return [SecondGame new]; // 返回一个其他的对象，如果这个对象存在这个方法实现的话
    }
    
    return nil;
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (aSelector == @selector(play)) {
    
        // 这里返回方法签名
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
        // 上面是直接写，下面是返回一个方法的 types，都可以
        // return [self methodSignatureForSelector:@selector(anotherPlay)];
    }
    
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation {

    // 使用另一个方法实现做代替
    if (anInvocation.selector == @selector(play)) {
        anInvocation.selector = @selector(anotherPlay);
        // 也可以是其他类，看实际情况。
        [anInvocation invokeWithTarget:self];
    }
}

// Person

@interface Person : NSObject

- (void)hello;

@end
@implementation Person

- (void)hello {
    NSLog(@"Hello World!");
}

@end

// Machine

@interface Machine : NSObject

- (void)lubricate;

@end
@implementation Machine

- (void)lubricate {
    NSLog(@"Lubricate.");
}

// Robot
@interface Robot : NSObject

- (void)hello;
- (void)lubricate;

@end

#import "Robot.h"
#import "Person.h"
#import "Machine.h"

@interface Robot ()

@property (nonatomic, strong) Person *person;
@property (nonatomic, strong) Machine *machine;

@end

@implementation Robot

- (instancetype)init {
    self = [super init];
    
    if (self) {
        self.person = [[Person alloc] init];
        self.machine = [[Machine alloc] init];
    }
    
    return self;
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
    if ([self.person respondsToSelector:aSelector]) {
        return self.person;
    } else if ([self.machine respondsToSelector:aSelector]) {
        return self.machine;
    } else {
        return [super forwardingTargetForSelector:aSelector];
    }
}

@end

OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0)
OBJC_ROOT_CLASS
OBJC_EXPORT
@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

// Object.mm

typedef struct objc_class *Class;

// objc-runtime-new.h

struct objc_class : objc_object {
    // Class ISA;
    Class superclass; // 父类
    cache_t cache;             // formerly cache pointer and vtable // 方法缓存
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags // 类信息，包括变量、属性、方法等

    class_rw_t *data() const {
        return bits.data();
    } // 把类信息中的可读写部分暴露出来
    
    // ...
};

// objc-runtime-new.h

struct cache_t {

    // ...
public:
    static bucket_t *emptyBuckets();
    
    struct bucket_t *buckets();
    mask_t mask();
    mask_t occupied();
        
    // ...
};

// objc-runtime-new.h

struct bucket_t {
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    explicit_atomic<uintptr_t> _imp; // 无类型的函数指针，对应具体的函数实现
    explicit_atomic<SEL> _sel; // 方法选择器
#else
    explicit_atomic<SEL> _sel;
    explicit_atomic<uintptr_t> _imp;
#endif
    
    // ...
};

// objc-runtime-new.h

struct class_data_bits_t {
    friend objc_class;

    // Values are the FAST_ flags above.
    uintptr_t bits;
    
    // ...

public:

    class_rw_t* data() const {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    } // data，存储可动态改变的部分，内部还包含只读的部分
    
    // ...
    
    // Get the class's ro data, even in the presence of concurrent realization.
    // fixme this isn't really safe without a compiler barrier at least
    // and probably a memory barrier when realizeClass changes the data field
    const class_ro_t *safe_ro() {
        class_rw_t *maybe_rw = data();
        if (maybe_rw->flags & RW_REALIZED) {
            // maybe_rw is rw
            return maybe_rw->ro;
        } else {
            // maybe_rw is actually ro
            return (class_ro_t *)maybe_rw;
        }
    } // 将只读部分暴露出来
    
    // ...
};

// objc-runtime-new.h

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint16_t version;
    uint16_t witness;

    const class_ro_t *ro; // 编译就确定，不能动态修改

    method_array_t methods; // 方法列表
    property_array_t properties; // 属性列表
    protocol_array_t protocols; // 协议列表

    Class firstSubclass;
    Class nextSiblingClass;

    char *demangledName;

    // ...
};

// objc-runtime-new.h

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;
#ifdef __LP64__
    uint32_t reserved;
#endif

    const uint8_t * ivarLayout;
    
    const char * name; // 类名
    method_list_t * baseMethodList; // 方法列表
    protocol_list_t * baseProtocols; // 协议列表
    const ivar_list_t * ivars; // 变量列表

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties; // 属性列表

    // ...

    method_list_t *baseMethods() const {
        return baseMethodList;
    }
    
    // ...
};

// objc-runtime-new.h

struct method_t {
    SEL name; // 方法名
    const char *types; // 方法类型
    MethodListIMP imp; // 方法实现地址

    struct SortBySELAddress :
        public std::binary_function<const method_t&,
                                    const method_t&, bool>
    {
        bool operator() (const method_t& lhs,
                         const method_t& rhs)
        { return lhs.name < rhs.name; }
    };
};

// objc-runtime-new.h

struct protocol_t : objc_object { // 协议也是一个对象
    const char *mangledName; // 协议名
    struct protocol_list_t *protocols; // 协议列表
    method_list_t *instanceMethods; // 实例方法
    method_list_t *classMethods; // 类方法
    method_list_t *optionalInstanceMethods; // 可选实例方法
    method_list_t *optionalClassMethods; // 可选类方法
    property_list_t *instanceProperties; // 实例属性
    
    // ...
};

// objc-runtime-new.h

struct ivar_t {
#if __x86_64__
    // *offset was originally 64-bit on some x86_64 platforms.
    // We read and write only 32 bits of it.
    // Some metadata provides all 64 bits. This is harmless for unsigned 
    // little-endian values.
    // Some code uses all 64 bits. class_addIvar() over-allocates the 
    // offset for their benefit.
#endif
    int32_t *offset; // 地址的偏移
    const char *name; // 变量名
    const char *type; // 变量类型
    // alignment is sometimes -1; use alignment() instead
    uint32_t alignment_raw;
    uint32_t size;

    uint32_t alignment() const {
        if (alignment_raw == ~(uint32_t)0) return 1U << WORD_SHIFT;
        return 1 << alignment_raw;
    }
};

// objc-runtime-new.h

struct property_t {
    const char *name; // 属性名
    const char *attributes; // 属性修饰符
};

Object.mm

typedef struct objc_object *id;

// objc-private.h

struct objc_object {
private:
    isa_t isa;

    // 关于 isa 的一些相关操作，如通过 isa 获取类对象、元类对象
    // 弱引用相关方法
    // 关联对象相关方法
    // 内存管理相关方法
    // ...
};

// objc-private.h

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

// isa.h

#   define ISA_BITFIELD                                                      \
      uintptr_t nonpointer        : 1;                                       \
      uintptr_t has_assoc         : 1;                                       \
      uintptr_t has_cxx_dtor      : 1;                                       \
      uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \
      uintptr_t magic             : 6;                                       \
      uintptr_t weakly_referenced : 1;                                       \
      uintptr_t deallocating      : 1;                                       \
      uintptr_t has_sidetable_rc  : 1;                                       \
      uintptr_t extra_rc          : 19

NSLog(@"Person实例地址：%@", self);

Class personClass = objc_getClass("Person");
NSLog(@"Person类对象地址：%p", personClass);

Class personMetaClass = objc_getMetaClass("Person");
NSLog(@"Person元类对象地址：%p", personMetaClass);

Class personSuperClass = class_getSuperclass(personClass);
NSLog(@"Person父类类对象地址：%p", personSuperClass);

NSObject *obj = [NSObject new];
NSLog(@"NSObject实例地址：%@", obj);

Class objectClass = objc_getClass("NSObject");
NSLog(@"NSObject类对象地址：%p", objectClass);

Class objectMetaClass = objc_getMetaClass("NSObject");
NSLog(@"NSObject元类对象地址：%p", objectMetaClass);

Class objectSuperClass = class_getSuperclass(objectClass);
NSLog(@"NSObject父类类对象地址：%p", objectSuperClass);

NSLog(@"Person实例对象的isa：%p", object_getClass(self));
NSLog(@"Person类对象的isa：%p", object_getClass(personClass));
NSLog(@"Person元类对象的isa：%p", object_getClass(personMetaClass));

NSLog(@"NSObject实例对象的isa：%p", object_getClass(obj));
NSLog(@"NSObject类对象的isa：%p", object_getClass(objectClass));
NSLog(@"NSObject元类对象的isa：%p", object_getClass(objectMetaClass));

/*
 Person实例地址：<Person: 0x1005b5ef0>
 Person类对象地址：0x100003208
 Person元类对象地址：0x1000031e0
 Person父类类对象地址：0x7fff970c7118
 
 NSObject实例地址：<NSObject: 0x103804920>
 NSObject类对象地址：0x7fff970c7118
 NSObject元类对象地址：0x7fff970c70f0
 NSObject父类类对象地址：0x0
 
 Person实例对象的isa：0x100003208
 Person类对象的isa：0x1000031e0
 Person元类对象的isa：0x7fff970c70f0
 
 NSObject实例对象的isa：0x7fff970c7118
 NSObject类对象的isa：0x7fff970c70f0
 NSObject元类对象的isa：0x7fff970c70f0
 */

@interface Person : NSObject

@property (nonatomic, copy) NSString *name;

@end

@implementation Person

@end

@interface Student : Person

@end

@implementation Student

- (instancetype)init {
    self = [super init];
    
    if (self) {
        
        NSLog(@"%@", NSStringFromClass([self class])); // Student
        NSLog(@"%@", NSStringFromClass([super class])); // Student
    }
    
    return self;
}

@end

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained _Nonnull id receiver; // 还是调用者本身

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained _Nonnull Class class;
#else
    __unsafe_unretained _Nonnull Class super_class;
#endif
    /* super_class is the first class to search */
};

Person *olivia = [[Person alloc] init];
[olivia sayHi];

// message.h

OBJC_EXPORT id _Nullable
objc_msgSend(id _Nullable self, SEL _Nonnull op, ...)
    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);

// objc.h

/// An opaque type that represents a method selector.
typedef struct objc_selector *SEL;

OBJC_EXPORT SEL _Nonnull
sel_registerName(const char * _Nonnull str)
    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);

- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;

- (BOOL)isProxy;

- (BOOL)isKindOfClass:(Class)aClass;
- (BOOL)isMemberOfClass:(Class)aClass;
- (BOOL)conformsToProtocol:(Protocol *)aProtocol;

- (BOOL)respondsToSelector:(SEL)aSelector;

#import <objc/runtime.h>
#import <objc/message.h>