摘要

在Objective-C 2.0中谷徙，提供了category這個(gè)語言特性，可以動態(tài)地為已有類添加新行為祷嘶。如今category已經(jīng)遍布于Objective-C代碼的各個(gè)角落维哈，從Apple官方的framework到各個(gè)開源框架雄驹，從功能繁復(fù)的大型APP到簡單的應(yīng)用块促，catagory無處不在荣堰。本文對category做了比較全面的整理，希望對讀者有所裨益竭翠。

目錄結(jié)構(gòu)

1振坚、 category簡介
2、 category結(jié)構(gòu)組成
3斋扰、 category加載過程
4渡八、category和+load

1、 category簡介

category是Objective-C 2.0之后添加的語言特性传货，category的主要作用是為已經(jīng)存在的類添加方法呀狼。除此之外，apple還推薦了category的另外兩個(gè)使用場景1

• 可以把類的實(shí)現(xiàn)分開在幾個(gè)不同的文件里面损离。這樣做有幾個(gè)顯而易見的好處，a)可以減少單個(gè)文件的體積 b)可以把不同的功能組織到不同的category里 c)可以由多個(gè)開發(fā)者共同完成一個(gè)類 d)可以按需加載想要的category 等等绝编。
• 聲明私有方法

不過除了apple推薦的使用場景僻澎，廣大開發(fā)者腦洞大開，還衍生出了category的其他幾個(gè)使用場景：

• 模擬多繼承
• 把framework的私有方法公開

Objective-C的這個(gè)語言特性對于純動態(tài)語言來說可能不算什么十饥，比如JavaScript窟勃，你可以隨時(shí)為一個(gè)“類”或者對象添加任意方法和實(shí)例變量。但是對于不是那么“動態(tài)”的語言而言逗堵，這確實(shí)是一個(gè)了不起的特性秉氧。

2、 category結(jié)構(gòu)組成

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

• name: 分類名字
• cls: 所屬的class類
• instance_methods: 實(shí)例方法列表
• class_methods: 類方法列表
• protocols: 協(xié)議列表
• properties: 屬性列表

可見一個(gè) category持有了一個(gè)method_list_t 類型的數(shù)組蜒秤，method_list_t又繼承自 entsize_list_tt汁咏，這是一種泛型容器:

struct method_list_t : entsize_list_tt<method_t, method_list_t, 0x3> {
    // 成員變量和方法
};
template <typename element, typename list, uint32_t flagmask>
struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
    Element first;
};</typename element, typename list, uint32_t flagmask></method_t, method_list_t, 0x3>

• entsize_list_tt: 可以理解為一個(gè)容器，擁有自己的迭代器用于遍歷所有元素
• Element: 元素類型
• List: 用于指定容器類型
• uint32_t flagmask: 標(biāo)記位

在category結(jié)構(gòu)體構(gòu)造中可以看到_method_list_t類型的方法列表作媚，當(dāng)類中有一個(gè)方法時(shí)的定義如下：

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
}

可以看到_method_list_t結(jié)構(gòu)體中包含_objc_method類型方法列表,即存儲方法的容器,_objc_method定義：

struct _objc_method {
    struct objc_selector * _cmd;
    const char *method_type;
    void  *_imp;
}

以上是category結(jié)構(gòu)體構(gòu)造攘滩，最后，我們還有一個(gè)結(jié)構(gòu)體 category_list 用來存儲所有的 category纸泡，它的定義如下:

struct locstamped_category_list_t {
    uint32_t count;
    locstamped_category_t list[0];
};
struct locstamped_category_t {
    category_t *cat;
    struct header_info *hi;
};
typedef locstamped_category_list_t category_list;

除了標(biāo)記存儲的 category 的數(shù)量外漂问，locstamped_category_list_t 結(jié)構(gòu)體還聲明了一個(gè)長度為零的數(shù)組，這其實(shí)是 C99 中的一種寫法，允許我們在運(yùn)行期動態(tài)的申請內(nèi)存蚤假。

3栏饮、category加載過程

在分析category加載過程之前，我們先通過一段代碼看下category內(nèi)部實(shí)現(xiàn)：
oc代碼：

//.h
#import <Foundation/Foundation.h>

@interface Person : NSObject
- (void)printName;
@property(nonatomic, copy) NSString *name;
@end

@interface Person(PersonAddtion)
@property(nonatomic, copy) NSString *name;
- (void)printName;
@end

