2015-07-14 21:34:53 songrotek 阅读数 9414

1 引言

作为曾经的iOS开发者,在研究深度学习的时候,总有一个想法就是在iPhone上运行深度学习,不管是在手机上训练还是利用训练好的数据进行测试。
因为iOS的开发环境支持C++,因此,只要你的代码是C/C++,本质上就可以在iOS上运行。
怎么才能更快更好地在iOS上运行CNN呢?

2 方法1:通过Matlab转码

Matlab自带转成c的工具,如果你研究过UFLDL的深度学习教程,就知道如何在Matlab上使用CNN,那么,转换成c后,放到iOS的开发环境中,然后将参数存成txt格式再读取分割,也就是可以实现。
如下图就是已经将matlab代码转换为c后导入的结果:
这里写图片描述
打开predict.h文件,可以看到可以调用的接口:

/* Function Declarations */
extern real_T predict(const real_T Theta1[10025], const real_T Theta2[260], const real_T X[400]);

这是训练MNIST的一个神经网络,我这边用了测试手写数字的识别。

因此,接下来需要对图片进行处理,从而转换为x[400]的向量格式。

这个只要能读取图片的像素,进行转换就可以。可以考虑用opencv来实现。

这里写图片描述
这里我的方法是在用手画出数字之后,将图片转换为20*20像素的图片,如右下角所示,再将右下角的图片转换为400的数组,输入predict得到的结果。

3 方法2:使用DeepBeliefSDK

https://github.com/jetpacapp/DeepBeliefSDK
这个是别人专门写的一个用于iOS的深度学习的SDK。可以使用,但是存在的问题就是如果要自己训练的话很受限制。

4 方法3:使用tinyCNN

https://github.com/nyanp/tiny-cnn
这个很不错,它对比Caffe,Theano等框架最大的特点就是不需要安装,只要能用C++ 11.然后里面的例子使用了boost库。因此,为了运行它,我们需要在xcode安装ios的boost库。

网上找到了一个编译好的boost库:
https://github.com/danoli3/ofxiOSBoost

导入boost库的方法非常简单:

In Xcode Build Settings for your project:

Add to Library Search Paths ( LIBRARY_SEARCH_PATHS ) $(SRCROOT)/../../../addons/ofxiOSBoost/libs/boost/lib/ios
Add to Header Search Paths ( HEADER_SEARCH_PATHS )
$(SRCROOT)/../../../addons/ofxiOSBoost/libs/boost/include
In the Target under Build Phases

Add to 'Link Binary With Libraries' the boost.a found in the ofxiOSBoost/libs/boost/lib/ios directory.
If not openFrameworks just add the libs/boost/include to Header Search Paths and the libs/boost/ios to Library Search Paths

那么具体在创建iOS应用的时候,这里使用作者提供的训练MNIST的例子,那么要注意在使用数据时,要更改路径:

NSString *trainLabels = [[NSBundle mainBundle] pathForResource:@"train-labels" ofType:@"idx1-ubyte"];
    NSString *trainImages = [[NSBundle mainBundle] pathForResource:@"train-images" ofType:@"idx3-ubyte"];
    NSString *t10kLabels = [[NSBundle mainBundle] pathForResource:@"t10k-labels" ofType:@"idx1-ubyte"];
    NSString *t10kImages = [[NSBundle mainBundle] pathForResource:@"t10k-images" ofType:@"idx3-ubyte"];


    parse_mnist_labels([trainLabels cStringUsingEncoding:NSUTF8StringEncoding], &train_labels);
    parse_mnist_images([trainImages cStringUsingEncoding:NSUTF8StringEncoding], &train_images);
    parse_mnist_labels([t10kLabels cStringUsingEncoding:NSUTF8StringEncoding], &test_labels);
    parse_mnist_images([t10kImages cStringUsingEncoding:NSUTF8StringEncoding], &test_images);

基本上这样就可以运行开始训练了。

如果想在Mac上训练,同样需要安装boost库。这个只要在官网下载boost,我用的是1.58版本。然后在terminal中安装,cd到路径,然后./boostrap.sh 然后./b2 安装就可以。然后在xcode引入路径:

The Boost C++ Libraries were successfully built!

The following directory should be added to compiler include paths:

    /Users/.../.../.../boost

The following directory should be added to linker library paths:

    /Users/.../.../.../boost/stage/lib

路径初始为自己boost的文件夹地址。

4 小结

上面说了一些很方便的方法来实现在iOS下运行CNN。当然,我们更多需要就是进行图像的识别。相信大家自己测试会觉得很有趣。

2017-06-16 13:58:45 IDOshi201109 阅读数 2256

iOS 项目运行“ARC forbids Objective-C objects in struct”错误

