Objective-C 运行时简介

#Original (English)

Source: https://www.mikeash.com/pyblog/friday-qa-2009-03-13-intro-to-the-objective-c-runtime.html

Welcome back to another Friday Q&A, on another Friday the 13th. This week I’m going to take Oliver Mooney’s suggestion and talk about the Objective-C runtime, how it works, and what it can do for you.

Many Cocoa programmers are only vaguely aware of the Objective-C runtime. They know it’s there (and some don’t even know this!), that it’s important, and you can’t run Objective-C without it, but that’s about where it stops.

Today I want to run through exactly how Objective-C works at the runtime level and what kinds of things you can do with it.

(Note: I’ll be talking only about Apple’s runtime on 10.5 and later. The runtime on 10.4 and earlier is missing many APIs, instead forcing direct structure access, and the runtimes for GNU and Cocotron are different beasts entirely.)

Objects In Objective-C we work with objects all the time, but what is an object? Well, let’s take a look and construct something that will tell us about them.

First, we know that objects are referred to using pointers, like NSObject *. And we know that we create them using the +alloc method. The documentation for that just says that it calls +allocWithZone:. Following the chain of documentation a bit further, we discover NSDefaultMallocZone and see that they’re just allocated using malloc. Easy!

But what do they look like when they’re allocated? Let’s find out:

1
    #import <Foundation/Foundation.h>
2

3
    @interface A : NSObject { @public int a; } @end
4
    @implementation A @end
5
    @interface B : A { @public int b; } @end
6
    @implementation B @end
7
    @interface C : B { @public int c; } @end
8
    @implementation C @end
9

10
    int main(int argc, char **argv)
11
    {
12
        [NSAutoreleasePool new];
13

14
        C *obj = [[C alloc] init];
15
        obj->a = 0xaaaaaaaa;
16
        obj->b = 0xbbbbbbbb;
17
        obj->c = 0xcccccccc;
18

19
        NSData *objData = [NSData dataWithBytes:obj length:malloc_size(obj)];
20
        NSLog(@"Object contains %@", objData);
21

22
        return 0;
23
    }

1
    2009-01-27 15:58:04.904 a.out[22090:10b] Object contains <20300000 aaaaaaaa bbbbbbbb cccccccc>

But what’s this 20300000 thing at the beginning? Well, it comes before A’s ivar, so it must be NSObject’s. Let’s look at NSObject’s definition:

1
    /***********  Base class    ***********/
2

3
    @interface NSObject  {
4
        Class  isa;
5
    }

1
    typedef struct objc_class *Class;

1
    struct objc_class {
2
        Class isa;
3

4
    #if !__OBJC2__
5
        Class super_class                                        OBJC2_UNAVAILABLE;
6
        const char *name                                         OBJC2_UNAVAILABLE;
7
        long version                                             OBJC2_UNAVAILABLE;
8
        long info                                                OBJC2_UNAVAILABLE;
9
        long instance_size                                       OBJC2_UNAVAILABLE;
10
        struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;
11
        struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;
12
        struct objc_cache *cache                                 OBJC2_UNAVAILABLE;
13
        struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;
14
    #endif
15

16
    } OBJC2_UNAVAILABLE;

Let’s look at another root class, NSProxy:

1
    @interface NSProxy  {
2
        Class  isa;
3
    }

1
    typedef struct objc_object {
2
        Class isa;
3
    } *id;

As the name and type imply, the isa ivar indicates what class a particular object is. Every Objective-C object must begin with an isa pointer, otherwise the runtime won’t know how to work with it. Everything about a particular object’s type is wrapped up in that one little pointer. The remainder of an object is basically just a big blob and as far as the runtime is concerned, it is irrelevant. It’s up to the individual classes to give that blob meaning.

Classes What exactly do classes contain, then? The “unavailable” structure members give a good clue. (They’re there for compatibility with the pre-Leopard runtime, and you shouldn’t use them if you’re targeting Leopard, but it still tells us what kind of information is there.) First comes the isa, which allows a class to act like an object as well. There’s a pointer to the superclass, giving the proper class hierarchy. Some other basic information about the class follows. At the end is the really interesting stuff. There’s a list of instance variables, a list of methods, and a list of protocols. All of this stuff is accessible at runtime, and can be modified at runtime too.

Looking at the rest of runtime.h you’ll see a lot of functions for accessing and manipulating these properties. Each function is prefixed with what it operates on. General runtime functions start with objc_, functions that operate on a class start with class_, and so forth. For example, you can call class_getInstanceMethod to get information about a particular method, like the argument/return types. Or you can call class_addMethod to add a new method to an existing class at runtime. You can even create a whole new class at runtime by using objc_allocateClassPair.

Practical Applications There are tons of useful things that can be done with this kind of runtime meta-information, but here are some ideas.

• Automatic ivar/method searches. Apple’s Key-Value Coding does this kind of thing already: you give it a name, and it looks up a method or ivar based on that name and does some stuff with it. You can do that kind of thing yourself, in case you need to look up an ivar based on a name or something of the sort.

• Automatically register/invoke subclasses. Using objc_getClassList you can get a list of all classes currently known to the runtime, and by tracing out the class hierarchy, you can identify which ones subclass a given class. This can let you write subclasses to handle specialized data formats or other such situations and let the superclass look them up without having to tediously register every subclass manually.

• Automatically call a method on every class. This can be useful for custom unit testing frameworks and the like. Similar to #2, but look for a method being implemented rather than a particular class hierarchy.

• Override methods at runtime. The runtime provides a complete set of tools for re-pointing methods to custom implementations so that you can change what classes do without touching their source code.

• Automatically deallocate synthesized properties. The @synthesize keyword is handy for making the compiler generate setters/getters but it still forces you to write cleanup code in -dealloc. By reading meta-information about the class’s properties, you can write code that will go through and clean up all synthesized properties automatically instead of having to write code for each case.

• Bridging. By dynamically generating classes at runtime, and by looking up the necessary properties on demand, you can create a bridge between Objective-C and another (sufficiently dynamic) language.

• Much more. Don’t feel limited to the above, come up with your own ideas!

Wrapping Up Objective-C is a powerful language and the comprehensive runtime API is an extremely useful part of it. While it may be a bit ugly groveling around in all that C code, it’s really not that difficult to work with, and it’s well worth the power it provides.

That’s it for this week’s Friday Q&A. Please send in your suggestions, either by posting them below or by e-mail (tell me if you don’t want me to use your name). Friday Q&A runs on your suggestions so please write in!

Have a favorite use of the ObjC runtime? Something you dislike about it? Have a tip to share? Post it all below.