准备工作

• 下载和编译源码，可参考OC底层探索01：objc-781 源码调试和编译

• 通过打印图中三个变量的 内存地址 和指针地址的 区别

  
  image.png

• 打印结果

  
  image.png
• 从打印结果可以知道3个对象的内存地址一样，但是对象的指针地址不同，这就是本文探索的内容，alloc和init在底层究竟做了什么？

alloc源码探索

• 通过YPPerson的alloc方法进入alloc方法的实现

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

• 跳转到_objc_rootAlloc的实现

// Base class implementation of +alloc. cls is not nil.
// Calls [cls allocWithZone:nil].
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;//slowpath()真值判断
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {//判断一个类是否有自定义的+allocWithZone 实现，fastpath()假值判断
        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方法中我们通过断点调试发现，是执行到_objc_rootAllocWithZone
其中 cls->ISA()->hasCustomAWZ()表示判断一个类是否有自定义的+allocWithZone 实现

• 跳转到_objc_rootAllocWithZone方法实现,通过源码可知，_class_createInstanceFromZone的实现可已分为三部分:
  • cls->instanceSize:计算对象需要开辟的内存大小
  • calloc:开辟对应的内存，返回地址指针
  • obj->initInstanceIsa：isa和类进行绑定
• objc_msgSend是NSobject这种系统类走的

NEVER_INLINE
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方法实现

/***********************************************************************
* class_createInstance
* fixme
* Locking: none
*
* Note: this function has been carefully written so that the fastpath
* takes no branch.
**********************************************************************/
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;
    //计算需要开辟的内存大小，传入的extraBytes 为 0
    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) {
        //将 cls类 与 obj指针（即isa） 关联
        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);
}

calloc源码

• 跳转到 cls->instanceSize源码中,通过断点调试会执行cache.fastInstanceSize方法，快速计算所需内存大小

size_t instanceSize(size_t extraBytes) const {
    //编译器快速计算内存大小
    if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
        return cache.fastInstanceSize(extraBytes);
    }
    
    // 计算类中所有属性的大小 + 额外的字节数0
    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    //如果size 小于 16，最小取16
    if (size < 16) size = 16;
    return size;
}

• 跳转到alignedInstanceSize方法中，通过断点发现会执行align16

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

    //Gcc的内建函数 __builtin_constant_p 用于判断一个值是否为编译时常数，如果参数EXP 的值是常数，函数返回 1，否则返回 0
    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
        //删除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8个字节
        return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
    }
}

• 跳转到align16源码，会发现这是个16字节对齐的算法

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

内存对齐原则

• 数据成员对齐规则：struct 或者 union 的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数据、结构体等）的整数倍开始（例如int在32位机中是4字节，则要从4的整数倍地址开始存储）
• 数据成员为结构体：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（例如：struct a里面存有struct b，b里面有char、int、double等元素，则b应该从8的整数倍开始存储）
• 结构体的整体对齐规则：结构体的总大小，即sizeof的结果，必须是其内部最大成员的整数倍，不足的要补齐

字节对齐-总结

• 在字节对齐算法中，对齐的主要是对象，而对象的本质则是一个 struct objc_object的结构体，
• 结构体在内存中是连续存放的，所以可以利用这点对结构体进行强转。
• 苹果早期是8字节对齐，现在是16字节对齐

16字节对齐算法

字节对齐算法

• 首先将原始的内存 8 与 size_t(15)相加，得到 8 + 15 = 23
• 将 size_t(15) 即 15进行~（取反）操作
• 最后将 23 与 15的取反结果 进行 &（与）操作，最后的结果为 16，即内存的大小是以16的倍数增加的

calloc：申请内存，返回地址指针

obj = (id)calloc(1, size)通过instanceSize计算的内存大小，向内存中申请 大小 为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针
这里我们可以通过断点调试的方式，来po obj观察obj的变化，未执行calloc前为nil，执行后为一个16进制地址

obj->initInstanceIsa：类与isa关联

这个过程主要是初始化一个isa指针，并将isa指针指向申请的内存地址，在将指针与cls类进行关联，同样也可以通过断点调试的方法，在执行完initInstanceIsa后，在通过po obj可以得出一个对象指针，而不是先前的16进制地址

alloc总结

• 通过对alloc源码的分析，可以知道alloc的主要作用是开辟内存，在开辟内存的时候使用了16字节对齐算法，所有开辟的内存大小为16的整数倍
• 开辟内存的三个步骤：计算内存大小 --> 申请内存 --> 指针和内存关联

alloc流程图

alloc流程图

init源码探索

init 类方法

这里的init是一个构造方法 ，是通过工厂设计,主要是用于给用户提供构造方法入口。这里能使用id强转的原因，主要还是因为内存字节对齐后，可以使用类型强转为你所需的类型

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

init实例方法

• 跳转到init方法实现

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

• 跳转到_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;
}

new源码探索

通过源码可以得知，new函数中直接调用了callAlloc函数，且调用了init函数，所以可以得出new其实就等价于[alloc init]

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