前言:
项目加入了一个MRC的库,然后运行项目,提示“ARC forbids Objective-C objects in struct”错误,这边我也参考了一些文章。这边先把我自己的代码和解决方法给贴出来。

一、解决问题
有一个MRC的 .h文件的typedef中,用到了OC对象,代码如下:

typedef struct structBlueTooth
{
    NSString *nsBlueToothName;
    NSString *nsBlueToothDevId;
}STRUCE_BLUETOOTH;

typedef struct binderstructBlueTooth
{
    NSMutableArray *nsArrayBlueToothName;
    NSMutableArray *nsArrayBlueToothDevId;
}BINDER_STRUCE_BLUETOOTH;
查阅资料,得知:
在`ARC`环境下,在结构体中使用`objc`对象,必须使用  `__unsafe_unretained`,这个是苹果的规定。

解决后代码:

typedef struct structBlueTooth
{
    __unsafe_unretained NSString *nsBlueToothName;
    __unsafe_unretained NSString *nsBlueToothDevId;
}STRUCE_BLUETOOTH;

typedef struct binderstructBlueTooth
{
    __unsafe_unretained NSMutableArray *nsArrayBlueToothName;
    __unsafe_unretained NSMutableArray *nsArrayBlueToothDevId;
}BINDER_STRUCE_BLUETOOTH;

参考链接:
参考文章

2016-07-17 21:43:47 CHENYUFENG1991 阅读数 11037

       运行时是iOS中一个很重要的概念,iOS运行过程中都会被转化为runtime的C代码执行。例如[target doSomething];会被转化成objc)msgSend(target,@selector(doSomething))来执行。这篇博客会较为全面的来讲解下Runtime。

       OC是一门动态语言,它将很多静态语言在编译和链接时做的事放到了运行时来处理。这种动态语言的优势在于:写代码能更加灵活,可以把消息转发给想要的对象,或者随意交换一个方法的实现。

       OC Runtime目前有两个版本:Modern Runtime和Legacy Runtime。Modern Runtime覆盖了64位的App,Legacy Runtime使用早期的32位App,所以现在可以不用管了。

(1)当我们需要使用Runtime的接口时,需要导入头文件:#import <objc/runtime.h>,Runtime可以进行如下操作,在运行时来获取当前类中的一些信息:

获取属性列表:



获取方法列表:



获取成员变量列表:



获取协议列表:



所以,我们大概可以总结出Runtime的作用:

  • 程序运行中,动态创建一个类;
  • 程序运行中,动态为某个类添加属性/方法,修改属性/方法;
  • 遍历一个类的所有成员变量/属性/方法;


(2)方法调用:

     如果用实例对象调用实例方法,会到实例的isa指针指向的对象(也就是类对象,没错,其实类也是一个对象)操作。如果调用的是类方法,就会到类的isa指针指向的对象(元类对象)中操作。查找过程如下:

  • 首先在相应操作的对象中的缓存方法列表中找调用的方法,如果找到,转向相应实现并执行;
  • 如果没有找到,在相应操作的对象中的方法列表中找调用的方法,如果找到,转向相应实现执行;
  • 如果没找到,去父类指针所指向的对象中执行以上步骤;
  • 以此类推,如果一直到根类还没有找到,转向拦截调用;
  • 如果没有重写拦截调用的方法,程序报错;

说明下,重写父类的方法,其实并没有覆盖掉父类的方法,只是在当前类对象中找到这个方法后就不会再去父类中找了。如果想调用已经重写过的方法的父类实现,只需使用super这个编译器标志,它会在运行时跳过在当前类对象中寻找方法的过程。


(3)拦截调用

     拦截调用就是在找不到调用的方法程序崩溃之前,有机会通过重写NSObject的四个方法来处理:



以下两个方法需要转发到其他类处理:



  • 第一个方法是调用一个不存在的类方法的时候,会调用这个方法,默认返回NO,可以加上自己的处理后返回YES;
  • 第二个方法和第一个方法类似,处理的是实例方法;
  • 第三个方法是将你调用的不存在的方法重定向到一个其他声明了这个方法的类,只需要返回一个有这个方法的target;
  • 第四个方法是将你调用的不存在的方法打包成NSInvocation传给你。做完你自己的处理后,调用invokeWithTarget:方法让某个target触发这个方法;

(4)Runtime的常用之处就是可以在运行时动态添加方法。我们在上面讲到了拦截调用,动态添加方法可以和拦截调用结合起来使用。我们可以根据传递进来的SEL类型的selector动态添加一个方法。这样就算我们调用一个还没定义的方法程序也不会crash了。
.

其中class_addMethod的四个参数分别是:
  • Class cls :给哪个类添加方法;
  • SEL name:方法选择器selector;
  • IMP imp:方法的实现,C方法的实现可以直接获得。如果是OC方法,可以用+(IMP)instanceMethodForSelector获得方法的实现;
  • const char *types:方法的签名


