You can do the following: Suppose you have your A,B & C function as the following: bool A() { ….. } bool B() { ….. } bool C() { ….. } Now at some other function, say at main: int main() { bool (*choice) (); // now if there is if-else statement for making “choice” … Read more
The only legal way to do this is to access the bytes making up the pointer using a character type. Like this: #include <stdio.h> int main() { int (*funcptr)() = main; unsigned char *p = (unsigned char *)&funcptr; size_t i; for (i = 0; i < sizeof funcptr; i++) { printf(“%02x “, p[i]); } putchar(‘\n’); … Read more
int foo() is declared without specifying its parameters. This is an obsolescent feature that lets you call it with any arguments. When calling the function, integer arguments are promoted to int (if needed), and float arguments are promoted to double. Due to this, it’s impossible for this function to receive a float parameter, which makes … Read more
Converting a void* to a function pointer directly is not allowed (should not compile using any of the casts) in C++98/03. It is conditionally supported in C++0x (an implementation may choose to define the behavior and if it does define it, then it must do what the standard says it should do. A void*, as … Read more
You will have to check which of your 5 functions your pointer points to: if (func_ptr == my_function1) { puts(“func_ptr points to my_function1”); } else if (func_ptr == my_function2) { puts(“func_ptr points to my_function2”); } else if (func_ptr == my_function3) { puts(“func_ptr points to my_function3”); } … If this is a common pattern you need, … Read more
The type of a function pointer is just like the function declaration, but with “(*)” in place of the function name. So a pointer to: int foo( int ) would be: int (*)( int ) In order to name an instance of this type, put the name inside (*), after the star, so: int (*foo_ptr)( … Read more
After getting help from other answers and comments, and reading GCC source code and C++11 standard, I found that it is possible to parse a function type (its return type and its argument types) by using partial template specialization and function overloading. The following is a simple (and incomplete) example to implement something like std::function: … Read more
Given int a[10], both a and &a yield the same address, yes, but their types are different. a is of type int[10]. When it is implicitly converted to a pointer type, the pointer is of type int* and points to the initial element of the array. &a is of type int (*)[10] (that is, a … Read more
It looks like defect report 1400: Function pointer equality deals with this issue and seems to me to say that it is okay to do this optimization but as comments indicate, there is disagreement. It says (emphasis mine): According to 5.10 [expr.eq] paragraph 2, two function pointers only compare equal if they point to the … Read more
You can either use a lambda: repeat(lambda: bar(42)) Or functools.partial: from functools import partial repeat(partial(bar, 42)) Or pass the arguments separately: def repeat(times, f, *args): for _ in range(times): f(*args) This final style is quite common in the standard library and major Python tools. *args denotes a variable number of arguments, so you can use … Read more