正文

深入理解Objective-C中类的数据结构

︶ㄣSDDLL学院 メ
SDDLL学院V管理员 / 阅读
0713
最近发现用Objective-C确实好容易，下面这篇文章主要给大家介绍了关于Objective-C中类的数据结构的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编

最近发现用Objective-C确实好容易，下面这篇文章主要给大家介绍了关于Objective-C中类的数据结构的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧

一、类的结构

oc 中的代码在底层实现，使用的是 c、c++，所以要研究 oc 中的类结构，可以将 oc 的代码转成 c++的代码即可。首先看一下 nsobject 的结构是什么样子的，创建一个文件并简单的编写如下代码：

?
1
2
3
4
5
// customfile.m
#import <foundation/foundation.h>
void test() {
 [nsobject alloc];
}

进入终端，输入指令：

clang -rewrite-objc customfile.m

默认生成一个 customfile.cpp 文件。这个指令生成的代码会很多，也可以使用 xcrun 指令来指定一个特定的架构，这样的：

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc customfile.m -o customfile_arm64.cpp

这样在 customfile_arm64.cpp 文件中会生成一个 真机下的运行代码。相比之下 customfile_arm64.cpp 文件会比 customfile.cpp 小了很多，但是对于查看 nsobject 的实际结构都是可以的。

打开任意一个 .cpp 文件，都可以找到这样的定义：

?
1
2
3
struct nsobject_impl {
 class isa;
};

其中 class 的定义如下：

?
1
typedef struct objc_class *class;

再来看一下在实际中的 nsobject 类的声明是什么样的：

?
1
2
3
4
5
6
@interface nsobject <nsobject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-wobjc-interface-ivars"
 class isa objc_isa_availability;
#pragma clang diagnostic pop
}

简化后是这样的：

?
1
2
3
@interface nsobject {
 class isa;
}

总之class 是一个指针，nsobject_impl是一个结构体，与 nsobject 在结构上极为相似。

二、类继承后的结构

创建一个 person.m 文件，弄一个继承于 nsobject 的 person 类。代码编写如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// person.m
#import <foundation/foundation.h>
 
// 类的申明
@interface person : nsobject
@end
 
// 类的实现
@implementation person
@end
 
// 类的申明
@interface student : person
@end
 
// 类的实现
@implementation student
@end

其中 person 继承于 nsobject，student 继承于 person 于是在 .cpp 文件中找到这样的定义：

?
1
2
3
4
5
6
7
struct person_impl {
 struct nsobject_impl nsobject_ivars;
};
 
struct student_impl {
 struct person_impl person_ivars;
};

nsobject_ivars 看着这个命名就可以猜到是将父类的所有 ivar 都继承过来了。

似乎明白了一个套路

在 nsobject 中只有一个 class 类型的成员变量 isa，在没有自定义任何的成员属性的情况下，继承的子类中的 ivar 都来自于父类。

如果说给 person 与 student 都定义一个成员变量，是这样的：

?
1
2
3
4
5
6
7
8
9
struct person_impl {
 struct nsobject_impl nsobject_ivars;
 int _no;
};
 
struct student_impl {
 struct person_impl person_ivars;
 int _age;
};

终于对 class 的一些套路有进一步的理解了。

三、添加方法后的结构

创建一个 funclass.m 文件，编写代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// funclass.m
#import <foundation/foundation.h>
 
// 类的申明
@interface funclass : nsobject
- (void)testinstance;
+ (void)testclass;
@end
 
// 类的实现
@implementation funclass
- (void)testinstance {
 
}
 
+ (void)testclass {
 
}
@end

最后发现在 .cpp 中类的结构没有任何的改变，是这样的：

?
1
2
3
struct funclass_impl {
 struct nsobject_impl nsobject_ivars;
};

