一、疑惑点

采用Object-C语言进行开发的时候，我们都知道可以通过 [XXX alloc]、[[XXX alloc]init]、[XXX new]的形式进行对象实例的创建，那么我们不禁会疑惑alloc、init、new它们各自都做了什么呢？同样的都是进行实例创建，它们之间有什么内在的关联呢？它们之间又有着什么样的区别呢？带着这些疑惑我们一起深入底层探究一下。

Person *p = [Person alloc];
Person *p1 = [[Person alloc]init];
Person *p2 = [Person new];
NSLog(@"%p,%p,%p",p,p1,p2);

二、底层源码探究

既然是深入底层那我们肯定需要知道底层代码是做了什么，很幸运的是苹果开源了这部分的代码。可以在这里下载到。下载下来的源码直接编译是通不过的，需要自己修改下配置。

1、alloc探究

进入到alloc的源码里面，我们发现alloc调用了_objc_rootAlloc方法，而_objc_rootAlloc调用了callAlloc方法。

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

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 (slowpath(checkNil && !cls)) return nil;

#if __OBJC2__
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        // No alloc/allocWithZone implementation. Go straight to the allocator.
        // fixme store hasCustomAWZ in the non-meta class and 
        // add it to canAllocFast's summary
        if (fastpath(cls->canAllocFast())) {
            // No ctors, raw isa, etc. Go straight to the metal.
            bool dtor = cls->hasCxxDtor();
            id obj = (id)calloc(1, cls->bits.fastInstanceSize());
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            obj->initInstanceIsa(cls, dtor);
            return obj;
        }
        else {
            // Has ctor or raw isa or something. Use the slower path.
            id obj = class_createInstance(cls, 0);
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            return obj;
        }
    }
#endif

    // No shortcuts available.
    if (allocWithZone) return [cls allocWithZone:nil];
    return [cls alloc];
}

在callAlloc方法里面吸引我们注意的是if的判断条件。fastpath(!cls->ISA()->hasCustomAWZ())都做了什么呢？fastpath又是什么呢？

fastpath的定义是这样的

#define fastpath(x) (__builtin_expect(bool(x), 1))

我们要搞清楚fastpath是什么，就要知道__builtin_expect是什么。万能的google告诉了我们答案。这个指令是gcc引入的，作用是允许程序员将最有可能执行的分支告诉编译器。这个指令的写法为：__builtin_expect(EXP, N)。意思是：EXP==N的概率很大

!cls->ISA()->hasCustomAWZ()做了什么呢？很明显是调用了hasCustomAWZ这样一个方法。

    bool hasDefaultAWZ( ) {
        return data()->flags & RW_HAS_DEFAULT_AWZ;
    }
#define RW_HAS_DEFAULT_AWZ    (1<<16)

RW_HAS_DEFAULT_AWZ 这个是用来标示当前的class或者是superclass是否有默认的alloc/allocWithZone:。值得注意的是，这个值会存储在metaclass 中。

hasDefaultAWZ( )方法是用来判断当前class是否有重写allocWithZone。如果cls->ISA()->hasCustomAWZ()返回YES，意味着当前的class有重写allocWithZone方法，那么就直接对class进行allocWithZone，申请内存空间。

    if (allocWithZone) return [cls allocWithZone:nil];

+ (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}

allocWithZone内部调用了_objc_rootAllocWithZone方法，接下来我们分析下_objc_rootAllocWithZone方法。

id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
{
    id obj;

#if __OBJC2__
    // allocWithZone under __OBJC2__ ignores the zone parameter
    (void)zone;
    obj = class_createInstance(cls, 0);//创建对象
#else
    if (!zone) {
        obj = class_createInstance(cls, 0);
    }
    else {
        obj = class_createInstanceFromZone(cls, 0, zone);
    }
#endif

    if (slowpath(!obj)) obj = callBadAllocHandler(cls);
    return obj;
}

我们发现直接调用了class_createInstance方法来创建对象，好像已经逐渐接近alloc的真相了。

id class_createInstance(Class cls, size_t extraBytes)
{
    return _class_createInstanceFromZone(cls, extraBytes, nil);
}

