前言
首先,我们看下几个类型:NSObject
、Class
、objc_object
、objc_class
、id
的联系与区别。
- NSObject:OC中的基类,绝大多数类都继承
NSObject
(NSProxy
也是基类哦~) - Class:
NSObject
的类型,在objc
源码的NSObject.mm
文件中可以看到+ (Class)class { return self; }
- objc_object:
NSObject
类在C++的底层实现的结构体名称,在生成的cpp文件中可以看到,它和NSObject
是同一个东西,只是在不同语言环境的名字不同。objc_object
结构体里面,只有一个成员变量isa
指针。/// Represents an instance of a class. struct objc_object { Class _Nonnull isa OBJC_ISA_AVAILABILITY; }; /// A pointer to an instance of a class. typedef struct objc_object *id;
- objc_class:
Class
在C++底层实现的结构体名称,在生成的cpp文件中可以看到,它和Class
是同一个东西,只是在不同语言环境的名字不同。typedef struct objc_class *Class;
- id:OC环境中可以指向任何类型,并且不用带*号
typedef struct objc_object *id;
isa与superClass探究
我们先看下类在内存中地址,是不是每创建一对象,都会创建一个新的与之对应的类。
Class cls1 = Person.class;
Class cls2 = [Person alloc].class;
Class cls3 = object_getClass([Person alloc]);
Class cls4 = [Person alloc].class;
NSLog(@"cls1 : %p \n cls1 : %p \n cls1 : %p \n cls1 : %p \n", cls1, cls2, cls3, cls4);
执行打印结果如下:
也就是同样的类,在内存中只会有1份。
我们打印实例变量p
的内存,我们知道前8位是isa
指针
isa
地址与ISA_MASK
0x00007ffffffffff8ULL 做与运算,可以拿到类对象的地址。
我们继续拿类的isa
地址与ISA_MASK
0x00007ffffffffff8ULL 做与运算,看可以得到什么。
我们看到,最后打印的结果也是Person
,但是两个Person
的地址不一样,一个0x00000001000082a0,一个0x0000000100008278,也就是说这两个不是一个类型。第二个Person
就是我们常说的元类。
那我们继续看下元类的isa
指向哪里。
我们看到Perosn
元类的isa
打印出来是NSObject
,但是地址和NSObject
类对象地址不一样,我们在打印NSObject
的元类地址,发现地址一致了,也就是说Person
的元类的isa
指向NSObject
元类。Person
继承自NSObject
,那是不是说明直接指向父类的元类呢,我们再创建一个Student
继承Person
,再试一下。
我们看到$8
与$10
相同,也就是说,无论对象继承谁,自定义对象的元类的isa
都指向根元类。
继续往下,我们看下NSObject
元类的isa
指向哪里。
上图可得出根元类的isa
指向它自己。
继承关系isa
指向链我们看完了,再看下继承关系,元类也有继承吗,我们用以下代码测试以下:
NSObject *obj = [NSObject alloc];
Class objCls = object_getClass(obj);
Class objMetaCls = object_getClass(objCls);
Class objRootMetaCls = object_getClass(objMetaCls);
NSLog(@"\n\nNSObject实例对象: %p \n NSObject类对象: %p \n NSObject元类对象: %p \n NSObject根元类对象: %p \n ", obj, objCls, objMetaCls, objRootMetaCls);
Class pMetaCls = object_getClass([Person class]);
Class pMetaSuperCls = class_getSuperclass(pMetaCls);
NSLog(@"\n\nPerson元类对象: %p \n Person元类对象的父类: %p \n ", pMetaCls, pMetaSuperCls);
Class sMetaCls = object_getClass([Student class]);
Class sMetaSuperCls = class_getSuperclass(sMetaCls);
NSLog(@"\n\nStudent元类对象: %p \n Student元类对象的父类: %p \n ", sMetaCls, sMetaSuperCls);
Class rootMetaSuperCls = class_getSuperclass(objRootMetaCls);
NSLog(@"根元类对象的父类: %p", rootMetaSuperCls);
运行打印结果:
根据结果,我们看到Student
元类的父类就是Person
元类,Person
元类的父类就是NSObject
的元类,NSObject
元类的父类就是NSObject
类对象。isa
的流程图与继承流程图如下:
类的内存数据
OC的类在C++中是objc_class
类型,我们在objc
源码objc-runtime-new中找objc_class
的结构。
我们找到1个结构
struct objc_class : objc_object {
objc_class(const objc_class&) = delete;
objc_class(objc_class&&) = delete;
void operator=(const objc_class&) = delete;
void operator=(objc_class&&) = delete;
// Class ISA;
Class superclass;
cache_t cache; // formerly cache pointer and vtable
class_data_bits_t bits;
....
}
struct objc_object {
private:
isa_t isa;
}
类结构里面有isa
指针,superclass
,cache
,bits
。isa
我们已经分析过了,superclass
就是父类,cache
我们以后再说,我们接下来研究下bits
。
在此之前我们验证下superclass
:
Person
的父类是NSObject
,没有问题。
要研究bits
,首先我们需要知道bits
在内存存储的位置,isa
占8字节,superclass
占8字节,那么cache
占多少字节呢,我们点进去看下cache_t
的结构:
struct cache_t {
private:
explicit_atomic<uintptr_t> _bucketsAndMaybeMask;
union {
struct {
explicit_atomic<mask_t> _maybeMask;
#if __LP64__
uint16_t _flags;
#endif
uint16_t _occupied;
};
explicit_atomic<preopt_cache_t *> _originalPreoptCache;
};
}
再看下explicit_atomic
实现
template <typename T>
struct explicit_atomic : public std::atomic<T> {
explicit explicit_atomic(T initial) noexcept : std::atomic<T>(std::move(initial)) {}
operator T() const = delete;
T load(std::memory_order order) const noexcept {
return std::atomic<T>::load(order);
}
void store(T desired, std::memory_order order) noexcept {
std::atomic<T>::store(desired, order);
}
// Convert a normal pointer to an atomic pointer. This is a
// somewhat dodgy thing to do, but if the atomic type is lock
// free and the same size as the non-atomic type, we know the
// representations are the same, and the compiler generates good
// code.
static explicit_atomic<T> *from_pointer(T *ptr) {
static_assert(sizeof(explicit_atomic<T> *) == sizeof(T *),
"Size of atomic must match size of original");
explicit_atomic<T> *atomic = (explicit_atomic<T> *)ptr;
ASSERT(atomic->is_lock_free());
return atomic;
}
};
T
泛型,这个变量的大小取决于泛型T
的大小。uintptr_t
指针占8字节,第二个变量共用体,mask_t
:typedef uint32_t mask_t;
,占4字节,uint16_t
占2字节,结构体占8字节,_originalPreoptCache
是个*也就是指针类型也是8字节,所以,cache_t
一共占16字节。bits
从32字节开始。
再看下怎么获取bits
里面数据,在源码中可以找到data
方法。
class_rw_t *data() const {
return bits.data();
}
类的属性
如我们想看类里面的属性怎么办呢?答:从class_rw_t
结构里面找成员变量或者方法。
const property_array_t properties() const {
auto v = get_ro_or_rwe();
if (v.is<class_rw_ext_t *>()) {
return v.get<class_rw_ext_t *>(&ro_or_rw_ext)->properties;
} else {
return property_array_t{v.get<const class_ro_t *>(&ro_or_rw_ext)->baseProperties};
}
}
成员变量没找到,方法倒是看上去有一个,那我们接着调试。
class property_array_t :
public list_array_tt<property_t, property_list_t, RawPtr>
{
typedef list_array_tt<property_t, property_list_t, RawPtr> Super;
public:
property_array_t() : Super() { }
property_array_t(property_list_t *l) : Super(l) { }
};
template <typename Element, typename List, template<typename> class Ptr>
class list_array_tt {
struct array_t {
uint32_t count;
Ptr<List> lists[0];
static size_t byteSize(uint32_t count) {
return sizeof(array_t) + count*sizeof(lists[0]);
}
size_t byteSize() {
return byteSize(count);
}
};
}
struct property_list_t : entsize_list_tt<property_t, property_list_t, 0> {
};
template <typename Element, typename List, uint32_t FlagMask, typename PointerModifier = PointerModifierNop>
struct entsize_list_tt {
uint32_t entsizeAndFlags;
uint32_t count;
uint32_t entsize() const {
return entsizeAndFlags & ~FlagMask;
}
uint32_t flags() const {
return entsizeAndFlags & FlagMask;
}
Element& getOrEnd(uint32_t i) const {
ASSERT(i <= count);
return *PointerModifier::modify(*this, (Element *)((uint8_t *)this + sizeof(*this) + i*entsize()));
}
Element& get(uint32_t i) const {
ASSERT(i < count);
return getOrEnd(i);
}
size_t byteSize() const {
return byteSize(entsize(), count);
}
static size_t byteSize(uint32_t entsize, uint32_t count) {
return sizeof(entsize_list_tt) + count*entsize;
}
struct iterator;
}
分析下property_array_t
结构:是个数组,数组里面每个元素都是property_list_t
类型,property_list_t
也是个数组,因为entsize_list_tt
里面有迭代器iterator
,property_list_t
数组里面的元素是property_t
。大致结构:property_array_t = [property_list_t[property_t, property_t], property_list_t[property_t]]
。
再看下property_t
的结构:
struct property_t {
const char *name;
const char *attributes;
};
类的方法
属性看完了,再看下方法,在Person
里面添加两个方法,一个实例方法,一个类方法。
NS_ASSUME_NONNULL_BEGIN
@interface Person : NSObject
@property(nonatomic,strong)NSString *name;
@property(nonatomic,assign)int age;
@property(nonatomic,assign)float height;
-(void)saylloinstance;
+(void)saylloclass;
@end
NS_ASSUME_NONNULL_END
找方法同样我们看到class_rw_t
里面有个methods
方法,不出意外应该能拿到方法。
const method_array_t methods() const {
auto v = get_ro_or_rwe();
if (v.is<class_rw_ext_t *>()) {
return v.get<class_rw_ext_t *>(&ro_or_rw_ext)->methods;
} else {
return method_array_t{v.get<const class_ro_t *>(&ro_or_rw_ext)->baseMethods()};
}
}
method_array_t
的结构和property_array_t
一样,都是二维数组,只不过最里面的对象换成了method_t
我们看到同样的操作,怎么最后打印不出来数据,是不是我们操作不对?这就要说下property_t
里面有两个成员,打印的时候直接把两个成员打印出来,我们再看下method_t
的结构里面没有这种成员,但是里面有一个结构体:
struct big {
SEL name;
const char *types;
MethodListIMP imp;
};
这里面成员能看到方法所有内容,是不是我们打印这个big
就行呢?测试一下:
非常完美方法都打印出来了,但是自己观察,一共就3个方法,saylloclass没有打印出来,为什么呢?对象方法存在类结构中,那类方法会不会放在元类里面呢?类方法是存储在元类。
这也就是为什么iOS要设计元类的原因,因为OC中有实例方法和类方法,也就是所谓的减号方法和加号方法,但是在OC底层,是没有这个含义的,也就是所有方法都转化成同名函数,如果没有元类,我们写两个方法+(void)
saylle和-(void)
saylle,这两个方法都存储在类里面,那我们执行方法的时候,根据函数名,就无法确定到底是执行实例方法还是类方法了,所以设计元类把两种方法分离开。
类的成员变量
class_ro_t演变
在WWDC视频中,我们可以详细看到class_ro_t
演变优化过程,也知道成员变量存在class_ro_t
中。在Person
中添加一个成员变量hobby
。
//
// Person.h
// SXObjcDebug
//
// Created by wangyun on 2022/4/17.
//
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface Person : NSObject
{
NSString *hobby;
}
@property(nonatomic,strong)NSString *name;
@property(nonatomic,assign)int age;
@property(nonatomic,assign)float height;
-(void)saylloinstance;
+(void)saylloclass;
@end
NS_ASSUME_NONNULL_END
class_ro_t
怎么找呢,同样在源码中找方法
const class_ro_t *ro() const {
auto v = get_ro_or_rwe();
if (slowpath(v.is<class_rw_ext_t *>())) {
return v.get<class_rw_ext_t *>(&ro_or_rw_ext)->ro;
}
return v.get<const class_ro_t *>(&ro_or_rw_ext);
}
调试验证:
总结
类的整体结构
ro,rw,rwe
class_ro_t是在编译的时候生成的。当类在编译的时候,类的属性,实例方法,协议这些内容就存 在class_ro_t这个结构体里面了,这是一块纯净的内存空间,不允许被修改。
class_rw_t是在运行的时候生成的,类一经使用就会变成class_rw_t,它会先将class_ro_t的内 容"拿"过去,然后再将当前类的分类的这些属性、方法等拷⻉到class_rw_t里面。它是可读写的。
class_rw_ext_t可以减少内存的消耗。苹果在wwdc2020里面说过,只有大约10%左右的类需要动 态修改。所以只有10%左右的类里面需要生成class_rw_ext_t这个结构体。这样的话,可以节约很 大一部分内存。
class_rw_ext_t生成的条件:
第一:用过runtime的Api进行动态修改的时候。 第二:有分类的时候,且分类和本类都为非懒加载类的时候。实现了+load方法即为非懒加载类。