在分析 alloc 源碼之前，先看一下3個 變量、指針、內(nèi)存地址 的區(qū)別：

分別輸出3個對象的 內(nèi)容、指針地址、對象地址，下圖是打印結果

通過打印可以看出，3個對象指向的是同一個內(nèi)存空間，所以其內(nèi)容 和 指針地址是相同的，但是對象的內(nèi)存地址是不同的

• %p -> p1：是指向內(nèi)存地址的指針
• %p -> &p1：是內(nèi)存地址

這就是本文需要探索的內(nèi)容，alloc做了什么？init做了什么？

準備工作

• 下載 objc4-781 源碼
• 編譯源碼，可參考 iOS底層探究-02：objc4-781源碼編譯&調(diào)試

alloc 源碼探究

大致流程如下：

• 【第一步】首先根據(jù)main函數(shù)中的LCPerson類的alloc方法進入alloc方法的源碼（即源碼分析開始）

+ (id)alloc {
    return _objc_rootAlloc(self);
}

• 【第二步】跳轉至_objc_rootAlloc的源碼

id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

• 【第三步】跳轉至callAlloc的源碼

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        return _objc_rootAllocWithZone(cls, nil);
    }
#endif

    // No shortcuts available.
    if (allocWithZone) {
        return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
    }
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

??注意：當我們無法確定實現(xiàn)具體會走哪步時，可以借助斷點調(diào)試，判斷會走哪部分邏輯。這里是執(zhí)行到_objc_rootAllocWithZone

• 【第四步】跳轉至_objc_rootAllocWithZone的源碼

id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

• 【第五步】跳轉至_class_createInstanceFromZone的源碼，這部分是alloc源碼的核心操作，該方法的實現(xiàn)主要分為三部分：
  大致流程如下：
  

  • cls -> instanceSize：計算需要開辟的內(nèi)存空間大小
  • calloc：申請內(nèi)存，返回地址指針
  • obj -> initInstanceIsa：將 類 與 isa 關聯(lián)

static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
                              int construct_flags = OBJECT_CONSTRUCT_NONE,
                              bool cxxConstruct = true,
                              size_t *outAllocatedSize = nil)
{
    ASSERT(cls->isRealized());

    // Read class's info bits all at once for performance
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();
    size_t size;

    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    if (!zone && fast) {
        obj->initInstanceIsa(cls, hasCxxDtor);
    } else {
        // Use raw pointer isa on the assumption that they might be
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (fastpath(!hasCxxCtor)) {
        return obj;
    }

    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
    return object_cxxConstructFromClass(obj, cls, construct_flags);
}

cls -> instanceSize：計算所需內(nèi)存大小

• 跳轉至instanceSize的源碼

size_t instanceSize(size_t extraBytes) const {
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }

        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }

通過斷點調(diào)試，會執(zhí)行到cache.fastInstanceSize方法，計算內(nèi)存大小

• 跳轉至fastInstanceSize的源碼，通過斷點調(diào)試，會執(zhí)行到align16

size_t fastInstanceSize(size_t extra) const
    {
        ASSERT(hasFastInstanceSize(extra));

        if (__builtin_constant_p(extra) && extra == 0) {
            return _flags & FAST_CACHE_ALLOC_MASK16;
        } else {
            size_t size = _flags & FAST_CACHE_ALLOC_MASK;
            // remove the FAST_CACHE_ALLOC_DELTA16 that was added
            // by setFastInstanceSize
            return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
        }
    }

• 跳轉至align16的源碼，這個方法是16字節(jié)對齊算法

static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

內(nèi)存字節(jié)對齊原則

主要有以下三點

