runtime体验

引言

运行时作为面试题中高阶问题必不可少的一个技能点。经常面试官会问道是否使用过运行时，以及如何使用运行时。并且我认为这个技术算是高阶开发里面一个投机的技巧，绝大多数的UI开发都不会使用runtime，容易出现很严重的问题，并且官方也不是特别推荐使用。所以会导致很多人对运行时没有一个清晰全面的认识，网上资料也很少。所以你一定会有这样的疑问：什么是运行时？在我们的项目中怎么使用运行时？哪些时候可以使用运行时？等等。。

问题：当想在一个分类（category）中添加一个属性时，并且iOS是不允许给扩展类扩展属性的（category相对于子类来说，如果需要添加一个新的变量，则需添加子类。如果只是添加一个新的方法，用Category是比较好的选择。）

答案：使用runtime。

runtime机制

我们都知道Objective-C是C的超集，我们平时写的Objective-C都是最终转成了runtime的C语言代码，所以runtime是一套比较底层的纯C的API，属于C语言库，包含了很多底层C语言的API。

所以，在我们编译时，其实runtime是不存在。只有在运行过程中才去确定对象的类型，方法等等。而我们就可以根据这个特性再程序运行时动态的修改类、对象中的所有属性、方法。

我们在使用运行时的地方，都需要包含头文件：#import <objc/runtime.h>;。如果是Swift就不需要包含头文件，就可以直接使用了。

runtime头文件

在iOS 9.3 user/include>objc文件夹下有如下的文件

1
2
3
4
5
6
7
8
9

message.h
NSObjCRuntime.h
NSObject.h
objc-api.h
objc-auto.h
objc-exception.h
objc-sync.h
objc.h
runtime.h

这些都是runtime相关的头文件，其中我们主要使用的是message.h和runtime.h这2个文件。

• message.h：主要包含了一些向对象发送消息的函数，这是OC对象方法调用的底层实现。
• runtime.h：运行时最重要的文件，其中包含了对运行时进行操作的方法。

  runtime.h

首先贴上源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/// An opaque type that represents a method in a class definition. 一个类型，代表着类定义中的一个方法
typedef struct objc_method *Method;

/// An opaque type that represents an instance variable.代表实例(对象)的变量
typedef struct objc_ivar *Ivar;

/// An opaque type that represents a category.代表一个分类
typedef struct objc_category *Category;

/// An opaque type that represents an Objective-C declared property.代表OC声明的属性
typedef struct objc_property *objc_property_t;

// Class代表一个类，它在objc.h中这样定义的  typedef struct objc_class *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;
    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;

这些类型的定义，对一个类进行了完全的分解，将类定义或者对象的每一个部分都抽象为一个类型type，对操作一个类属性和方法非常方便。OBJC2_UNAVAILABLE标记的属性是Ojective-C 2.0不支持的,但实际上可以用响应的函数获取这些属性，例如：如果想要获取Class的name属性，可以按如下方法获取:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Class classPerson = Person.class;
// printf("%s\n", classPerson->name); 
//用这种方法已经不能获取name了 因为OBJC2_UNAVAILABLE
const char *cname  = class_getName(classPerson);
printf("%s", cname); // 输出:Person

/* 返回正在工作的Class */
/** 
 * Returns the name of a class.
 * 
 * @param cls A class object.
 * 
 * @return The name of the class, or the empty string if \e cls is \c Nil.
 */
     // OBJC_EXPORT const char *class_getName(Class cls) 
        // __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

函数的定义

• 对对象进行操作的方法一般以object_开头
• 对类进行操作的方法一般以class_开头
• 对类或对象的方法进行操作的方法一般以method_开头
• 对成员变量进行操作的方法一般以ivar_开头
• 对属性进行操作的方法一般以property_开头开头
• 对协议进行操作的方法一般以protocol_开头
  根据以上的函数的前缀 可以大致了解到层级关系。

