在探究对象本质之前先介绍一下clang
clang
Clang是⼀个C++编写、基于LLVM、发布于LLVM BSD许可证下的C/C++/Objective-C/Objective-C++编译器。
clang终端编译命令
把⽬标⽂件编译成c++⽂件
clang -rewrite-objc main.m -o main.cpp
复制代码xcode安装的时候顺带安装了xcrun命令，xcrun命令在clang的基础上进⾏了⼀些封装，要更好⽤⼀些。
模拟器
xcrun -sdk iphonesimulator clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp
复制代码真机
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main arm64.cpp
复制代码对象的本质
本质
使用clang -rewrite-objc main.m -o main.cpp命令编译main.m文件，main.m文件内容如下：
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
// 对象在底层的本质就是结构体
@interface XHPerson : NSObject
@property (nonatomic, strong) NSString *xhName;
@property (nonatomic, assign) int xhAge;
@end
@implementation XHPerson
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"Hello, World!");
}
return 0;
}
复制代码main.cpp文件中的XHPerson如下：
extern "C" unsigned long OBJC_IVAR_$_XHPerson$_xhName;
extern "C" unsigned long OBJC_IVAR_$_XHPerson$_xhAge;
struct XHPerson_IMPL {
struct NSObject_IMPL NSObject_IVARS;
int _xhAge;
NSString *_xhName;
};
typedef struct objc_object XHPerson;
struct NSObject_IMPL {
Class isa;
};
复制代码结论：XHPerson底层是结构体，XHPerson_IMPL结构体中有3个变量，其中_xhAge，_xhName 是自定义的属性，NSObject_IVARS就是NSObject中isa。XHPerson继承于NSObject，所以XHPerson也有NSObject所有的成员变量。
NSObject的底层是NSObject_IMPL里面只有一个成员变量是Class isa。通常叫isa叫做isa指针，那么这里的Class应该是个指针类型，在main.cpp文件中全局搜索*Class。如下
typedef struct objc_class *Class;
//对象的底层实现
struct objc_object {
Class _Nonnull isa __attribute__((deprecated));
};
//NSObject的底层实现
struct NSObject_IMPL {
Class isa;
};
复制代码Class类型实际是一个objc_class类型的结构体指针，objc_class是所有类的底层实现。由此我们猜测isa可能跟类信息存在着重要的关联，具体的关联下面会进行探究。NSObject的底层实现和对象的底层实现有什么区别。两者成员变量的结构体都是Class isa，那么就必然存在继承关系。所有对象的底层都是继承objc_object，在OC中基本上所有的对象都是继承NSObject，但是真正的底层实现是objc_object的结构体类型。
对象属性底层分析
// getter
// getter
static NSString * _I_XHPerson_xhName(XHPerson * self, SEL _cmd) {
return (*(NSString **)((char *)self + OBJC_IVAR_$_XHPerson$_xhName));
}
// setter
static void _I_XHPerson_setXhName_(XHPerson * self, SEL _cmd, NSString *xhName) {
(*(NSString **)((char *)self + OBJC_IVAR_$_XHPerson$_xhName)) = xhName;
}
复制代码成员变量的内存访问是通过先拿到对象的首地址加上变量的偏移地址，再根据计算的地址访问内存：
(char *)self：对象的首地址OBJC_IVAR_$_XHPerson$_xhName：成员变量name的偏移地址*(NSString **)((char *)self + OBJC_IVAR_$_XHPerson$_xhName)成员变量name的内存
位域
// 4 * 8 = 32 0000 0000 0000 0000 0000 0000 0000 1111
// 4 位
// 1 字节 3倍浪费
struct XHCar1 {
BOOL front; // 0 1
BOOL back;
BOOL left;
BOOL right;
};
// 0000 1111
// 位域
// 互斥
struct XHCar2 {
BOOL front: 1;
BOOL back : 1;
BOOL left : 1;
BOOL right: 1;
};
复制代码- 结构体
XHCar1占4个字节，因为其内部成员变量都是BOOL类型，其实用1个字节就能放下。 - 结构体
XHCar2占1个字节，节省了3个字节。
联合体
// 结构体 : 共存
struct XHTeacher1 {
char *name;
int age;
double height ;
};
// 联合体 : 互斥
union XHTeacher2 {
char *name;
int age;
double height ;
};
复制代码
teacher1结构体共存：name、age、height都有值。sizeof是24
teacher2共用体互斥：name、age、height只能有一个有值，最后一个被赋值，前面的被清空。sizeof是8
- 结构体(
struct)中所有变量是“共存”的——优点是“有容乃⼤”，全⾯；缺点是struct内存空间的分配是粗放的，不管⽤不⽤，全分配。 - 联合体(
union)中是各变量是“互斥”的——缺点就是不够“包容”；但优点是内存使⽤更为精细灵活，也节省了内存空间。
nonPointerIsa
ISA分为纯的ISA和NONPOINTER_ISA，NONPOINTER_ISA除了包含一个纯指针外，还包含了类的一些信息。
alloc底层文中，最终会通过initIsa将从堆申请的结构体指针和当前的class绑定在一起。
inline void
objc_object::initIsa(Class cls)
{
initIsa(cls, false, false);
}
复制代码inline void
objc_object::initIsa(Class cls, bool nonpointer, UNUSED_WITHOUT_INDEXED_ISA_AND_DTOR_BIT bool hasCxxDtor)
{
ASSERT(!isTaggedPointer());
isa_t newisa(0);
if (!nonpointer) {
newisa.setClass(cls, this);
} else {
ASSERT(!DisableNonpointerIsa);
ASSERT(!cls->instancesRequireRawIsa());
#if SUPPORT_INDEXED_ISA
ASSERT(cls->classArrayIndex() > 0);
newisa.bits = ISA_INDEX_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
newisa.bits = ISA_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
# if ISA_HAS_CXX_DTOR_BIT
newisa.has_cxx_dtor = hasCxxDtor;
# endif
newisa.setClass(cls, this);
#endif
newisa.extra_rc = 1;
}
// This write must be performed in a single store in some cases
// (for example when realizing a class because other threads
// may simultaneously try to use the class).
// fixme use atomics here to guarantee single-store and to
// guarantee memory order w.r.t. the class index table
// ...but not too atomic because we don't want to hurt instantiation
isa = newisa;
}
复制代码// 联合体
// nonPointerIsa
// 类 指针
// 8 x 8 = 64位
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);
};
复制代码ISA_BITFIELD在arm64及x86_64架构下的定义
# 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; \ // c++析构函数
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)
# else
# error unknown architecture for packed isa
# endif
// SUPPORT_PACKED_ISA
#endif
复制代码nonpointer：表示是否对isa指针开启指针优化。0：纯isa指针，1：不⽌是类对象地址，isa 中包含了类信息、对象的引⽤计数等。has_assoc：关联对象标志位，0没有，1存在。has_cxx_dtor：该对象是否有C++或者Objc的析构器，如果有析构函数，则需要做析构逻辑，如果没有，则可以更快的释放对象。shiftcls: 存储类指针的值。开启指针优化的情况下，在arm64架构中有33位⽤来存储类指针。magic：⽤于调试器判断当前对象是真的对象还是没有初始化的空间。weakly_referenced：志对象是否被指向或者曾经指向⼀个ARC的弱变量，没有弱引⽤的对象可以更快释放。deallocating：标志对象是否正在释放内存。has_sidetable_rc：当对象引⽤技术⼤于10时，则需要借⽤该变量存储进位extra_rc：当表示该对象的引⽤计数值，实际上是引⽤计数值减1，例如，如果对象的引⽤计数为10，那么extra_rc为9。如果引⽤计数⼤于10，则需要使⽤到下⾯的has_sidetable_rc。
ISA的位运算
通过ISA的位运算拿到shiftcls。以x86_64为例，shiftcls在64位结构中的位置：右边有3位，左边有17位。自己包含44位。
红框值是相等的，说明位运算成功拿到了shiftcls。
总结
- 对象在底层的本质就是结构体。
ISA是通过共用体(联合体)互斥的特性，确定ISA是纯的ISA还是NONPOINTER_ISA,并通过位域来实现节约空间。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
![[桜井宁宁]COS和泉纱雾超可爱写真福利集-一一网](https://www.proyy.com/skycj/data/images/2020-12-13/4d3cf227a85d7e79f5d6b4efb6bde3e8.jpg)
![[桜井宁宁] 爆乳奶牛少女cos写真-一一网](https://www.proyy.com/skycj/data/images/2020-12-13/d40483e126fcf567894e89c65eaca655.jpg)
