iOS 底层原理 文章汇总
本文的面试题主要涉及isa走位 & 继承关系 & 类结构
相关的面试题
以及针对面试题的分析
【面试题】类存在几份?
由于类的信息
在内存
中永远只存在一份
,所以 类对象只有一份
【百度面试题】objc_object 与 对象的关系
所有的
对象
都是以objc_object
为模板继承
过来的所有的对象 是 来自
NSObject
(OC) ,但是真正到底层的 是一个objc_object(C/C++)
的结构体类型
【总结】 objc_object
与 对象
的关系
是 继承
关系
【面试题】什么是 属性 & 成员变量 & 实例变量 ?
属性
(property):在OC中是通过@property开头定义
,且是带下划线成员变量
+setter
+getter
方法的变量成员变量
(ivar):在OC的类中{}中定义
的,且没有下划线
的变量实例变量
:通过当前对象类型,具备实例化的变量
,是一种特殊的成员变量
,例如 NSObject、UILabel、UIButton等
【附加】成员变量 和 实例变量什么区别?
实例变量
(即成员变量
中的对象变量
就是实例变量
):以实例对象实例化来的,是一种特殊的成员变量
NSString
是常量
类型, 因为不能添加属性
,如果定义在类中的{}
中,是成员变量
成员变量
中 除去基本数据类型、NSString
,其他都是实例变量
(即可以添加属性
的成员变量
),实例变量主要是判断是不是对象
【面试题】元类 中为什么会有 类对象 的 类方法?
在中的探索中,我们知道了实例方法
存储在类
中,类方法
存储在元类
中
为了探索我们的面试题现象,定义了以下几个方法,来探索方法
的归属问题
- 在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 {
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__);
}
以下是几个函数调用的打印结果
下面我们挨个分析不同的函数
lgObjc_copyMethodList函数 分析
在这个函数中,主要是获取LGPerson类中的方法列表,从实例方法存储在类中,类方法存储在元类中
可以得知,LGPerson的方法列表打印结果只有sayHello
方法
lgInstanceMethod_classToMetaclass函数 分析
在分析前,需要先了解class_getInstanceMethod
这个方法,主要是用于获取实例方法,针对该方法,苹果有如下说明
其大致含义就是:如果在传入的类或者类的父类中没有找到指定的实例方法,则返回NULL
从上面代码可知,传入的pclass
是类LGPerson
,通过objc_getMetaClass
获取的LGPerson的元类 是元类LGPerson
,函数中4个打印结果分别是:
-
method1
地址:0x1000031b0
- 传入的
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
地址:0x100003148
- 传入的
pClass
是LGPerson元类
,需要去获取selName = sayHappy
的实例方法 - 首先在
LGPerson元类
中查找,发现有sayHappy
的实例方法,主要是因为类对象的类方法存储在元类
中,类方法在元类中是实例方法
,然后返回查找到的实例方法,所以method3
的地址为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类
,selName
是sayHello
- 首先判断
LGPerson类
是否是元类
,此时不是
,返回LGPerson的元类
,然后在元类
中查找sayhello
实例方法。查找顺序如下:元类 --> 根元类 --> 根类 --> nil
,最后返回NULL
-
-
method2 地址:0x0
-
pClass
是LGPerson元类
,selName
是sayHello
- 首先判断
LGPerson元类
是否是元类
,此时是
,直接返回元类,然后在元类
中查找sayhello
实例方法,发现并没有找到,返回NULL
-
-
method3 地址:0x100003148
-
pClass
是LGPerson类
,selName
是sayHappy
- 首先判断
LGPerson类
是否是元类
,此时不是
,返回LGPerson的元类
,然后在元类
中查找sayHappy
实例方法,发现有这个实例方法,直接返回找到的实例方法
-
-
method4 地址:0x100003148
-
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 源码解析(实例方法 & 类方法)
//--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
- 类方法:
类的元类
与传入类
对比 - 实例方法:
对象的父类
与传入类
对比
- 类方法:
然后通过断点
调试,isMemberOfClass
的类方法
和 实例方法
的流程是正常
的,会走到上面分析的源码,而isKindOfClass
根本不会走到上面分析的源码
中(!!!注意这里,这是一个坑点
),而是会走到下面这个源码中,其类方法和实例方法都是走到objc_opt_isKindOfClass
方法源码中
-
汇编调用如下
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);
}
为什么会这样呢?主要是因为在llvm
中编译时对其进行了优化处理
所以调用objc_opt_isKindOfClass
实际走的逻辑如图所示
案例代码执行结果分析
根据源码的分析,来分析代码执行的结果为什么是0
或者1
使用类方法结果解析
- re1 :1 ,是
NSObject
与NSObject
的对比,使用+isKindOfClass
- NSObject(传入类,即
根类
) vs NSObject的元类即根元类
-- 不相等 - NSObject(传入类,即
根类
) vs 根元类的父类即根类
-- 相等,返回1
- NSObject(传入类,即
- re2 :0 ,是
NSObject
与NSObject
的对比,使用+isMemberOfClass
- NSObject
根类
(传入类) vs NSObject的元类即根元类
-- 不相等
- NSObject
- re3 :0 ,是
LGPerson
与LGPerson
的对比,使用+isisKindOfClass
- LGPerson(传入
类
) vs LGPerson的元类即元类
LGPerson -- 不相等 - LGPerson(传入
类
) vs 元类LGPerson的父类即根元类
-- 不相等 - LGPerson(传入
类
) vs 根元类的父类即根类
-- 不相等 - LGPerson(传入
类
) vs 根类的父类即nil
-- 不相等
- LGPerson(传入
- re4 :0 ,是
LGPerson
与LGPerson
的对比,使用+isMemberOfClass
- LGPerson(传入
类
) vs元类
-- 不相等
- LGPerson(传入
使用实例方法结果解析
- re5 :1 ,是
NSObject对象
与NSObject
的对比,使用-isKindOfClass
- NSObject(传入类,即
根类
) vs 对象的isa
即NSObject根类
-- 相等
- NSObject(传入类,即
- re6 :1 ,是
NSObject对象
与NSObject
的对比,使用-isMemberOfClass
- NSObject(传入类,即根类) vs 对象的类即NSObject根类 -- 相等
- re7 :1 ,是
LGPerson对象
与LGPerson
的对比,使用-isKindOfClass
- LGPerson(传入类) vs 对象的
isa
即LGPerson -- 相等
- LGPerson(传入类) vs 对象的
- re8 :1 ,是
LGPerson对象
与LGPerson
的对比,使用-isMemberOfClass
- LGPerson(传入类) vs 对象的类即LGPerson -- 相等