对于以objc_开头的方法，则是runtime最终的管家，可以获取内存中类的加载信息,类的列表，关联对象和关联属性等操作。

例如：使用runtime对当前的应用中加载的类进行打印。

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    unsigned int count = 0;
    Class *classes = objc_copyClassList(&count);
    for (int i = 0; i < count; i++) {
        const char *cname = class_getName(classes[i]);
        printf("%s\n", cname);
    }
}

获取对象所有属性名

利用运行时获取对象的所有属性名是可以的，但是变量名获取就得用另外的方法了。我们可以通过class_copyPropertyList方法获取所有的属性名称。

下面我们通过一个Person类来学习，这里的方法没有写成扩展，只是为了简化，将获取属性名的方法直接作为类的实例方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#import <Foundation/Foundation.h>

@interface Person : NSObject {
    NSString *_variableString;
}

// 默认会是什么呢？
@property (nonatomic, copy) NSString *name;

// 默认是strong类型
@property (nonatomic, strong) NSMutableArray *array;

// 默认是assign类型
@property (nonatomic, assign) NSUInteger age;

// 默认是assign类型
@property (nonatomic, assign) BOOL sex;

// 获取所有的属性名
- (NSArray *)allProperties;

@end

下面主要是写如何获取类的所有属性名的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#import "Person.h"
#import <objc/runtime.h>

@implementation Person
- (NSArray *)allProperties {
    unsigned int count;

    // 获取类的所有属性
    // 如果没有属性，则count为0，properties为nil
    objc_property_t *properties = class_copyPropertyList([self class], &count);
    NSMutableArray *propertiesArray = [NSMutableArray arrayWithCapacity:count];

    for (NSUInteger i = 0; i < count; i++) {
        // 获取属性名称
        const char *propertyName = property_getName(properties[i]);
        NSString *name = [NSString stringWithUTF8String:propertyName];

        [propertiesArray addObject:name];
    }

    // 注意，这里properties是一个数组指针，是C的语法，
    // 我们需要使用free函数来释放内存，否则会造成内存泄露
    free(properties);

    return propertiesArray;
}
@end

现在，我们来测试一下，我们的方法是否正确获取到了呢？看下面的打印结果就明白了吧！

1
2
3
4
5
6
7
8
9
10
11
12

- (void)test1_2{

    Person *p = [[Person alloc] init];
    p.name = @"BirdMichael";

    size_t size = class_getInstanceSize(p.class);
    NSLog(@"classSize = %ld", size);

    for (NSString *propertyName in p.allProperties) {
        NSLog(@"%@", propertyName);
    }
}

输出结果：

1
2
3
4
5

2016-05-05 17:27:47.667 runtime[2368:257719] classSize = 48
2016-05-05 17:27:47.667 runtime[2368:257719] name
2016-05-05 17:27:47.668 runtime[2368:257719] array
2016-05-05 17:27:47.668 runtime[2368:257719] age
2016-05-05 17:27:47.668 runtime[2368:257719] sex

注意：上面提到的objc_property_t是一个结构体指针objc_property *，因此我们声明的properties就是二维指针。所以在使用完毕以后，一定要释放内存，否则会造成内存泄露。并且由于runtime使用的是C语言的API，所以我们也需要使用C语言释放内存的方法：free()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/** 
 * Describes the properties declared by a class.
 * 
 * @param cls The class you want to inspect.
 * @param outCount On return, contains the length of the returned array. 
 *  If \e outCount is \c NULL, the length is not returned.        
 * 
 * @return An array of pointers of type \c objc_property_t describing the properties 
 *  declared by the class. Any properties declared by superclasses are not included. 
 *  The array contains \c *outCount pointers followed by a \c NULL terminator. You must free the array with \c free().
 * 
 *  If \e cls declares no properties, or \e cls is \c Nil, returns \c NULL and \c *outCount is \c 0.
 */
