前言

在分析源码之前，先看一看这段代码：

结论：从上图可以看出，三个不同的对象指针，都指向了同一片内存区域。本文即要通过源码，探索alloc，init，new他们都做了什么

准备工作：

• 请自行准备本文将会用到objc源码，在苹果的开源网站有下载
• 基本的断点知识

从alloc到_objc_rootAllocWithZone方法

//初始化一个对象
TestObject *obj = [[TestObject alloc] init];
//alloc会调用_objc_rootAlloc方法
+ (id)alloc {
	//传入一个类对象TestObject
    return _objc_rootAlloc(self);	
}
//_objc_rootAlloc会调用callAlloc
id 
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
// 这个方法稍微复杂
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
	/**
    slowpath和fastpath表示是否进行编译器优化
    参考链接：https://www.jianshu.com/p/536824702ab6
    */
    if (slowpath(checkNil && !cls)) return nil;
    //判断一个类是否有自定义的 +allocWithZone 实现
    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));
}

//即将进入核心方法
NEVER_INLINE
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
	//在这个return方法打个断点，这时候zone还是Null，Class依旧是TestObject，接下来系统马上将会给这个对象初始化并分配内存空间。
    // allocWithZone under __OBJC2__ ignores the zone parameter
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

写一行最简单的初始化方法，点击alloc方法查看源码并一路向下，从源码中可以看出，代码会这么调用

alloc->_objc_rootAlloc->callAlloc->_objc_rootAllocWithZone

其中直到callAlloc这个方法的调用外，都非常简单，这里简单解释一下callAlloc不太明白的地方

slowpath，fastpath宏

这里看到第一眼很懵逼的就是slowpath,fastpath宏定义这俩是什么鬼？

其实slowpath和fastpath表示是否有编译器优化，苹果其实对OC进行了很多优化，有兴趣的同学可以参考链接：www.jianshu.com/p/536824702…

cls->ISA()->hasCustomAWZ()

hasCustomAWZ()这个判断又是什么鬼？怎么还有ISA()?

关于ISA的问题在后面的文章解释，是用来拿到类结构里数据的方法，hasCustomAWZ()表示是否有是否有自定义的+allocWithZone实现。大家应该都知道zone是iOS的一个遗留问题，通过断点我们在这里会进入对象初始化的重要方法

_class_createInstanceFromZone

//核心方法来了！！！！
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;
    //历史遗留，不会进入zone的判断
    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;
    }

    //将 cls类 与 obj指针（即isa）关联
    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);
}

_class_createInstanceFromZone是整个alloc里的核心方法

前面几行的几个bool变量请暂时忽略，他们不影响后面的东西

开辟内存

第一个要点就是size = cls->instanceSize(extraBytes); 这个方法表示需要开辟的内存空间 这里点进去，看这个方法的源码

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

通过断点，会进入cache.fastInstanceSize方法中去

这里注意一下最后两行的代码和注释，明确告诉我们如果小于16字节的对象，都会统一给他分配16字节的内存。在fastInstanceSize中也会有内存的16字节对齐

接下来是

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

通过断点能进入return _flags & FAST_CACHE_ALLOC_MASK;这一行代码 这个_flags表示的是类的标识与FAST_CACHE_ALLOC_MASK宏定义进行与运算，拿到一个size。（这个flag具体是个啥，为啥要通过与FAST_CACHE_ALLOC_MASK得出size我也不明白有知道的大神可以讲一讲）

在return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);上加个断点，我们可以看到此时

size = 16

extra = 0

FAST_CACHE_ALLOC_DELTA16是一个#define FAST_CACHE_ALLOC_DELTA16 0x0008宏定义，也就是8

此时，传入align16里的值为16 + 0 - 8 = 8

配合align16的源码

static inline size_t align16(size_t x) {
	//字节对齐
    return (x + size_t(15)) & ~size_t(15);
}

(x + size_t(15)) & ~size_t(15);是一个对于16字节对齐的算法

苹果的字节对齐

通过上面算出的16 + 0 - 8 = 8，得出x = 8。也就是

8 + size_t(15)) & ~size_t(15)

就拿8做例子，看看苹果是如何做到对齐的

将  8 换做2进制 	-> 0000 0000 0000 1000
将 15 换做2进制  -> 0000 0000 0000 1111
将 ~15换做2进制  -> 1111 1111 1111 0000

将8与15相加，并与上15的取非

将 23 换做2进制  -> 0000 0000 0001 0111
将 ~15换做2进制  -> 1111 1111 1111 0000
得值			  -> 0000 0000 0001 0000 = 16

将23与上15的取非，可以看出就是将最后的四位抹零！得到的数永远都是16的倍数~ 也就是每个对象所占用的内存，都是16字节的倍数

再举一个例子，随便拿一个数字56做例子，那么是56 + 15 = 71与上15的取非

将 71 换做2进制  -> 0000 0000 0100 0111
将 ~15换做2进制  -> 1111 1111 1111 0000
得值			  -> 0000 0000 0100 0000 = 64

得到的值为64，依旧是16的倍数 由此我们可以得出结论：

苹果的内存对齐原则为16字节对齐，小于16字节则按照16字节分配（会先加上15，保证不会出现小于16的情况），大于16字节按照16字节的倍数进行分配

既然得出了字节对齐的方式，那么为什么要16字节对齐？？？

总结

aaa