Question

I am looking at this page about C++ differences from Objective C and it states this:

The dynamic nature of Objective C allows existing classes to be extended at runtime. Objective C allows you to define categories, related sets of extensions to objects you’ve already created. For example, in converting a text-based app into a graphics app, the code your objects needed to draw themselves could be compiled as a category and loaded at run-time only when needed. This saves memory and allows you to leave your original objects unmodified.

Now I am familiar with Categories and have used them, but I do not see how they lead to dynamic loading. If you import a Category file, is it not compiled along with the class it extends, taking up memory whenever you use that class, whether you use the Category methods or not?

Answer 1

If you link with a static library containing a category, the linker will copy all of the category code into your executable file. If you link with a shared library, the shared library’s entire code segment gets mapped into your process’s address space, but it’s paged in lazily, so you might not actually read all of the category code off of the disk unless you use it all.

But I think that’s not really what the page is talking about.

Link-time libraries

First, let’s talk about libraries that you tell the linker to link your app with.

Consider NSString. The NSString class is defined in the Foundation framework, which is a framework full of general-purpose classes useful in programs that have GUIs and in programs that don’t have GUIs. So the NSString class as defined in Foundation doesn’t include any code for drawing a string into a graphics context, because that code would (usually) be useless in a non-GUI app.

The AppKit framework (on OS X) manages a GUI. It’s useful in a GUI to be able to draw strings to a graphics context, so AppKit contains a category on NSString that adds methods for drawing a string, like drawAtPoint:withAttributes:. UIKit (on iOS) does the same thing (but the methods are a little bit different).

So if you write a program on the OS X and use Foundation but don’t use AppKit, your process won’t load the AppKit NSString category and you won’t pay the price for all of those graphics methods on NSString.

For a shared library like AppKit, the price is pretty trivial on modern hardware.

Now, you could do the same thing with your own libraries, which you might make static. Let’s say you make a “TwitterModel” library for talking to Twitter. It’s full of classes that model the things you find on Twitter, like accounts and tweets. But you don’t include code for managing a GUI to display tweets.

Instead, you make another library, “TwitterGUI”, that (in addition to defining yet more classes) uses categories to add methods to the model classes in your “TwitterModel” library.

If you write a program that links to both TwitterGUI and TwitterModel, the executable file will contain all of the Objective-C code from both libraries. But if you write a command-line only program (no GUI) and only link it with TwitterModel, that program won’t contain any of the GUI-related code. Oh, the savings!

Run-time libraries

Now let’s consider shared libraries that you don’t tell the linker to link your app with.

You can dynamically load new code into your process at runtime, using an API like dlopen or -[NSBundle load]. If the library contains categories, those categories will be added to the classes in your running program.

So, you could make your app optionally use a shared library if it exists on the user’s system when he runs your app, by trying to load the library programmatically. If you succeed, you can call any category methods that you know the library defines. (And of course you can use the classes that the library provides, if any.) If you fail to load the library, you carefully avoid calling any of those category methods from the library.

Typically, though, we use a dynamic loading API to load a plugin, and the plugin provides some class that subclasses a base class, or conforms to a protocol, that we’ve defined specifically for plugins to implement. We just need to get the name of that class, and then we create an instance of it and send it the messages that we defined in our base class or protocol.