OBJC_EXPORT objc_property_t *class_copyPropertyList(Class cls, unsigned int *outCount)
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
```     
- 官方文档中也明确指出：The array contains \c *outCount pointers followed by a \c NULL terminator. You must free the array with \c free().


## 获取对象的所有属性名和属性值

对于获取对象的所有属性名，在上面的`-allProperties`方法已经可以拿到了，但是并没有处理获取属性值，下面的方法就是可以获取属性名和属性值，将属性名作为`key`，属性值作为`value`。

@interface Person : NSObject {
NSString *_variableString;
}

// 默认会是什么呢？
@property (nonatomic, copy) NSString *name;

// 默认是assign类型
@property (nonatomic, copy) NSString *firtName;

// 默认是strong类型
@property (nonatomic, strong) NSMutableArray *array;

// 默认是assign类型
@property (nonatomic, assign) NSUInteger age;

// 默认是assign类型
@property (nonatomic, assign) BOOL sex;

// 获取对象的所有属性名和属性值

• (NSDictionary *)allPropertyNamesAndValues;

@end

1

下面主要是写如何获取对象的所有属性名和属性值的方法。

• (NSDictionary )allPropertyNamesAndValues {
  NSMutableDictionary resultDict = [NSMutableDictionary dictionary];

  unsigned int outCount;
  objc_property_t *properties = class_copyPropertyList([self class], &outCount);

  for (int i = 0; i < outCount; i++) {

  objc_property_t property = properties[i];
  const char *name = property_getName(property);
  
  // 得到属性名
  NSString *propertyName = [NSString stringWithUTF8String:name];
  
  // 获取属性值
  id propertyValue = [self valueForKey:propertyName];
  
  if (propertyValue && propertyValue != nil) {
      [resultDict setObject:propertyValue forKey:propertyName];
  }
  

  }

  // 记得释放
  free(properties);

  return resultDict;
  }

  1

  继续测试一下：

• (void)test1_3{
  Person p = [[Person alloc] init];
  p.name = @”BirdMichael”;
  p.age = 8;
  NSDictionary dict = p.allPropertyNamesAndValues;
  for (NSString *propertyName in dict.allKeys) {

  NSLog(@"propertyName: %@ propertyValue: %@", propertyName, dict[propertyName]); }
  

  }

  1

  输出结果：

2016-05-05 18:27:10.345 runtime[2618:313291] propertyName: name propertyValue: BirdMichael
2016-05-05 18:27:10.347 runtime[2618:313291] propertyName: age propertyValue: 8
2016-05-05 18:27:10.347 runtime[2618:313291] propertyName: sex propertyValue: 0

1
2
3
4

## 获取对象的所有方法名

通过class_copyMethodList方法就可以获取所有的方法。并且我们知道，每一个属性都会自动生成一个成员变量和setter以及getter方法。(省略部分相同代码)

• (void)allMethods {
  unsigned int outCount = 0;
  Method *methods = class_copyMethodList([self class], &outCount);

  for (int i = 0; i < outCount; ++i) {

  Method method = methods[i];
  
  // 获取方法名称，但是类型是一个SEL选择器类型
  SEL methodSEL = method_getName(method);
  // 需要获取C字符串
  const char *name = sel_getName(methodSEL);
  // 将方法名转换成OC字符串
  NSString *methodName = [NSString stringWithUTF8String:name];
  
  // 获取方法的参数列表
  int arguments = method_getNumberOfArguments(method);
  NSLog(@"方法名：%@, 参数个数：%d", methodName, arguments);
  

  }

  // 记得释放
  free(methods);
  }

  1

  测试一下：

• (void)test1_4{
  Person *p = [[Person alloc] init];

  [p allMethods];
  }

  1

  输出结果：

2016-05-05 18:35:39.886 runtime[2709:323818] 方法名：allProperties, 参数个数：2
2016-05-05 18:35:39.886 runtime[2709:323818] 方法名：setAge:, 参数个数：3
2016-05-05 18:35:39.887 runtime[2709:323818] 方法名：allPropertyNamesAndValues, 参数个数：2
2016-05-05 18:35:39.887 runtime[2709:323818] 方法名：allMethods, 参数个数：2
2016-05-05 18:35:39.887 runtime[2709:323818] 方法名：firtName, 参数个数：2
2016-05-05 18:35:39.887 runtime[2709:323818] 方法名：setFirtName:, 参数个数：3
2016-05-05 18:35:39.888 runtime[2709:323818] 方法名：age, 参数个数：2
2016-05-05 18:35:39.888 runtime[2709:323818] 方法名：sex, 参数个数：2
2016-05-05 18:35:39.888 runtime[2709:323818] 方法名：setSex:, 参数个数：3
2016-05-05 18:35:39.888 runtime[2709:323818] 方法名：setArray:, 参数个数：3
2016-05-05 18:35:39.888 runtime[2709:323818] 方法名：.cxx_destruct, 参数个数：2
2016-05-05 18:35:39.888 runtime[2709:323818] 方法名：name, 参数个数：2
2016-05-05 18:35:39.889 runtime[2709:323818] 方法名：array, 参数个数：2
2016-05-05 18:35:39.889 runtime[2709:323818] 方法名：setName:, 参数个数：3

1

调用打印结果如下，为什么参数个数看起来不匹配呢？比如`-allProperties`方法，其参数个数为0才对，但是打印结果为2。根据打印结果可知，无参数时，值就已经是2了。**这个在后面会详细讲解。**

/ Working with Methods /

/**

• Returns the name of a method.
• @param m The method to inspect.
• @return A pointer of type SEL.
• @note To get the method name as a C string, call \c sel_getName(method_getName(method)).
  */
  OBJC_EXPORT SEL method_getName(Method m)
  OSX_AVAILABLE_STARTING(MAC_10_5, __IPHONE_2_0);

/**

• Returns the number of arguments accepted by a method.
• @param m A pointer to a \c Method data structure. Pass the method in question.
• @return An integer containing the number of arguments accepted by the given method.
  */
  OBJC_EXPORT unsigned int method_getNumberOfArguments(Method m)
  OSX_AVAILABLE_STARTING(MAC_10_0, __IPHONE_2_0);

  1 2 3

  ## 获取对象的成员变量名称 要获取对象的成员变量，可以通过`class_copyIvarList`方法来获取，通过ivar_getName来获取成员变量的名称。并且我们知道，每一个属性都会自动生成一个成员变量和setter以及getter方法。(省略部分相同代码)

• (NSArray )allMemberVariables {
  unsigned int count = 0;
  Ivar ivars = class_copyIvarList([self class], &count);

  NSMutableArray *results = [[NSMutableArray alloc] init];
  for (NSUInteger i = 0; i < count; ++i) {

  Ivar variable = ivars[i];
  
  const char *name = ivar_getName(variable);
  NSString *varName = [NSString stringWithUTF8String:name];
  
  [results addObject:varName];
  

  }

  free(ivars);

  return results;
  }

  1

  测试一下：

• (void)test1_4{
  Person p = [[Person alloc] init];
  for (NSString varName in p.allMemberVariables) {

  NSLog(@"%@", varName);
  

  }
  }

  1

  打印结果：

2016-05-05 18:48:19.969 runtime[2846:343854] _variableString
2016-05-05 18:48:19.970 runtime[2846:343854] _sex
2016-05-05 18:48:19.970 runtime[2846:343854] _name
2016-05-05 18:48:19.970 runtime[2846:343854] _firtName
2016-05-05 18:48:19.970 runtime[2846:343854] _array
2016-05-05 18:48:19.970 runtime[2846:343854] _age

1
2
3
4
5
6

## 运行时发消息

iOS中，可以在运行时发送消息，让接收消息者执行对应的动作。可以使用`objc_msgSend`方法，发送消息。因为objc_msgSend是因为只有对象才能发送消息，所以肯定是以objc开头的。

另外：使用运行时发送消息前，必须导入`#import <objc/message.h>`

