美文网首页
OC底层探究(4)-- 类的结构分析

OC底层探究(4)-- 类的结构分析

作者: 墨守青城 | 来源:发表于2019-12-28 00:18 被阅读0次

    类的结构

    老规矩,还是从源码搞起。我们先在main.m中定义一个类ZPerson,继承自NSObject。

    @interface ZPerson : NSObject{
       NSString *hobby;
    }
    @property (nonatomic, copy) NSString *name;
    
    - (void)sayHello;
    + (void)sayHappy;
    
    @end
    
    @implementation ZPerson
    - (void)sayHello{
       NSLog(@"ZPerson say : Hello!!!");
    }
    
    + (void)sayHappy{
       NSLog(@"ZPerson say : Happy!!!");
    }
    @end
    

    然后通过通过命令行进行编译。

    clang -rewrite-objc main.m
    
    typedef struct objc_class *Class;
    

    编译后得到一个main.cpp文件。之后我们可以在文件中查找关于类Class的定义,即Class是一个objc_class类型的结构体。在objc的源码中,继续查找关于objc_class结构体的一些信息。

    struct objc_class : objc_object {
        // Class ISA;  继承自objc_object  //8
        Class superclass;  //8
        cache_t cache;  //16           // formerly cache pointer and vtable
        class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
       
        //bits 从bits中读取数据
        class_rw_t *data() { 
            return bits.data();
        }
        void setData(class_rw_t *newData) {
            bits.setData(newData);
        }
        ...
    }
    
    

    根据源码我们可以知道,objc_class集成了objc_object。哈哈,原来类也是一个对象啊,类对象。万物皆对象!objc_class中包含了isa(从objc_object集成而来)、superclass(它的父类)、cache_t(缓存, 以后再分析)、bits(存储的数据,属性、方法、协议等)等一系列信息。

    补充:NSObject是一个类,而类的底层是objc_class,所以我们可以认为NSObject就是对底层的objc_class的上层封装。

    类中的数据存储

    从上面类的结构中,我们知道类的数据存贮才bits中,可以通过data()方法得到。data()返回一个class_rw_t结构,我们可以从中拿到我们想要的哟。rw代表可读可写,类中的属性、方法还有遵循的协议等信息都保存在 class_rw_t 中。下面看一下class_rw_t的源码结构:

    struct class_rw_t {
        // Be warned that Symbolication knows the layout of this structure.
        uint32_t flags;
        uint32_t version;
    
        const class_ro_t *ro;
    
        method_array_t methods;
        property_array_t properties;
        protocol_array_t protocols;
        ...
    }
    

    再看一下class_ro_t的数据结构:

    struct class_ro_t {
        uint32_t flags;
        uint32_t instanceStart;
        uint32_t instanceSize;
    #ifdef __LP64__
        uint32_t reserved;
    #endif
    
        const uint8_t * ivarLayout;
        
        const char * name;//类名
        method_list_t * baseMethodList;//原始方法列表
        protocol_list_t * baseProtocols;//原始协议列表
        const ivar_list_t * ivars;//成员变量列表
    
        const uint8_t * weakIvarLayout;
        property_list_t *baseProperties;//属性列表
    
        method_list_t *baseMethods() const {
            return baseMethodList;
        }
    };
    

    ro是一个class_ro_t 结构体类型的指针,占8个bytes大小。class_ro_t与class_rw_t名字类似,rw是可读可写,那ro就是只读(readonly)了吧,哈哈。class_ro_t与class_rw_t结构也有些类似,class_ro_t中存储了当前类在编译期就已经确定的属性、方法以及遵循的协议,不包括分类和后来动态添加的东西。baseProperties存贮了属性,属性在编译时会将一个“_”+属性名成员变量添加到ivars中。ivar中存贮了声明的所有成员变量。属性在编译时还会自动生成set、get方法存储在baseMethodList方法列表中,成员变量不会生成set、get方法。baseMethodList存储了类中的所有原始方法。
    下面我们就会汇编探究一下是不是这样。
    创建一个person对象


    image.png

    然后在控制台做如下打印:
    打印出person.class的类

    (lldb) x/6gx person.class
    0x1000024e0: 0x001d8001000024b9 0x0000000100b37140
    0x1000024f0: 0x0000000101e633f0 0x0000000200000003
    0x100002500: 0x0000000101e62d24 0x0000000100b370f0
    

    0x1000024e0 为类在内存中起始指针,指向isa

    (lldb) po 0x1000024e0
    ZPerson
    

    根据上面类的结构和内存偏移,再偏移8位,就是superclass

    (lldb) po 0x1000024e8
    <NSObject: 0x1000024e8>
    

    同理0x1000024e0指针偏移32位, 就是bits, 强转为class_data_bits_t类型

    (lldb) p (class_data_bits_t *)0x100002500
    (class_data_bits_t *) $3 = 0x0000000100002500
    

    调用data()方法,获取bits里面的数据,返回一个class_rw_t结构体

    (lldb) p $3->data()
    (class_rw_t *) $4 = 0x0000000101872d30
    

    打印出$4指针所指向的值 看一下class_rw_t结构

    (lldb) p *$4
    (class_rw_t) $5 = {
      flags = 2148139008
      version = 0
      ro = 0x00000001000022e8
      methods = {
        list_array_tt<method_t, method_list_t> = {
           = {
            list = 0x0000000100002220
            arrayAndFlag = 4294976032
          }
        }
      }
      properties = {
        list_array_tt<property_t, property_list_t> = {
           = {
            list = 0x00000001000022d0
            arrayAndFlag = 4294976208
          }
        }
      }
      protocols = {
        list_array_tt<unsigned long, protocol_list_t> = {
           = {
            list = 0x0000000000000000
            arrayAndFlag = 0
          }
        }
      }
      firstSubclass = nil
      nextSiblingClass = NSUUID
      demangledName = 0x0000000100001f75 "ZPerson"
    }
    

    打印一下ro

    (lldb) p $5.ro
    (const class_ro_t *) $6 = 0x00000001000022e8
    (lldb) p *$6
    (const class_ro_t) $7 = {
      flags = 388
      instanceStart = 8
      instanceSize = 24
      reserved = 0
      ivarLayout = 0x0000000100001f7d "\x02"
      name = 0x0000000100001f75 "ZPerson"
      baseMethodList = 0x0000000100002220
      baseProtocols = 0x0000000000000000
      ivars = 0x0000000100002288
      weakIvarLayout = 0x0000000000000000
      baseProperties = 0x00000001000022d0
    }
    

    打印ro中的baseProperties属性列表, 我们找到了我们声明的属性nickName

    (lldb) p *$7.baseProperties
    (property_list_t) $8 = {
      entsize_list_tt<property_t, property_list_t, 0> = {
        entsizeAndFlags = 16
        count = 1
        first = (name = "nickName", attributes = "T@\"NSString\",C,N,V_nickName")
      }
    }
    

    在打印一下ivars成员变量列表

    (lldb) p *$7.ivars
    (const ivar_list_t) $9 = {
      entsize_list_tt<ivar_t, ivar_list_t, 0> = {
        entsizeAndFlags = 32
        count = 2 //总有2个成员变量
        first = {
          offset = 0x0000000100002498
          name = 0x0000000100001e62 "hobby"
          type = 0x0000000100001fa2 "@\"NSString\""
          alignment_raw = 3
          size = 8
        }
      }
    }
    

    在打印一下第二个成员变量

    (lldb) p $9.get(1)
    (ivar_t) $10 = {
      offset = 0x00000001000024a0
      name = 0x0000000100001e68 "_nickName"
      type = 0x0000000100001fa2 "@\"NSString\""
      alignment_raw = 3
      size = 8
    }
    

    找到了nickName, 这是自动生成的,验证了上面所说的属性在编译时会将一个“”+属性名成员变量添加到ivars中

    再找一下方法

    (lldb) p *$7.baseMethodList
    (method_list_t) $11 = {
      entsize_list_tt<method_t, method_list_t, 3> = {
        entsizeAndFlags = 26
        count = 4
        first = {
          name = "sayHello"
          types = 0x0000000100001f87 "v16@0:8"
          imp = 0x0000000100001a80 (LGTest`-[ZPerson sayHello] at main.m:109)
        }
      }
    }
    (lldb) p $11.get(0)
    (method_t) $13 = {
      name = "sayHello"
      types = 0x0000000100001f87 "v16@0:8"
      imp = 0x0000000100001a80 (LGTest`-[ZPerson sayHello] at main.m:109)
    }
    (lldb) p $11.get(1)
    (method_t) $12 = {
      name = ".cxx_destruct"
      types = 0x0000000100001f87 "v16@0:8"
      imp = 0x0000000100001b50 (LGTest`-[ZPerson .cxx_destruct] at main.m:108)
    }
    (lldb) p $11.get(2)
    (method_t) $14 = {
      name = "setNickName:"
      types = 0x0000000100001f97 "v24@0:8@16"
      imp = 0x0000000100001b10 (LGTest`-[ZPerson setNickName:] at main.m:101)
    }
    (lldb) p $11.get(3)
    (method_t) $15 = {
      name = "nickName"
      types = 0x0000000100001f8f "@16@0:8"
      imp = 0x0000000100001ae0 (LGTest`-[ZPerson nickName] at main.m:101)
    }
    

    总共四个方法我们创建的sayHello()、系统自动为属性nickName自动添加的get/set方法和一个系统默认添加的方法。并没有找到我们创建的sayHappy(),说明类方法并没有存在类里。那么类方法存在哪里呢?类方法存在元类里!那么我们怎么去验证呢?
    根据isa的走位图我们知道,类的isa指向元类,所以我们要先拿到当前类isa,再按照上面的流程,去元类中查看class_ro_t结构,就能找到了。
    先拿到类的isa的指向地址,也就是元类

    (lldb) p/x 0x001d8001000024b9 & 0x00007ffffffffff8ULL
    (unsigned long long) $3 = 0x00000001000024b8
    

    打印元类内存地址信息

    (lldb) x/6gx 0x00000001000024b8
    0x1000024b8: 0x001d800100b370f1 0x0000000100b370f0
    0x1000024c8: 0x0000000102d1a9a0 0x0000000100000003
    0x1000024d8: 0x0000000102d1a900 0x001d8001000024b9
    

    参考上面拿到类的class_ro_t信息流程,我们可以拿到了元类的class_ro_t,打印一下baseMethodList,我们看到sayHappy方法。验证了类方法存贮在元类中。还有谁!

    (lldb) p *$11
    (method_list_t) $12 = {
      entsize_list_tt<method_t, method_list_t, 3> = {
        entsizeAndFlags = 26
        count = 1
        first = {
          name = "sayHappy"
          types = 0x0000000100001f87 "v16@0:8"
          imp = 0x0000000100001ab0 (LGTest`+[ZPerson sayHappy] at main.m:113)
        }
      }
    }
    

    我们再看一下除了ro以外的其他信息:
    method_list_t methods:方法列表(如果是类对象存储的是对象方法,元类对象存储的是类方法)。methods是一个二维数组,外层是method_list_t,每个method_list_t又包含了多个method_t。这个是可写的,因为后期可能会有多个分类需要合并到类的方法列表中,还有可能动态添加方法。关于动态方法我们放在后面再探究,目前先简单看一下method_array_t和method_t的数据结构:

    class method_array_t : 
        public list_array_tt<method_t, method_list_t> 
    {
        typedef list_array_tt<method_t, method_list_t> Super;
    
     public:
        method_list_t **beginCategoryMethodLists() {
            return beginLists();
        }
        
        method_list_t **endCategoryMethodLists(Class cls);
    
        method_array_t duplicate() {
            return Super::duplicate<method_array_t>();
        }
    };
    
    struct method_t {
        //方法\函数名,一般叫做选择器
        SEL name;
       //包含了函数返回值,参数编码的字符串。通过字符串拼接的方式将返回值和参数拼接成一个字符串,来代表函数返回值及参数。
        const char *types;
        //代表函数的具体实现,存储的内容是函数地址。也就是说当找到imp的时候就可以找到函数实现,进而对函数进行调用。
        MethodListIMP imp;
    
        struct SortBySELAddress :
            public std::binary_function<const method_t&,
                                        const method_t&, bool>
        {
            bool operator() (const method_t& lhs,
                             const method_t& rhs)
            { return lhs.name < rhs.name; }
        };
    };
    

    我们发现method_array_t中有一个beginCategoryMethodLists()方法。我们猜想,能否通过它来读取存储在method_array_t中的方法呢?
    先打印一下methods

    (lldb) p $8.methods
    (method_array_t) $20 = {
      list_array_tt<method_t, method_list_t> = {
         = {
          list = 0x00000001000021f8
          arrayAndFlag = 4294975992
        }
      }
    }
    

    //再打印一下beginCategoryMethodLists()方法的返回,返回一个指向method_list_t的二级指针

    (lldb) p $20.beginCategoryMethodLists()
    (method_list_t **) $21 = 0x0000000101b53bb0
    

    //取一下二级指针的值,变成指向method_list_t的指针

    (lldb) p *$21
    (method_list_t *) $22 = 0x00000001000021f8
    

    //取一下method_list_t指针指向的内存空间,找到了跟ro中存储的一样的方法,method_array_t取值成功。

    (lldb) p *$22
    (method_list_t) $23 = {
      entsize_list_tt<method_t, method_list_t, 3> = {
        entsizeAndFlags = 26
        count = 5
        first = {
          name = "sayHello"
          types = 0x0000000100001f82 "v16@0:8"
          imp = 0x0000000100001a30 (LGTest`-[ZPerson sayHello] at main.m:124)
        }
      }
    }
    (lldb) p $23.get(0)
    (method_t) $24 = {
      name = "sayHello"
      types = 0x0000000100001f82 "v16@0:8"
      imp = 0x0000000100001a30 (LGTest`-[ZPerson sayHello] at main.m:124)
    }
    

    property_array_t、protocol_array_t与method_list_t类似,就不重复列举了。

    相关文章

      网友评论

          本文标题:OC底层探究(4)-- 类的结构分析

          本文链接:https://www.haomeiwen.com/subject/wixroctx.html