'void (*)(int)' 和 'void (^)(int)' 一样吗？

Question

Today, I'm working on a callback pass from C++ to Objective-c method.
Finally, I worked it out, but a few code confuse me.
In Objective-c, people ordinary use block to implement a callback, a block declare looks like this:

returnType (^blockName)(parameterTypes)

I also learned about C++ callback, a same type callback defined like this:

returnType (*funcName)(parameterTypes)

When I passed a callback from C++ to Objective-c, compiler warning me:

"Cannot initialize a parameter of type 'void (^)(int)' with an rvalue of type 'void (*)(int)"

Finally, I changed ^ to * , it works. I wondering to know, what's the difference between ^ and * in definition, is that have the same behavior?

Answer 1

This is a block:

returnType (^blockName)(parameterTypes)

This is a function pointer:

returnType (*funcName)(parameterTypes)

They aren't compatible.

Answer 2

Standard C and C++ do not have callable blocks. Apparently, however, some compilers for those languages do implement the feature as an extension. Some of the docs I see suggest that it's an Apple extension to Objective C, too, but inasmuch as Objective C is little used outside the Apple world, that may be a distinction without a difference.

In whatever language, if you implement a callback as a function, then you must present that callback to the intended caller via a function pointer, and the caller must be prepared to accept it in that form. On the other hand, if you implement a callback as a block then you must present it to the caller via a block pointer, and the caller must be prepared to accept that form. The two are not interchangeable, and they have different syntaxes, which you have presented. It would be possible to design a mechanism that could accept both forms, however, via separate parameters or altogether separate registration functions.

Answer 3

Objective-C blocks ( ^ ) are incompatible with function pointers ( * ).
Compared to function pointers, they have the benefit of being able to capture values and variables from the surrounding context (they are closures ).

It's easy enough to write a wrapper that calls a function pointer from a block:

typedef int (*funptr)(int);
typedef int (^funblock)(int);


int use_block_callback(int y, funblock fb)
{
    return fb(y);
}

int use_funptr_callback(int y, funptr f)
{
     return use_block_callback(y, ^ int (int x) { return f(x); }); 
}

int add_one(int x) { return x + 1; }

int foo(int x)
{
    return use_funptr_callback(23, add_one);
}

// Or
int (*some_pointer)(int) = add_one;
int (^some_block)(int) = ^ int (int x) { return some_pointer(x); } 

( "Programming with Objective-C" about blocks. )