• (void)test1_5{
  Person *p = [[Person alloc] init];
  p.name = @”BirdMichael”;
  p.age = 8;
  objc_msgSend(p, @selector(allMethods));
  }
  `` 但是这样就等于把[p allMethods]`这个方法用底层的方法表示出来，其实[p allMethods]也会转成这句代码。此时你会发现很尴尬的一个现象是：编译器会报错。

/ Associative References /

/
  Policies related to associative references.
  These are options to objc_setAssociatedObject()
 */
typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,           /< Specifies a weak reference to the associated object. /
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object. 
                                               The association is not made atomically. /
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied. 
                                               The association is not made atomically. /
    OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object.
                                               The association is made atomically. /
    OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied.
                                               The association is made atomically. /
};

/** 
  Sets an associated value for a given object using a given key and association policy.
  
  @param object The source object for the association.
  @param key The key for the association.
  @param value The value to associate with the key key for object. Pass nil to clear an existing association.
  @param policy The policy for the association. For possible values, see “Associative Object Behaviors.”
 
  @see objc_setAssociatedObject
  @see objc_removeAssociatedObjects
 /
OBJC_EXPORT void objc_setAssociatedObject(id object, const void key, id value, objc_AssociationPolicy policy)
    OSX_AVAILABLE_STARTING(MAC_10_6, IPHONE_3_1);

/* 
  Returns the value associated with a given object for a given key.
  
  @param object The source object for the association.
  @param key The key for the association.
 
  @return The value associated with the key \e key for \e object.
 
  @see objc_setAssociatedObject
 /
OBJC_EXPORT id objc_getAssociatedObject(id object, const void *key)
    OSX_AVAILABLE_STARTING(MAC_10_6, IPHONE_3_1);

/
  Removes all associations for a given object.
 
  @param object An object that maintains associated objects.
 
  @note The main purpose of this function is to make it easy to return an object 
   to a “pristine state”. You should not use this function for general removal of
   associations from objects, since it also removes associations that other clients
   may have added to the object. Typically you should use \c objc_setAssociatedObject
   with a nil value to clear an association.
 
  @see objc_setAssociatedObject
  @see objc_getAssociatedObject
 /
OBJC_EXPORT void objc_removeAssociatedObjects(id object)
    OSX_AVAILABLE_STARTING(MAC_10_6, __IPHONE_3_1);

#import “Person.h”

@interface Person (associative)
@property (nonatomic, strong) NSString 

#import “Person+associative.h”
#import <objc/runtime.h>

@implementation Person (associative)

- (void)setSonName:(NSString )sonName{
    objc_setAssociatedObject(self, @selector(sonName), sonName, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString )sonName{
    NSObject obj = objc_getAssociatedObject(self, @selector(sonName));
    if (obj && [obj isKindOfClass:[NSString class]]) {
        return (NSString )obj;
    }

    return nil;
}
@end

- (void)test1_6{
    Person *p = [[Person alloc] init];
    p.name = @”BirdMichael”;
    p.sonName = @”BirdMichael’s son”;
    NSLog(@”%@ > %@”,p.name ,p.sonName);
}

2016-05-06 16:15:00.888 runtime[4837:801744] BirdMichael > BirdMichael’s son

#import <objc/runtime.h>
#import <objc/objc.h>

消息（Message）

为什么叫消息呢？因为面向对象编程中，对象调用方法叫做发送消息。在编译时，应用的源代码就会被编将对象发送消息转换成runtime的objc_msgSend函数调用。

在Objective-C，消息在运行时并不要求实现。编译器会转换消息表达式：

[receiver message];

id objc_msgSend(id self, SEL op, ...)

/** 
 * Sends a message with a simple return value to an instance of a class.
 * 
 * @param self A pointer to the instance of the class that is to receive the message.
 * @param op The selector of the method that handles the message.
 * @param ... 
 *   A variable argument list containing the arguments to the method.
 * 
 * @return The return value of the method.
 * 
 * @note When it encounters a method call, the compiler generates a call to one of the
 *  functions \c objc_msgSend, \c objc_msgSend_stret, \c objc_msgSendSuper, or \c objc_msgSendSuper_stret.
 *  Messages sent to an object’s superclass (using the \c super keyword) are sent using \c objc_msgSendSuper; 
 *  other messages are sent using \c objc_msgSend. Methods that have data structures as return values
 *  are sent using \c objc_msgSendSuper_stret and \c objc_msgSend_stret.
 */

/* Floating-point-returning Messaging Primitives
 * 
 * Use these functions to call methods that return floating-point values 
 * on the stack. 
 * Consult your local function call ABI documentation for details.
 * 
 * arm:    objc_msgSend_fpret not used
 * i386:   objc_msgSend_fpret used for `float`, `double`, `long double`.
 * x86-64: objc_msgSend_fpret used for `long double`.
 *
 * arm:    objc_msgSend_fp2ret not used
 * i386:   objc_msgSend_fp2ret not used
 * x86-64: objc_msgSend_fp2ret used for `_Complex long double`.
 *
 * These functions must be cast to an appropriate function pointer type 
 * before being called. 
 */

@interface NSInvocation : NSObject {
@private
    __strong void *_frame;
    __strong void *_retdata;
    id _signature;
    id _container;
    uint8_t _retainedArgs;
    uint8_t _reserved[15];
}

+ (NSInvocation *)invocationWithMethodSignature:(NSMethodSignature *)sig;

@property (readonly, retain) NSMethodSignature *methodSignature;

- (void)retainArguments;
@property (readonly) BOOL argumentsRetained;

@property (nullable, assign) id target;
@property SEL selector;

- (void)getReturnValue:(void *)retLoc;
- (void)setReturnValue:(void *)retLoc;

- (void)getArgument:(void *)argumentLocation atIndex:(NSInteger)idx;
- (void)setArgument:(void *)argumentLocation atIndex:(NSInteger)idx;

- (void)invoke;
- (void)invokeWithTarget:(id)target;

@end

/// An opaque type that represents an Objective-C class.
typedef struct objc_class *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;

#if !OBJC_TYPES_DEFINED
    /// An opaque type that represents an Objective-C class.
    typedef struct objc_class *Class;

    /// Represents an instance of a class.
    struct objc_object {
        Class isa  OBJC_ISA_AVAILABILITY;
    };

    /// A pointer to an instance of a class.
    typedef struct objc_object *id;
    #endif

typedef struct objc_cache *Cache                             OBJC2_UNAVAILABLE;

    #define CACHE_BUCKET_NAME(B)  ((B)->method_name)
    #define CACHE_BUCKET_IMP(B)   ((B)->method_imp)
    #define CACHE_BUCKET_VALID(B) (B)
    #ifndef __LP64__
    #define CACHE_HASH(sel, mask) (((uintptr_t)(sel)>>2) & (mask))
    #else
    #define CACHE_HASH(sel, mask) (((unsigned int)((uintptr_t)(sel)>>3)) & (mask))
    #endif
    struct objc_cache {
        unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
        unsigned int occupied                                    OBJC2_UNAVAILABLE;
        Method buckets[1]                                        OBJC2_UNAVAILABLE;
    };

`NSArray *array = [NSArray array];
    `

`meta-class是一个类对象的类。