//.m
#import "Person.h"
@implementation Person
- (void)printName{
    NSLog(@"Person - printName");
}
@end

@implementation Person(PersonAddtion)
- (void)printName{
    NSLog(@"PersonAddtion - printName");
}
@end

我們使用clang的命令clang -rewrite-objc Person.m去看看category到底會變成什么磷仰。
我們得到了一個(gè)3M大小袍嬉，1w行的.cpp文件，我們忽略掉所有和我們無關(guān)的東西芒划，在文件的最后冬竟，我們找到了如下代碼片段：

//這是Person類的代碼
//這是Person類的代碼
static struct /*_ivar_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count;
    struct _ivar_t ivar_list[1];
} _OBJC_$_INSTANCE_VARIABLES_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_ivar_t),
    1,
    {{(unsigned long int *)&OBJC_IVAR_$_Person$_name, "_name", "@\"NSString\"", 3, 8}}
};

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[3];
} _OBJC_$_INSTANCE_METHODS_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    3,
    {{(struct objc_selector *)"printName", "v16@0:8", (void *)_I_Person_printName},
    {(struct objc_selector *)"name", "@16@0:8", (void *)_I_Person_name},
    {(struct objc_selector *)"setName:", "v24@0:8@16", (void *)_I_Person_setName_}}
};

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 __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"name","T@\"NSString\",C,N,V_name"}}
};

static struct _class_ro_t _OBJC_METACLASS_RO_$_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    1, sizeof(struct _class_t), sizeof(struct _class_t), 
    (unsigned int)0, 
    0, 
    "Person",
    0, 
    0, 
    0, 
    0, 
    0, 
};

static struct _class_ro_t _OBJC_CLASS_RO_$_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    0, __OFFSETOFIVAR__(struct Person, _name), sizeof(struct Person_IMPL), 
    (unsigned int)0, 
    0, 
    "Person",
    (const struct _method_list_t *)&_OBJC_$_INSTANCE_METHODS_Person,
    0, 
    (const struct _ivar_list_t *)&_OBJC_$_INSTANCE_VARIABLES_Person,
    0, 
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person,
};

//這是PersonAddtion中實(shí)現(xiàn)代碼
//這是PersonAddtion中實(shí)現(xiàn)代碼
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[1];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_PersonAddtion __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    1,
    {{(struct objc_selector *)"printName", "v16@0:8", (void *)_I_Person_PersonAddtion_printName}}
};

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_$_PersonAddtion __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    1,
    {{"name","T@\"NSString\",C,N"}}
};

extern "C" __declspec(dllexport) struct _class_t OBJC_CLASS_$_Person;

static struct _category_t _OBJC_$_CATEGORY_Person_$_PersonAddtion __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "Person",
    0, // &OBJC_CLASS_$_Person,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_PersonAddtion,
    0,
    0,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_PersonAddtion,
};
static void OBJC_CATEGORY_SETUP_$_Person_$_PersonAddtion(void ) {
    _OBJC_$_CATEGORY_Person_$_PersonAddtion.cls = &OBJC_CLASS_$_Person;
}
#pragma section(".objc_inithooks$B", long, read, write)
__declspec(allocate(".objc_inithooks$B")) static void *OBJC_CATEGORY_SETUP[] = {
    (void *)&OBJC_CATEGORY_SETUP_$_Person_$_PersonAddtion,
};
static struct _class_t *L_OBJC_LABEL_CLASS_$ [1] __attribute__((used, section ("__DATA, __objc_classlist,regular,no_dead_strip")))= {
    &OBJC_CLASS_$_Person,
};
static struct _category_t *L_OBJC_LABEL_CATEGORY_$ [1] __attribute__((used, section ("__DATA, __objc_catlist,regular,no_dead_strip")))= {
    &_OBJC_$_CATEGORY_Person_$_PersonAddtion,
};

從以上兩段代碼可以看出：

• Person類中生成了_name變量、printName方法民逼、name的getter方法泵殴、setName方法、name屬性
• PersonAddtion類中僅僅有printName方法拼苍、name屬性

以上就可以看出category中并不會生成實(shí)例變量笑诅，所以在category中不能使用實(shí)例變量.

接著對以上PersonAddtion代碼分析:

• 首先編譯器生成了實(shí)例方法列表_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_PersonAddtion和屬性列表_OBJC_$_PROP_LIST_Person_$_PersonAddtion，兩者的命名都遵循了公共前綴+類名+category名字的命名方式疮鲫，而且實(shí)例方法列表里面填充的正是我們在PersonAddtion這個(gè)category里面寫的方法printName吆你，而屬性列表里面填充的也正是我們在PersonAddtio里添加的name屬性。還有一個(gè)需要注意到的事實(shí)就是category的名字用來給各種列表以及后面的category結(jié)構(gòu)體本身命名俊犯，而且有static來修飾妇多，所以在同一個(gè)編譯單元里我們的category名不能重復(fù)，否則會出現(xiàn)編譯錯(cuò)誤燕侠。
• 編譯器生成了category本身_OBJC_$_CATEGORY_Person_$_PersonAddtion者祖，并用前面生成的列表來初始化category本身。
• 編譯器在DATA段下的objc_catlist section里保存了一個(gè)大小為1的category_t的數(shù)組L_OBJC_LABEL_CATEGORY_$ [1]（當(dāng)然绢彤，如果有多個(gè)category七问，會生成對應(yīng)長度的數(shù)組，用于運(yùn)行期category的加載茫舶。

接下來我們看下category如何加載械巡？

我們知道，Objective-C的運(yùn)行是依賴OC的runtime的饶氏，而OC的runtime和其他系統(tǒng)庫一樣讥耗，是OS X和iOS通過dyld動態(tài)加載的。
對于OC運(yùn)行時(shí)嚷往，入口方法如下（在objc-os.mm文件中）：

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;

    // fixme defer initialization until an objc-using image is found?
    environ_init();
    tls_init();
    lock_init();
    exception_init();

    // Register for unmap first, in case some +load unmaps something
    _dyld_register_func_for_remove_image(&unmap_image);
    dyld_register_image_state_change_handler(dyld_image_state_bound,
                                             1/*batch*/, &map_images);
    dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}

