一、分类的使用场景

可以减少单个文件的体积
可以按照功能分组，放到不同的分类里，使类结构更清晰
降低耦合性，同一个类可以有多个开发人员进行开发
模拟多继承
把静态库的私有方法公开

二、特点

运行时决议
给系统类添加分类

三、分类的底层结构

在

runtime

文件

objc-runtime-new.h

中，找到分类

category_t

的结构体：

struct category_t {
    const char *name;		//分类的名称
    classref_t cls;			//类
    struct method_list_t *instanceMethods;	//分类中所有给类添加的实例方法的列表
    struct method_list_t *classMethods;		//分类中所有给类添加的类方法的列表
    struct protocol_list_t *protocols;		//实现的所有协议的列表
    struct property_list_t *instanceProperties;	//添加的所有属性
    // Fields below this point are not always present on disk.
    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);
    
    protocol_list_t *protocolsForMeta(bool isMeta) {
        if (isMeta) return nullptr;
        else return protocols;
    }
};

从上面的

category_t

结构体中可以看出，我们可以在分类中添加

实例方法

、

类方法

、

协议

、

属性

。

并且我们发现分类结构体中不存在成员变量的，因此分类是不允许添加成员变量的。分类中添加的属性并不会帮组我们自动生成成员变量，只会生成

get set

方法的声明，需要我们自己去实现。

下面写一个简单的分类，然后将其转换为c/c++的

.cpp

文件。

/** Person.h */
@interface Person : NSObject

@property (nonatomic, copy) NSString *name;

@property (nonatomic, copy) NSString *age;

- (void)run;

@end

/** Person+Test.h */
@interface Person (Test)<NSCopying>
@property (nonatomic, copy) NSString *categoryName;
- (void)printClassName;
+ (void)classMethods;
@end

/** Person+Test.m */
@implementation Person (Test)
- (void)setCategoryName:(NSString *)categoryName {
    
}
- (NSString *)categoryName {
    return @"categoryName";
}
- (void)printClassName {
    NSLog(@"printClassName");
}
+ (void)classMethods {
    NSLog(@"classMethods");
}
#pragma mark -- NSCopying
- (id)copyWithZone:(nullable NSZone *)zone {
    return self;
}
@end

使用

clang

命令生成.cpp文件

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Preson+Test.m

1、_category_t

在分类转化为c++文件中可以看出

_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;
};

2、_method_list_t

然后是

_method_list_t

类型结构体

对象方法

static struct /*_method_list_t*/ {
	unsigned int entsize;  // sizeof(struct _objc_method)
	unsigned int method_count;
	struct _objc_method method_list[3];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
	sizeof(_objc_method),
	3,
	{{(struct objc_selector *)"setCategoryName:", "[email protected]:[email protected]", (void *)_I_Person_Test_setCategoryName_},
	{(struct objc_selector *)"categoryName", "@[email protected]:8", (void *)_I_Person_Test_categoryName},
	{(struct objc_selector *)"printClassName", "[email protected]:8", (void *)_I_Person_Test_printClassName}}
};

上图中我们发现这个结构体

_OBJC_$_CATEGORY_INSTANCE_METHODS_Preson_$_Test

从名称可以看出是

INSTANCE_METHODS

对象方法，并且一一对应为上面结构体内赋值。我们可以看到结构体中存储了方法占用的

内存

，

方法数量

，以及

方法列表

。并且从上图中找到分类中我们实现对应的对象方法，

setCategoryName

categoryName

printClassName

三个方法。

类方法

static struct /*_method_list_t*/ {
	unsigned int entsize;  // sizeof(struct _objc_method)
	unsigned int method_count;
	struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
	sizeof(_objc_method),
	1,
	{{(struct objc_selector *)"classMethods", "[email protected]:8", (void *)_C_Person_Test_classMethods}}
};

同上面对象方法列表一样，这个我们可以看出是类方法列表结构体

_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test

，同对象方法结构体相同，同样可以看到我们实现的类方法，

classMethods

。

3、_protocol_list_t

协议列表