当我们向一个对象发送消息时，runtime会在这个对象所属的这个类的方法列表中查找方法；而向一个类发送消息时，会在这个类的meta-class的方法列表中查找。

meta-class之所以重要，是因为它存储着一个类的所有类方法。每个类都会有一个单独的meta-class，因为每个类的类方法基本不可能完全相同。
> 其实，meta-class也是一个类，也可以向它发送一个消息，那么它的isa又是指向什么呢？为了不让这种结构无限延伸下去，Objective-C的设计者让所有的meta-class的isa指向基类的meta-class，以此作为它们的所属类。即，任何NSObject继承体系下的meta-class都使用NSObject的meta-class作为自己的所属类，而基类的meta-class的isa指针是指向它自己。这样就形成了一个完美的闭环。
通过上面的描述，再加上对objc_class结构体中super_class指针的分析，我们就可以描绘出类及相应meta-class类的一个继承体系了，如下图所示：

[![QQ20160509-2](http://birdmichael.com/wp-content/uploads/2016/05/QQ20160509-2.png)](http://birdmichael.com/wp-content/uploads/2016/05/QQ20160509-2.png)

对于NSObject继承体系来说，其实例方法对体系中的所有实例、类和meta-class都是有效的；而类方法对于体系内的所有类和meta-class都是有效的。

# 操作函数

## 类名(name)

/** 
 * Returns the name of a class.
 * 
 * @param cls A class object.
 * 
 * @return The name of the class, or the empty string if \e cls is \c Nil.
 */
OBJC_EXPORT const char *class_getName(Class cls) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);


对于class_getName函数，如果传入的cls为Nil，则返回一个char字字符串。

父类(super_class)和元类(meta-class)
/** 
 * Returns a Boolean value that indicates whether a class object is a metaclass.
 * 
 * @param cls A class object.
 * 
 * @return \c YES if \e cls is a metaclass, \c NO if \e cls is a non-meta class, 
 *  \c NO if \e cls is \c Nil.
 */
OBJC_EXPORT BOOL class_isMetaClass(Class cls) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

/** 
 * Returns the superclass of a class.
 * 
 * @param cls A class object.
 * 
 * @return The superclass of the class, or \c Nil if
 *  \e cls is a root class, or \c Nil if \e cls is \c Nil.
 *
 * @note You should usually use \c NSObject's \c superclass method instead of this function.
 */
OBJC_EXPORT Class class_getSuperclass(Class cls) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

/** 
 * Sets the superclass of a given class.
 * 
 * @param cls The class whose superclass you want to set.
 * @param newSuper The new superclass for cls.
 * 
 * @return The old superclass for cls.
 * 
 * @warning You should not use this function.
 */
OBJC_EXPORT Class class_setSuperclass(Class cls, Class newSuper) 
     __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5,__MAC_10_5, __IPHONE_2_0,__IPHONE_2_0);


