上一篇 介绍了alloc的调用顺序和init及new的底层逻辑。这一篇将带大家继续了解对象的内存分布。

影响对象内存的因素

对象⾥⾯存储了⼀个isa指针 + 成员变量的值，，所以影响对象内存的只有成员变量（属性会⾃动⽣成带下划线的成员变量）

@interface LGPerson : NSObject
//isa -- 48 
@property (nonatomic ,copy) NSString *name;
@property (nonatomic ,copy) NSString *hobby;
@property (nonatomic ,assign) int age;
@property (nonatomic ,assign) double hight;
@property (nonatomic ,assign) short number;
@property (nonatomic ,assign) char a;

@end

LGPerson *p = [[LGPerson alloc] init];
p.name      = @"Vitus";
p.age       = 67;
NSLog(@"对象至少需要的内存大小--%lu",class_getInstanceSize([p class])); //40
NSLog(@"系统分配的内存大小--%lu",malloc_size((__bridge const void *)(p))); //48

打印输出结果，LGPerson实际占用内存是40字节，而系统分配给它的内存是48个字节。

image.png

class_getInstanceSize()执行流程图：

image.png

接下来，我们给LGPerson分别添加一个实例方法，一个类方法，看对它的内存有没有影响。

@interface LGPerson : NSObject
...
- (void)test;
+ (void)test;

@end

@implementation LGPerson

- (void)test {
    NSLog(@"%s",__func__);
}

+ (void)test {
    NSLog(@"%s",__func__);
}
@end

编译项目代码，发现输出结果并没有变化，说明给对象添加实例方法和类方法对它的内存并没有任何影响。那么这个现象出现的原因是什么呢？

其实是因为，在我们的实例对象中，实际存储的是对象的isa指针和实例对象的成员变量的具体的值。

image.png

苹果会自动重排成员变量的顺序来达到一个内存优化的目的，不满8字节的成员变量的属性，会把其对应的值存放在一个8字节的内存空间里面。

联合体

联合体⼜叫共⽤体，union就是在内存中划了⼀个⾜够⽤的空间，联合体的成员变量就相当于为这块内存空间开辟了⼏个访问途径，他们共享这⼀块内存。
联合体的⼤⼩计算奉⾏俩个规则
1.联合体⼤⼩必须能容纳联合体中最⼤的成员变量
2.通过1计算出的联合体⼤⼩必须是联合体中占内存⼤⼩最⼤的基本数据类型⼤⼩的整数倍

struct Teacher1 {
    char *name;
    int age;
    double height;
}t1;

NSLog(@"name=%s, age=%d, height=%f", t1.name, t1.age, t1.height); // name=(null), age=0, height=0.000000
t1.name = "安安老师";
NSLog(@"name=%s, age=%d, height=%f", t1.name, t1.age, t1.height); // name=安安老师, age=0, height=0.000000
t1.age = 18;
NSLog(@"name=%s, age=%d, height=%f", t1.name, t1.age, t1.height); // name=安安老师, age=18, height=0.000000
t1.height = 1.80;
NSLog(@"name=%s, age=%d, height=%f", t1.name, t1.age, t1.height); // name=安安老师, age=18, height=1.800000
// 0x100008508: 0x100008508 -- 0x100008510 -- 0x100008518
NSLog(@"%p: %p -- %p -- %p", &t1, &t1.name, &t1.age, &t1.height); 

// 联合体
union Teacher2 {
    char *name;  // 8字节
    int age;
    double height;
}t2;

t2.name = "安安老师";
t2.age = 18;
t2.height = 1.80;
// 0x100008508: 0x100008508 -- 0x100008508 -- 0x100008508
NSLog(@"%p: %p -- %p -- %p", &t2, &t2.name, &t2.age, &t2.height);

联合体的所有成员变量共用同一个内存地址，赋值了一个成员会影响别的不同类型成员的取值。
联合体的大小决定于最大成员(基本数据类型的整数倍，数组不是基本数据类型)（t2最大的是char * 相当于是对象8个字节）。