以上方法加載過程：

void _objc_init(void)
└──const char *map_2_images(...)
    └──const char *map_images_nolock(...)
        └──void _read_images(header_info **hList, uint32_t hCount)

category被附加到類上面是在map_images的時(shí)候發(fā)生的葛账，在new-ABI的標(biāo)準(zhǔn)下，_objc_init里面的調(diào)用的map_images最終會調(diào)用objc-runtime-new.mm里面的_read_images方法皮仁，而在_read_images方法的結(jié)尾籍琳，有以下的代碼片段：

// Discover categories. 
    for (EACH_HEADER) {
        category_t **catlist =
            _getObjc2CategoryList(hi, &count);
        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            class_t *cls = remapClass(cat->cls);

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Disavow any knowledge of this category.
                catlist[i] = NULL;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class",
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category. 
            // First, register the category with its target class. 
            // Then, rebuild the class's method lists (etc) if 
            // the class is realized. 
            BOOL classExists = NO;
            if (cat->instanceMethods ||  cat->protocols 
                ||  cat->instanceProperties)
            {
                addUnattachedCategoryForClass(cat, cls, hi);
                if (isRealized(cls)) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s",
                                 getName(cls), cat->name,
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols 
                /* ||  cat->classProperties */)
            {
                addUnattachedCategoryForClass(cat, cls->isa, hi);
                if (isRealized(cls->isa)) {
                    remethodizeClass(cls->isa);
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)",
                                 getName(cls), cat->name);
                }
            }
        }
    }

這段代碼很容易理解：

• 把category的實(shí)例方法菲宴、協(xié)議以及屬性添加到類上
• 把category的類方法和協(xié)議添加到類的metaclass上

在上述的代碼片段里，addUnattachedCategoryForClass只是把類和category做一個(gè)關(guān)聯(lián)映射趋急，而remethodizeClass才是真正去處理添加事宜的功臣喝峦，remethodizeClass實(shí)現(xiàn)：

static void remethodizeClass(class_t *cls)
{
    category_list *cats;
    BOOL isMeta;

    rwlock_assert_writing(&runtimeLock);

    isMeta = isMetaClass(cls);

    // Re-methodizing: check for more categories
    if ((cats = unattachedCategoriesForClass(cls))) {
        chained_property_list *newproperties;
        const protocol_list_t **newprotos;

        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s",
                         getName(cls), isMeta ? "(meta)" : "");
        }

        // Update methods, properties, protocols

        BOOL vtableAffected = NO;
        attachCategoryMethods(cls, cats, &vtableAffected);

        newproperties = buildPropertyList(NULL, cats, isMeta);
        if (newproperties) {
            newproperties->next = cls->data()->properties;
            cls->data()->properties = newproperties;
        }

        newprotos = buildProtocolList(cats, NULL, cls->data()->protocols);
        if (cls->data()->protocols  &&  cls->data()->protocols != newprotos) {
            _free_internal(cls->data()->protocols);
        }
        cls->data()->protocols = newprotos;

        _free_internal(cats);

        // Update method caches and vtables
        flushCaches(cls);
        if (vtableAffected) flushVtables(cls);
    }
}