tatic __attribute__((always_inline)) 
id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, 
                              bool cxxConstruct = true, 
                              size_t *outAllocatedSize = nil)
{
    if (!cls) return nil;

    assert(cls->isRealized());
    // Read class's info bits all at once for performance
    //读取class的信息
    bool hasCxxCtor = cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();

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

    id obj;
    if (!zone  &&  fast) {
        obj = (id)calloc(1, size);
        if (!obj) return nil;
        obj->initInstanceIsa(cls, hasCxxDtor);
    } 
    else {
        if (zone) {
            obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
        } else {
            obj = (id)calloc(1, size);
        }
        if (!obj) return nil;

        // Use raw pointer isa on the assumption that they might be 
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (cxxConstruct && hasCxxCtor) {
        obj = _objc_constructOrFree(obj, cls);
    }

    return obj;
}

哇瑟，一眼看去就晕了！但是静下心分析下来我们发现了些端倪。创建对象就要为对象开辟内存空间，这里会不会就是为对象开辟了空间呢？发现方法里面调用了instanceSize方法，这个是不是就是开辟内存空间的方法呢？

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

uint32_t alignedInstanceSize() {
  return word_align(unalignedInstanceSize());
}

// May be unaligned depending on class's ivars.
//读取当前的类的属性数据大小
uint32_t unalignedInstanceSize() {
  assert(isRealized());
  return data()->ro->instanceSize;
}
//进行内存对齐
//WORD_MASK == 7
static inline uint32_t word_align(uint32_t x) {
   return (x + WORD_MASK) & ~WORD_MASK;
}

哇瑟，我们的猜测是对的，instanceSize方法计算出了对象的大小，而且必须是大于或等于16字节，然后调用calloc函数为对象分配内存空间了。
有必要说明的一点是，对齐算法使用很巧妙，关于内存对齐在上一篇文章中我有讲解。
由此我们总结一点alloc创建了一个对象并且为其分配了不少于16字节的内存。

但是仅仅是申请了一块内存空间吗？我们还注意到initInstanceIsa方法，那么这个方法是干什么的呢？其实这个方法就是初始化isa指针，关于isa在这里不做描述，在后续的文章中会专门讲解isa。

刚才我们分析了hasDefaultAWZ( )方法返回Yes的情况，那如果hasDefaultAWZ( )方法返回NO呢。

    if (fastpath(cls->canAllocFast())) {
            // No ctors, raw isa, etc. Go straight to the metal.
            bool dtor = cls->hasCxxDtor();
            id obj = (id)calloc(1, cls->bits.fastInstanceSize());
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            obj->initInstanceIsa(cls, dtor);
            return obj;
        }
        else {
            // Has ctor or raw isa or something. Use the slower path.
            id obj = class_createInstance(cls, 0);
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            return obj;
        }

这一段是hasDefaultAWZ( )返回NO的情况，有去判断当前的class是否支持快速alloc。如果可以，直接调用calloc函数，并且申请1块bits.fastInstanceSize()大小的内存空间，然后初始化isa指针，否则直接调用class_createInstance方法，这样就走到了我们上面分析流程了。

总结上面分析流程，我们得出了一个结论

alloc为我们创建了一个对象并且申请了一块不少于16字节的内存空间。

alloc流程图

既然alloc为我们创建了对象，那还要init干嘛呢？init有做了什么呢？

2、init探究

我们进入到init方法源码中

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

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

额的天呐，init啥都没做，只是把当前的对象返回了。既然啥都没做那我们还需要调用init吗？答案是肯定的，其实init就是一个工厂范式，方便开发者自行重写定义。

我们在来看看new方法做了啥。

3、new探究

进入到new的底层代码

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

发现new调用的是callAlloc方法和init，那么可以理解为new实际上就是alloc+init的综合体。

总结

1. alloc创建了对象并且申请了一块不少于16字节的内存控件。
2. init其实什么也没做，返回了当前的对象。其作用在于提供一个范式，方便开发者自定义。
3. new其实是alloc+init的一个综合体。