ios 底层-经典面试题

1.元类中为什么会有类对象的类方法

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

为了探索我们面试题现象，定义了以下方法进行探索方法的归属。

• 在LGPerson中定义类方法和实例方法

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

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

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

@end

• main函数，用于调用自定义的方法

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        // 0x0000000100000000
        // LGTeacher *teacher = [LGTeacher alloc];

        LGPerson *person = [LGPerson alloc];
        Class pClass     = object_getClass(person);
        lgObjc_copyMethodList(pClass);

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

• lgObjc_copyMethodList 函数：用于获取类的方法列表

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

• lgInstanceMethod_classToMetaclass函数：用于获取类的实例方法

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

• lgClassMethod_classToMetaclass函数：用于获取类的类方法

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

• lgIMP_classToMetaclass函数：用于获取方法的实现

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

打印结果是

Method, name: sayHello
lgInstanceMethod_classToMetaclass - 0x1000031b0-0x0-0x0-0x100003148
lgClassMethod_classToMetaclass-0x0-0x0-0x100003148-0x100003148
2020-09-16 09:08:11.552454+0800 002-类方法归属分析[34960:402763] Hello, World!
Program ended with exit code: 0

现在针对不同的函数进行分析

lgObjc_copyMethodList函数分析

这个函数，主要是获取LGPerson类中的方法列表，通过探索，我们知道实例方法存储在类中，类方法存储在元类中并且在元类的类方法称为实例方法，由此LGPerson打印结果只有sayHello

lgInstanceMethod_classToMetaclass函数分析

苹果官方文档中对class_getInstanceMethod方法的解释，主要用于获取实例方法。

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

根据代码可以知道，传入的pclass 是类LGPerson，objc_getMetaClass获取元类。打印结果的分析

• method1地址：0x1000031b0
  • 传入pclass是LGPerson类，需要获取name = sayHello的实例方法。
  • 首先在LGPerson类中查找，根据实例方法存储在类中可知是有这个实例方法，返回method1地址：0x1000031b0。
• method2地址：0x0
  • 传入pclass是LGPerson元类，需要获取name = sayHello的实例方法。
  • 查找顺序元类 --> 根元类 --> 根类 --> nil，直到最后也没有找到,所以class_getInstanceMethod返回NULL，其method2的地址为0x0，表示未找到
• method3地址：0x0
  • 传入pclass是LGPerson类，需要获取name = sayHappy的实例方法。
  • 首先在LGPerson类中查找，查找顺序LGPerson类 --> 根类 --> nil，根据类方法存储在元类中，因此没有找到实例方法，所以method3地址：0x0。
• method4地址：0x100003148
  • 传入pclass是LGPerson元类，需要获取name = sayHappy的实例方法。
  • 首先LGPerson元类中查找，因为类方法存储在元类中并且在元类的类方法称为实例方法，所以是有sayHappy的实例方法，由此method4地址：0x100003148

lgClassMethod_classToMetaclass函数分析

苹果官方文档中对class_getClassMethod方法的解释，主要用于获取类方法。

大致含义就是：如果在传入的类或者类的父类中没有找到指定的类方法，则返回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();
}

打印结果有以下分析

• method1 地址：0x0
  • pClass 是 LGPerson类，name 是 sayHello
  • 判断 LGPerson类 是否是元类，此时不是，返回LGPerson的元类，然后在元类中查找 sayhello实例方法。查找顺序如下：元类 --> 根元类 --> 根类 --> nil，最后返回NULL
• method2 地址：0x0
  • pClass 是 LGPerson元类，name 是 sayHello
  • 判断 LGPerson类 是否是元类，此时是，然后在元类中查找 sayhello实例方法。查找顺序如下：元类 --> 根元类 --> 根类 --> nil，最后返回NULL
• method3 地址：0x100003148
  • pClass 是 LGPerson类，name 是 sayHappy
  • 判断 LGPerson类 是否是元类，此时不是，然后在元类中查找 sayHappy实例方法，发现有这个实例方法，直接返回找到的实例方法
• method4 地址：0x100003148
  • pClass 是 LGPerson元类，name 是 sayHappy
  • 判断 LGPerson类 是否是元类，此时是，然后在元类中查找 sayHappy实例方法，发现有这个实例方法，直接返回找到的实例方法

从上面分析结果中，我们发现了一个问题method4不为NULL，那么为什么元类中为什么会有 sayHappy 类方法？
主要还是因为class_getClassMethod方法在元类的判断导致的，这是苹果人为制造的 递归终止条件，目的就是防止无限次递归

lgIMP_classToMetaclass函数分析

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

其大致含义就是：该函数在向类实例发送消息时会被调用，并返回一个指向方法实现函数的指针。这个函数会比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;
}