而對于添加類的實(shí)例方法而言，又會去調(diào)用attachCategories這個(gè)方法呜达，我們?nèi)タ聪耡ttachCategories：

static void attachCategories(Class cls, category_list *cats, bool flush_caches) {
    if (!cats) return;
    bool isMeta = cls->isMetaClass();
    method_list_t **mlists = (method_list_t **)malloc(cats->count * sizeof(*mlists));
    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int i = cats->count;
    while (i--) {
        auto& entry = cats->list[i];
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            mlists[mcount++] = mlist;
        }
    }
    auto rw = cls->data();
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);
}

以上調(diào)用過程如下：

void _read_images(header_info **hList, uint32_t hCount)
└──static void remethodizeClass(Class cls)
    └──static void attachCategories(Class cls, category_list *cats, bool flush_caches)

首先谣蠢，通過 while 循環(huán)，我們遍歷所有的 category查近，也就是參數(shù) cats 中的 list 屬性眉踱。對于每一個(gè) category，得到它的方法列表 mlist 并存入 mlists 中霜威。

換句話說谈喳，我們將所有 category 中的方法拼接到了一個(gè)大的二維數(shù)組中，數(shù)組的每一個(gè)元素都是裝有一個(gè) category 所有方法的容器戈泼。這句話比較繞婿禽，但你可以把 mlists 理解為文章開頭所說，舊版本的 objc_method_list **methodLists大猛。

在 while 循環(huán)外扭倾，我們得到了拼接成的方法，此時(shí)需要與類原來的方法合并:

auto rw = cls->data();
rw->methods.attachLists(mlists, mcount);

這兩行代碼讀不懂是必然的挽绩，因?yàn)樵?Objective-C 2.0 時(shí)代膛壹，對象的內(nèi)存布局已經(jīng)發(fā)生了一些變化。我們需要先了解對象的布局模型才能理解這段代碼唉堪。

Objective-C 2.0 對象布局模型

我們主要看下一下三個(gè)概念：

1恢筝、 objc_class
2、 class_data_bits_t
3巨坊、 class_rw_t

• objc_class

相信讀到這里的大部分讀者都學(xué)習(xí)過文章開頭所說的對象布局模型，因此在這一部分此改，我們采用類比的方法趾撵，來看看 Objective-C 2.0 下發(fā)生了哪些改變。

首先共啃，Class 和 id 指針的定義并沒有發(fā)生改變占调，他們一個(gè)指向類對應(yīng)的結(jié)構(gòu)體，一個(gè)指向?qū)ο髮?yīng)的結(jié)構(gòu)體:

// objc.h
typedef struct objc_class *Class;
typedef struct objc_object *id;

比較有意思的一點(diǎn)是移剪，objc_class 結(jié)構(gòu)體是繼承自 objc_object的:

struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};
struct objc_class : objc_object {
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
    class_rw_t *data() {
        return bits.data();
    }
};

這一點(diǎn)也很容易理解究珊，早在 Objective-C 1.0 時(shí)代，我們就知道一個(gè)對象的結(jié)構(gòu)體只有 isa 指針纵苛，指向它所屬的類剿涮。而類的結(jié)構(gòu)體也有 isa 指針指向它的元類.

可見 Objective-C 1.0 的布局模型中言津，cache和 super_class 被原封不動的移過來了，而剩下的屬性則似乎消失不見取试。取而代之的是一個(gè) bits屬性悬槽，以及 data() 方法，這個(gè)方法調(diào)用的其實(shí)是 bits 屬性的data()方法瞬浓，并返回了一個(gè) class_rw_t類型的結(jié)構(gòu)體指針初婆。

• class_data_bits_t

以下是簡化版 class_data_bits_t 結(jié)構(gòu)體的定義:

struct class_data_bits_t {
    uintptr_t bits;
public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
}