(5)关联对象
      现在准备使用一个系统的类,你需要额外添加一个属性。我们可以使用继承。但是只增加一个属性,就去继承一个类,是比较浪费的。这时我们就可以使用Runtime的关联属性。

 先定义一个全局变量,用它的地址作为关联对象的key:


设置关联对象:




objc_setAssociatedObject的四个参数:
  • id object:给谁设置关联对象;
  • const void *key:关联对象唯一的key,就是上面定义的全局变量;
  • id value:关联对象;
  • objc_AssociatedPolicy:关联策略:





objc_getAssociatedObject的两个参数:
  • id object:获取谁的关联对象;
  • const void *key:根据这个唯一的key获取关联对象;

(6)方法交换
    将两个方法的实现交换。例如,将A方法和B方法交换,调用A方法的时候,就会执行B方法中的代码。反之亦然。我们一般在类的Category中实现以下代码:




(7)Runtime原理与机制
     Runtime运行时,就是系统在运行的时候的一些机制,其中最主要的是消息机制。同时Runtime是一套比较底层的C语言API,属于一个C语言库,包含了很多底层的C语言API。程序运行时,最终都是转成了Runtime的C语言代码。
OC实现动态调用:
[obj makeText];

在编译时Runtime会将代码转化为:
objc_msgSend(obj,@selector(makeText));

obj对象有一个isa指针,




所有metaclass中isa指针都指向根metaclass,而根metaclass则指向自身。Root metaclass是通过继承Root Class产生的,与root class结构体成员一致。
@selector(makeText):这是一个SEL方法选择器。SEL主要作用是快速通过方法名字(makeText)查找到对应方法的函数指针,然后调用函数。SEL本身是一个int类型的地址,地址中存放着方法的名字。对于一个类中,每一个方法对应着一个SEL,所以iOS中不能存在2个名称相同的方法,即使参数类型不同。

动态查找过程:
      编译器将代码[obj makeText];转化为objc_msgSend(obj,@selector(makeText));在objc_msgSend函数中,首先通过obj的isa指针找到obj对应的class。在Class中先去cache中通过SEL查找对应函数method,若cache中未找到,再去methodList中查找,若methodList中未找到,则到superClass查找。若能找到,则将method加入到cache中,以方便下次查找,并通过method中的函数指针跳转到对应的函数中去执行。

注意:上面提到为什么要先去查找缓存cache?
因为当调用了一个方法,很有可能之后还会调用它。软件开发的同学应该都可以理解。


(8)OC中的类

     OC类是由Class类型来表示的,实际上是一个指向objc_class结构体的指针,Class定义在objc.h中:


苹果注释中也说明了,Class是一个隐含类型代表了一个OC类。查看runtime.h中关于objc_class结构体的定义:


注释中也说明,以后使用Class来替代struct objc_class,这样就可以方便类型定义。


  • version:类的版本信息,默认为0;
  • info:类信息,运行时使用的一些位标志;
  • instance_size:类的实例变量的大小;
其中我们最关心的参数是:
  • isa:所有的类自身也是一个对象,这个对象的Class里面也有一个isa指针,它指向metaClass元类;
  • super_class:指向该类的父类,如果该类已经是最顶层的根类(如NSObject或NSProxy),则super_class为NULL;


(9)类的实例
     objc_object表示的是一个类的实例的结构体,在objc.h中定义:


注释中也说明了,objc_object代表了类的实例。然后使用id来指向这个类的实例结构体,同样在objc_h中定义:

       一个指向实例的指针。可以看到在结构体中只有一个字段,就是指向其类的isa指针。这样,当我们向一个OC对象发送消息时,运行时库会根据实例对象的isa指针找到这个实例对象所属的类。Runtime库会在类的方法列表及父类的方法列表中去寻找与消息对应的selector指向的方法,找到后即运行这个方法。
       id:是一个objc_object结构类型的指针,可以转换为任何一种对象,类似C中的void *.

(10)元类MetaClass

      所有的类自身也是一个对象,可以向这个对象发送消息(即调用类方法)。

NSArray *array = [NSArray array];

+array消息发送给了NSArray类,而这个NSArray也是一个对象。既然是对象,那么它也是一个objc_object指针,包含一个指向其类的一个isa指针。为了调用+array方法,这个类的isa指针必须指向一个包含这些类方法的一个objc_class结构体。这就需要meta_class概念。

      meta_class是一个类对象的类。当我们向一个对象发送消息时,Runtime会在这个对象所属的这个类的方法列表中查找方法。而向一个类发送消息时,会在这个类的meta_class的方法列表中查找。meta_class很重要,因为它存储着一个类的所有的类方法。每个类都会有一个单独的meta_class,因为每个类的类方法基本不可能完全相同。

      再看一下上面提到的图,现在应该有更深的理解:


所有的meta_class的isa指向基类的meta_class,依次作为他们的所属类。即任何NSObject继承体系下的meta_class都使用NSObject的meta_class作为自己的所属类,而基类的meta_class的isa指针指向自己,这样就形成了闭环。


(11)类与对象操作函数

     类的操作方法大部分是以class为前缀的,而对象的操作方法大部分是以objc或object_为前缀的。

  • 类名


返回一个类的名字,传入的参数是类对象。


  • 父类(super_class)和元类(meta_class)
获取类的父类:




判断给定的Class是否是一个元类:


获取实例变量的大小:




     在objc_class中,所有的成员变量,属性的信息是放在链表ivars中的,ivars是一个数组,数组中每个元素是指向Ivar的指针。

  • 获取类中实例成员变量的信息



  • 获取类成员变量的信息



  • 添加成员变量



  • 获取成员变量列表




-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

以下数属性操作函数

  • 获取指定的属性



  • 获取属性列表




  • 为类添加属性



  • 替换类的属性



-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

以下为方法操作函数:

  • 添加方法



  • 获取实例方法



  • 获取类方法



  • 获取所有方法的数组



  • 替换方法的实现



  • 返回方法的具体实现



  • 类实例是否响应指定的selector




-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


协议操作函数如下:

  • 添加协议



  • 返回类是否实现指定的协议



  • 返回类实现的协议列表



-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


获取版本Version如下:

  • 获取版本号



  • 设置版本号




(12)动态创建类

  • 创建一个新类和元类



  • 销毁一个类及其相关联的类



  • 在应用中注册由objc_allocateClassPair创建的类


objc_allocateClassPair函数:如果要创建一个根类,则superclass指定为nil,extraBytes通常指定为0,该参数是分配给类和元类对象尾部的索引ivars的字节数。然后使用诸如class_addMethod,class_addIvar等函数来为新创建的类添加方法,实例变量和属性。完成这些后,需要调用objc_registerClassPair函数来注册类,之后这个新类就可以在程序中使用了。

注意:实例方法和实例变量应该添加到类自身上,类方法应该添加到类的元类上。


(13)动态创建对象

  • 创建类实例



  • 在指定位置创建类实例



  • 销毁类实例




(14)实例操作函数

     实例操作函数主要是针对我们创建的实例对象的一系列操作函数,我们可以使用这组函数来从实例对象中获取我们要的信息,如实例对象中变量的值。

  • 返回指定对象的一份拷贝



  • 释放指定对象占用的内存



----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

针对对象实例变量进行操作的函数

  • 修改类实例的实例变量的值


  • 获取类对象中实例变量



  • 返回对象中实例变量的值




  • 设置对象中实例变量的值



----------------------------------------------------------------------------------------------------------------------------------------------------------------------------


针对对象的类进行操作的函数

  • 返回给定对象的类名



  • 返回对象的类



  • 设置对象的类



----------------------------------------------------------------------------------------------------------------------------------------------------------------------------


获取类定义:Runtime会自动注册我们代码中定义的所有类,我们也可以在运行时创建类定义并使用objc_addClass函数来注册他它们。

  • 获取已注册的类定义的列表





  • 创建并返回一个指向所有已注册类的指针列表




  • 返回指定类的类定义







  • 返回指定类的元类



(15)成员变量、属性

  • Ivar
Ivar是表示实例变量的类型,实际是一个指向objc_ivar结构体的指针。





  • objc_property_t
objc_property_t是表示OC声明的属性的类型,实际是指向objc_property结构体的指针。



  • objc_property_attribute_t
定义了属性的特性,是一个结构体。




(16)关联对象
      关联对象类似于成员变量,不过是在运行时添加的。通常会把成员变量Ivar放在类声明的头文件中,或者放在类实现的@implementation后面。但是有一个缺点,不能在Category中添加成员变量,否则会编译器报错。可以把关联对象想象成一个OC对象(如字典),这个对象通过给定的key连接到类的一个实例上。由于使用的是C接口,所以key是一个void指针(const void *). 其中使用以下的内存管理策略来管理这个对象。同上面(5)




(17)SEL
    SEL叫选择器,是表示一个方法的selector指针,定义如下:



objc_selector结构体的详细定义没有在头文件中找到,方法的selector用于表示运行时方法的名字。OC在编译时,会根据每一个方法的名字生成一个唯一的整型标志(int类型的地址),这个标示就是SEL。
代码所示:


打印结果如下:


     两个类之间,如果是继承关系,只要方法名相同,那么方法的SEL就是一样的。每一个方法对应一个SEL。所以在OC的同一个类中(或类的继承体系中),不能存在两个同名的方法,即使参数类型不同也不行。所以说,OC不存在重载的概念。当然,不同的类可以拥有相同的selector。不同类的实例对象执行相同的selector时,会在各自的方法列表中去根据selector寻找自己对应的IMP。
     工程中所有的SEL组成了一个Set集合,Set的特点就是唯一,因此SEL是唯一的。因此,如果我们想到这个方法集合中查找某个方法时,只需要找到这个方法对应的SEL即可。SEL实际上就是根据方法名hash了一个字符串,而对于字符串的比较仅仅需要比较他们的地址就可以了。本质上,SEL只是一个指向方法的指针。
  

(18)IMP
     IMP实际上是一个函数指针,指向方法实现的首地址。定义如下:


第一个参数是指向self的指针(如果是实例方法,则是类实例的内存地址;如果是类方法,则是指向元类的指针),第二个参数是方法选择器(selector),接下来是方法的实际参数列表。


(19)Method




看到在结构体中有SEL和IMP,相当于在SEL和IMP之间做了一个映射。有了SEL,就可以找到对应的IMP,从而调用方法的实现代码。

objc_method_description定义了一个OC方法,定义如下:



(20)方法相关操作函数
  • 调用指定方法的实现






  • 获取方法名


  • 返回方法的实现



  • 获取描述方法参数和返回值类型的字符串


  • 获取方法指定位置参数的类型字符串



  • 通过引用返回方法的返回值类型字符串


  • 返回方法的参数个数


  • 返回指定方法的方法描述结构体



  • 设置方法的实现



  • 交换两个方法的实现



(21)方法选择器
  • 返回给定选择器指定的方法的名称



  • Runtime中注册一个方法,将方法名映射到一个选择器,并返回这个选择器。在我们将一个方法添加到类定义时,必须在Runtime中注册一个方法名以获取方法的选择器。



  • 在Runtime中注册一个方法


  • 比较两个选择器



(22)方法调用流程
       在OC中,消息直到运行时才绑定到方法的实现上。编译器会将消息表达式[receive message]转化为一个消息函数的调用,即objc_msgSend。这个函数将消息接收者和方法名作为基础参数,如下所示:


可以看到,第三个参数是个可变参数,用来传递原方法的参数列表:
objc_msg_Send(receive,selector,arg1,arg2).这个函数完成了动态绑定的所有事情。
  • 首先它找到selector对应的方法实现。因为同一个方法可能在不同的类中有不同的实现,所以我们需要依赖接收者的类来找到确切的实现。
  • 它调用方法的实现,并将接收者对象及方法的所有参数传给它。
  • 最后,它将实现的返回值作为他自己的返回值。
消息的关键在于objc_class,有两个字段是我们在分发消息时关注的:
-- 指向父类的指针;
-- 一个类的方法的分发表,即methodList;

消息的基本框架:





(23)消息转发
     当一个对象能接收一个消息时,就会走正常的方法调用流程。默认情况下,如果是以[object message]的方式调用方法,如果object无法响应message消息时,编译器会报错。但如果是以perform...的形式来调用,则需要等到运行时才能确定object是否能接收message消息。如果不能,则程序崩溃。通常,当我们不能确定一个对象是否能接收某个消息时,会先调用respondsToSelector:来判断一下:



----------------------------------------------------------------------------------------------------------------------------------------------

当一个对象无法接收某一消息时,就会使用”消息转发(message forwarding)“机制。通过这一机制,我们可以告诉对象如何处理未知的消息。消息转发分为三个步骤:
  • 动态方法解析;
  • 备用接收者;
  • 完整转发;

--- 动态方法解析
对象在接收到未知的消息时,首先会调用所属类的类方法+resolveInstanceMethod:实例方法或者+resolveClassMethod:类方法。在这个方法中,我们有机会为该未知消息新增一个处理方法,不过使用该方法的前提是我们已经实现了该处理方法,只需要在运行时通过class_addMethod函数动态添加到类里面就行了。如下代码所示:
void functionForMethod1(id self, SEL _cmd) {
  NSLog(@"%@, %p", self, _cmd);
}

+ (BOOL)resolveInstanceMethod:(SEL)sel {

    NSString *selectorString = NSStringFromSelector(sel);

    if ([selectorString isEqualToString:@"method1"]) {

        class_addMethod(self.class, @selector(method1), (IMP)functionForMethod1, "@:");
    }

    return [super resolveInstanceMethod:sel];

}


---备用接收者
     如果上一步无法处理消息,则Runtime会继续调用以下方法:


如果一个对象实现了这个方法,并返回一个非nil的结果,则这个对象会作为消息的新接收者,且消息会被分发到这个对象。当然这个对象不能是self自身,否则会出现无线循环。


--- 完整消息转发
如果在上一步还不能处理未知消息,则唯一能做的就是启用完整的消息转发机制了,此时会调用以下方法:


