How to pass a callback function from C++ to Objective-C

You're not 100% specific as to the exact use case you're trying to cover here, but I'm going to set out a scenario where this kind of situation occurs, and then show you how to solve it. I hope that will cover your problem too.

So I'm going to assume you have an Objective-C class MyClass with its interface declared in MyClass.h:

@interface MyClass : NSObject
- (void)someMethod;
- (void)otherMethodWhichShouldTakeACallback:?????;
@end

You now have a C++ class MyCPPClass, declared in MyCPPClass.hpp on which you want to pass memberFunction as the callback argument to the otherMethod on MyClass:

class MyCPPClass : public MyBase
{
    void memberFunction();
};

First, we need to figure out the method signature on MyClass. The modern way for callbacks in Objective-C is with Blocks. Blocks work pretty well with Objective-C++, so let's go with that and modify MyClass.h with the following line:

- (void)otherMethodWithBlock:(void(^)(void))callbackBlock;

The calling code will need to reside in an Objective-C++ compilation unit (caller.mm):

void callOtherMemberWithCPP(MyCPPClass* cpp_obj, MyClass* objc_obj)
{
    [objc_obj otherMethodWithBlock:^{
            cpp_obj->memberFunction();
        }];
}

Note that this does not deal with object lifetimes. If you're managing lifetimes on the C++ side with std::shared_ptr, you can use that in your Objective-C++ code too, in which case we might end up with something like:

void callOtherMemberWithCPP(std::shared_ptr<MyCPPClass> cpp_obj, MyClass* objc_obj)
{
    [objc_obj otherMethodWithBlock:^{
            cpp_obj->memberFunction();
        }];
}

In this case, the C++ object will only have its reference count decremented when the Objective-C class is done with the block.

For completeness, the other way to do this would be to use C function pointer syntax. In this case, you would need to declare the Objective-C method along these lines:

- (void)otherMethodWithCallback:(void(*)(void*))callback object:(void*)opaqueCallbackArgument;

And the C++ class's method call would need to be wrapped in a free function or static member function:

void memberFunctionCallback(void* opaque_object)
{
    MyCPPClass* object = static_cast<MyCPPClass*>(opaque_object);
    object->memberFunction
}

…and then call the Objective-C method like this:

    [objc_obj otherMethodWithCallback:memberFunctionCallback object:cpp_obj];

Making this version work nicely with automatic lifetime mechanisms such as shared_ptr is a lot more tricky though.