在长期iOS开发中，oc是iOS的基础也是重中之重，相比runtime，runloop，多线程等知识都要重要的多，更加深入的了解oc的知识，才能写出加健壮的代码
以下内容，摘自网络，如有版权，可以联系。
探寻OC对象的本质，我们平时编写的Objective-C代码，底层实现其实都是C\C++代码。我们通过clang 将OC代码转为C\C++代码
OC如下代码
int main(int argc, char * argv[]) {
@autoreleasepool {
NSObject* objc = [[NSObject alloc] init];
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
我们通过clang命令行将OC的mian.m文件转化为c++文件。
输入指令要注意斜体位置的路径是本机Xcode的路径
clang -x objective-c -rewrite-objc -isysroot /Users/admin/Desktop/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk main.m
补充下我的xcode位置在桌面所以是上面链接，正常的应该是下面的clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk main.m
.cpp文件添加进入项目无法编译运行，需要去掉它
NSObject_IMPL内部
typedef struct objc_class *Class;
struct NSObject_IMPL {
Class isa;
};
NSObjcet的底层实现，点击NSObjcet进入发现NSObject的内部实现
@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
Class isa OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}
@end
转化为c语言其实就是一个结构体
为了探寻OC对象在内存中如何体现，我们来看下面一段代码
NSObject* objc = [[NSObject alloc] init];
转换后代码
NSObject* objc = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)
((NSObject *(*)(id, SEL))(void *)objc_msgSend)
((id)objc_getClass("NSObject"), sel_registerName("alloc")),
sel_registerName("init"));
上述一段代码中系统为NSObject对象分配8个字节的内存空间，用来存放一个成员isa指针。那么isa指针这个变量的地址就是结构体的地址，也就是NSObjcet对象的地址。
获取对象大小
class_getInstanceSize([NSObject class]); // 8 返回的是对象的大小
malloc_size( (__bridge const void *)(objc));// 16 返回的是分配空间大小
oc分配对象大小源码
size_t instanceSize(size_t extraBytes) {
size_t size = alignedInstanceSize() + extraBytes;
//CF要求所有对象至少为16个字节。当小于16后会分配16。
if (size < 16) size = 16;
return size;
}
那么这个结构体占多大的内存空间呢，我们发现这个结构体只有一个成员，isa指针，而指针在64位架构中占8个字节。也就是说一个NSObjec对象所占用的内存是8个字节。
但是我们发现NSObject对象中还有很多方法，那这些方法不占用内存空间吗？其实类的方法等也占用内存空间，但是这些方法所占用的存储空间并不在NSObject对象中。
那跟复杂的继承关系对象的大小是如何计算的
继承自NSObject的对象，那么底层结构体内一定有一个isa指针。
那么他们所占的内存空间是多少呢？单纯的将指针和成员变量所占的内存相加即可吗？上述代码实际打印的内容是16 16，也就是说，person对象和student对象所占用的内存空间都为16个字节。
其实实际上person对象确实只使用了12个字节。但是因为内存对齐的原因。使person对象也占用16个字节。
编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能是该基本数据类型的整倍的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为对齐模数。
为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。
我们可以总结内存对齐为两个原则：
原则 1. 前面的地址必须是后面的地址正数倍,不是就补齐。
原则 2. 整个Struct的地址必须是最大字节的整数倍。
通过上述内存对齐的原则我们来看，person对象的第一个地址要存放isa指针需要8个字节，第二个地址要存放_age成员变量需要4个字节，根据原则一，8是4的整数倍，符合原则一，不需要补齐。然后检查原则2，目前person对象共占据12个字节的内存，不是最大字节数8个字节的整数倍，所以需要补齐4个字节，因此person对象就占用16个字节空间。
而对于student对象，我们知道sutdent对象中，包含person对象的结构体实现，和一个int类型的_no成员变量，同样isa指针8个字节，_age成员变量4个字节，_no成员变量4个字节，刚好满足原则1和原则2，所以student对象占据的内存空间也是16个字节。
对象alloc的流程图，以及调用方法
+ (id)alloc {
return _objc_rootAlloc(self);
}
_objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
if (slowpath(checkNil && !cls)) return nil;
#if __OBJC2__
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
// No alloc/allocWithZone implementation. Go straight to the allocator.
// fixme store hasCustomAWZ in the non-meta class and
// add it to canAllocFast's summary
if (fastpath(cls->canAllocFast())) {
// No ctors, raw isa, etc. Go straight to the metal.
bool dtor = cls->hasCxxDtor();
id obj = (id)calloc(1, cls->bits.fastInstanceSize());
if (slowpath(!obj)) return callBadAllocHandler(cls);
obj->initInstanceIsa(cls, dtor);
return obj;
}
else {
// Has ctor or raw isa or something. Use the slower path.
id obj = class_createInstance(cls, 0);
if (slowpath(!obj)) return callBadAllocHandler(cls);
return obj;
}
}
#endif
// No shortcuts available.
if (allocWithZone) return [cls allocWithZone:nil];
return [cls alloc];
}
// Replaced by ObjectAlloc
+ (id)allocWithZone:(struct _NSZone *)zone {
return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
{
id obj;
#if __OBJC2__
// allocWithZone under __OBJC2__ ignores the zone parameter
(void)zone;
obj = class_createInstance(cls, 0);
#else
if (!zone) {
obj = class_createInstance(cls, 0);
}
else {
obj = class_createInstanceFromZone(cls, 0, zone);
}
#endif
if (slowpath(!obj)) obj = callBadAllocHandler(cls);
return obj;
}
id
class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone)
{
return _class_createInstanceFromZone(cls, extraBytes, zone);
}
static __attribute__((always_inline))
id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
bool cxxConstruct = true,
size_t *outAllocatedSize = nil)
{
if (!cls) return nil;
assert(cls->isRealized());
// Read class's info bits all at once for performance
bool hasCxxCtor = cls->hasCxxCtor();
bool hasCxxDtor = cls->hasCxxDtor();
bool fast = cls->canAllocNonpointer();
size_t size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (!zone && fast) {
obj = (id)calloc(1, size);
if (!obj) return nil;
obj->initInstanceIsa(cls, hasCxxDtor);
}
else {
if (zone) {
obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
if (!obj) return nil;
// Use raw pointer isa on the assumption that they might be
// doing something weird with the zone or RR.
obj->initIsa(cls);
}
if (cxxConstruct && hasCxxCtor) {
obj = _objc_constructOrFree(obj, cls);
}
return obj;
}
可以使用断点，Debug Workflow -> viewMemory address中输入isa的地址去验证上述所说
或者 memory read + 对象地址 或者x +地址 或x/（数量+格式+字节数） +地址（格式x是16进制 f是浮点 d十进制 字节大小b：byte 1字节 h：half word 2字节 w：word 4字节 g：giant word 8字节）例
momory write + 地址+数据 （方便调试）
同时需要理解一句话，isa地址是结构体首地址，即结构体地址，这个理解下，后面要用
关于内存对其相关知识
补充编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能是该基本数据类型的整倍的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为对齐模数。
补充结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。
（换句话说，结构体大小必须是最大成员的倍数）
iOS 是小端 从高地址开始读取数据
接着来看下oc对象的信息如何存放的
注意一个写法oc对象->一个属性。 t1->_name（通过指针直接访问成员变量）
苹果在解释oc的时候给出过一个图表
在这张图表中instance对象（实例对象）class对象（类对象）meta-class对象（元类对象）
instance 是由alloc方法生成的 ，每次调用alloc都会产生新的instance对象。在写单利时候要清楚这件事
说下alloc和init
alloc方法生成悬挂指针，他指向一个新的内存地址，并将其持有返回地址给指针,所以每次调用都会生成新的对象，在没有进行init的时候不建议使用，因为没有合理的内存布局
同时我们需要思考调用alloc后内存是直接映射到堆还是只分配给了虚拟内存
而init是在为内存地址进行初始化，但是init不一定是在alloc产生的内存上进行的初始化，有可能是在新的内存上原因在[super init]
在block被当作属性使用时，特别是在多线程中一定要判断属性是否为空
iOS里的内存是有分类的，它分成Clean Memory和Dirty Memory。顾名思义，Clean Memory是可以被操作系统回收的，Dirty Memory是不可被操作系统回收的。
Clean Memory:在闪存中有备份，能再次读取重建。如：Code(代码段)，framework，memory-mapped files
Dirty Memory:所有非Clean Memory，如：被分配了的堆空间，image cache
例如
对每行分析：
1.Dirty Memory。
因为stringWithString:是在堆上分配内存的，如果我们不回收它的话，系统会一直占用这块内存。
2.Clean Memory。
因为用这样的方法创建的是一个常量字符串，常量字符串是放在只读数据段的，如果这块内存被释放了，而我们又访问它的时候，操作系统可以在只读数据段中把值再读取出来重建这块内存。(所以用这种方法创建的string是没有引用计数的。)
3.Clean Memory。
这个时候buf指向的100M内存区域是Clean Memory的，因为操作系统是很懒的，只有当我们要用到这块区域的时候才会映射到物理内存，没有使用的时候只会分配一块虚拟内存给buf。
可以看到虚拟内存和物理内存没有映射关系，所以是Clean Memory的。
4.Dirty & Clean Memory混合。
前3M是Dirty Memory，后97M是Clean Memory。这句for语句执行完成后，buf的前3M内存被赋值，也就是buf的前3M被使用了，所以这个时候的映射关系是这样的：
alloc不只分配在虚拟内存，同时会在物理内存建立映射。
iOS7过后部分苹果机就开始从32位操作系统转到64位了
回归主线
class对象 我们通过class方法或runtime方法得到一个class对象。class对象也就是类对象
Class Class1 = [object class];
// runtimeClass
objectClass = object_getClass(object);
相同的类的类对象在内存中只有一个,class对象在内存中存储的信息主要包括 isa指针 superclass指针 类的属性信息（@property），类的成员变量信息（ivar）类的对象方法信息（instance method），类的协议信息（protocol）
成员变量的值时存储在实例对象中的，因为只有当我们创建实例对象的时候才为成员变赋值。但是成员变量叫什么名字，是什么类型，只需要有一份就可以了。所以存储在class对象中。
元类对象 meta-class
meta-class对象和class对象的内存结构是一样的，但是用途不一样，在内存中存储的信息主要包括isa指针 superclass指针 类的类方法的信息（class method）所以meta-class中也有类的属性信息，类的对象方法信息等成员变量，但是其中的值可能是空的。
对象的isa指针指向哪里
当对象调用实例方法的时候，我们上面讲到，实例方法信息是存储在class类对象中的，那么要想找到实例方法，就必须找到class类对象，那么此时isa的作用就来了。
[oc ocMethod];
instance的isa指向class，当调用对象方法时，通过instance的isa找到class，最后找到对象方法的实现进行调用。
当类对象调用类方法的时候，同上，类方法是存储在meta-class元类对象中的。那么要找到类方法，就需要找到meta-class元类对象，而class类对象的isa指针就指向元类对象
[NSObjc NSObjcClassMethod];
class的isa指向meta-class当调用类方法时，通过class的isa找到meta-class，最后找到类方法的实现进行调用
同理 当t1的instance对象要调用父类t的对象方法时，会先通过isa找到t1的class，然后通过superclass找到t的class，最后找到对象方法的实现进行调用，同样如果t发现自己没有响应的对象方法，又会通过Person的superclass指针找到NSObject的class对象，去寻找响应的方法
当类对象调用父类的类方法时，就需要先通过isa指针找到meta-class，然后通过superclass去寻找响应的方法
对isa、superclass总结
instance的isa指向class,class的isa指向meta-class,meta-class的isa指向基类的meta-class，基类的isa指向自己,class的superclass指向父类的class，如果没有父类，superclass指针为nil,meta-class的superclass指向父类的meta-class，基类的meta-class的superclass指向基类的class,instance调用对象方法的轨迹，isa找到class，方法不存在，就通过superclass找父类,class调用类方法的轨迹:isa找meta-class，方法不存在，就通过superclass找父类注意最后没找到会找到类的实例方法中。
