Category的本质(一)编译阶段都做了什么？

Category对我们并不陌生，相信大家在开发过程中都有用过。使用较多的场景，我猜应该有2个：

在没有拿到源码的情况下，对静态库或动态库添加方法，便于做一些额外的操作，比如我们对NSString类添加一个一个判断是否为空的方法；
将我们自己在项目中经常使用到的模块，抽取出来，通过Category实现，打破原有的继承体系，更多的使用组合的方式，便于代码维护。

当然还有其他场景，也希望大家多谈一下自己对于Category的使用心得。

我们都知道Category可以添加实例方法、类方法、属性、遵循协议，那么究竟是怎么实现的呢，下面我们通过代码，来探究一下Category的本质。

首先我们仍旧以PMPerson为例，并为其添加两个分类Test和Eat，如下：

@interface PMPerson : NSObject

- (void)run;

+ (void)jump;

@end

@implementation PMPerson

- (void)run
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

+(void)jump
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

@end

@interface PMPerson (Eat)<NSCopying>

@property (nonatomic, strong) NSString *food;

/// 吃面条
- (void)eatNoodles;

/// 吃米饭
- (void)eatRice;

/// 吃肉
- (void)eatMeat;

/// 吃吃
+ (void)eat;

/// 喝喝
+ (void)drink;

@end


@implementation PMPerson (Eat)
- (void)eatNoodles
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

- (void)eatRice
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

- (void)eatMeat
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

+ (void)eat
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

+ (void)drink
{
     NSLog(@"%@",NSStringFromSelector(_cmd));
}



- (nonnull id)copyWithZone:(nullable NSZone *)zone {
    return [[PMPerson alloc] init];
}

@end


@interface PMPerson (Test)

-  (void)test;

+  (void)test;

@end


@implementation PMPerson (Test)

- (void)test
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

+ (void)test
{
    NSLog(@"%@",NSStringFromSelector(_cmd));
}

我们使用clang编译器，看一下PMPerson(Eat)经过编译后，是怎样的实现，在终端输入如下命令：

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc PMPerson+Eat.m -o PMPerson+Eat.cpp

不熟悉此命令的，可以参看这里：NSObject本质（一）一个NSObject对象在内存中占用多少个字节

打开编译后的cpp文件，搜索category_t，我们发现如下结构体：

struct _category_t {
    const char *name;   ///类名
    struct _class_t *cls;
    const struct _method_list_t *instance_methods;  ///实例方法列表
    const struct _method_list_t *class_methods;      ///类方法列表
    const struct _protocol_list_t *protocols;            ///遵循的协议
    const struct _prop_list_t *properties;                ///属性列表
};

继续往下查找：

static struct _category_t _OBJC_$_CATEGORY_PMPerson_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "PMPerson",
    0, // &OBJC_CLASS_$_PMPerson,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_PMPerson_$_Eat,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_PMPerson_$_Eat,
    (const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_PMPerson_$_Eat,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_PMPerson_$_Eat,
};

这个其实是我们实现的PMPerson(Eat)经编译后的结果。
对比category_t结构体，不难发现：

name = PMPerson
cls = PMPerson (生成的注释)
实例方法列表
类方法列表
遵循的协议列表
属性列表。

到这里，由于cls = PMPerson，我们可以得出一个结论Category的实现过程并没有重新生成类，而是在原有类的基础上，新增了一套属性、协议、实例方法、类方法的结构。

那么新增的这些属性、方法和协议是怎样与原有的类，进行关联呢，这个是在运行时做的事情，我们留到下篇文章讲解，今天先把编译阶段新增的属性、方法和协议的结构搞清楚。

新增的属性
在.cpp文件中搜索

_OBJC_$_PROP_LIST_PMPerson_$_Eat

看到如下结果：

static struct /*_prop_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)  ///属性占有的空间大小
    unsigned int count_of_properties;         ///属性的数量
    struct _prop_t prop_list[1];                  /// 属性列表
} _OBJC_$_PROP_LIST_PMPerson_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"food","T@\"NSString\",&,N"}}
};

属性列表中会记录所有属性占有的内存空间，同时会记录属性的数量和类型。

新增的实例方法
在.cpp中搜索

_CATEGORY_INSTANCE_METHODS_PMPerson_

会看到实例方法的实现结构：

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[4];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_PMPerson_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    4,
    {{(struct objc_selector *)"eatNoodles", "v16@0:8", (void *)_I_PMPerson_Eat_eatNoodles},
    {(struct objc_selector *)"eatRice", "v16@0:8", (void *)_I_PMPerson_Eat_eatRice},
    {(struct objc_selector *)"eatMeat", "v16@0:8", (void *)_I_PMPerson_Eat_eatMeat},
    {(struct objc_selector *)"copyWithZone:", "@24@0:8^{_NSZone=}16", (void *)_I_PMPerson_Eat_copyWithZone_}}
};

同样记录了实例方法占用的内存空间，方法数量和每个方法的方法名、返回类型和实现。

新增的类方法实现
在.cpp文件中搜索

_CATEGORY_CLASS_METHODS_PMPerson_

看到如下结果：

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[2];
} _OBJC_$_CATEGORY_CLASS_METHODS_PMPerson_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    2,
    {{(struct objc_selector *)"eat", "v16@0:8", (void *)_C_PMPerson_Eat_eat},
    {(struct objc_selector *)"drink", "v16@0:8", (void *)_C_PMPerson_Eat_drink}}
};

大致结构与实例方法的实现一样，唯一的区别在于方法实现中，一个以I开头，一个以C开头，对比看待，就很容易发现，以I开头的是实例方法，I就是instance的缩写，以C开头的就是Class的缩写，是类方法。

新增的协议
在.cpp中搜索

_OBJC_CATEGORY_PROTOCOLS_$_PMPerson_$_Eat

看到如下结果：

static struct /*_protocol_list_t*/ {
    long protocol_count;  // Note, this is 32/64 bit
    struct _protocol_t *super_protocols[1];
} _OBJC_CATEGORY_PROTOCOLS_$_PMPerson_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    1,
    &_OBJC_PROTOCOL_NSCopying
};

依然有所遵循的协议的数量和协议名称，与属性和方法不同的是，少了一个内存空间的占用，为什么会这样呢，协议是怎么实现的呢？这个问题我们留待以后慢慢探讨。

通过以上分析，我们可以得到如下结论：

Category的实现，并没有创建新的类，而是依附于原有的类；
Category可以添加属性、实例方法、类方法和遵循协议，但是不能添加成员变量，因为我们在_category_t结构体中，没有看到成员变量的声明。
在编译阶段，会将新增的属性、方法和协议生成对应的结构体，在运行时，添加到原有的类中。

那么运行时究竟做了什么呢，我们会在下篇文章着重分析。

Category的本质(一)编译阶段都做了什么？

到这里，由于cls = PMPerson，我们可以得出一个结论Category的实现过程并没有重新生成类，而是在原有类的基础上，新增了一套 属性、协议、实例方法、类方法的结构。

通过以上分析，我们可以得到如下结论：

到这里，由于cls = PMPerson，我们可以得出一个结论Category的实现过程并没有重新生成类，而是在原有类的基础上，新增了一套属性、协议、实例方法、类方法的结构。