为了跳槽，最近研究了一下runtime的源码，对自己进行充电。写这篇文章一是为了对这个星期研究的总结（好记性不如烂笔头），二是为了组内的技术分享（JOJO！这是我最后的波纹，收下吧！）
以下贴的代码为runtime源码（objc4-723），是通过c++转化的，暂且可以将其中的结构体看成是类。

类

首先，是类的结构。类也是一个对象，正常的类，在编译期就确定了类的结构和大小。它在内存中的地址和大小是不变的，这点很容易证明。可以写个小demo打印类对象的地址，不改变代码结构，每次运行demo，取到的地址都是相同的。

接着上源码：

类在源码中的结构体

类也是对象，所以继承objc_object。从中我们可以看出，除去一些方法，类对象里面实际存着4块内容，分别是
ISA：继承自objc_object，是个指针，指向元类，元类中有类方法的信息。
superclass：指向父类的指针。
cache：缓存成员方法，当实例对象接受到一个消息时，会优先在cache中找。
bits：class_rw_t的地址和一些flags。其中，类中的属性，协议，成员变量，方法等信息都存在class_rw_t中。
先说下bits中的标签。在不同系统是不一样的。分别是：
32位：

// class is a Swift class
#define FAST_IS_SWIFT         (1UL<<0)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR   (1UL<<1)
// data pointer
#define FAST_DATA_MASK        0xfffffffcUL

64位兼容版：

// class is a Swift class
#define FAST_IS_SWIFT           (1UL<<0)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<1)
// class's instances requires raw isa
#define FAST_REQUIRES_RAW_ISA   (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL

64位不兼容版：

// class is a Swift class
#define FAST_IS_SWIFT           (1UL<<0)
// class's instances requires raw isa
#define FAST_REQUIRES_RAW_ISA   (1UL<<1)
// class or superclass has .cxx_destruct implementation
//   This bit is aligned with isa_t->hasCxxDtor to save an instruction.
#define FAST_HAS_CXX_DTOR       (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL
// class or superclass has .cxx_construct implementation
#define FAST_HAS_CXX_CTOR       (1UL<<47)
// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define FAST_HAS_DEFAULT_AWZ    (1UL<<48)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<49)
// summary bit for fast alloc path: !hasCxxCtor and 
//   !instancesRequireRawIsa and instanceSize fits into shiftedSize
#define FAST_ALLOC              (1UL<<50)
// instance size in units of 16 bytes
//   or 0 if the instance size is too big in this field
//   This field must be LAST
#define FAST_SHIFTED_SIZE_SHIFT 51

class_rw_t

上面的有个了解就行，源码注释也很详细。重点来看class_rw_t中的内容，”rw“是readwrite的意思，运行时对类的扩展大多是操作它。

class_rw_t源码中的结构体

分别说一下里面的各种字段含义：
flags：存储了类的一些信息，也是和bits中的flag类似，通过二进制位置上的0，1判断。其位置含义如下：

// Values for class_rw_t->flags
// These are not emitted by the compiler and are never used in class_ro_t. 
// Their presence should be considered in future ABI versions.
// class_t->data is class_rw_t, not class_ro_t
#define RW_REALIZED           (1<<31)
// class is unresolved future class
#define RW_FUTURE             (1<<30)
// class is initialized
#define RW_INITIALIZED        (1<<29)
// class is initializing
#define RW_INITIALIZING       (1<<28)
// class_rw_t->ro is heap copy of class_ro_t
#define RW_COPIED_RO          (1<<27)
// class allocated but not yet registered
#define RW_CONSTRUCTING       (1<<26)
// class allocated and registered
#define RW_CONSTRUCTED        (1<<25)
// available for use; was RW_FINALIZE_ON_MAIN_THREAD
// #define RW_24 (1<<24)
// class +load has been called
#define RW_LOADED             (1<<23)
#if !SUPPORT_NONPOINTER_ISA
// class instances may have associative references
#define RW_INSTANCES_HAVE_ASSOCIATED_OBJECTS (1<<22)
#endif
// class has instance-specific GC layout
#define RW_HAS_INSTANCE_SPECIFIC_LAYOUT (1 << 21)
// available for use
// #define RW_20       (1<<20)
// class has started realizing but not yet completed it
#define RW_REALIZING          (1<<19)