运行时系统会在这一步给消息接收者最后一次机会将消息转发给其他对象。对象会创建一个表示消息的NSInvocation对象,把与尚未处理的消息有关的全部细节都封装在NSInvocation中,包括selector,target和参数。我们可以在forwardInvocation方法中将消息转发给其他对象。
同时我们必须重写以下方法:


 

      Runtime博大精深,以上只是对Runtime的概念、原理和接口方法讲解,在之后的博客中我会来实现一些实例,来实际演示Runtime的使用。欢迎持续关注哦!


2016-08-24 16:34:27 jiuchabaikaishui 阅读数 945

iOS运行时简介

因为Objc是一门动态语言,所以它总是想办法把一些决定工作从编译连接推迟到运行时。也就是说只有编译器是不够的,还需要一个运行时系统 (runtime system) 来执行编译后的代码。这就是 Objective-C Runtime 系统存在的意义,它是整个Objc运行框架的一块基石。

iOS运行时的一些概念

1.类:Objective-C类是由Class类型来表示的,它实际上是一个指向objc_class结构体的指针。objc_class结构体的定义如下

struct objc_class {

    Class isa  OBJC_ISA_AVAILABILITY;



#if !__OBJC2__

    Class super_class                       OBJC2_UNAVAILABLE;  // 父类

    const char *name                        OBJC2_UNAVAILABLE;  // 类名

    long version                            OBJC2_UNAVAILABLE;  // 类的版本信息,默认为0

    long info                               OBJC2_UNAVAILABLE;  // 类信息,供运行期使用的一些位标识

    long instance_size                      OBJC2_UNAVAILABLE;  // 该类的实例变量大小

    struct objc_ivar_list *ivars            OBJC2_UNAVAILABLE;  // 该类的成员变量链表

    struct objc_method_list **methodLists   OBJC2_UNAVAILABLE;  // 方法定义的链表

    struct objc_cache *cache                OBJC2_UNAVAILABLE;  // 方法缓存

    struct objc_protocol_list *protocols    OBJC2_UNAVAILABLE;  // 协议链表

#endif



} OBJC2_UNAVAILABLE;

2.实例对象:既是objc_object表示的一个类的实例的结构体,它的定义如下

struct objc_object {

    Class isa  OBJC_ISA_AVAILABILITY;

};

typedef struct objc_object *id;

3.元类(Meta Class):meta-class是一个类对象的类。它存储着一个类的所有类方法。每个类都会有一个单独的meta-class。

4.方法调用过程:首先在本类中查找,如果没有就向父类中查找,然后响应该方法,最后把该方法添加到cache列表中,以后再调用该方法,直接从cache中取出相应的方法调用。

5.实例对象的isa指针指向对象所属类,类的isa指针指向元类,元类的isa指针指向根元类(根类的元类),根元类的isa指正指向自身。类的superclass指针指向父类,根类的superclass指针指向nil,根元类的superclass指针指向根类。如下图所示:
这里写图片描述

void testClass(id self, SEL _cmd)
{
    NSObject *object = [[NSObject alloc] init];
    NSLog(@"NSObject实例:%@, 地址:%p", object, object);
    NSLog(@"NSObject类名:%@ 地址:%p,NSObject父类名:%@ 地址:%p", [object class], [object class], [object superclass], [object superclass]);

    NSLog(@"MyObject实例:%@,%p", self, self);
    NSLog(@"MyObject类名:%@ 地址:%p,MyObject父类名:%@ 地址:%p", [self class], [self class], [self superclass], [self superclass]);

    Class currentClass;
    Class superClass = [self class];
    do {
        currentClass = superClass;
        superClass = class_getSuperclass(currentClass);
        NSLog(@"当前类:%@ 地址:%p, 父类:%@ 地址:%p", currentClass, currentClass, superClass, superClass);
    } while (superClass != NULL);

    Class isaClass = [self class];
    currentClass = NULL;
    do {
        currentClass = isaClass;
        isaClass = object_getClass(currentClass);
        NSLog(@"当前类:%@ 地址:%p,isa指针指向的类:%@ 地址:%p", currentClass, currentClass, isaClass, isaClass);
    } while (!(currentClass == isaClass));
}
- (void)createClass
{
    //创建一个类,注意名称一定不能是已经存在的类
    Class myObjectClass = objc_allocateClassPair([NSObject class], "MyObject", 0);
    //向类中添加一个方法
    class_addMethod(myObjectClass, @selector(testClass), (IMP)testClass, "v@:");
    //注册类,注册后方能使用该类
    objc_registerClassPair(myObjectClass);

    id myObject = [[myObjectClass alloc] init];
    [myObject performSelector:@selector(testClass)];
}

打印如下:
这里写图片描述

