1.alloc的功能

先上一段简单的代码如下：

   ZCPerson *p1 = [ZCPerson alloc];
   ZCPerson *p2 = [p1 init];   
   ZCPerson *p3 = [p1 init];

输出：

    NSLog(@"p1 -- %@ -- %p ",p1,p1);
    NSLog(@"p2 -- %@ -- %p ",p2,p2);
    NSLog(@"p3 -- %@ -- %p ",p3,p3);

打印结果:

2020-11-19 16:52:35.700247+0800 alloc[8085:217607] p1 -- <ZCPerson: 0x6000037b06d0> -- 0x6000037b06d0
2020-11-19 16:52:35.700545+0800 alloc[8085:217607] p2 -- <ZCPerson: 0x6000037b06d0> -- 0x6000037b06d0
2020-11-19 16:52:35.700755+0800 alloc[8085:217607] p3 -- <ZCPerson: 0x6000037b06d0> -- 0x6000037b06d0

上述打印结果中，可以看出p1、p2、p3打印的对象以及内存地址相同，这个结果说明了对象进行内存空间的开辟是在alloc方法中进行的，而init对对象的内存空间并没有任何的操作。
再一次输出：

    NSLog(@"p1 -- %@ -- %p -- %p",p1,p1,&p1);
    NSLog(@"p2 -- %@ -- %p -- %p",p2,p2,&p2);
    NSLog(@"p3 -- %@ -- %p -- %p",p3,p3,&p3);

打印结果:

2020-11-19 16:57:08.187221+0800 alloc[8279:221378] p1 -- <ZCPerson: 0x600003d4b5b0> -- 0x600003d4b5b0 -- 0x7ffee2984178
2020-11-19 16:57:08.187486+0800 alloc[8279:221378] p2 -- <ZCPerson: 0x600003d4b5b0> -- 0x600003d4b5b0 -- 0x7ffee2984170
2020-11-19 16:57:08.187675+0800 alloc[8279:221378] p3 -- <ZCPerson: 0x600003d4b5b0> -- 0x600003d4b5b0 -- 0x7ffee2984168

以上打印，我们发现&p1、&p2和&p3不相等。所以我们可以得出，当我们在对ZCPerson 进行alloc方法调用时，会在系统中申请一片内存空间，然后我们会用指针p2/p3 = [p1 init]进行接收，通过打印我们知道p2、p3和p1打印出来的内存地址相同，因此说明init并没有对p1内存做任何操作,所以p1和p2/p3应该是指向了同一片内存地址空间。
结论：
系统是通过alloc进行内存开辟，p1、p2和p3虽然地址是不同的，但是他们都指向同一片内存空间，也就是[ZCPerson alloc]方法开辟的空间。

[ZCPerson alloc].png

2. alloc底层探索

通过以上的打印，我们已经得出结论alloc是为对象在系统中申请内存的，但是alloc具体是如何开辟的呢？还是通过上述的基础代码进行探究。
在普通的xcode文件，当我们点击alloc方法进行下层寻找的时候，会发现并没有能看见alloc的方法的具体实现，这说明了Apple并没有在普通API中进行开源，这个时候就需要一些另类的方法进行查找了。
首先，我们在上述代码ZCPerson *p1 = [ZCPerson alloc];打一个断点，然后打开符号断点：

符号断点.png
因为我们探究的是alloc方法，所以在symbol中输入alloc
符号断点alloc.png

注：代码运行时，先将符号断点关闭，等断点先在ZCPerson *p1 = [ZCPerson alloc];方法停住时再打开。因为我们探究的是ZCPerson对象，而alloc方法再底层会被多个底层对象调用，为了保持专一性，在代码运行前必须先将符号断点关闭。

当断点在符号断点处停住时的结果如下：