// NOTE: MORE RW_ FLAGS DEFINED BELOW


// Values for class_rw_t->flags or class_t->bits
// These flags are optimized for retain/release and alloc/dealloc
// 64-bit stores more of them in class_t->bits to reduce pointer indirection.

#if !__LP64__

// class or superclass has .cxx_construct implementation
#define RW_HAS_CXX_CTOR       (1<<18)
// class or superclass has .cxx_destruct implementation
#define RW_HAS_CXX_DTOR       (1<<17)
// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define RW_HAS_DEFAULT_AWZ    (1<<16)
// class's instances requires raw isa
#if SUPPORT_NONPOINTER_ISA
#define RW_REQUIRES_RAW_ISA   (1<<15)

version：版本？在动态创建类的方法里面，发现元类赋值为7，正常类赋值为0.（不知道干啥）

// Set basic info

    cls->data()->flags = RW_CONSTRUCTING | RW_COPIED_RO | RW_REALIZED | RW_REALIZING;
    meta->data()->flags = RW_CONSTRUCTING | RW_COPIED_RO | RW_REALIZED | RW_REALIZING;
    cls->data()->version = 0;
    meta->data()->version = 7;

firstSubclass：木知（TODO）
nextSiblingClass：木知（TODO）
methods,properties,protocols分别代表成员方法，属性以及协议。
ro: 这个非常重要，它是一个常量，并且和class_rw_t很像（坑定有py关系）。其实ro是readOnly的简写,对于已经存在的类，我们无法更改它的ro属性.可以进去看看ro是什么。

class_ro_t

class_ro_t在源码中的结构体

flags：同样有个flag记录类的一些信息。ps.（有个特殊的值是RO_FUTURE和RW_FUTURE，RO_REALIZED和RW_REALIZED是一样的。其中RW_FUTURE是为了类初始化时将rw强转成ro时用的标签。）

// Values for class_ro_t->flags
// These are emitted by the compiler and are part of the ABI.
// Note: See CGObjCNonFragileABIMac::BuildClassRoTInitializer in clang
// class is a metaclass
#define RO_META               (1<<0)
// class is a root class
#define RO_ROOT               (1<<1)
// class has .cxx_construct/destruct implementations
#define RO_HAS_CXX_STRUCTORS  (1<<2)
// class has +load implementation
// #define RO_HAS_LOAD_METHOD    (1<<3)
// class has visibility=hidden set
#define RO_HIDDEN             (1<<4)
// class has attribute(objc_exception): OBJC_EHTYPE_$_ThisClass is non-weak
#define RO_EXCEPTION          (1<<5)
// this bit is available for reassignment
// #define RO_REUSE_ME           (1<<6) 
// class compiled with ARC
#define RO_IS_ARC             (1<<7)
// class has .cxx_destruct but no .cxx_construct (with RO_HAS_CXX_STRUCTORS)
#define RO_HAS_CXX_DTOR_ONLY  (1<<8)
// class is not ARC but has ARC-style weak ivar layout 
#define RO_HAS_WEAK_WITHOUT_ARC (1<<9)

// class is in an unloadable bundle - must never be set by compiler
#define RO_FROM_BUNDLE        (1<<29)
// class is unrealized future class - must never be set by compiler
#define RO_FUTURE             (1<<30)
// class is realized - must never be set by compiler
#define RO_REALIZED           (1<<31)

instanceStart：木知啊 TODO
instanceSize：对象大小
reserved：我也木知 TODO
ivarLayout：成员变量布局？和weakIvarLayout类似。
name 是类名
baseMethodList，baseProtocols，baseProperties分别是编译期类的成员方法，协议，属性的信息，即类和类扩展中的类信息。这些将被赋值回class_rw_t中的类信息中。
ivars 是成员变量信息，注意是const，并且在class_rw_t中并没有相关字段（所以不能动态添加成员变量）。
weakIvarLayout：
是这东西的地址。。不知道有软用，必须是创建中才可以设置，就是ivarLayout的弱引用
// &UnsetLayout is the default ivar layout during class construction
static const uint8_t UnsetLayout = 0;

对象

在源码中，对象并没有类那样写那么详细，只知道对象中有一个isa指针。那么对象中还有什么呢？我当时有个猜想：