但是我们会发现另外一个问题，在 oc 中的方法变成这样的了：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 实例方法
_objc_$_instance_methods_funclass __attribute__ ((used, section ("__data,__objc_const"))) = {
 sizeof(_objc_method),
 1,
 {{(struct objc_selector *)"testinstance", "v16@0:8", (void *)_i_funclass_testinstance}}
static void _i_funclass_testinstance(funclass * self, sel _cmd) {
}
 
// 类方法
_objc_$_class_methods_funclass __attribute__ ((used, section ("__data,__objc_const"))) = {
 sizeof(_objc_method),
 1,
 {{(struct objc_selector *)"testclass", "v16@0:8", (void *)_c_funclass_testclass}}
static void _c_funclass_testclass(class self, sel _cmd) {
 
}

发现这几个特点：

     1、实例方法有这个：_instance_methods_funclass，类方法的是这个：_class_methods_funclass

     2、两个方法都是 static 方法

     3、方法都多了两个参数：self 与_cmd，这也回答了为什么 self 与 _cmd 只能在方法中有的根本原因。

关于 方法 的这部分先介绍到这里，后期会有专门的专题。

四、自定义一个 class 与对应的结构体

上面啰嗦了这么多，到底是对不对呢？！那就来亲自试一下吧。

这里的自定义是指不再继承于 nsobject 了，自己搞一个结构体。为了证明其正确性，分别定义一个 hgnobject 类 与 hgnobject_impl 结构体。编写的代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// ==== 类的定义部分 ====
// 类的申明
@interface hgnobject : nsobject {
 @public
 int _no;
 int _age;
}
@end
 
// 类的实现
@implementation hgnobject
@end
 
// ==== 结构体 ====
struct hgnobject_impl {
 class isa_hg;
 int _no_hg;
 int _age_hg;
};

做两个试验：

1、类转结构体

2、结构体转类

1、类转结构体

示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 类转结构体
- (void)class2struct {
 // 创建一个对象
 hgnobject* nobj = [[hgnobject alloc] init];
 // 成员变量赋值
 nobj->_no = 771722918;
 nobj->_age = 18;
 
 { // 类对象直接转成一个结构体
 struct hgnobject_impl* nobj_s = (__bridge struct hgnobject_impl*)nobj;
 // 打印结构体中的值
 nslog(@"%zd, %zd", nobj_s->_no_hg, nobj_s->_age_hg);
 // 打印结果: 771722918, 18
 }
}

通过结构体指针能打印出在类对象中设置的值，说明在 类转结构体的过程是有效的。

2、结构体转类

示例代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 结构体转类
- (void)struct2class {
 nslog(@"结构体转类");
 // 生成一个结构体
 struct hgnobject_impl nobj_s = {0, 771722918, 20};
 // 结构体中的值打印
 nslog(@"isa_hg = %zd, _no_hg = %zd, _age_hg = %zd", nobj_s.isa_hg, nobj_s._no_hg, nobj_s._age_hg);
 
 struct hgnobject_impl* nobj_spointer = &nobj_s;
 
 // 结构体转成对象
 hgnobject* nobj = (__bridge hgnobject *)(nobj_spointer);
 
 nslog(@"_no_hg = %zd, _age_hg = %zd", nobj->_no, nobj->_age);
}

运行代码，直接 crash 了：

深入理解Objective-C中类的数据结构

由于 block 解开多年来的误解 的惨痛教训，所以对遇到的 crash 就会很敏感。看一下上面的这张图，有一个关键的点是不可以忽视的，就是这里的值：

深入理解Objective-C中类的数据结构

简单的分析（我这里的分析都是猜的，暂时我也不知道，【抱歉抱歉抱歉】）

nobj_s 是有正确的值的，说明 nobj_spointer 指针也是没有问题的，但是为什么会报一个坏地址访问错误呢？并且 address 的值每次都是一样的 0x20。我猜想：在转化的过程中不仅仅是一个简单的赋值操作、可能还做了其他的地址访问操作，这个操作很有可能与 +alloc 方法中操作有关，毕竟在 oc 中正常的创建一个对象必先 +alloc方法，对于 +alloc中都做了什么事，暂时我还不清楚，所以这里我是蒙的。各位大神若有新的理解，望指教！

所以在第一个实验中的 类转结构体 中是有效的，也许是一个偶然。毕竟我们在上面的 .cpp 文件中查看数据结构的时候也只是看了一个大概，并没有看全部的。

ok，忘记本节（自定义一个 class 与对应的结构体）中遇到的不愉快, 至少 类转结构体 是有效的，也能说明一些问题。

本系列的文章，有：

1、objective-c 中类的数据结构

2、objective-c 中实例所占内存的大小

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对米米素材网的支持。

原文链接：https://www.jianshu.com/p/e3e1baeae8d8