• 數(shù)據(jù)成員對齊規(guī)則：struct 或者 union 的數(shù)據(jù)成員，第一個數(shù)據(jù)成員放在offset為0的地方，以后每個數(shù)據(jù)成員存儲的起始位置要從該成員大小或者成員的子成員大小（只要該成員有子成員，比如數(shù)據(jù)、結構體等）的整數(shù)倍開始（例如int在32位機中是4字節(jié)，則要從4的整數(shù)倍地址開始存儲）
• 數(shù)據(jù)成員為結構體：如果一個結構里有某些結構體成員，則結構體成員要從其內(nèi)部最大元素大小的整數(shù)倍地址開始存儲（例如：struct a里面存有struct b，b里面有char、int、double等元素，則b應該從8的整數(shù)倍開始存儲）
• 結構體的整體對齊規(guī)則：結構體的總大小，即sizeof的結果，必須是其內(nèi)部做大成員的整數(shù)倍，不足的要補齊

為什么需要16字節(jié)對齊

需要字節(jié)對齊的原因，有以下幾點：

• 通常內(nèi)存是由一個個字節(jié)組成的，cpu在存取數(shù)據(jù)時，并不是以字節(jié)為單位存儲，而是以塊為單位存取，塊的大小為內(nèi)存存取力度。頻繁存取字節(jié)未對齊的數(shù)據(jù)，會極大降低cpu的性能，所以可以通過減少存取次數(shù)來降低cpu的開銷
• 16字節(jié)對齊，是由于在一個對象中，第一個屬性isa占8字節(jié)，當然一個對象肯定還有其他屬性，當無屬性時，會預留8字節(jié)，即16字節(jié)對齊，如果不預留，相當于這個對象的isa和其他對象的isa緊挨著，容易造成訪問混亂
• 16字節(jié)對齊后，可以加快CPU讀取速度，同時使訪問更安全，不會產(chǎn)生訪問混亂的情況

字節(jié)對齊-總結

• 在字節(jié)對齊算法中，對齊的主要是對象，而對象的本質則是一個 struct objc_object的結構體，
• 結構體在內(nèi)存中是連續(xù)存放的，所以可以利用這點對結構體進行強轉。
• 蘋果早期是8字節(jié)對齊，現(xiàn)在是16字節(jié)對齊。

calloc：申請內(nèi)存，返回地址指針

通過instanceSize計算的內(nèi)存大小，向內(nèi)存中申請 大小 為size 的內(nèi)存，并賦值給obj，因此 obj是指向內(nèi)存地址的指針

obj = (id)calloc(1, size);

obj -> initInstanceIsa：類與isa關聯(lián)

經(jīng)過calloc，內(nèi)存已經(jīng)申請好了，類也已經(jīng)傳入進來了，那么接下來就需要將 類 與 地址指針 即 isa指針進行關聯(lián)

init 源碼探索

alloc源碼探索完了，接下來探索init源碼，通過源碼可知，inti的源碼實現(xiàn)有以下兩種

類方法 init

• 通過代碼進行探索實例方法 init

LCPerson *p1 = [[LCPerson alloc] init];

• 通過main中的init跳轉至init的源碼

- (id)init {
    return _objc_rootInit(self);
}

• 跳轉至_objc_rootInit的源碼

id
_objc_rootInit(id obj)
{
    // In practice, it will be hard to rely on this function.
    // Many classes do not properly chain -init calls.
    return obj;
}

有此可見，返回的是傳入的self本身。

new 源碼探索

一般在開發(fā)中，初始化除了init，還可以使用new，兩者本質上并沒有什么區(qū)別，以下是objc中new的源碼實現(xiàn)，通過源碼可以得知，new函數(shù)中直接調(diào)用了callAlloc函數(shù)（即alloc中分析的函數(shù)），且調(diào)用了init函數(shù)，所以可以得出new 其實就等價于 [alloc init]的結論

+ (id)new {
    return [callAlloc(self, false/*checkNil*/) init];
}

??注意：但是一般開發(fā)中并不建議使用new，主要是因為有時會重寫init方法做一些自定義的操作，例如 initWithXXX，會在這個方法中調(diào)用[super init]，用new初始化可能會無法走到自定義的initWithXXX部分。