6.super:super与self不同。self是类的一个隐藏参数,每个方法的实现的第一个参数即为self。而super并不是隐藏参数,它实际上只是一个”编译器标示符”,它负责告诉编译器,当调用viewDidLoad方法时,去调用父类的方法,而不是本类中的方法。而它实际上与self指向的是相同的消息接收者。
super的定义:

struct objc_super {
     id receiver;//即消息的实际接收者
     Class superClass;//指针当前类的父类
 };

例证:

- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"self:%@ super:%@", self, super.class);
}

打印如下:
这里写图片描述

7.SEL:SEL又叫选择器,是表示一个方法的selector的指针,本质上,SEL只是一个指向方法的指针(准确的说,只是一个根据方法名hash化了的KEY值,能唯一代表一个方法),它的存在只是为了加快方法的查询速度。其定义如下:

typedef struct objc_selector *SEL;

8.IMP:IMP实际上是一个函数指针,指向方法实现的首地址。SEL就是为了查找方法的最终实现IMP的。由于每个方法对应唯一的SEL,因此我们可以通过SEL方便快速准确地获得它所对应的IMP,查找过程将在下面讨论。取得IMP后,我们就获得了执行这个方法代码的入口点,此时,我们就可以像调用普通的C语言函数一样来使用这个函数指针了。其定义如下:

id (*IMP)(id, SEL, ...)

9.Method:既是objc_method表示的一个结构体,该结构体中包含一个SEL和IMP,实际上相当于在SEL和IMP之间作了一个映射。有了SEL,我们便可以找到对应的IMP,从而调用方法的实现代码。Method用于表示类定义中的方法,则定义如下:

typedef struct objc_method *Method;



struct objc_method {

    SEL method_name                 OBJC2_UNAVAILABLE;  // 方法名

    char *method_types                  OBJC2_UNAVAILABLE;

    IMP method_imp                      OBJC2_UNAVAILABLE;  // 方法实现

}  
2015-07-15 20:49:27 fuzheng0301 阅读数 3247

一.先思考两个问题:

第一个问题,
1》runtime实现的机制是什么,怎么用,一般用于干嘛?
这个问题我就不跟大家绕弯子了,直接告诉大家,
runtime是一套比较底层的纯C语言API, 属于1个C语言库, 包含了很多底层的C语言API。
在我们平时编写的OC代码中, 程序运行过程时, 其实最终都是转成了runtime的C语言代码, runtime算是OC的幕后工作者
比如说,下面一个创建对象的方法中,
举例:
OC :
[[MJPerson alloc] init]
runtime :
objc_msgSend(objc_msgSend(“MJPerson” , “alloc”), “init”)


第二个问题
runtime 用来干什么呢??用在那些地方呢?怎么用呢?
runtime是属于OC的底层, 可以进行一些非常底层的操作(用OC是无法现实的, 不好实现)

  • 在程序运行过程中, 动态创建一个类(比如KVO的底层实现)

  • 在程序运行过程中, 动态地为某个类添加属性\方法, 修改属性值\方法

  • 遍历一个类的所有成员变量(属性)\所有方法
    例如:我们需要对一个类的属性进行归档解档的时候属性特别的多,这时候,我们就会写很多对应的代码,但是如果使用了runtime就可以动态设置!

二.学习runtime机制首先要了解下面几个问题

       Objective-c是一门编译型、动态语言(这里强调下oc是静态类型语言),这在开发语言中是并多见的,一般的动态语言多为解释性语言。OC之所以能够做到即使编译型语言,又是动态语言。就是得益于RunTime机制。

1.相关的头文件和函数
1> 头文件

  • 利用头文件,我们可以查看到runtime中的各个方法!

2> 相关应用

  • NSCoding(归档和解档, 利用runtime遍历模型对象的所有属性)
  • 字典 –> 模型 (利用runtime遍历模型对象的所有属性, 根据属性名从字典中取出对应的值, 设置到模型的属性上)
  • KVO(利用runtime动态产生一个类)
  • 用于封装框架(想怎么改就怎么改)
    这就是我们runtime机制的只要运用方向

3> 相关函数

    1、class_copyPropertyList  获取一份拷贝的成员列表数组

    2、property_getName获取成员名称

    3、class_getInstanceVariable  获取成员对象的Ivar

    4、object_getIvar从Ivar对象中取值

    5、object_setIvar赋值函数

    6、objc_msgSend : 给对象发送消息

    7、class_copyMethodList : 遍历某个类所有的方法

    8、class_copyIvarList : 遍历某个类所有的成员变量

    9、class_…..

    这些是我们学习runtime必须知道的函数!

2.必备常识
1> Ivar : 成员变量
2> Method : 成员方法
从上面例子中我们看到我们定义的成员变量,如果要是动态创建方法,可以使用Method,