class_isMetaClass函数，如果是cls是元类，则返回YES；如果否或者传入的cls为Nil，则返回NO。
class_getSuperclass函数，当cls为Nil或者cls为根类时，返回Nil。不过通常我们可以使用NSObject类的superclass方法来达到同样的目的。
class_setSuperclass函数，为一个cls设置一个新的superclass，并且返回cls以前的superclass。

版本(version)
/** 
 * Returns the version number of a class definition.
 * 
 * @param cls A pointer to a \c Class data structure. Pass
 *  the class definition for which you wish to obtain the version.
 * 
 * @return An integer indicating the version number of the class definition.
 *
 * @see class_setVersion
 */
OBJC_EXPORT int class_getVersion(Class cls)
    __OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);

/** 
 * Sets the version number of a class definition.
 * 
 * @param cls A pointer to an Class data structure. 
 *  Pass the class definition for which you wish to set the version.
 * @param version An integer. Pass the new version number of the class definition.
 *
 * @note You can use the version number of the class definition to provide versioning of the
 *  interface that your class represents to other classes. This is especially useful for object
 *  serialization (that is, archiving of the object in a flattened form), where it is important to
 *  recognize changes to the layout of the instance variables in different class-definition versions.
 * @note Classes derived from the Foundation framework \c NSObject class can set the class-definition
 *  version number using the \c setVersion: class method, which is implemented using the \c class_setVersion function.
 */