• imp1： 函数指针地址：0x100001d00

  • pClass是LGPerson类，sel是sayHelloc
  • 在LGPerson查到sayHello的具体实现，所以返回imp函数的指针地址

• imp2 函数指针地址：0x7fff66238d80

  • pClass是LGPerson元类，sel是sayHelloc
  • 根据类方法存储在元类中，实例方法存储在类中，sayHello是一个实例方法，并不存储在元类中，也没有其任何实现，所以进行了消息转发

• imp3 函数指针地址：0x7fff66238d80

  • pClass 是 LGPerson类，sel 是 sayHappy
  • 在LGPerson找不到sayHappy，所以进行了消息转发

• imp4 函数指针地址：0x100001d30

  • pClass 是 LGPerson元类，sel 是 sayHappy
  • 在LGPerson查到sayHappy的具体实现，所以返回imp函数的指针地址

• imp4 函数指针地址：0x100001d30

• class_getInstanceMethod：获取实例方法，如果指定的类或其父类不包含带有指定选择器的实例方法，则为NULL

• class_getClassMethod：获取类方法，如果指定的类或其父类不包含具有指定选择器的类方法，则为NULL。

• class_getMethodImplementation：获取方法的具体实现，如果未查找到，则进行消息转发

2.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---类方法、对象方法
//+ 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（实例方法 & 类方法）

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

isKindOfClass

• 类方法：元类（isa） --> 根元类（父类） --> 根类（父类） --> nil（父类） 与 传入类的对比
• 实例方法：对象的类 --> 父类 --> 根类 --> nil与 传入类的对比

isMemberOfClass

• 类方法： 类的元类 与 传入类 对比
• 实例方法：对象的父类与 传入类 对比

objc_opt_isKindOfClass方法源码如下

// Calls [obj isKindOfClass]
BOOL
objc_opt_isKindOfClass(id obj, Class otherClass)
{
#if __OBJC2__
    if (slowpath(!obj)) return NO;
    //获取isa，
    //如果obj 是对象，则isa是类，
    //如果obj是类，则isa是元类
    Class cls = obj->getIsa(); 
    if (fastpath(!cls->hasCustomCore())) {
        // 如果obj 是对象，则在类的继承链进行对比，
        // 如果obj是类，则在元类的isa中进行对比
        for (Class tcls = cls; tcls; tcls = tcls->superclass) { 
            if (tcls == otherClass) return YES;
        }
        return NO;
    }
#endif
    return ((BOOL(*)(id, SEL, Class))objc_msgSend)(obj, @selector(isKindOfClass:), otherClass);
}

通过断点调试，我们可以发现isMemberOfClass的类方法和实例方法都会走上面的源码，但是isKindOfClass不走上面的源码（需要的点），而是类方法还是实例方法都会走objc_opt_isKindOfClass
这种现象是llvm编译时，对其做了优化处理

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

类方法分析

• re1 :1 ，是 NSObject 与 NSObject 的对比，使用 +isKindOfClass
  • NSObject（传入类，即根类） vs NSObject的元类即根元类-- 不相等
  • NSObject（传入类，即根类） vs 根元类的父类即根类 -- 相等，返回1
• re2 :0 ，是 NSObject 与 NSObject 的对比，使用 +isMemberOfClass
  • NSObject根类（传入类） vs NSObject的元类即根元类 -- 不相等
• re3 :0 ，是 LGPerson 与 LGPerson 的对比，使用 +isisKindOfClass
  • LGPerson（传入类） vs LGPerson元类 --不相等
  • LGPerson（传入类） vs LGPerson元类的父类即根元类 --不相等
  • LGPerson（传入类） vs LGPerson根元类的父类即根类 --不相等
  • LGPerson（传入类） vs LGPerson根类的父类即nil --不相等
• re4 :0 ，是 LGPerson 与 LGPerson 的对比，使用 +isMemberOfClass
  • LGPerson（传入类） vs 元类 -- 不相等

实例方法调用

• re5 :1 是 NSObject对象 与 NSObject 的对比，使用-isKindOfClass
  * NSObject（传入类，即根类） vs 对象的类即NSObject根类 -- 相等
• re6 :1 是 NSObject对象 与 NSObject 的对比，使用-isMemberOfClass
  • NSObject（传入类，即根类） vs 对象的类即NSObject根类 -- 相等
• re7 :1 ，是 LGPerson对象 与 LGPerson 的对比，使用 -isKindOfClass
  • LGPerson（传入类） vs 对象的类（LGPerson） -- 相等
• re8 :1 ，是 LGPerson对象 与 LGPerson 的对比，使用-isMemberOfClass`
  • LGPerson（传入类） vs 对象的类（LGPerson） -- 相等