libobjc.A.dylib`+[NSObject alloc]:
->  0x7fff50bbdf34 <+0>: jmp    0x7fff50bbdf58            ; _objc_rootAlloc

通过断点，我们可以看到，alloc方法是在libobjc的系统库内被调用的，于是我们可以通过源码来看看alloc方法在底层的具体实现。

底层源码实现

我们可以在NSObject.mm文件里找到alloc方法,然后不断点击进入：

+ (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 __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));
}

当我们一步一步跟流程，走到callAlloc方法里时，看见很多if条件，当你不确定会在哪一步条件里执行命令时，你可以选择在源码里配置运行，也可以结合源码进行汇编调试。
汇编方式：
目前，我们通过代码Jump to Definition的方式了解到，ZCPerson在进行alloc的时候，会调用_objc_rootAlloc,callAlloc方法，而在callAlloc方法里尚且不能确定的是调用的_objc_rootAllocWithZone方法还是objc_msgSend，所以，我们可以将这几个方法都打上符号断点。

alloc底层探索.png

通过调试，我们会发现，ZCPerson在进行调用alloc方法时，开始正如我们探索的那样，先调用_objc_rootAlloc，然后调用的是_objc_rootAllocWithZone方法，于是，我们可以进入_objc_rootAllocWithZone方法进行接下来的探索了。在我们进行汇编调试的时候，我们发现在执行完_objc_rootAlloc方法后，并没有在callAlloc方法断点停住，是没有调用吗？这就是Apple自己所做的编译器优化。通过汇编调试，我们可以接着借助源码继续进行alloc的探索。

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

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;
    // 1:要开辟多少内存
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        // 2;怎么去申请内存
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    // 3: ?
    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方法里，有3个比较重要的方法instanceSize，calloc，initInstanceIsa，这也是我们接下来着重探索的方法。我们知道alloc方法是为了向系统申请内存空间，那么它究竟是怎么申请的呢？接下来，我们将分为3个步骤一一去探索。

• 1.申请多大的空间，也是上述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;
    }

在instanceSize里，我们又看到了熟悉的if条件,这个时候，就需要在源码上运行才能知道到底走的cache.fastInstanceSize(extraBytes);还是size_t size = alignedInstanceSize() + extraBytes;。将我们的ZCPerson文件导入已经配置好的源码当中，然后在 instanceSize处加一个断点:

instanceSize方法探索.png

然后进入方法里一步一步执行，发现进入的是return cache.fastInstanceSize(extraBytes);。

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);//#define FAST_CACHE_ALLOC_DELTA16      0x0008

        }
    }

接着往下执行，就来到了return align16(size + extra -FAST_CACHE_ALLOC_DELTA16);。
最终我们发现了苹果开辟空间的奥秘，16字节对齐原则。感兴趣的小伙伴可以自行计算，这里就不做过多探讨了。

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

我们知道，每个对象都会自带一个属性，isa指针，这个指针在我们的内存中占据8个字节，那么Apple为什么不用8字节对齐，而是使用16字节对齐呢？如果我们使用了8字节对齐，当我们生成多个对象时，每个对象都带有一个isa指针，而这些对象分布在内存中是连续的，使用8字节对齐的时候，每个对象的isa都会相互紧挨着，这个时候如果isa内存访问错误，不小心访问到了隔壁对象就会造成内存的紊乱，这个时候我们使用16字节对齐，就会为对象预留了内存空间，使用也会更加安全。

• 开辟内存,calloc方法

void    *calloc(size_t __count, size_t __size) __result_use_check __alloc_size(1,2);

在上述_class_createInstanceFromZone方法中，我们会发现一个zone的条件判断，这个现在已经基本不会走了，因为这个条件大概是在MRC的时候调用了，也就是说，MRC的alloc流程是通过zone的条件来开辟内存的。
当我们探索完instanceSize方法后，接着打上断点调试

objc.png
输出一下obj:

(lldb) po obj
0x00000001008ac1b0

这也说明了，我们通过calloc方法向系统申请开辟了一块内存空间，这块内存空间的地址就是我们输出的obj的地址。

• initInstanceIsa方法的探索

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

通过以上calloc方法，我们输出了0x00000001008ac1b0这样一串地址，但是在外面刚刚开始探索的时候，我们打印ZCPerson的时候，发现我们输出是<ZCPerson: 0x6000037b06d0>这个样子的，而在我们上方的断点处，我们却只输出了0x00000001008ac1b0这样一串地址。我们接着在下面加一个断点：

InitInstanceIsa.png
然后过一下，输出obj：

(lldb) po obj
<ZCPerson: 0x1008ac1b0>

通过输出，我们可以得出结论，initInstanceIsa方法的作用正是将我们开辟的空间的地址指针关联到我们的类。

2. init和new

• init 类方法

+ (id)init {
    return (id)self;
}

• 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其实并没有做什么实质性的动作，只是简单的将自己返回而已。这在ios中是一种常见的工厂设计模式，是一种构造方法。仔细想想，在我们自定义view时，是不是经常会调用initWithFrame方法，或者带一些其他的参数，还有比如NSArray，NSDictionary这些，都会带一些自定义的参数。说白了，init方法是为用户提供构造方法入口的。

• new

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

通过源码可以很清晰的看到，new方法是调用了alloc内的callAlloc方法以及init方法，因此，new方法也等价于[[alloc]init]。