OBJC_EXPORT void class_setVersion(Class cls, int version)
    __OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);


class_getVersion函数可以获取类定义的版本号，返回一个int类型。

class_setVersion函数对cls设置一个int类型的版本号,不过通常我们可以使用NSObject类的setVersion方法来达到同样的目的。


实例变量大小(instance_size)
/** 
 * Returns the size of instances of a class.
 * 
 * @param cls A class object.
 * 
 * @return The size in bytes of instances of the class \e cls, or \c 0 if \e cls is \c Nil.
 */
OBJC_EXPORT size_t class_getInstanceSize(Class cls) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

成员变量(ivars)及属性
成员变量
/** 
 * Returns the \c Ivar for a specified instance variable of a given class.
 * 
 * @param cls The class whose instance variable you wish to obtain.
 * @param name The name of the instance variable definition to obtain.
 * 
 * @return A pointer to an \c Ivar data structure containing information about 
 *  the instance variable specified by \e name.
 */
OBJC_EXPORT Ivar class_getInstanceVariable(Class cls, const char *name)
    __OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);

/** 
 * Returns the Ivar for a specified class variable of a given class.
 * 
 * @param cls The class definition whose class variable you wish to obtain.
 * @param name The name of the class variable definition to obtain.
 * 
 * @return A pointer to an \c Ivar data structure containing information about the class variable specified by \e name.
 */
