iOS面试系列（附面试答案）
2021-03-24 本文已影响0人
iOS开发面试总结
推荐👇：
推荐作者：iOS的火影乱斗
一、isKindOfClass和isMemberOfClass
题目：
有一道经典面试题关于isKindOfClass和isMemberOfClass
代码：
BOOL re1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]; // 1
BOOL re2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]]; // 0
BOOL re3 = [(id)[LGPerson class] isKindOfClass:[LGPerson class]]; // 0
BOOL re4 = [(id)[LGPerson class] isMemberOfClass:[LGPerson class]]; // 0
NSLog(@" re1 :%hhd\n re2 :%hhd\n re3 :%hhd\n re4 :%hhd\n",re1,re2,re3,re4);
BOOL re5 = [(id)[NSObject alloc] isKindOfClass:[NSObject class]]; // 1
BOOL re6 = [(id)[NSObject alloc] isMemberOfClass:[NSObject class]]; // 1
BOOL re7 = [(id)[LGPerson alloc] isKindOfClass:[LGPerson class]]; // 1
BOOL re8 = [(id)[LGPerson alloc] isMemberOfClass:[LGPerson class]]; // 1
NSLog(@" re5 :%hhd\n re6 :%hhd\n re7 :%hhd\n re8 :%hhd\n",re5,re6,re7,re8);
输出结果：
2019-12-31 14:49:22.734091+0800 LGTest[35237:2807868]
re1 :1
re2 :0
re3 :0
re4 :0
2019-12-31 14:49:22.735580+0800 LGTest[35237:2807868]
re5 :1
re6 :1
re7 :1
re8 :1
为什么结果是这样呢？
答案：
我们先放一个isa的指针图：
再打开一份objc的源码，来看一下对应方法里面的实现
- 1、我们先看一下类的class方法
+ (Class)class {
return self;
}
- 2、看一下类的isKindOfClass的实现
+ (BOOL)isKindOfClass:(Class)cls {
//
for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
if (tcls == cls) return YES;
}
return NO;
}
再看一下object_getClass的源码
Class object_getClass(id obj)
{
if (obj) return obj->getIsa();
else return Nil;
}
我们发现isKindOfClass是循环不断获取self的isa指针以及父类的isa指针指向和cls做对比，通过上面isa的指向图，我们对上面判断一一解释下：
BOOL re1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]; // 1
因为NSObject的isa指向NSObject的元类，先拿到NSObject的元类跟NSObject比，不通过，而NSObject元类的isa指向的是NSObject，然后跟NSObject对比，所以结果是YES
BOOL re3 = [(id)[LGPerson class] isKindOfClass:[LGPerson class]]; // 0
而LGPerson的isa指向依次是LGPerson的元类 ---> NSObject的元类 ---> NSObject --- > nil,然后和LGPerson进行对比，没有匹配的，所以结果是NO
- 3、再看一下类的isMemberOfClass的实现
+ (BOOL)isMemberOfClass:(Class)cls {
return object_getClass((id)self) == cls;
}
我们发现isMemberOfClass仅仅是拿到当前self的isa指针指向和cls对比，然后我们分析测试代码逻辑：
BOOL re2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]]; // 0
NSObject的元类和NSObject不匹配，所以不成立
BOOL re4 = [(id)[LGPerson class] isMemberOfClass:[LGPerson class]]; // 0
LGPerson的元类和LGPerson不匹配，所以不成立
- 4、再看一下实例方法的isKindOfClass方法和isMemberOfClass的实现
- (BOOL)isKindOfClass:(Class)cls {
// 类 - NSObject 类 vs 父类 nil
for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
if (tcls == cls) return YES;
}
return NO;
}
- (BOOL)isMemberOfClass:(Class)cls {
return [self class] == cls;
}
- (Class)class {
return object_getClass(self);
}
这里有一个iOS交流圈：891 488 181 分享BAT,阿里面试题、面试经验，讨论技术，有兴趣的可以进来了解。
我们可以发现对于对象方法，只是拿到对象的isa指向和相应的类对比，而对象的isa指向的都是相应的类，所以下面四个输出结果都是YES。
二、[super class]和[self class]
题目：
我们创建一个集成LGPerson的类LGStudent的类，然后在LGStudent的实例方法里面写下面代码，然后调用该对象方法：
-(void)testSuperClass{
NSLog(@"%@",NSStringFromClass([self class]));
NSLog(@"%@",NSStringFromClass([super class]));
}
输出：
2020-01-16 10:36:23.651909+0800 LGTest[18422:366866] LGStudent
2020-01-16 10:36:23.652760+0800 LGTest[18422:366866] LGStudent
这是为什么呢，[self class]我们都能理解是LGStudent，但是[super class]为什么也是LGStudent呢，不应该是LGPerson吗，下面我们来探索下：
答案：
1、汇编分析法
首先我们开启下汇编调试模式（），在[super class]处加个断点，看看在[super class]处是怎么调用的
我们发现[super class]是通过objc_msgSendSuper2进行发送消息的，而不是通过objc_msgSend发送消息的，我们再到objc源码中去找一下objc_msgSendSuper2的实现
/********************************************************************
* id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
*
* struct objc_super {
* id receiver;
* Class cls; // SUBCLASS of the class to search
* }
********************************************************************/
ENTRY _objc_msgSendSuper2
ldr r9, [r0, #CLASS] // class = struct super->class
ldr r9, [r9, #SUPERCLASS] // class = class->superclass
CacheLookup NORMAL
// cache hit, IMP in r12, eq already set for nonstret forwarding
ldr r0, [r0, #RECEIVER] // load real receiver
bx r12 // call imp
CacheLookup2 NORMAL
// cache miss
ldr r9, [r0, #CLASS] // class = struct super->class
ldr r9, [r9, #SUPERCLASS] // class = class->superclass
ldr r0, [r0, #RECEIVER] // load real receiver
b __objc_msgSend_uncached
END_ENTRY _objc_msgSendSuper2
我们最终在汇编地方找到了实现，并且发现_objc_msgSendSuper2的参数分别为objc_super、SEL等等，其中objc_super是消息接受者，并且它是一个结构体：
* struct objc_super {
* id receiver;
* Class cls; // SUBCLASS of the class to search
* }
我们知道receiver是self，cls是self的父类，_objc_msgSendSuper2其实就从self的父类开始查找方法，但是消息接受者还是self本身，也就类似是让self去调父类的class方法，所以返回的都是LGStudent
2、hook分析法：
我们创建一个NSObject的分类，然后在里面hook一下class方法
+ (void)load{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
[LGRuntimeTool lg_bestMethodSwizzlingWithClass:self oriSEL:@selector(class) swizzledSEL:@selector(lg_class)];
});
}
- (Class)lg_class{
NSLog(@"来了,老弟");
return [self lg_class]; // sel -> imp(class)
}
我们在lg_class里面打一个断点，通过lldb来看一下调进来的self是什么： 打印结果：
2020-01-16 11:04:30.876482+0800 LGTest[19658:395083] 来了,老弟
(lldb) p self
(LGStudent *) $0 = 0x00000001022327c0
2020-01-16 11:04:54.903791+0800 LGTest[19658:395083] 来了,老弟
(lldb) p self
(NSTaggedPointerString *) $1 = 0xd76f961d90151cc3 @"LGStudent"
2020-01-16 11:05:07.057101+0800 LGTest[19658:395083] LGStudent
我们发现调进来的self都是LGStudent，所以也验证了[super class]的调用者还是self本身
三、weak和strong底层原理
问题：
__weak我们在项目中经常用于打破循环引用，但为什么weak可以打破循环引用呢？strong又是怎么回事呢？
答案：
weak
我们在objc源码中的main方法中写上下面这句代码，打上断点并打开汇编调试：
LGPerson __weak *objc = object;
然后我们发现在此处调用了objc_initWeak方法，我们再点击进去：
/**
* Initialize a fresh weak pointer to some object location.
* It would be used for code like:
*
* (The nil case)
* __weak id weakPtr;
* (The non-nil case)
* NSObject *o = ...;
* __weak id weakPtr = o;
*
* This function IS NOT thread-safe with respect to concurrent
* modifications to the weak variable. (Concurrent weak clear is safe.)
*
* @param location Address of __weak ptr.
* @param newObj Object ptr.
*/
id
objc_initWeak(id *location, id newObj)
{
if (!newObj) {
*location = nil;
return nil;
}
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
}
根据注释我们知道weak的使用方法，并且介绍了该方法是用来初始化对象弱指针的，并且是线程不安全的，根据代码进入到了storeWeak函数，我们再进入到storeWeak里面看看。
源码太长就先不放了，根据源码分析，前部分都是对表进行判断的，并且我们知道弱引用指针是存在一个叫SideTable的表中，再往下我们发现如果没表就走weak_register_no_lock函数，看名字知道应该是注册弱引用指针的方法，如果有就走weak_unregister_no_lock方法
我们再进入到weak_register_no_lock方法里：
id
weak_register_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id, bool crashIfDeallocating)
{
objc_object *referent = (objc_object *)referent_id;
objc_object **referrer = (objc_object **)referrer_id;
if (!referent || referent->isTaggedPointer()) return referent_id;
// ensure that the referenced object is viable
bool deallocating;//判断该对象是否在dealloc
if (!referent->ISA()->hasCustomRR()) {
deallocating = referent->rootIsDeallocating();
}else {
BOOL (*allowsWeakReference)(objc_object *, SEL) =
(BOOL(*)(objc_object *, SEL))
object_getMethodImplementation((id)referent,
SEL_allowsWeakReference);
if ((IMP)allowsWeakReference == _objc_msgForward) {
return nil;
}
deallocating =
! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
}
if (deallocating) {
if (crashIfDeallocating) {
_objc_fatal("Cannot form weak reference to instance (%p) of "
"class %s. It is possible that this object was "
"over-released, or is in the process of deallocation.",
(void*)referent, object_getClassName((id)referent));
} else {
return nil;
}
}
// now remember it and where it is being stored
weak_entry_t *entry;//判断表里有没有这个对象的子表，如果有就从weak_table中取出weak_entry_t然后将弱指针插入到weak_entry_t中
if ((entry = weak_entry_for_referent(weak_table, referent))) {
append_referrer(entry, referrer);
}
else { //如果没有就创建一个weak_entry_t，再将这个weak_entry_t插入到weak_table中去
// 创建了这个weak_entry_t 再插入到weak_table
weak_entry_t new_entry(referent, referrer);
weak_grow_maybe(weak_table);
weak_entry_insert(weak_table, &new_entry);
}
// Do not set *referrer. objc_storeWeak() requires that the
// value not change.
return referent_id;
}
从上我们会发现weak指针在创建的时候并没有调用retain操作，并且会将weak指针存储在SideTable的weak_table中，然后每个对象在weak_table里面都有一个对应的weak_entry_t，每个weak_entry_t里面可以放多个弱指针
strong
有了weak我们再看看strong是什么情况呢？ 我们依然打开汇编调试，然后将__weak改成__strong然后运行
LGPerson __strong *objc = object;
我们发现此处调用的是objc_retain，command+点击，进不去，我们就在OBJC源码里面搜，也搜不到，怎么办呢，考虑到汇编一般会在函数前面添加，我们去掉_再次搜索，然后我们找到了objc_retain函数
id
objc_retain(id obj)
{
if (!obj) return obj;
if (obj->isTaggedPointer()) return obj;
return obj->retain();
}
然后进入到retaun函数
inline id
objc_object::retain()
{
assert(!isTaggedPointer());
if (fastpath(!ISA()->hasCustomRR())) {
return rootRetain();
}
return ((id(*)(objc_object *, SEL))objc_msgSend)(this, SEL_retain);
}
发现是通过objc_msgSend发送了SEL_retain消息，然后让引用计数器+1
四、runtime的应用以及注意点
问题：
我们经常在项目中用的runtime，并且用的最多的是交换方法，在交换方法中有哪些注意事项呢：
答案：
1、NSArray 类簇，
类簇实际上是Foundation framework框架下的一种设计模式，它管理了一组隐藏在公共接口下的私有类，
所以涉及到类簇的类，NSDictionary、NSArray、，本身类并不是NSArray等，这个需要去确定该类是否是类簇，然后在确定真正的类是什么，然后对真正的类进行交换才行
2、交换的方法是父类的方法
如果交换的方法是父类的方法，就会导致当父类调用该方法时候报错，因为父类没有子类的方法。
解决方法就是：先尝试给交换的类添加要交换的方法，如果添加成功，说明自己没有这个方法，那么就对该类做替换操作，如果添加失败说明自己有这个方法，那么就直接做交换操作。 代码：
+ (void)lg_betterMethodSwizzlingWithClass:(Class)cls oriSEL:(SEL)oriSEL swizzledSEL:(SEL)swizzledSEL{
if (!cls) NSLog(@"传入的交换类不能为空");
Method oriMethod = class_getInstanceMethod(cls, oriSEL);
Method swiMethod = class_getInstanceMethod(cls, swizzledSEL);
//方式一：
//给cls添加oriSEL方法，确保cls有oriSEL方法
class_addMethod(cls, oriSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
//取到cls的oriSEL的Method，因为上面oriMethod可能是cls父类的，交换的话可能会导致父类找不到swizzledSEL方法
Method oriMethod1 = class_getInstanceMethod(cls, oriSEL);
//交换方法
method_exchangeImplementations(oriMethod1, swiMethod);
/**************************************************************/
//方式二：
//尝试添加，如果添加成功，说明自己没有这个方法，那么就对该类做替换操作，因为此处给oriSEL方法添加的方法指针是swiMethod的方法指针，那么swizzledSEL的指针就要改成oriSEL的指针
//如果添加失败说明自己有这个方法，那么就直接做交换操作
// BOOL isSuccess = class_addMethod(cls, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(oriMethod));
//
// if (isSuccess) {// 自己没有 - 交换 - 没有父类进行处理 (重写一个)
// class_replaceMethod(cls, swizzledSEL, method_getImplementation(oriMethod), method_getTypeEncoding(oriMethod));
//
// }else{ // 自己有就做交换操作
// method_exchangeImplementations(oriMethod, swiMethod);
// }
}
本质就是先给cls添加oriSEL方法，确保cls有了oriSEL方法后再交换，这样就不会交换到cls父类的方法
3、交换的方法不存在
假如交换的方法不存在，就会导致交换失败，那么就要在上面代码中单独处理下单独处理下：
Method oriMethod = class_getInstanceMethod(cls, oriSEL);
Method swiMethod = class_getInstanceMethod(cls, swizzledSEL);
if (!oriMethod) {
// 在oriMethod为nil时，替换后将swizzledSEL复制一个不做任何事的空实现,代码如下:
class_addMethod(cls, oriSEL, method_getImplementation(swiMethod), method_getTypeEncoding(swiMethod));
method_setImplementation(swiMethod, imp_implementationWithBlock(^(id self, SEL _cmd){ }));
}
当方法不存在时候就需要单独给cls添加一个方法实现
五、内存偏移面试题
问题：
我们创建一个有saySomething实例方法的LGPerson的类，问下面代码能执行吗？
id pcls = [LGPerson class];
void *pp= &pcls;
[(__bridge id)pp saySomething];
//p -> LGPerson 实例对象
LGPerson *p = [LGPerson alloc];
[p saySomething];
答案：
答案是可以执行的。为什么呢?我们来分析下：
- 1、首先对象的本质是个结构体，并且第一个元素是isa，isa指向的是对象的类对象
- 2、我们知道指针指向的对象的地址其实就是对象的首地址，所以p指向的是LGPerson对象的首地址isa
- 3、而isa指向的是LGPerson的类对象，那么对象指针就形成了这样的指向关系：p ---> 对象 ---> LGPerson类对象
- 4、再看上面的pcls：pcls指向的是LGPerson的类对象，pp又指向的是pcls，这样也形成了一个指向关系：pp ---> pcls ---> LGPerson类对象
- 5、两者对比起来，p和pp性质就是一样的了，所以上面两个都能执行
疑问：但是对象是个结构体可以执行方法，&pcls只是个地址为啥也能执行方法
我们再扩展一下： 我们将saySomething重写一下，并且给LGPerson增加一个NSString属性name
- (void)saySomething{
NSLog(@"NB %s - %@",__func__,self.name);
}
在执行一下，看一下打印：
2020-01-16 21:07:16.278767+0800 LGTest[50715:802279] NB -[LGPerson saySomething] - <ViewController: 0x7f84047063b0>
这又是为啥呢，我们猜测一下这个地方是野指针，正好ViewController对象在那一块，但是我们多次运行测试后结果却一样，我们来分析一下：
我们做一个测试，在方法中写下如下代码：
int a = 1;
int b = 2;
int c = 3;
int d = 4;
NSLog(@"a = %p\nb = %p\nc = %p\nd = %p\n",&a,&b,&c,&d);
得到打印结果
a = 0x7ffee837d19c
b = 0x7ffee837d198
c = 0x7ffee837d194
d = 0x7ffee837d190
我们发现a、b、c、d地址是连续的，且abcd都是临时变量，变量是以栈的形式存储，
- 1、我们知道OC对象本质是结构体，里面第一个元素是isa，然后下面元素依次是对象的属性
- 2、当我们只有一个属性时候，对象访问属性其实就是将对象的指针下移属性大小的位置
- 3、那么上面那只方式其实访问的就是pp下移8个字节的位置的数据
- 4、每个方法都有两个隐藏参数super和self，所以在方法中临时变量顺序是super、self、pcls、pp，pp指向的是pcls
- 5、当我们用pp获取name的时候，本质上就是得到pcls指针然后往下移name的大小的位置，然后读取值，name大小是8字节，pcls大小也是8字节，所以移完之后正好指向了self
这就是为啥打印出<ViewController: 0x7f84047063b0>的原因。
我们可以再做一个实验，在代码前加上一个NSString临时变量
NSString *tem = @"KC";
id pcls = [LGPerson class];
void *pp= &pcls;
[(__bridge id)pp saySomething];
再执行，打印：
2020-01-16 21:43:05.084478+0800 LGTest[52497:844500] NB -[LGPerson saySomething] - KC
更印证了我们的结果
五、关联对象的原理
问题：
分类中如何创建属性？
答案：
在分类中创建属性，我们一般会写上一个属性，然后实现该属性的set和get方法，再关联对象，这是为什么呢，我们来一步步分析：
1、创建属性
在分类中创建了一个属性，会在rw中属性列表中有数据，然后有了set和get方法，但是该属性没有成员变量，需要重写该属性的set/get方法来保存属性值。
2、重写set/get方法，关联对象
首先我们来看下set方法
-(void)setCate_name:(NSString *)cate_name{
/**
参数一：id object : 给哪个对象添加属性，这里要给自己添加属性，用self。
参数二：void * == id key : 属性名，根据key获取关联对象的属性的值，在objc_getAssociatedObject中通过次key获得属性的值并返回。
参数三：id value : 关联的值，也就是set方法传入的值给属性去保存。
参数四：objc_AssociationPolicy policy : 策略，属性以什么形式保存。
*/
objc_setAssociatedObject(self, @"name",cate_name, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
然后我们再看看objc_setAssociatedObject方法：
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) {
_object_set_associative_reference(object, (void *)key, value, policy);
}
这里我们会发现，苹果对外接口，一般都有一个加_的对内接口与之对应，这是苹果为了解耦合，即使底层内部实现了也不会影响到对外接口，我们再看一下_object_set_associative_reference的实现：
void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
// This code used to work when nil was passed for object and key. Some code
// probably relies on that to not crash. Check and handle it explicitly.
// rdar://problem/44094390
if (!object && !value) return;
assert(object);
if (object->getIsa()->forbidsAssociatedObjects())
_objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
// retain the new value (if any) outside the lock.
// 在锁之外保留新值（如果有）。
ObjcAssociation old_association(0, nil);
// acquireValue会对retain和copy进行操作，
id new_value = value ? acquireValue(value, policy) : nil;
{
// 关联对象的管理类
AssociationsManager manager;
// 获取关联的 HashMap -> 存储当前关联对象
AssociationsHashMap &associations(manager.associations());
// 对当前的对象的地址做按位去反操作 - 就是 HashMap 的key (哈希函数)
disguised_ptr_t disguised_object = DISGUISE(object);
if (new_value) {
// break any existing association.
// 获取 AssociationsHashMap 的迭代器 - (对象的) 进行遍历
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
// secondary table exists
ObjectAssociationMap *refs = i->second;
// 根据key去获取关联属性的迭代器
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
old_association = j->second;
// 替换设置新值
j->second = ObjcAssociation(policy, new_value);
} else {
// 到最后了 - 直接设置新值
(*refs)[key] = ObjcAssociation(policy, new_value);
}
} else {
// create the new association (first time).
// 如果AssociationsHashMap从没有对象的关联信息表，
// 那么就创建一个map并通过传入的key把value存进去
ObjectAssociationMap *refs = new ObjectAssociationMap;
associations[disguised_object] = refs;
(*refs)[key] = ObjcAssociation(policy, new_value);
object->setHasAssociatedObjects();
}
} else {
// setting the association to nil breaks the association.
// 如果传入的value是nil，并且之前使用相同的key存储过关联对象，
// 那么就把这个关联的value移除（这也是为什么传入nil对象能够把对象的关联value移除）
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
old_association = j->second;
refs->erase(j);
}
}
}
}
// release the old value (outside of the lock).
// 最后把之前使用传入的这个key存储的关联的value释放（OBJC_ASSOCIATION_SETTER_RETAIN策略存储的）
if (old_association.hasValue()) ReleaseValue()(old_association);
}
从上面我们梳屡一下逻辑：
- 1、先对传进来的值做下retain或者copy处理得到new_value
- 2、再获取到管理所有关联对象的哈希map总表的管理者AssociationsManager，然后拿到哈希map总表AssociationsHashMap
- 3、对关联对象的地址进行取反操作得到哈希表对应的下标index（其实disguised_ptr_t就是一个long类型的）
- 4、如果得到的new_value不为空的话，就拿到总表的迭代器通过拿到的下标index进行遍历查找
- 5、如果找到管理对象的关联属性哈希map表，然后再通过key去遍历取值，
- 如果取到了，就先把新值设置到key上，再将旧值释放掉
- 如果没取到，就直接将新值设置在key上
- 6、如果没找到关联对象的关联属性哈希map表，就创建一个表，然后将新值设置在key上
- 7、如果得到的new_value为空的话，就尝试取值，取到了的话就将key对应的值置为nil，如果取不到就不做处理
我们再看一下objc_getAssociatedObject：
id objc_getAssociatedObject(id object, const void *key) {
return _object_get_associative_reference(object, (void *)key);
}
id _object_get_associative_reference(id object, void *key) {
id value = nil;
uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
{
// 关联对象的管理类
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
// 生成伪装地址。处理参数 object 地址
disguised_ptr_t disguised_object = DISGUISE(object);
// 所有对象的额迭代器
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
// 内部对象的迭代器
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
// 找到 - 把值和策略读取出来
ObjcAssociation &entry = j->second;
value = entry.value();
policy = entry.policy();
// OBJC_ASSOCIATION_GETTER_RETAIN - 就会持有一下
if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
objc_retain(value);
}
}
}
}
if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
objc_autorelease(value);
}
return value;
}
发现流程跟objc_setAssociatedObject反过来而已~
推荐👇：
作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：891 488 181 ，不管你是小白还是大牛欢迎入驻 ，分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长！
申请即送：
-
BAT大厂面试题、独家面试工具包,
-
资料免费领取，包括 数据结构、底层进阶、图形视觉、音视频、架构设计、逆向安防、RxSwift、flutter，
文章到这里就结束了，你也可以私信我及时获取最新资料以及面试相关资料。如果你有什么意见和建议欢迎给我留言。
