OC语法相关
1.一个NSObject对象占用多少内存?
- 系统分配了16个字节给NSObject对象(通过malloc_size函数获得)
- 但NSObject对象内部只使用了8个字节的空间(在64bit环境下,可以ton过class_getInstanceSize函数获得
2.对象的isa指针指向哪里?
- instance对象的isa指针指向class对象
- class对象的isa指针指向meta-class对象
- meta-class对象的isa指针指向基类的meta-class对象
3.OC的类信息存放在哪里?
- 对象方法、属性、成员变量、协议信息,存放在class对象中
- 类方法,存放在meta-class对象中
- 成员变量的具体值,存放在instance对象
KVO
-
KVO的全称是Key-Value-Observing,俗称“键值监听”,可以用于监听某个对象属性值的改变
——————监听—————— Person(age) Observer <————————————————
未使用KVO监听的对象
- Person的instance对象(isa)
- Person的class对象(isa、superclass、setAge:、age、......)
- [Person setAge:]
- [Person age]
使用了KVO监听的对象
- Person的instance对象(isa)
- NSKVONotifying_Person的class对象(isa、superclass、setAge:、class、dealloc、_isKVOA、......)
- setAge: 内部调用 Foundation的 _NSSetIntValueAndNotify
- class return [Person class]
- Person的class对象(isa、superclass、setAge:、age、......)
- [Person setAge:]
- [Person age]
_NSSet*ValueAndNotify的内部实现
[self willChangeValueForKey:@"age"];
// 原来的setter实现
[self didChangeValueForKey:@"age"];
- 调用willChangeValueForKey:
- 调用原来的setter实现
- 调用didChangeValueForKey:
- didChangeValueForKey:内部会调用observer的observeValueForKeyPath:ofObject:change:context:方法
1.iOS用什么方式实现对一个对象的KVO?(KVO的本质是什么?)
- 利用RuntimeApi动态生成一个子类,并且让instance对象的isa指针指向这个全新的子类
- 当修改instance对象的属性时,会调用Foundation的_NSSetXXXValueAndNotify函数
- willChangeValueForKey:
- 父类原来的setter
- didChangeValueForKey:
- 内部会触发监听器(Oberser)的监听方法(observeValueForKeyPath:ofObject:change:context:)
2.如何手动触发KVO?
手动调用willChangeValueForKey:和didChangeValueForKey:
3.直接修改成员变量会触发KVO么?
不会触发KVO
4.通过KVC修改属性会触发KVO么?
会触发KVO
KVC
- KVC的全称是Key-Value Coding,俗称”键值编码“,可以通过一个key来访问某个属性
常见的API
- (void)setValue:(id)value forKeyPath:(NSString *)keyPath;
- (void)setValue:(id)value forKey:(NSString *)key;
- (id)valueForKeyPath:(NSString *)keyPath;
- (id)valueForKey:(NSString *)key;
setValue:forKey:的原理
- setValue:forKey:
- 按照setKey:、_setKey:顺序查找方法
-
找到了方法
(传递参数,调用方法) -
没找到方法
- 查看accessInstanceVariablesDirectly方法的返回值
- NO(调用setValue:forUndefinedKey并抛出异常NSUnknownKeyException
- YES
- 按照 _key、 _isKey、key、isKey顺序查找成员变量
- 找到了成员变量(直接赋值)
- 没有找到成员变量(调用setValue:forUndefinedKey:并抛出异常NSUnknownKeyException)
- 按照 _key、 _isKey、key、isKey顺序查找成员变量
- 查看accessInstanceVariablesDirectly方法的返回值
-
- 按照setKey:、_setKey:顺序查找方法
valueForKey:的原理
- valueForKey:
- 按照 getKey、key、isKey、_key顺序查找方法
- 找到了方法(调用方法)
- 没找到方法
- 查看accessInstanceVariablesDirectly方法的返回值
- NO(调用valueForUndefinedKey:并抛出异常NSUnknownKeyException)
- YES(按照_key、isKey、key、isKey的顺序查找成员变量)
- 找到了成员变量(直接取值)
- 没有找到成员变量(调用valueForUndefindKey:并抛出异常NSUnknownKeyException)
- 查看accessInstanceVariablesDirectly方法的返回值
- 按照 getKey、key、isKey、_key顺序查找方法
Category
Category的底层结构
- 定义在objc-runtime-new.h中
struct category_t {
const char * name;
classref_t cls;
struct method_list_t * instanceMethods;
struct methos_list_t * classMethods;
struct protocol_list_t * protocols;
struct property_list_t * instanceProperties;
struct property_list_t * _classProperties;
method_list_t * methodsForMeta(bool isMeta) {
if (isMeta) return classMethods;
else return instanceMethods;
}
property_list_t * propertiesForMeta(bool isMeta, struct header_info * hi);
};
Category的加载处理过程
- 1.通过Runtime加载某个类的所有Category数据
- 2.把所有Category方法、属性、协议数据,合并到一个大数组中
- 后面参与编译的Category数据,会在数组的前面
- 3.将合并后的分类数据(方法、属性、协议),插入到类原来数据的前面
源码解读顺序
objc-os.mm
_objc_init
map_images
map_images_nolock
objc_runtime-new.mm
_read_images
remethodizeClass
attachCategories
attachLists
realloc、memmove、memcpy
1.Category的使用场合是什么?
- Category的实现原理
- Category编译之后的底层结构是struct categort_t,里面存储着分类的对象方法、类方法、属性、协议信息
- 在程序运行的时候,runtime会将Category的数据,合并到类信息中(类对象、元类对象中)
- Category和Class Extension的区别是什么?
- Class Extension在编译的时候,它的数据就已经包含在类信息中
- Category是在运行时,才会将数据合并到类信息中
2.Category中有load方法吗?load方法是什么时候调用的?load方法能继承吗?
- 有load方法
- load方法在runtime加载类、分类的时候调用
- load方法可以继承,但是一般情况下不会主动去调用load方法,都是让系统自动调用
3.Category能否添加成员变量?如果可以,如何给Category添加成员变量?
- 不能直接给Category添加成员变量,但是可以间接实现Category有成员变量的效果
如何实现给分类”添加成员变量“?
- 默认情况下,因为分类底层结构的限制,不能添加成员变量到分类中。但是可以通过关联对象来间接实现
- 关联对象提供了以下API
// 添加关联对象
void objc_setAssociatedObject(id object, const void * key, id value, objc_AssociationPolicy policy)
// 获得关联对象
id objc_getAssociatedObject(id object, const void * key)
// 移除所有的关联对象
void objc_removeAssociatedObjects(id object)
key的常见用法
static void *MyKey = &MyKey;
objc_setAssociatedObject(obj, MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, &MyKey)
static char MyKey;
objc_setAssociatedObject(obj, &MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, &MyKey)
// 使用属性名作为key
objc_setAssociatedObject(obj, @"property", value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, @"property")
// 使用get方法的@selector作为key
objc_setAssociatedObject(obj, @selected(getter), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
objc_getAssociatedObject(obj, @selector(getter))
objc_AssociationPolicy
objc_AssociationPolicy | 对应的修饰符 |
---|---|
OBJC_ASSOCIATION_ASSIGN | assign |
OBJC_ASSOCIATION_RETAIN_NONATOMIC | strong,nonatomic |
OBJC_ASSOCIATION_COPY_NONATOMIC | copy,nonatomic |
OBJC_ASSOCIATION_RETAIN | strong, atomic |
OBJC_ASSOCIATION_COPY | copy, atomic |
关联对象的原理
- 实现关联对象技术的核心对象有
- AssociationsManager
- AssociationsHashMap
- ObjectAssociationMap
- ObjcAssociation
objc4源码解读:objc-references.mm
class AssociationsManager {
static AssociationsHashMap *_map;
};
class AssociationsHashMap : public unordered_map<disguised_ptr_t, ObjectAssociationMap>
class ObjectAssociationMap : public std::map<void *, ObjcAssociation>
class ObjcAssociation {
uintptr_t _policy;
id _value;
};
关联对象并不是存储在被关联对象本身内存中
关联对象存储在全局的统一的一个AssociationsManager中
设置关联对象为nil,就相当于是移除关联对象
+load方法
- +load方法会在runtime加载类、分类的时候调用
- 每个类、分类的+load,在程序运行过程中只调用一次
- 调用顺序
- 1.先调用类的+load
- 按照编译先后顺序调用(先编译,先调用)
- 调用子类的+load之前会调用父类的+load
- 2.在调用分类的+load
- 按照编译先后顺序调用(先编译,先调用)
- 1.先调用类的+load
源码解读顺序
+load方法时根据方法地址直接调用,并不是经过objc_msgSend函数调用
objc-os.mm
_objc_init
load_images
prepare_load_methods
schedule_class_load
add_class_to_loadable_list
add_category_to_loadable_list
call_load_methods
call_class_loads
call_category_loads
(*load_method)(cls,SEL_load)
+initialize方法
- +initialize方法会在
类
第一次接收到消息时调用 - 调用顺序
- 先调用父类的+initialize方法,再调用子类的+initialize方法
- (先初始化父类,在初始化子类,每个类只会初始化1次)
- +initialize和+load的很大区别是,+initialize是通过objc_msgSend进行调用的,所以有一下特点
- 如果子类没有时间+initialize,会调用父类的+initialize(所以父类的+initialize可能会被调用多次)
- 如果分类实现了+initialize,就会覆盖本身的+initialize调用
Block
block的本质
- block本质上也是一个OC对象,它内部也有个isa指针
- block是封装了函数调用以及函数调用环境的OC对象
- block的底层机构
- Block_layout((void
*
)isa、(int)flags、(int)reserved、(void*
(void*
,...))invoke、(struct Block_descriptor *)descriptor、variables)- Block_descriptor((unsigned long int)reserved、(unsigned long int)size、(void
*
(void*
,void*
))copy、(void*
(void*
))dispose)
- Block_descriptor((unsigned long int)reserved、(unsigned long int)size、(void
- Block_layout((void
block变量捕获(capture)
变量类型 | 捕获到block内部 | 访问方式 |
---|---|---|
局部变量 auto | 是 | 值传递 |
局部变量 static | 是 | 指针访问 |
全局变量 | 否 | 直接访问 |
atuo变量的捕获
int age = 20;
void (^block)(void) = ^{
NSLog(@"age is %d", age);
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0 *Desc;
int age;
};
// impl
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// Desc
struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
};
block的类型
- block有3中类型,可以通过调用class方法或者isa指针查看具体类型,最终都是继承自NSBlock类型
-
__NSGlobalBlock__
(_NSConcreteGlobalBlock) 存放在数据区域.data区 -
__NSMallocBlock__
(_NSConcreteMallocBlock) 堆 -
__NSStackBlock__
(_NSConcreteStackBlock) 栈
-
block类型 | 环境 |
---|---|
__NSGlobalBlock__ |
没有访问auto变量 |
__NSStackBlock__ |
访问了auto变量 |
__NSMallocBlock__ |
__NSStackBlock__ 调用了copy |
- 每一种类型的block调用copy后的结果
Block的类 | 副本源的配置存储域 | 复制效果 |
---|---|---|
_NSConcreteStackBlock | 栈 | 从栈复制到堆 |
_NSConcreteGlobalBlock | 程序的数据区域 | 什么也不做 |
_NSConcreteMallocBlock | 堆 | 引用计数增加 |
block的copy
-
在ARC环境下,编译器会根据情况自动将栈上的block赋值到堆上,比如以下情况
- block作为函数的返回值时
- 将block赋值给__strong指针时
- block作为Cocoa API中方法名含有usingBlock的方法参数时
- block作为GCD API的方法参数时
-
MRC下block属性的建议写法
- @property(copy, nonatomic) void(^block)(void);
-
ARC下block属性的建议写法
- @property(strong, nonatomic) void(^block)(void);
- @property(copy, nonatomic) void (^block)(void);
对象类型的auto变量
- 当block内部访问了对象类型的auto变量时
-
如果block是在栈上,将不会对auto变量产生强引用
-
如果block被拷贝到堆上
- 会调用block内部的copy函数
- copy函数内部会调用_Block_object_assign函数
- _Block_object_assign函数会根据auto变量的修饰符(__strong、__weak、__unsafe_unretained)做出相对应的操作,形成强引用(retain)或者弱引用
-
如果block从堆上移除
- 会调用block内部的dispose函数
- dispose函数内部会调用_Block_object_dispose函数
- _Block_object_dispose函数会自动释放引用的auto变量(release)
-
1.block的原理是怎样的?本质是什么?
封装了函数调用以及调用环境的OC对象
2.block的属性修饰词为什么是copy?使用block有哪些使用注意?
- block一旦没有进行copy操作,就不会在堆上
- 使用注意:循环引用问题
函数 | 调用时机 |
---|---|
copy函数 | 栈上的Block赋值到堆时 |
dispose函数 | 堆上的Block被废弃时 |
__weak问题解决
- 在使用clang转换OC为C++代码时,可能会遇到一下问题
- cannot create
__weak
reference in file using manual reference
- cannot create
- 解决方案:支持ARC、指定运行时系统版本,比如
- xcrun -sdk iphones clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m
__block修饰符
-
__block
可以用来解决block内部无法修改auto变量值得问题 -
__block
不能修饰全局变量、静态变量(static) - 编译器会将
__block
变量包装成一个对象-
__isa
、__forwarding
(指向自身的指针)、__flags
、__size
、val(使用值)
-
__block int age = 10;
^{
NSLog(@"%d", age);
}();
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0 * Desc;
__Block_byref_age_0 * age; // by ref
};
struct __Block_byref_age_0 {
void *__isa;
__Block_byref_age_0 * __forwarding;
int __flags;
int __size;
int age;
};
__block的内存管理
-
当block在栈上时,并不会对__block变量产生强引用
-
当block被copy到堆上时
- 会调用block内部的copy函数
- copy函数内部会调用_Block_object_assign函数
-
_Block_object_assign
函数会对__block变量形成强引用(retain)
-
当block从堆上移除时
- 会调用block内部的dispose函数
- dispose函数内部会调用_Block_object_dispose函数
- _Block_object_dispose函数会自动释放引用的__block变量(release)
__block的__forwarding指针
- 栈 (__block变量用结构体、__forwarding指向自己本身的指针)
- 复制到堆之后(栈上的__forwarding指向复制到堆上的__block变量用结构体,堆上的__forwarding指向自己本身的指针)
对象类型的auto变量、__block变量
-
当block在栈上时,对它们都不会产生强引用
-
当block拷贝到堆上时,都会通过copy函数来处理它们
- __block变量(假设变量名叫做a)
_Block_object_assign((void*)&dst->a,(void*)src->a,8/*BLOCK_FIELD_IS_BYREF*/);
- 对象类型的auto变量(假设变量名叫做p)
_Block_object_assign((void*)&dst->p,(void*)src->p,3/*BLOCK_FIELD_IS_OBJECT*/);
- __block变量(假设变量名叫做a)
-
当block从堆上移除时,都会通过dispose函数来释放它们
- __block变量(假设变量名叫做a)
_Block_object_dispose((void*)&dst->a, 8/*BLOCK_FIELD_IS_BYREF*/);
- 对象类型的auto变量(假设变量名叫做p)
_Block_object_dispose((void*)&dst->,3/*BLOCK_FIELD_IS_OBJECT*/);
- __block变量(假设变量名叫做a)
对象 | BLOCK_FIELD_IS_OBJECT |
---|---|
__block变量 | BLOCK_FIELD_IS_BYREF |
循环引用问题
对象(self)持有Block,Block持有对象(self)
解决循环引用问题 - ARC
- 用__weak、__unsafe_unretained解决
__weak typeof(self) weakSelf = self;
self.block = ^{
printf("%p", weakSelf);
};
__unsafe_unretained id weakSelf = self;
self.block = ^{
NSLog(@"%p", weakSelf);
};
对象(self)持有Block,Block对对象的持有是弱引用
- 用__block解决(必须要调用block)
__block id weakSelf = self;
self.block = ^{
printf("%p", weakSelf);
weakSelf = nil; // (关键:设置为nil,将闭合的环切断)
};
self.block();
解决循环引用问题 - MRC
- 用__unsafe_unretained解决
__unsafe_unretained id weakSelf = self;
self.block = ^{
NSLog(@"%p",weakSelf);
};
- 用__block解决
__block id weakSelf = self;
self.block = ^{
printf("%p", weakSelf);
};
Objective-C的本质
- 我们平时编写的Objective-C代码,底层实现其实都是C\C++
- Objective-c ——> C\C++ ——> 汇编语言 ——> 机器语言
- 所以Objective-C的面向对象都是基于C\C++的数据结构实现的
思考:Objective-C的对象、类主要是基于C\C++的什么数据结构实现的?
- 结构体
- 将Objective-C代码转换为C\C++代码
- xcrun -sdk iphones clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
- 如果需要链接其他框架,使用-framework参数。比如-framework UIKit
OC对象的本质
思考:一个OC对象在内存中是如何布局的?
NSObject的底层实现
@interface NSObject {
Class isa;
}
@end
struce NSObject_IMPL {
Class isa;
};
typedef struct objc_class *Class;
NSObject *obj = [[NSObject class] init];
@interface Student : NSObject {
@public
int _no;
int _age;
}
@end
struct Student_IMPL {
Class isa;
int _no;
int _age;
};
Student *stu = [[Student alloc] init];
stu->_no = 4;
stu->_age = 5;
struct Student_IMPL *stu2 = (__bridge struct Student_IMPL *)stu;
NSLog(@"%d, %d", stu2->_no, stu2->age);
@interface Student : NSOjbect {
@public
int _no;
int _age;
}
@end
struct Student_IMPL {
struct NSObject_IMPL NSObject_IVARS;
int _no;
int _age;
};
struct NSObject_IMPL {
Class isa;
};
思考:一个Person对象、一个Student对象占用多少内存空间?
@interface Person : NSObject {
int _age;
}
@end
struct Person_IMPL {
struct NSObject_IMPL NSObject_IVARS;
int _age
};
struct NSObject_IMPL {
Class isa;
};
@interface Student : Person {
int _no;
}
@end
struct Student_IMPL {
struct Person_IMPL Person_IVARS;
int _no;
};
实时查看内存数据
- Debug ——> Debug Workfllow ——> View Memory (Shift + Command + M)
2个容易混淆的函数
创建一个实例对象,至少需要多少内存
#import <objc/runtime.h>
class_getInstanceSize([NSObject class]);
创建一个实例对象,实际上分配了多少内存?
#import <malloc/malloc.h>
malloc_size((__bridge const void *)obj);
OC对象的分类
Objective-C中的对象,简称OC对象,主要可以分为3种
- instance对象(实例对象)
- class对象(类对象)
- meta-class(元类对象)
instance
- instance对象就是通过alloc出来的对象,每次调用alloc都会产生新的instance对象
NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];
- object1、object2是NSBbject的instance对象(实例对象)
- 它们是不同的两个对象,分别占据着两块不同的内存
- instance对象在内存中存储的信息包括
- isa指针
- 其他成员变量
class
NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];
Class objectClass1 = [object1 class];
Class objectClass2 = [object2 class];
Class objectClass3 = [NSObject class];
Class objectClass4 = object_getClass(object1); // Runtime API
Class objectClass5 = object_getClass(object2); // Runtime API
- objectClass1 ~ objectClass5都是NSObject的class对象(类对象)
- 它们是同一个对象。每个类在内存中有且只有一个class对象
- class对象在内存中存储的信息主要包括
- isa指针
- superclass指针
- 类的属性信息(@property)、类的对象方法信息(instance method)
- 类的协议信息(protocol)、类的成员变量信息(ivar)
- ......
meta-class
Class objectMetaClass = object_getClass([NSObject class]); // Runtime API
- objectMetaClass是NSObject的meta-class对象(元类对象)
- 每个类在内存中有且只有一个meta-class对象
- meta-class对象和class对象的内存结构是一样的,但是用途不一样,在内存中存储的信息主要包括
- isa指针
- superclass指针
- 类的类方法信息(class method)
- ......
注意
- 以下代码获取的objectClass是class对象,并不是meta-class对象
Class objectClass = [[NSObject class] class];
查看Class是否为meta-class
BOOL result = class_isMetaClass([NSObject class]);
isa指针
- instance的isa指向class
- 当调用对象方法时,通过instance的isa找到class,最后找到对象方法的实现进行调用
- class的isa指向meta-class
- 当调用类方法时,通过class的isa找到meta-class,最后找到类方法的实现进行调用
- instace(isa、其他成员变量)
- instance的isa ————> class
- class(isa、superclass、属性、对象方法、协议、成员变量.....)
- class的isa ——————> meta-class
- meta-class(isa、superclass、类方法......)
instance(isa、其他成员便来那个)& ISA_MASK
找到 class(isa、superclass、属性、对象方法、协议、成员变量......) & ISA_MASK
找到 meta-class(isa、superclass、类方法......)
从64bit开始,isa需要进行一次位运算,才能计算出真实地址
# if __arm64__
# define ISA_MASK 0x0000000ffffffff8ULL
# elif __x86_64__
# define ISA_MASK 0x00007ffffffffff8ULL
# endif
class、meta-class对象的本质结构都是 struct objc_class
struct objc_class的结构
struct objc_class {
Class isa;
Class superclass;
cache_t cache; // 方法缓存
class_data_bits_t bits; // 用于获取具体的类信息
};
// bits & FAST_DATA_MASK 找到 class_rw_t结构体
struct class_rw_t {
uint32_t flags;
uint32_t version;
const class_ro_t *ro;
method_list_t * methods; // 方法列表
property_list_t * properties; // 属性列表
const protocol_list_t * protocols; // 协议列表
Class firstSubclass;
Class nextSiblingClass;
char * demangledName;
};
struct class_ro_t {
uint32_t flags;
uint32_t instanceStart;
uint32_t instanceSize; // instance对象占用的内存空间
#ifdef __LP64__
uint32_t reserved;
#endif
const uint8_t * ivarLayout;
const char * name; // 类名
method_list_t * baseMethodList;
protocol_list_t * baseProtocols;
const ivar_list_t * ivars; // 成员变量列表
const uint8_t * weakIvarLayout;
property_list_t * baseProperties;
};
class对象的superclass指针
@interface Student : Person
@interface Person : NSObject
- Student的class(isa、superclass、属性、对象方法、协议、成员变量......)
- Student的superclass指针 ——————> Person的class
- Person的class(isa、superclass、属性、对象方法、协议、成员变量......)
- Person的superclass指针 ————————> NSObject的class
- NSObject的class(isa、superclass、属性、对象方法、协议、成员变量......)
当
Student的instance对象
调用Person的对象方法
时,会先通过isa
找到Student的class
,然后通过superclass
找到Person的class
,最后找到对象方法的实现
进行调用
meta-class对象的superclass指针
@interface Student : Person
@interface Person : NSObject
- Student的meta-class(isa、superclass、类方法......)
- Student的superclass指针 ————————> Person的meta-class
- Person的meta-class(isa、superclass、类方法......)
- Person的superclass指针 ————————> NSObject的meta-class
- NSObject的meta-class(isa、superclass、类方法......)
当
Student的class
要调用Person的类方法
时,会先通过isa
找到Student的meta-class
,然后通过superclass
找到Person的meta-class
,最后找到类方法的实现
进行调用
isa、superclass总结
- instance的isa指向class
- class的isa指向meta-class
- meta-class的isa指向基类的meta-class
- class的superclass指向父类的class
- 如果没有父类,superclass指针为nil
- meta-class的superclass指向父类的meta-class
- 基类的meta-class的superclass指向基类的class
- instance调用对象方法的轨迹
- isa找到class,方法不存在,就通过superclass找父类
- class调用类方法的轨迹
- isa找到meta-class,方法不存在,就通过superclass找父类