OBJC_EXPORT Ivar class_getClassVariable(Class cls, const char *name) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

/** 
 * Describes the instance variables declared by a class.
 * 
 * @param cls The class to inspect.
 * @param outCount On return, contains the length of the returned array. 
 *  If outCount is NULL, the length is not returned.
 * 
 * @return An array of pointers of type Ivar describing the instance variables declared by the class. 
 *  Any instance variables declared by superclasses are not included. The array contains *outCount 
 *  pointers followed by a NULL terminator. You must free the array with free().
 * 
 *  If the class declares no instance variables, or cls is Nil, NULL is returned and *outCount is 0.
 */
OBJC_EXPORT Ivar *class_copyIvarList(Class cls, unsigned int *outCount) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

/** 
 * Adds a new instance variable to a class.
 * 
 * @return YES if the instance variable was added successfully, otherwise NO 
 *         (for example, the class already contains an instance variable with that name).
 *
 * @note This function may only be called after objc_allocateClassPair and before objc_registerClassPair. 
 *       Adding an instance variable to an existing class is not supported.
 * @note The class must not be a metaclass. Adding an instance variable to a metaclass is not supported.
 * @note The instance variable's minimum alignment in bytes is 1<<align. The minimum alignment of an instance 
 *       variable depends on the ivar's type and the machine architecture. 
 *       For variables of any pointer type, pass log2(sizeof(pointer_type)).
 */
OBJC_EXPORT BOOL class_addIvar(Class cls, const char *name, size_t size, 
                               uint8_t alignment, const char *types) 
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);


class_getInstanceVariable函数，它返回一个指向包含name指定的成员变量信息的objc_ivar结构体的指针(Ivar)。
class_getClassVariable函数，目前没有找到关于Objective-C中类变量的信息，一般认为Objective-C不支持类变量。注意，返回的列表不包含父类的成员变量和属性。
class_copyIvarList函数，它返回一个指向成员变量信息的数组，数组中每个元素是指向该成员变量信息的objc_ivar结构体的指针。这个数组不包含在父类中声明的变量。outCount指针返回数组的大小。需要注意的是，我们必须使用free()来释放这个数组。
class_addIvar函数，我们知道Objective-C不支持往已存在的类中添加实例变量，因此不管是系统库提供的提供的类，还是我们自定义的类，都无法动态添加成员变量。但如果我们通过运行时来创建一个类的话，又应该如何给它添加成员变量呢？这时我们就可以使用class_addIvar函数了。不过需要注意的是，这个方法只能在objc_allocateClassPair函数与objc_registerClassPair之间调用。另外，这个类也不能是元类。成员变量的按字节最小对齐量是1<<alignment。这取决于ivar的类型和机器的架构。如果变量的类型是指针类型，则传递log2(sizeof(pointer_type))。

未完待续