static struct /*_method_list_t*/ {
	unsigned int entsize;  // sizeof(struct _objc_method)
	unsigned int method_count;
	struct _objc_method method_list[1];
} _OBJC_PROTOCOL_INSTANCE_METHODS_NSCopying __attribute__ ((used, section ("__DATA,__objc_const"))) = {
	sizeof(_objc_method),
	1,
	{{(struct objc_selector *)"copyWithZone:", "@[email protected]:8^{_NSZone=}16", 0}}
};

struct _protocol_t _OBJC_PROTOCOL_NSCopying __attribute__ ((used)) = {
	0,
	"NSCopying",
	0,
	(const struct method_list_t *)&_OBJC_PROTOCOL_INSTANCE_METHODS_NSCopying,
	0,
	0,
	0,
	0,
	sizeof(_protocol_t),
	0,
	(const char **)&_OBJC_PROTOCOL_METHOD_TYPES_NSCopying
};
struct _protocol_t *_OBJC_LABEL_PROTOCOL_$_NSCopying = &_OBJC_PROTOCOL_NSCopying;

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

通过上述源码可以看到先将协议方法通过

_method_list_t

结构体存储，之后通过

_protocol_t

结构体存储在

_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test

中同

_protocol_list_t

结构体一一对应，分别为

protocol_count

协议数量以及存储了协议方法的

_protocol_t

结构体。

4、_prop_list_t

属性列表

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_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
	sizeof(_prop_t),
	1,
	{{"categoryName","[email protected]\"NSString\",C,N"}}
};

属性列表结构体

_OBJC_$_PROP_LIST_Person_$_Test

同

_prop_list_t

结构体对应，存储属性的占用空间，属性属性数量，以及属性列表，从上图中可以看到我们自己写的

categoryName

属性。

5、赋值

最后我们可以看到定义了

_OBJC_$_CATEGORY_Preson_$_Test