可見這個(gè)結(jié)構(gòu)體只有一個(gè) 64 位的 bits 成員，存儲了一個(gè)指向 class_rw_t 結(jié)構(gòu)體的指針和三個(gè)標(biāo)志位猿棉。它實(shí)際上由三部分組成磅叛。首先由于 Mac OS X 只使用 47 位內(nèi)存地址，所以前 17 位空余出來萨赁，提供給 retain/release 和 alloc/dealloc 方法使用弊琴，做一些優(yōu)化。其次位迂，由于內(nèi)存對齊访雪，指針地址的后三位都是 0，因此可以用來做標(biāo)志位:

// class is a Swift class
#define FAST_IS_SWIFT           (1UL<<0)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<1)
// class's instances requires raw isa
#define FAST_REQUIRES_RAW_ISA   (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL

如果計(jì)算一下就會發(fā)現(xiàn)掂林，F(xiàn)AST_DATA_MASK 這個(gè) 16 進(jìn)制常量的二進(jìn)制表示恰好后三位為0臣缀，且長度為47位: 11111111111111111111111111111111111111111111000，我們通過這個(gè)掩碼做按位與運(yùn)算即可取出正確的指針地址泻帮。

引用 Draveness 在 深入解析 Objective-C 中方法的結(jié)構(gòu) 中的圖片做一個(gè)總結(jié):

• class_rw_t

bits 中包含了一個(gè)指向 class_rw_t結(jié)構(gòu)體的指針精置，它的定義如下:

struct class_rw_t {
    uint32_t flags;
    uint32_t version;
    const class_ro_t *ro;
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;
}

注意到有一個(gè)名字很類似的結(jié)構(gòu)體 class_ro_t，這里的rw和 ro分別表示 readwrite 和 readonly锣杂。因?yàn)? class_ro_t存儲了一些由編譯器生成的常量脂倦。

正是由于 class_ro_t中的兩個(gè)屬性instanceStart 和 instanceSize的存在，保證了 Objective-C2.0 的 ABI 穩(wěn)定性元莫。因?yàn)榧词垢割愒黾臃椒ɡ底瑁宇愐部梢栽谶\(yùn)行時(shí)重新計(jì)算 ivar 的偏移量，從而避免重新編譯踱蠢。

我們回頭接著分析代碼：

auto rw = cls->data();
rw->methods.attachLists(mlists, mcount);

現(xiàn)在來看火欧，rw 是一個(gè) class_rw_t 類型的結(jié)構(gòu)體指針。根據(jù) runtime 中的數(shù)據(jù)結(jié)構(gòu)茎截，它有一個(gè) methods 結(jié)構(gòu)體成員苇侵，并從父類繼承了 attachLists 方法，用來合并 category 中的方法:

void attachLists(List* const * addedLists, uint32_t addedCount) {
    if (addedCount == 0) return;
    uint32_t oldCount = array()->count;
    uint32_t newCount = oldCount + addedCount;
    setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
    array()->count = newCount;
    memmove(array()->lists + addedCount, array()->lists, oldCount * sizeof(array()->lists[0]));
    memcpy(array()->lists, addedLists, addedCount * sizeof(array()->lists[0]));
}

在實(shí)際代碼中企锌，比上面略復(fù)雜一些榆浓。因?yàn)闉榱颂岣咝阅埽O果做了一些優(yōu)化撕攒，比如當(dāng) List 處于第二種狀態(tài)(只有一個(gè)指針陡鹃，指向一個(gè)元數(shù)據(jù)的集合)時(shí)烘浦，其實(shí)并不需要在原地?cái)U(kuò)容空間，而是只要重新申請一塊內(nèi)存杉适，并將最后一個(gè)位置留給原來的集合即可谎倔。

這樣只多花費(fèi)了很少的內(nèi)存空間，也就是原來二維數(shù)組占用的內(nèi)存空間猿推，但是 malloc() 的性能優(yōu)勢會更加明顯片习，這其實(shí)是一個(gè)空間換時(shí)間的權(quán)衡問題。

需要注意的是蹬叭，無論執(zhí)行哪種邏輯藕咏，參數(shù)列表中的方法都會被添加到二維數(shù)組的前面。而我們簡單的看一下 runtime 在查找方法時(shí)的邏輯:

static method_t *getMethodNoSuper_nolock(Class cls, SEL sel){
    for (auto mlists = cls->data()->methods.beginLists(),
              end = cls->data()->methods.endLists();
         mlists != end;
         ++mlists) {
        method_t *m = search_method_list(*mlists, sel);
        if (m) return m;
    }
    return nil;
}
static method_t *search_method_list(const method_list_t *mlist, SEL sel) {
    for (auto& meth : *mlist) {
        if (meth.name == sel) return &meth;
    }
}

