iOS-底层原理 ：类 & isa 经典问题分析

2020-09-16  本文已影响0人  z夜流星

今天主要研究isa走位 & 继承关系 & 类结构 相关的问题的分析

类存在几份？

由于类的信息在内存中永远只存在一份，所以 类对象只有一份

objc_object 与 对象的关系

总结： objc_object 与 对象的关系 是 继承关系

什么是 属性 & 成员变量 & 实例变量 ？
成员变量 和 实例变量什么区别？
元类 中为什么会有 类对象 的 类方法？

在以下的探索中，我们知道了实例方法 存储在类中，类方法存储在元类中

为了探索这种现象，定义了以下几个方法，来探索方法的归属问题

@interface LGPerson : NSObject
- (void)sayHello;
+ (void)sayHappy;

@end

@implementation LGPerson

- (void)sayHello{
    NSLog(@"LGPerson say : Hello!!!");
}

+ (void)sayHappy{
    NSLog(@"LGPerson say : Happy!!!");
}

@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        LGPerson *person = [LGPerson alloc];
        Class pClass     = object_getClass(person);
        lgObjc_copyMethodList(pClass);

        lgInstanceMethod_classToMetaclass(pClass);
        lgClassMethod_classToMetaclass(pClass);
        NSLog(@"Hello, World!");
    }
    return 0;
}


void lgObjc_copyMethodList(Class pClass){
    unsigned int count = 0;
    Method *methods = class_copyMethodList(pClass, &count);
    for (unsigned int i=0; i < count; i++) {
        Method const method = methods[I];
        //获取方法名
        NSString *key = NSStringFromSelector(method_getName(method));

        LGLog(@"Method, name: %@", key);
    }
    free(methods);
}


void lgInstanceMethod_classToMetaclass(Class pClass){

    const char *className = class_getName(pClass);
    Class metaClass = objc_getMetaClass(className);

    Method method1 = class_getInstanceMethod(pClass, @selector(sayHello));
    Method method2 = class_getInstanceMethod(metaClass, @selector(sayHello));

    Method method3 = class_getInstanceMethod(pClass, @selector(sayHappy));
    Method method4 = class_getInstanceMethod(metaClass, @selector(sayHappy));

    LGLog(@"%s - %p-%p-%p-%p",__func__,method1,method2,method3,method4);
}


void lgClassMethod_classToMetaclass(Class pClass){

    const char *className = class_getName(pClass);
    Class metaClass = objc_getMetaClass(className);

    Method method1 = class_getClassMethod(pClass, @selector(sayHello));
    Method method2 = class_getClassMethod(metaClass, @selector(sayHello));

    Method method3 = class_getClassMethod(pClass, @selector(sayHappy));
    // 元类 为什么有 sayHappy 类方法 0 1
    //
    Method method4 = class_getClassMethod(metaClass, @selector(sayHappy));

    LGLog(@"%s-%p-%p-%p-%p",__func__,method1,method2,method3,method4);
}


void lgIMP_classToMetaclass(Class pClass){

    const char *className = class_getName(pClass);
    Class metaClass = objc_getMetaClass(className);

    // - (void)sayHello;
    // + (void)sayHappy;
    IMP imp1 = class_getMethodImplementation(pClass, @selector(sayHello));
    IMP imp2 = class_getMethodImplementation(metaClass, @selector(sayHello));

    IMP imp3 = class_getMethodImplementation(pClass, @selector(sayHappy));
    IMP imp4 = class_getMethodImplementation(metaClass, @selector(sayHappy));

    NSLog(@"%p-%p-%p-%p",imp1,imp2,imp3,imp4);
    NSLog(@"%s",__func__);
}

以下是几个函数调用的打印结果

下面我们挨个分析不同的函数

lgObjc_copyMethodList函数 分析

在这个函数中，主要是获取LGPerson类中的方法列表，从实例方法存储在类中，类方法存储在元类中可以得知，LGPerson的方法列表打印结果只有sayHello方法

lgInstanceMethod_classToMetaclass函数 分析

在分析前，需要先了解class_getInstanceMethod这个方法，主要是用于获取实例方法。

Method class_getInstanceMethod(Class cls,SEL name )

如果在传入的类或者类的父类中没有找到指定的实例方法，则返回NULL

从上面代码可知，传入的pclass 是类LGPerson，通过objc_getMetaClass获取的LGPerson的元类 是元类LGPerson，函数中4个打印结果分别是：

lgClassMethod_classToMetaclass函数 分析

在分析前，需要先了解class_getClassMethod这个方法，主要是用于获取类方法。

Method class_getClassMethod(Class cls,SEL name )

如果在传入的类或者类的父类中没有找到指定的实例方法，则返回NULL