结构体，并且将我们上面着重分析的结构体一一赋值，我们通过两段代码对照一下。

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_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
	"Person",
	0, // &OBJC_CLASS_$_Person,
	(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test,
	(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test,
	(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Test,
	(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_Test,
};
static void OBJC_CATEGORY_SETUP_$_Person_$_Test(void ) {
	_OBJC_$_CATEGORY_Person_$_Test.cls = &OBJC_CLASS_$_Person;
}

上下两张图一一对应，并且我们看到定义

_class_t

类型的

OBJC_CLASS_$_Preson

结构体，最后将

_OBJC_$_CATEGORY_Preson_$_Test

的cls指针指向

OBJC_CLASS_$_Preson

结构体地址。我们这里可以看出，cls指针指向的应该是分类的主类类对象的地址。

分类的实现原理是将category中的方法，属性，协议数据放在category_t结构体中，然后将结构体内的 方法列表 拷贝到 类对象 的 方法列表
中。

Category可以添加属性，但是并不会自动生成成员变量及set/get方法。因为category_t结构体中并不存在成员变量。通过之前对对象的分析我们知道成员变量是存放在实例对象中的，并且编译的那一刻就已经决定好了。而分类是在运行时才去加载的。那么我们就无法再程序运行时将分类的成员变量中添加到实例对象的结构体中。因此分类中不可以添加成员变量。

四、catagory_t的方法，属性，协议等的存储类对象中

objc4-781.tar.gz

1、runtime初始化函数

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

2、map_images

接着我们来到 &map_images读取模块（images这里代表模块或镜像）

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

来到map_images_nolock函数中找到_read_images函数，在_read_images函数中我们找到load_categories_nolock函数

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

从上述代码中我们可以知道这段代码是用来查找有没有分类的。通过_getObjc2CategoryList函数获取到分类列表之后，进行遍历，获取其中的方法，协议，属性等。可以看到最终都调用了attachCategories();函数。我们来到attachCategories();函数内部查看。

3、attachCategories();

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

上述源码中可以看出，首先根据方法列表，属性列表，协议列表，malloc分配内存，根据多少个分类以及每一块方法需要多少内存来分配相应的内存地址。之后从分类数组里面往三个数组里面存放分类数组里面存放的分类方法，属性以及协议放入对应mlist、proplists、protolosts数组中，这三个数组放着所有分类的方法，属性和协议。

之后分别通过rwe调用方法列表、属性列表、协议列表的attachList函数，将所有的分类的方法、属性、协议列表数组传进去，我们大致可以猜想到在attachList方法内部将分类和本类相应的对象方法，属性，和协议进行了合并。

4、attachLists

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

上述源代码中有两个重要的数组

array()->lists：类对象原来的方法列表，属性列表，协议列表。

addedLists：传入所有分类的方法列表，属性列表，协议列表。

attachLists函数中最重要的两个方法为memmove内存移动和memcpy内存拷贝。我们先来分别看一下这两个函数

// memmove ：内存移动。
/*  __dst : 移动内存的目的地
*   __src : 被移动的内存首地址
*   __len : 被移动的内存长度
*   将__src的内存移动__len块内存到__dst中
*/
void    *memmove(void *__dst, const void *__src, size_t __len);

// memcpy ：内存拷贝。
/*  __dst : 拷贝内存的拷贝目的地
*   __src : 被拷贝的内存首地址
*   __n : 被移动的内存长度
*   将__src的内存移动__n块内存到__dst中
*/
void    *memcpy(void *__dst, const void *__src, size_t __n);

下面我们图示经过memmove和memcpy方法过后的内存变化。

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

经过memmove方法之后，内存变化为

// array()->lists 原来方法、属性、协议列表数组
// addedCount 分类数组长度
// oldCount * sizeof(array()->lists[0]) 原来数组占据的空间
memmove(array()->lists + addedCount, array()->lists, 
                  oldCount * sizeof(array()->lists[0]));

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

经过memmove方法之后，我们发现，虽然本类的方法，属性，协议列表会分别后移，但是本类的对应数组的指针依然指向原始位置。

memcpy方法之后，内存变化

// array()->lists 原来方法、属性、协议列表数组
// addedLists 分类方法、属性、协议列表数组
// addedCount * sizeof(array()->lists[0]) 原来数组占据的空间
memcpy(array()->lists, addedLists, 
               addedCount * sizeof(array()->lists[0]));

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

我们发现原来指针并没有改变，至始至终指向开头的位置。并且经过memmove和memcpy方法之后，分类的方法，属性，协议列表被放在了类对象中原本存储的方法，属性，协议列表前面。

那么为什么要将分类方法的列表追加到本来的对象方法前面呢，这样做的目的是为了保证分类方法优先调用，我们知道当分类重写本类的方法时，会覆盖本类的方法。

其实经过上面的分析我们知道本质上并不是覆盖，而是优先调用。本类的方法依然在内存中的。

iOS 分类（Category）一、分类的使用场景二、特点三、分类的底层结构四、catagory_t的方法，属性，协议等的存储类对象中

一、分类的使用场景

二、特点

三、分类的底层结构

1、_category_t

2、_method_list_t

对象方法

类方法

3、_protocol_list_t

4、_prop_list_t

5、赋值

四、catagory_t的方法，属性，协议等的存储类对象中

1、runtime初始化函数

2、map_images

3、attachCategories();

4、attachLists

继续阅读

类别和类扩展的区别

(iOS-基本知识)Category VS Extension 原理详解1、什么是Category?Extension（三）category和extension的区别参考文章

类别(类目)与延展 iOS Category Extension

iOS------消息、Category和protocol

OC语言--分类(category)

OC Category 分类 Extension 延展.mdOC Category 分类OC Extension 延展

分类Category分类的定义无名分类

iOS 工程由shell脚本配置一套代码生成多个APP

ICCV 2023 | Prior真的重要吗？IST-Net：更强更快的category-level物体位姿估计模型

Objective-C之类别（类扩展：Class Categories）1 前言2 代码实例3 结语

Category 高级使用

Effective Objective-C 2.0：Item 26: Avoid Properties in Categories

runtime源码探究（五）category的加载

OC中特有的一些语法

ObjC 源码

activity之隐式启动intent