可見搜索的過程是按照從前向后的順序進(jìn)行的秽五，一旦找到了就會停止循環(huán)孽查。因此 category 中定義的同名方法不會替換類中原有的方法，但是對原方法的調(diào)用實(shí)際上會調(diào)用 category 中的方法坦喘。

4盲再、-category和+load方法

我們知道，在類和category中都可以有+load方法瓣铣，那么有兩個(gè)問題：

• 在類的+load方法調(diào)用的時(shí)候答朋，我們可以調(diào)用category中聲明的方法么？
• 這么些個(gè)+load方法棠笑，調(diào)用順序是咋樣的呢梦碗？

鑒于上述幾節(jié)我們看的代碼太多了，對于這兩個(gè)問題我們先來看一點(diǎn)直觀的：

我們的代碼里有Person和Person的兩個(gè)category （Category1和Category2）蓖救，Person和兩個(gè)category都添加了+load方法洪规，并且Category1和Category2都寫了Person的printName方法。
在Xcode中點(diǎn)擊Edit Scheme循捺，添加如下兩個(gè)環(huán)境變量（可以在執(zhí)行l(wèi)oad方法以及加載category的時(shí)候打印log信息斩例，更多的環(huán)境變量選項(xiàng)可參見objc-private.h）:

objc[85057]: REPLACED: -[Person printName]  by category Category1 
objc[85057]: REPLACED: -[Person printName]  by category Category2
objc[85057]: LOAD: class 'Person' scheduled for +load
objc[85057]: LOAD: category 'Person(Category1)' scheduled for +load
objc[85057]: LOAD: category 'Person(Category2)' scheduled for +load
objc[85057]: LOAD: +[Person load]
objc[85057]: LOAD: +[Person(Category1) load]
objc[85057]: LOAD: +[Person(Category2) load]

所以，對于上面兩個(gè)問題洋满，答案是很明顯的：
1)、可以調(diào)用珍坊，因?yàn)楦郊?code>category到類的工作會先于+load方法的執(zhí)行
2)牺勾、+load的執(zhí)行順序是先類，后category阵漏，而category的+load執(zhí)行順序是根據(jù)編譯順序決定的驻民。
目前的編譯順序是這樣的：

我們調(diào)整一個(gè)Category1和Category2的編譯順序翻具，run。ok回还，我們可以看到控制臺的輸出順序變了：

objc[85494]: REPLACED: -[Person printName]  by category Category2
objc[85494]: REPLACED: -[Person printName]  by category Category1
objc[85494]: LOAD: class 'Person' scheduled for +load
objc[85494]: LOAD: category 'Person(Category2)' scheduled for +load
objc[85494]: LOAD: category 'Person(Category1)' scheduled for +load
objc[85494]: LOAD: +[Person load]
objc[85494]: LOAD: +[Person(Category2) load]
objc[85494]: LOAD: +[Person(Category1) load]

雖然對于+load的執(zhí)行順序是這樣裆泳，但是對于“覆蓋”掉的方法，則會先找到最后一個(gè)編譯的category里的對應(yīng)方法柠硕。
那么怎么調(diào)用到原來類中被category覆蓋掉的方法工禾？
對于這個(gè)問題，我們已經(jīng)知道category其實(shí)并不是完全替換掉原來類的同名方法蝗柔，只是category在方法列表的前面而已闻葵，所以我們只要順著方法列表找到最后一個(gè)對應(yīng)名字的方法，就可以調(diào)用原來類的方法：

Person currentClass = [Person class];
Person *per = [[Person alloc] init];

if (currentClass) {
    unsigned int methodCount;
    Method *methodList = class_copyMethodList(currentClass, &methodCount);
    IMP lastImp = NULL;
    SEL lastSel = NULL;
    for (NSInteger i = 0; i < methodCount; i++) {
        Method method = methodList[i];
        NSString *methodName = [NSString stringWithCString:sel_getName(method_getName(method)) 
                                        encoding:NSUTF8StringEncoding];
        if ([@"printName" isEqualToString:methodName]) {
            lastImp = method_getImplementation(method);
            lastSel = method_getName(method);
        }
    }
    typedef void (*fn)(id,SEL);

    if (lastImp != NULL) {
        fn f = (fn)lastImp;
        f(per,lastSel);
    }
    free(methodList);
}

參考資料：
結(jié)合 category 工作原理分析 OC2.0 中的 runtime
iOS category內(nèi)部實(shí)現(xiàn)原理