Question

I have a C struct that contains a function pointer. Now, I have used this setup within C with no problems, but now I’m using this C struct in Objective-C and I need to pass a function (or selector) pointer that is defined in the Objective-C class.

1. Here is what I have for the Objective-C selector that needs to be passed as a pointer to the C function:

- (void)myObjCSelector:(int*)myIntArray
{
    // Do whatever I need with myIntArray
}

2. And here is where I run into a wall, Within Objective-C I’m trying to pass the selector as a pointer to the C function call: In place of “myObjCSelectorPointer” I need the proper syntax to pass the selector as a function pointer in this C function call:

passObjCSelectorPointerToCContext(cContextReference, myObjCSelectorPointer);

I did investigate this issue, but could mainly find several different ways of doing similar things, but I couldn’t find anything specific for calling C functions and passing an Objective-C selector pointer.

Answer 1

In objc a selector is not a function pointer. A selector is a unique integer that is mapped to a string in a method lookup table stored by the objc runtime. In the above case your method name would be myObjCSelector: and to get the unique selector for it you would type @selector(myObjCSelector:). However this would be of no use to you because it doesnt represent a particular implementation of a function.

What youre looking for is IMP. Refer to this SO question.

EDIT 2:

 IMP myObjCSelectorPointer = (void (*)(id,SEL,int*))[self methodForSelector:@selector(myObjCSelector:)];

Then you can call the method using

myObjCSelectorPointer(self,@selector(myObjCSelector:),myIntArray);

However, what this means you will need to make sure that you add the pointer to self in the c function call passObjCSelectorPointerToCContext.
So it should look like this

passObjCSelectorPointerToCContext(cContextReference, self, myObjCSelectorPointer); 

when called from within the object that contains the method.

It is important to note though that using IMP is almost never the right technique. You should try to stick with pure Obj-C. Obj-C is quite efficient after the first call to a message because it uses temporal caching.

EDIT 1:

It’s useful to understand why objc works in this way. The Apple documents explain it in depth. However a short explanation is as follows:

When you send a message to an object such as [myobject somemethod] the compiler won’t immediately know which particular implementation of somemethod to call because there might be multiple classes with multiple overriden versions of somemethod. All of those methods have the same selector, irrespective of its arguments and return values and hence the decision about which implementation of somemethod is deffered to when the program is running. [myobject somemethod] gets converted by the compiler into a C function call:

objc_msgSend(myobject, @selector(somemethod))

This is a special function that searches each myobject class layout to see whether that class knows how to respond to a somemethod message. If not it then searches that class’s parent and so on until the root. If none of the classes can respond to somemethod then NSObject defines a private method called forward where all unknown messages are sent.

Assuming that a class can respond to the somemethod message then it will also have a particular pointer of type IMP that points to the actual implementation of the method. At that point the method will be called.

There is considerably more to this procedure than I have described but the outline should be enough to help you understand what the goal of a selector is.

One final point is that the reason method names are mapped to unique integers via the @selector directive is so that the runtime doesn’t have to waste time doing string comparisons.