OC 对象原理探索（一）：alloc1. alloc 对象的指针地址和内存首先我们先用一个例子进行分析：查看打印结果

一、 alloc 对象的指针地址和内存

首先我们先用一个例子进行分析：

SSLPerson *p1 = [SSLPerson alloc];
SSLPerson *p2 = [p1 init];
SSLPerson *p3 = [p2 init];
    
SSLPerson *p4 = [SSLPerson alloc];
    
NSLog(@"%@-%p-%p",p1,p1,&p1);
NSLog(@"%@-%p-%p",p2,p2,&p2);
NSLog(@"%@-%p-%p",p3,p3,&p3);
NSLog(@"%@-%p-%p",p4,p4,&p4);

查看打印结果：

<SSLPerson: 0x600000eef1a0>-0x600000eef1a0-0x7ffeeec48448
<SSLPerson: 0x600000eef1a0>-0x600000eef1a0-0x7ffeeec48440
<SSLPerson: 0x600000eef1a0>-0x600000eef1a0-0x7ffeeec48438
<SSLPerson: 0x600000eef1b0>-0x600000eef1b0-0x7ffeeec48430

p1、p2、p3 指向同一片内存空间：0x600000eef1a0；
p4指向内存空间：0x600000eef1b0；
p1、p2、p3、p4的指针地址分别是：0x7ffeeec48448、0x7ffeeec48440、0x7ffeeec48438、0x7ffeeec48430。

分析：

alloc有开辟内存，init没有开辟内存；
内存地址是以0x6开头，存储在了堆上，指针地址是以0x7开头，存储在了栈上；
指针地址尾部48、40、38，30相差8，说明他们是连续开辟的内存地址，48>40>38>30，说明栈是高地址向低地址存储；
b0 > a0，说明堆是低地址向高地址存储。

通过上面我们可以发现，对象内存地址是通过alloc创建，我们看一下alloc是怎么实现的。

点击alloc方法进入NSObject.h:

+ (instancetype)alloc OBJC_SWIFT_UNAVAILABLE("use object initializers instead");

进入NSObject.h我们发现看不到alloc的实现，下面介绍探索底层的三种方法。

二、底层探索的三种方法

2.1 下符号断点

在alloc调用位置打断点，运行程序，断点断住的时候，按住control键，点击step into进入下一步；
在汇编中找到方法objc_alloc；
为objc_alloc方法添加符号断点；
找到所在底层库和方法。

具体步骤如下图：

2.2 汇编跟流程

在alloc调用位置打断点，运行程序；
断点断住的时候，Xcode -> Debug -> Debug Workflow -> Always Show Disassembly,进入汇编；
汇编中callq是函数调用的意思，通过它找到方法调用；
找到方法调用以后可以通过step into或者下符号断点的方式继续调试，来找到所在底层库和方法。。

具体步骤如下图：

2.3 通过已知函数下符号断点，断住位置

在alloc调用位置打断点，运行程序；
添加alloc符号断点，点击断点跳转按钮；
找到所在底层库和方法。

具体步骤如下图：

三、编译源码，探索底层

上面介绍的三种方法，帮助我们找到了底层方法objc_alloc和所在的底层库libobjc。接下来我们把objc源码跑起来，进行更加深入的底层探索。

3.1 源码下载

苹果开源源码: opensource.apple.com/tarballs/

下载步骤如下：

下载下来的源码不能直接编译调试，可以去网上查一下配置方法，我们下边用配置好的代码进行探索，用的版本是818.2。

3.2 源码断点调试

根据源码调试，alloc调用流程如下：

断点进入alloc方法：

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

断点进入_objc_rootAlloc方法：

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

断点进入callAlloc方法：

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

断点进入_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：

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(extraBytes)：计算所需内存;
(id)calloc(1, size)：开辟内存，返回地址指针;
obj->initInstanceIsa(cls, hasCxxDtor)：初始化指针，和类进行关联。

instanceSize：计算所需内存

断点进入instanceSize：

inline 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：

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：

得到所需空间大小：

通过上面的结果，我们发现align16这个方法进行了16字节对齐处理，下面我们来分析一下(x + size_t(15)) & ~size_t(15)。

解释说明：

先简化下代码得到：(x + 15) & ~15；
(x + 15)的意思是对x进行升阶操作，如果x不是16的整数倍，那么升阶到下一个倍数等级，等待下一步计算；
~15的意思是对15取反得到1111 0000；
最后&操作，得到的是16的倍数，剩下不足16的抹去。

注：此算法和>> 4 << 4是一样的

以x = 23为例：

(23 + 15) = 38，把23从16的一倍数升阶到了16的二倍数，得到0010 0110 15：0000 1111 ~15：1111 0000 38 & ~15 0010 0110 & 1111 0000 结果：0010 0000 即 32

为什么需要16字节对齐

访问速度更快：cpu并不是以字节为单位来存取数据的，它会把内存当成一块一块的，每次读取都是一个固定的开销，减少内存存取次数提升应用程序的性能。
更安全：iOS中对象都有自己的isa指针，占8字节内存，如果8字节对齐，对象之间都是紧挨着没有一点空隙，内存访问时一点的错误或者偏移就有可能发生内存混乱，所以我们选取8的倍数16来进行对齐。

现在所需内存size已经计算完成，接下来根据size进行内存空间的开辟。

calloc：开辟内存，返回地址指针

断点继续查看：

可以看到我们并没有给obj赋值，它却已经有地址了，说明这是一块脏地址，并没有什么实际意义。

calloc调用后查看：

可以发现obj地址已经发生变化，说明内存已经开辟完成。

initInstanceIsa：初始化指针，和类进行关联

断点进入initInstanceIsa方法：

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

    initIsa(cls, true, hasCxxDtor);
}

initInstanceIsa调用后打印ojb：

打印结果为：<SSLPerson: 0x10062bf70>，到此指针和类已经进行关联，alloc探索完成。

OC 对象原理探索（一）：alloc

一、 alloc 对象的指针地址和内存

二、 底层探索的三种方法

2.1 下符号断点

2.2 汇编跟流程

2.3 通过已知函数下符号断点，断住位置

三、 编译源码，探索底层

3.1 源码下载

3.2 源码断点调试

instanceSize：计算所需内存

calloc：开辟内存，返回地址指针

initInstanceIsa：初始化指针，和类进行关联

二、底层探索的三种方法

三、编译源码，探索底层