union Teahcer3 {
    char a[7]; // 占7字节
    int b; // 占4字节
}t3;  // 4字节的整数倍，至少需要8字节

结构体与联合体的区别：
结构体(struct)中所有变量是“共存”的，⽽联合体(union)中是各变量是“互斥”的，只能存在⼀个。
struct内存空间的分配是粗放的，不管⽤不⽤，全部分配。这样带来的⼀个坏处就是对于内存的消耗要⼤⼀些。但是结构体⾥⾯的数据是完整的。
联合体⾥⾯的数据只能存在⼀个，但优点是内存使⽤更为精细灵活，也节省了内存空间。

位域

struct LGStruct1 {
    char a;
    char b;
    char c;
    char d;
}struct1;


struct LGStruct2 {
    // a: 位域名  32:位域长度
    int a : 32;
    char b : 2;
    char c : 7;
    char d : 2;
}struct2;

struct LGStruct3 {
    // a: 位域名  32:位域长度
    char a : 1;
    char b : 1;
    char c : 1;
    char d : 1;
}struct3;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //4,1,4
        NSLog(@"%ld,%ld,%ld",sizeof(struct1),sizeof(struct2),sizeof(struct3));
    }
    return 0;
}

image.png

char a : 1;//位域这里的1表示的是位域的信息，用位域表示信息需要注意两点：

位域的长度不能超过数据类型的最大长度。
一个位域是存储在同一个内存空间，如果当前位域的空间不够存储，会从下一个字节开始存储，如struct2就是这样的情况。

nonPointerIsa

nonPointerIsa是内存优化的⼀种⼿段。isa是⼀个Class类型的结构体指针，占8个字节，主要是⽤
来存内存地址的。但是8个字节意味着它就有8*8=64位。存储地址根本不需要这么多的内存空间。
⽽且每个对象都有个isa指针，这样就浪费了内存。所以苹果就把和对象⼀些息息相关的东⻄，存
在了这块内存空间⾥⾯。这种isa指针就叫nonPointerIsa。

isa详解

• 在arm64架构之前，isa就是一个普通的指针，存储着Class、MetaClass对象的内存地址。
• 从arm64架构开始，对isa进行了优化，变成了一个共用体(union)结构，还使用位域来存储更多信息。
  来看看isa_t的声明，它是一个联合体：

#include "isa.h"

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    uintptr_t bits;

private:
    // Accessing the class requires custom ptrauth operations, so
    // force clients to go through setClass/getClass by making this
    // private.
    Class cls;

public:
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };

    bool isDeallocating() {
        return extra_rc == 0 && has_sidetable_rc == 0;
    }
    void setDeallocating() {
        extra_rc = 0;
        has_sidetable_rc = 0;
    }
#endif

    void setClass(Class cls, objc_object *obj);
    Class getClass(bool authenticated);
    Class getDecodedClass(bool authenticated);
};

# if __arm64__
// ARM64 simulators have a larger address space, so use the ARM64e
// scheme even when simulators build for ARM64-not-e.
#   if __has_feature(ptrauth_calls) || TARGET_OS_SIMULATOR
#     define ISA_MASK        0x007ffffffffffff8ULL
#     define ISA_MAGIC_MASK  0x0000000000000001ULL
#     define ISA_MAGIC_VALUE 0x0000000000000001ULL
#     define ISA_HAS_CXX_DTOR_BIT 0
#     define ISA_BITFIELD                                                      \
        uintptr_t nonpointer        : 1;                                       \
        uintptr_t has_assoc         : 1;                                       \
        uintptr_t weakly_referenced : 1;                                       \
        uintptr_t shiftcls_and_sig  : 52;                                      \
        uintptr_t has_sidetable_rc  : 1;                                       \
        uintptr_t extra_rc          : 8
