我们平时编写的Objective-C代码，底层实现其实都是C\C++代码
Objective-C转换成C\C++，再转换成汇编语言，然后是机器语言，如下图：
Objective-C的面向对象都是基于C\C++的数据结构实现的，那么Objective-C的对象、类主要是基于C\C++的什么数据结构实现的呢？(结构体)
将Objective-C代码转换为C\C++代码的方法：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
如果需要链接其他框架，使用-framework参数。比如-framework UIKit
1.NSObject的底层实现
struct NSObject_IMPL {
Class isa; // 8个字节
};
// 指针
// typedef struct objc_class *Class;
那么一个NSObject对象占用多少个字节呢？
// 16个字节
NSObject *obj = [[NSObject alloc] init];
// 获得NSObject实例对象的成员变量所占用的大小 >> 8
NSLog(@"%zd", class_getInstanceSize([NSObject class]));
// 获得obj指针所指向内存的大小 >> 16
NSLog(@"%zd", malloc_size((__bridge const void *)obj));
我们可以看到，OC类底层实现的本质就是一个结构体，而isa就是一个指针（typedef struct objc_class *Class），所以isa占用了8个字节（64位）。实际上系统分配了16个字节给NSObject对象（通过malloc_size函数获得）但NSObject对象内部只使用了8个字节的空间（64bit环境下，可以通过class_getInstanceSize函数获得）
同理一个Person对象占用多少内存空间?
//struct NSObject_IMPL
//{
// Class isa;
//};
//
//struct Person_IMPL
//{
// struct NSObject_IMPL NSObject_IVARS; // 8
// int _age; // 4
// int _height; // 4
// int _no; // 4
//}; // 24
struct NSObject_IMPL {
Class isa;
};
struct Person_IMPL {
struct NSObject_IMPL NSObject_IVARS;
int _age;
int _height;
int _no;
}; // 计算结构体大小，内存对齐，24
@interface Person : NSObject
{
int _age;
int _height;
int _no;
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p = [[Person alloc] init];
NSLog(@"%zd %zd",
class_getInstanceSize([Person class]), // 24
malloc_size((__bridge const void *)(p))); // 32
}
return 0;
}
//打印结果： 24 32
可以看到Person底层结构体需要20个字节，由于结构体内存对齐，结构体的大小必须是最大成员大小的倍数， 计算出Person的对象的内存占用 24，但是苹果自有内存对齐方式为16的倍数，所以最终一个Person对象占用的内存为32个字节
如何实时查看内存数据
通过查看内存 ，也可以验证Person对象的内存大小为32个字节
Debug -> Debug Workfllow -> View Memory （Shift + Command + M）
2.OC对象的分类
Objective-C中的对象，简称OC对象，主要可以分为3种：实例对象、class对象、meta-class对象（元类对象）
1.instance对象（实例对象）
instance对象就是通过类alloc出来的对象，每次调用alloc都会产生新的instance对象
NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];
object1、object2是NSObject的instance对象（实例对象）,它们是不同的两个对象，分别占据着两块不同的内存。
instance对象在内存中存储的信息包括： isa指针，其他成员变量
2.class对象（类对象）
NSObject *object1 = [[NSObject alloc] init];
NSObject *object2 = [[NSObject alloc] init];
Class objectClass1 = [object1 class];
Class objectClass2 = [object2 class];
Class objectClass3 = object_getClass(object1);
Class objectClass4 = object_getClass(object2);
Class objectClass5 = [NSObject class];
objectClass1 ~ objectClass5都是NSObject的class对象（类对象）.
它们是同一个对象。每个类在内存中有且只有一个class对象
class对象在内存中存储的信息主要包括:
isa指针superclass指针- 类的属性信息（
@property）、类的对象方法信息（instance method） -
类的协议信息（
protocol）、类的成员变量信息（ivar）
......
3.meta-class对象（元类对象）
Class objectClass = object_getClass( [NSObject class]);
//注意~~~~~~
//Class objectClass = [[NSObject class] class]; 获取的objectClass是class对象，并不是meta-class对象
objectMetaClass是NSObject的meta-class对象（元类对象）
每个类在内存中有且只有一个meta-class对象
meta-class对象和class对象的内存结构是一样的，但是用途不一样，在内存中存储的信息主要包括
-
isa指针 -
superclass指针 - 类的类方法信息（
class method）
......
isa指针
instance的isa指向class
当调用对象方法时，通过instance的isa找到class，最后找到对象方法的实现进行调用
class的isa指向meta-class
当调用类方法时，通过class的isa找到meta-class，最后找到类方法的实现进行调用
class对象的superclass指针
当Student的instance对象要调用Person的对象方法时，会先通过isa找到Student的class，然后通过superclass找到Person的class，最后找到对象方法的实现进行调用
meta-class对象的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找父类
3. 窥探struct objc_class的结构
#import <Foundation/Foundation.h>
#ifndef MJClassInfo_h
#define MJClassInfo_h
# if __arm64__
# define ISA_MASK 0x0000000ffffffff8ULL
# elif __x86_64__
# define ISA_MASK 0x00007ffffffffff8ULL
# endif
#if __LP64__
typedef uint32_t mask_t;
#else
typedef uint16_t mask_t;
#endif
typedef uintptr_t cache_key_t;
struct bucket_t {
cache_key_t _key;
IMP _imp;
};
struct cache_t {
bucket_t *_buckets;
mask_t _mask;
mask_t _occupied;
};
struct entsize_list_tt {
uint32_t entsizeAndFlags;
uint32_t count;
};
struct method_t {
SEL name;
const char *types;
IMP imp;
};
struct method_list_t : entsize_list_tt {
method_t first;
};
struct ivar_t {
int32_t *offset;
const char *name;
const char *type;
uint32_t alignment_raw;
uint32_t size;
};
struct ivar_list_t : entsize_list_tt {
ivar_t first;
};
struct property_t {
const char *name;
const char *attributes;
};
struct property_list_t : entsize_list_tt {
property_t first;
};
struct chained_property_list {
chained_property_list *next;
uint32_t count;
property_t list[0];
};
typedef uintptr_t protocol_ref_t;
struct protocol_list_t {
uintptr_t count;
protocol_ref_t list[0];
};
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;
};
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;
};
#define FAST_DATA_MASK 0x00007ffffffffff8UL
struct class_data_bits_t {
uintptr_t bits;
public:
class_rw_t* data() {
return (class_rw_t *)(bits & FAST_DATA_MASK);
}
};
/* OC对象 */
struct mj_objc_object {
void *isa;
};
/* 类对象 */
struct mj_objc_class : mj_objc_object {
Class superclass;
cache_t cache;
class_data_bits_t bits;
public:
class_rw_t* data() {
return bits.data();
}
mj_objc_class* metaClass() {
return (mj_objc_class *)((long long)isa & ISA_MASK);
}
};