然后再来看该方法的源码实现，可以得出class_getClassMethod的实现是获取类的类方法，其本质就是获取元类的实例方法，最终还是会走到class_getInstanceMethod，但是在这里需要注意的一点是：在getMeta源码中，如果判断出cls是元类，那么就不会再继续往下递归查找，会直接返回this，其目的是为了防止元类的无限递归查找

//获取类方法
Method class_getClassMethod(Class cls, SEL sel)
{
    if (!cls  ||  !sel) return nil;

    return class_getInstanceMethod(cls->getMeta(), sel);
}


//获取元类
 // NOT identical to this->ISA when this is a metaclass 判断是否是元类，是元类就直接返回，反之，继续找isa指向
Class getMeta() {
    if (isMetaClass()) return (Class)this;
    else return this->ISA();
}

所以针对该函数的打印结果有以下分析

从上面的分析结果中，我们就发现了一个问题 method4也不为NULL，此时就很疑惑：元类中为什么会有 sayHappy 类方法？

主要还是因为class_getClassMethod方法在元类的判断导致的，这是苹果人为制造的 递归终止条件，目的就是防止无限次递归

lgIMP_classToMetaclass函数 分析

class_getMethodImplementation 主要是返回方法的具体实现，针对这个方法有如下官方说明

Method class_getMethodImplementation(Class cls,SEL name )

该函数在向类实例发送消息时会被调用，并返回一个指向方法实现函数的指针。这个函数会比method_getImplementation(class_getInstanceMethod(cls, name))更快。返回的函数指针可能是一个指向runtime内部的函数，而不一定是方法的实际实现。如果类实例无法响应selector，则返回的函数指针将是运行时消息转发机制的一部分

下面我们也可以通过这个方法的源码来印证上面的这个说法，

IMP class_getMethodImplementation(Class cls, SEL sel)
{
    IMP imp;

    if (!cls  ||  !sel) return nil;

    //查找方法实现
    imp = lookUpImpOrNil(nil, sel, cls, LOOKUP_INITIALIZE | LOOKUP_RESOLVER);

    //如果没有找到，则进行消息转发
    if (!imp) {
        return _objc_msgForward;
    }

    return imp;
}

接下来分析这个函数中的4个打印结果

总结

iskindOfClass & isMemberOfClass 的理解

关于iskindOfClass & isMemberOfClass的代码，分析出最终结果

//-----使用 iskindOfClass & isMemberOfClass 类方法
BOOL re1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];       //
BOOL re2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];     //
BOOL re3 = [(id)[LGPerson class] isKindOfClass:[LGPerson class]];       //
BOOL re4 = [(id)[LGPerson class] isMemberOfClass:[LGPerson class]];     //
NSLog(@" re1 :%hhd\n re2 :%hhd\n re3 :%hhd\n re4 :%hhd\n",re1,re2,re3,re4);


//------iskindOfClass & isMemberOfClass 实例方法
BOOL re5 = [(id)[NSObject alloc] isKindOfClass:[NSObject class]];       //
BOOL re6 = [(id)[NSObject alloc] isMemberOfClass:[NSObject class]];     //
BOOL re7 = [(id)[LGPerson alloc] isKindOfClass:[LGPerson class]];       //
BOOL re8 = [(id)[LGPerson alloc] isMemberOfClass:[LGPerson class]];     //
NSLog(@" re5 :%hhd\n re6 :%hhd\n re7 :%hhd\n re8 :%hhd\n",re5,re6,re7,re8);

其最终结果打印如下

####### 源码解析

先分析结果之前，首先需要分析下这两个方法的源码

//--isKindOfClass---类方法、对象方法
//+ isKindOfClass：第一次比较是 获取类的元类 与 传入类对比，再次之后的对比是获取上次结果的父类 与 传入 类进行对比
+ (BOOL)isKindOfClass:(Class)cls {
    // 获取类的元类 vs 传入类
    // 根元类 vs 传入类
    // 根类 vs 传入类
    // 举例：LGPerson vs 元类 (根元类) (NSObject)
    for (Class tcls = self->ISA(); tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

//- isKindOfClass：第一次是获取对象类 与 传入类对比，如果不相等，后续对比是继续获取上次 类的父类 与传入类进行对比
- (BOOL)isKindOfClass:(Class)cls {
/*
获取对象的类 vs 传入的类 
父类 vs 传入的类
根类 vs 传入的类
nil vs 传入的类
*/
    for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}


//-----类方法
//+ isMemberOfClass : 获取类的元类，与 传入类对比
+ (BOOL)isMemberOfClass:(Class)cls {
    return self->ISA() == cls;
}
//-----实例方法
//- isMemberOfClass : 获取对象的类，与 传入类对比
- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

源码分析总结

案例代码执行结果分析

根据源码的分析，来分析代码执行的结果为什么是0或者1

使用类方法结果解析

使用实例方法结果解析

上一篇下一篇

猜你喜欢

热点阅读