类 & isa 经典面试题分析

本文的面试题主要涉及isa走位 & 继承关系 & 类结构 相关的面试题以及针对面试题的分析

【面试题】类存在几份？

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

【百度面试题】objc_object 与 对象的关系

• 所有的对象 都是以 objc_object为模板继承过来的
• 所有的对象 是 来自 NSObject（OC） ，但是真正到底层的 是一个objc_object（C/C++）的结构体类型

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

【面试题】属性 & 成员变量 & 实例变量

• 实例变量是一种特殊的成员变量（类的实例化）
• 属性是带下划线成员变量 + setter + getter方法的变量

获取成员变量和属性

void lgObjc_copyIvar_copyProperies(Class pClass){
    unsigned int count = 0;
    Ivar *ivars = class_copyIvarList(pClass, &count);
    for (unsigned int i=0; i < count; i++) {
        Ivar const ivar = ivars[i];
        //获取实例变量名
        const char*cName = ivar_getName(ivar);
        NSString *ivarName = [NSString stringWithUTF8String:cName];
        LGLog(@"class_copyIvarList:%@",ivarName);
    }
    free(ivars);

    unsigned int pCount = 0;
    objc_property_t *properties = class_copyPropertyList(pClass, &pCount);
    for (unsigned int i=0; i < pCount; i++) {
        objc_property_t const property = properties[i];
        //获取属性名
        NSString *propertyName = [NSString stringWithUTF8String:property_getName(property)];
        //获取属性值
        LGLog(@"class_copyProperiesList:%@",propertyName);
    }
    free(properties);
}

【面试题】类方法归属分析

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

为了探索我们的面试题现象，定义了以下几个方法，来探索方法的归属问题

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

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

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

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

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

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

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

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

lgObjc_copyMethodList函数 分析

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

Method, name: sayHello
Method, name: name
Method, name: .cxx_destruct
Method, name: setName:
Method, name: obj
Method, name: setObj:

lgInstanceMethod_classToMetaclass函数 分析

在分析前，需要先了解class_getInstanceMethod这个方法，主要是用于获取实例方法，针对该方法，苹果有如下说明

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

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

• method1 地址：0x1000081c0

  • 传入的pClass是LGPerson类，需要去获取selName = sayHello的实例方法
  • 首先在LGPerson中查找，有前面的LGPerson类可知，是有这个实例方法的，所以会返回查找到的实例方法，所以method1的地址不为0x0

• method2 地址：0x0

  • 传入的pClass是LGPerson元类，需要去获取selName = sayHello的实例方法
  • 其查找的顺序为元类 --> 根元类 --> 根类 --> nil，直到最后也没有找到,所以class_getInstanceMethod返回NULL，其method2的地址为0x0，表示未找到

• method3 地址：0x0

  • 传入的pClass是LGPerson类，需要去获取selName = sayHappy的实例方法
  • 查找顺序为LGPerson类 --> 根类 --> nil,也没有找到sayhello实例方法，返回NULL，所以method3的地址为0x0，表示未找到

• method4 地址：0x100008158

  • 传入的pClass是LGPerson元类，需要去获取selName = sayHappy的实例方法
  • 首先在LGPerson元类中查找,发现有sayHappy的实例方法，主要是因为类对象的类方法存储在元类中，类方法在元类中是实例方法，然后返回查找到的实例方法，所以method4的地址为0x100008158，表示找到了指定的实例方法 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类，selName 是 sayHello
  • 首先判断 LGPerson类 是否是元类，此时不是，返回LGPerson的元类，然后在元类中查找 sayhello实例方法。查找顺序如下：元类 --> 根元类 --> 根类 --> nil，最后返回NULL

• method2 地址：0x0

  • pClass 是 LGPerson元类，selName 是 sayHello
  • 首先判断 LGPerson元类 是否是元类，此时是，直接返回元类，然后在元类中查找 sayhello实例方法，发现并没有找到，返回NULL

• method3 地址：0x100008158

  • pClass 是 LGPerson类，selName 是 sayHappy
  • 首先判断 LGPerson类 是否是元类，此时不是，返回LGPerson的元类，然后在元类中查找 sayHappy实例方法，发现有这个实例方法，直接返回找到的实例方法

• method4 地址：0x100008158

  • pClass 是 LGPerson元类，selName 是 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;
}

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

• imp1 函数指针地址：0x100001d00

  • pClass 是 LGPerson类，sel 是 sayHello
  • 根据LGPerson文件，可以得出LGPerson类中可以查找到sayHello的具体实现，所以返回一个imp函数指针的地址

• imp2 函数指针地址：0x7fff66238d80

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

• imp3 函数指针地址：0x7fff66238d80

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

• imp4 函数指针地址：0x100001d30

  • pClass 是 LGPerson元类，sel 是 sayHappy
  • 根据类方法存储在元类文件，可以在元类中查找到sayHappy的具体实现，所以返回一个imp函数指针的地址

总结

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

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

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

【面试题】iskindOfClass & isMemberOfClass 的理解

有这么几行关于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 实例方法调用

//------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 源码解析（实例方法 & 类方法）

• isMemberOfClass 源码解析（实例方法 & 类方法）

源码分析总结

• isKindOfClass

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

• isMemberOfClass

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

然后通过断点调试，isMemberOfClass 的类方法 和 实例方法的流程是正常的，会走到上面分析的源码，而isKindOfClass根本不会走到上面分析的源码中（！！！注意这里，这是一个坑点），而是会走到下面这个源码中，其类方法和实例方法都是走到objc_opt_isKindOfClass方法源码中

汇编调用如下

• objc_opt_isKindOfClass方法源码如下

为什么会这样呢？主要是因为在llvm中编译时对其进行了优化处理

所以调用objc_opt_isKindOfClass实际走的逻辑如图所示

案例代码执行结果分析

根据源码的分析，来分析代码执行的结果为什么是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 -- 不相等
  • LGPerson（传入类） vs 元类LGPerson的父类即根元类 -- 不相等
  • LGPerson（传入类） vs 根元类的父类即根类 -- 不相等
  • LGPerson（传入类） vs 根类的父类即 nil -- 不相等

• re4 :0 ，是 LGPerson 与 LGPerson 的对比，使用 +isMemberOfClass

  • LGPerson（传入类） vs 元类 -- 不相等 使用实例方法结果解析

• re5 :1 ，是 NSObject对象 与 NSObject 的对比，使用 -isKindOfClass

  • NSObject（传入类，即根类） vs 对象的isa即NSObject根类 -- 相等

• re6 :1 ，是 NSObject对象 与 NSObject 的对比，使用 -isMemberOfClass

  • NSObject（传入类，即根类） vs 对象的类即NSObject根类 -- 相等

• re7 :1 ，是 LGPerson对象 与 LGPerson 的对比，使用 -isKindOfClass

  • LGPerson（传入类） vs 对象的isa即LGPerson -- 相等

• re8 :1 ，是 LGPerson对象 与 LGPerson 的对比，使用 -isMemberOfClass

  • LGPerson（传入类） vs 对象的类即LGPerson -- 相等