#     define RC_ONE   (1ULL<<56)
#     define RC_HALF  (1ULL<<7)
#   else
#     define ISA_MASK        0x0000000ffffffff8ULL
#     define ISA_MAGIC_MASK  0x000003f000000001ULL
#     define ISA_MAGIC_VALUE 0x000001a000000001ULL
#     define ISA_HAS_CXX_DTOR_BIT 1
#     define ISA_BITFIELD                                                      \
        uintptr_t nonpointer        : 1;                                       \
        uintptr_t has_assoc         : 1;                                       \
        uintptr_t has_cxx_dtor      : 1;                                       \
        uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \
        uintptr_t magic             : 6;                                       \
        uintptr_t weakly_referenced : 1;                                       \
        uintptr_t unused            : 1;                                       \
        uintptr_t has_sidetable_rc  : 1;                                       \
        uintptr_t extra_rc          : 19
#     define RC_ONE   (1ULL<<45)
#     define RC_HALF  (1ULL<<18)
#   endif

# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
#   define ISA_MAGIC_MASK  0x001f800000000001ULL
#   define ISA_MAGIC_VALUE 0x001d800000000001ULL
#   define ISA_HAS_CXX_DTOR_BIT 1
#   define ISA_BITFIELD                                                        \
      uintptr_t nonpointer        : 1;                                         \
      uintptr_t has_assoc         : 1;                                         \
      uintptr_t has_cxx_dtor      : 1;                                         \
      uintptr_t shiftcls          : 44; /*MACH_VM_MAX_ADDRESS 0x7fffffe00000*/ \
      uintptr_t magic             : 6;                                         \
      uintptr_t weakly_referenced : 1;                                         \
      uintptr_t unused            : 1;                                         \
      uintptr_t has_sidetable_rc  : 1;                                         \
      uintptr_t extra_rc          : 8
#   define RC_ONE   (1ULL<<56)
#   define RC_HALF  (1ULL<<7)

nonPointerIsa里64位域里的内容

名称	含义
nonpointer	表示是否对 isa 指针开启指针优化。0：纯isa指针，1：不止是类对象地址,isa 中包含了类信息、对象的引用计数等
has_assoc	关联对象标志位，0没有，1存在
has_cxx_dtor	该对象是否有 C++ 或者 Objc 的析构器,如果有析构函数，则需要做析构逻辑，如果没有，则可以更快的释放对象。有成员变量就有c++析构函数。
shiftcls	存储类指针的值。开启指针优化的情况下，在 arm64 架构(真机)中有 33 位用来存储类指针。
magic	用于调试器判断当前对象是真的对象还是没有初始化的空间
weakly_referenced	对象是否被指向或者曾经指向一个 ARC 的弱变量，没有弱引用的对象可以更快释放。(是否被__weak修饰)
deallocating	标志对象是否正在释放内存
has_sidetable_rc	是否需要使用 sidetable 来存储引用计数
extra_rc	表示该对象的引用计数值

如何利用isa的位运算得到类对象

通过上面的内容我们可以知道shiftcls存储着Class、Meta-Class对象的内存地址信息。

image.png

image.png

首先我们右移3位，跳过 nonpointer、has_assoc、has_cxx_dtor，来到shiftcls头部，然后左移31位再右移28位，这个时候我们来到了shiftcls尾部，这个中间部分的就是我们的shiftcls的内容。用p/x LGPerson.class输出打印验证，地址对应上，这里就是存储的我们的类对象Class。

而苹果给的方案就是：isa地址 & ISA_MASK = 类对象地址

image.png

注意验证的时候，要看清楚机型对应的架构。

总结

1. OC对象⾥⾯存储了⼀个isa指针 + 成员变量的值影响了对象内存。
2. 给对象添加实例方法和类方法对它的内存并没有任何影响,因为实例方法存放在类对象中。而类方法存放在meta-class对象中。
3. nonPointerIsa是isa的优化。保存了引用计数等和对象一些息息相关的东西。不同的架构对应的shiftcls占用的位数不一样。
4. 结构体(struct)中所有变量是“共存”的，⽽联合体(union)中是各变量是“互斥”的，只能存在⼀个。