三.我们通过一幅图可以看清楚OC中类与对象的继承层次关系:

注意:所有的metaclass中isa指针都是指向根metaclass,而根metaclass则指向自身。根metaclass是通过继承根类产生的,与根class结构体成员一致,不同的是根metaclass的isa指针指向自身。

1、当我们调用某个对象的对象方法时,它会首先在自身isa指针指向的类(class)methodLists中查找该方法,如果找不到则会通过class的super_class指针找到其父类,然后从其methodLists中查找该方法,如果仍然找不到,则继续通过 super_class向上一级父类结构体中查找,直至根class;

2、当我们调用某个类方法时,它会首先通过自己的isa指针找到metaclass,并从其methodLists中查找该类方法,如果找不到则会通过metaclass的super_class指针找到父类的metaclass结构体,然后从methodLists中查找该方法,如果仍然找不到,则继续通过super_class向上一级父类结构体中查 找,直至根metaclass;


四.下面我们来看一下代码实现:

1、创建一个类

CustomClass.h


#import <Foundation/Foundation.h>

@interface CustomClass : NSObject

@property (nonatomic , strong) NSString *age;

- (void)test;

@end

CustomClass.m


#import "CustomClass.h"

@implementation CustomClass

- (void)test
{
    NSLog(@"这里是CustomClass");
    
}

@end

接下来创建一个类别来实现RunTime机制

NSObject+RunTimeTest.h


#import <Foundation/Foundation.h>

@interface NSObject (RunTimeTest)

//动态创建一个类,之后为这个类的age属性赋值。
- (id) testRunTime:(NSString *)classname age:(NSString *)age;


@end

NSObject+RunTimeTest.m


#import "NSObject+RunTimeTest.h"
#import <objc/runtime.h>
#import "CustomClass.h"


@implementation NSObject (RunTimeTest)

- (CustomClass *)testRunTime:(NSString *)classname age:(NSString *)age
{
    // propertyCount 成员属性的数量
    unsigned int propertyCount = 0;
    /* objc_property_t 根据苹果文档的解释:An opaque type that represents an Objective-C declared property.
  个人理解:一个任意类型的对象代表一个oc声明的属性成员 (本人英语水平实在有限)*/
    /* class_copyPropertyList  
     文档:Return Value
     An array of pointers of type objc_property_t describing the properties declared by the class. Any properties declared by superclasses are not included. The array contains *outCount pointers followed by a NULL terminator. You must free the array with free().
     个人理解:主要2个意思:返回一个数组指针,类型为objc_property_t,用完要记得free,释放掉。
     */
    objc_property_t *properties = class_copyPropertyList([self class], &propertyCount);
    for (unsigned int i = 0; i < propertyCount; i++) {
  objc_property_t property = properties[i];
  //获取成员的名称
  NSString *propertyName = [[NSString alloc] initWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
  NSLog(@"propertyName = %@ -- 成员名称",propertyName);
  
  //获取成员内容的Ivar
  Ivar iVar = class_getInstanceVariable([self class], [propertyName UTF8String]);
  //其实上面那行获取代码是为了保险起见,基本是获取不到内容的。因为成员的名称默认会在前面加"_" ,
  if (iVar == nil) {
      iVar = class_getInstanceVariable([self class], [[NSString stringWithFormat:@"_%@",propertyName] UTF8String]);
  }
  
  //  取值
  id propertyVal = object_getIvar(self, iVar);
  NSLog(@"propertyVal = %@ --值",propertyVal);
  
       
  
  
  // 动态创建类
  Class varClass = NSClassFromString(classname);
  id varObj = [[varClass alloc] init];
  //调用新创建类的方法,这里要主要一定引入对应得头文件,不然调用方法会不错。
  [varObj test];
  
  Ivar iVarObj = class_getInstanceVariable(varClass, [@"_age" UTF8String]);
  
  
  
  object_setIvar(varObj, iVarObj, age);
  
  
  return varObj;
    }
    return nil;
    
    
    
}

@end

测试:

ViewController.m


#import "NSObject+RunTimeTest.h"
#import "CustomClass.h"

@interface ViewController ()

@property (nonatomic , strong) NSString *name;


@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
  
  _name = @"xiaonan";
  CustomClass *tmp = [self testRunTime:@"CustomClass" age:@"098"];
  NSLog(@"tmp.age = %@",tmp.age);
  
  
}

结果输出:

2014-11-29 17:16:55.483 TestRunTime2[21001:176367] propertyName = name -- 成员名称
2014-11-29 17:16:55.483 TestRunTime2[21001:176367] propertyVal = xiaonan --值
2014-11-29 17:16:55.484 TestRunTime2[21001:176367] 这里是CustomClass
2014-11-29 17:16:55.484 TestRunTime2[21001:176367] tmp.age = 098


没有更多推荐了,返回首页