对象中存有isa指针，和成员变量的值。

方法都是存放在对象的类中，这很容易理解。因为多个对象是共用一个类的方法，属性也是一样的。但是，关于成员变量的值，每个对象虽然属性相同，但属性的值是不同的。每个类的成员变量的值是独立的，那应该是存在对象中。那么下面是我的验证过程：
方法size_t class_getInstanceSize(Class cls);可以获取类的实例对象大小。我们可以通过源码去看它的实现原理，可以推断出对象内部是什么。

屏幕快照 2018-03-28 下午10.05.56.png

屏幕快照 2018-03-28 下午10.06.05.png

屏幕快照 2018-03-28 下午10.06.21.png

通过源码可以了解到，调用获取对象大小的方法实际上是取ro中instanceSize经过对齐后的值。那我们再看看instanceSize怎么来的。

前面说过，ro是编译期决定的，我们无法通过这份源码看编译期的事。但是runtime支持动态创建类，这给了我们窥探的机会。

这里简单讲一下利用runtime动态添加类的过程。动态创建类，要先调用Class objc_allocateClassPair方法创建类，然后可以增加成员变量，增加属性，成员方法等。但如果想用创建的类新建实例对象，就必须调用objc_registerClassPair方法进行注册。

接下来看源码：

objc_initializeClassPair_internal部分源码内容

可以看到，当一个类被创建的时候，如果没有父类，那么它的instanceSize值是一个isa指针大小。如果这时候再调用动态注册类的方法void objc_registerClassPair(Class cls),那用该类创建出来的实例大小就只是isa指针的大小。如果有父亲，则它的初始instanceSize值是父类的instanceSize大小。
再看动态添加属性的源码：

class_addIvar部分源码

每次增加一个属性，instanceSize就增加对应属性的大小。
在源码中全局搜索了一下setInstanceSize，发现在动态创建类相关的过程中，只有class_addIvar才会重新设置instanceSize。所以，instanceSize就是实例变量分配空间+isa的地址。ps：感觉其中有进行对齐操作，instanceSize不是单纯的成员变量的实际大小，这得之后再研究alignMask字段。

现在，我们反过来看，为什么成员变量无法动态添加到已经有的类中？为什么动态添加成员变量只能在创建类和注册类之间，这2个问题应该都已经明白了。

上面我们从源码角度验证了我的猜想，接着，我们继续去demo中验证。
我新建了一个自定义类,设置3个不同类型的属性。

#import 

@interface Gakki : NSObject

@property (nonatomic,copy)NSString *name;
@property (nonatomic,assign)int jin;
@property (nonatomic,strong)NSArray *arr;

@end

在main函数中创建类的实例对象。

int main(int argc, const char * argv[]) {

    @autoreleasepool {
        
        Class cla = [Gakki class];
        NSLog(@"%p",cla);

        Gakki *myGakki = [Gakki new];
        NSLog(@"");

        
    }
    return 0;
}

接下来，我们运用lldb来打印信息。
先是类的信息。

屏幕快照 2018-03-29 下午1.50.59.png

我们可以从图中看到类中ro的内容，以及成员变量的结构。
接着，我们打印实例对象在内存中的信息。这我们需要x命令。比如x/8xg ,第一个x代表显示内存,数字8表示读取8个，第二个x表示按16进制显示，g表示按8字节读取。
结果如下图：

屏幕快照 2018-03-29 下午2.05.33.png

上图对myGakki对象分别添加了3个变量，看其内存的变化。

结论：对象里面存着isa指针和成员变量的内容，如果成员变量是对象，则存地址，如果是基本变量，存的是基本变量的值。

最后附上一张图做总结：图片来自网上

1.jpg

参考：
http://melonteam.com/posts/objectc_dui_xiang_nei_cun_bu_ju_fen_xi/
http://yulingtianxia.com/blog/2014/11/05/objective-c-runtime/#Runtime-%E7%9A%84%E5%87%BD%E6%95%B0
https://yq.aliyun.com/articles/63323#1

OC中类与对象在内存中的结构

类

class_rw_t

class_ro_t

对象

对象中存有isa指针，和成员变量的值。

你可能感兴趣的:(OC中类与对象在内存中的结构)