In _Bjarne Stroustrup_&#39;s home page ([C++11 FAQ][1]):

    struct X { int foo(int); };

    std::function&lt;int(X*, int)&gt; f;
    f = &amp;X::foo; //pointer to member

    X x;
    int v = f(&amp;x, 5); //call X::foo() for x with 5

How does it work? How does _std::function_ call a _foo member function_?

The template parameter is `int(X*, int)`, is `&amp;X::foo` converted from the _member function pointer_ to a _non-member function pointer_?!

    (int(*)(X*, int))&amp;X::foo //casting (int(X::*)(int) to (int(*)(X*, int))

----------

To clarify: I know that we don&#39;t need to cast any pointer to use _std::function_, but I don&#39;t know how the internals of _std::function_ handle this incompatibility between a _member function pointer_ and a _non-member function pointer_. I don&#39;t know how the standard allows us to implement something like _std::function_!

  [1]: http://www.stroustrup.com/C++11FAQ.html#std-function

How does the template parameter of std::function work? (implementation)

So I figured when making function pointers, you do not need the `operator &amp;` to get the address of the initial function:

    #include &lt;stdio.h&gt;

    double foo (double x){
        return x*x;
    }

    int main () {

        double (*fun1)(double) = &amp;foo;
        double (*fun2)(double) =  foo;
        
        printf(&quot;%f\n&quot;,fun1(10));
        printf(&quot;%f\n&quot;,fun2(10));
        
        printf(&quot;fun1 = %p \t &amp;foo = %p\n&quot;,fun1, &amp;foo);
        printf(&quot;fun2 = %p \t  foo = %p\n&quot;,fun2,  foo);       
        
        int a[10];
        
        printf(&quot;  a = %p \n &amp;a = %p  \n&quot;,a,&amp;a);
        
        return 0;
    }

output:

    &gt;./a.out 
    100.000000
    100.000000
    fun1 = 0x4004f4 	 &amp;foo = 0x4004f4
    fun2 = 0x4004f4 	  foo = 0x4004f4
      a = 0x7fff26804470 
     &amp;a = 0x7fff26804470 

Then I realized this is also true for arrays, meaning that if you have `int a[10]` both `a` and `&amp;a` point to the same location. Why is that with arrays and functions? Is the address saved in a memory location that has the same address as the value(address) being saved in it?

Function pointers and address of a function

I only just started learning Python and found out that I can pass a function as the parameter of another function. Now if I call `foo(bar())` it will not pass as a function pointer but the return value of the used function. Calling `foo(bar)` will pass the function, but this way I am not able to pass any additional arguments. What if I want to pass a function pointer that calls `bar(42)`?

I want the ability to repeat a function regardless of what arguments I have passed to it.

    def repeat(function, times):
        for calls in range(times):
            function()

    def foo(s):
        	print s

    repeat(foo(&quot;test&quot;), 4)

In this case the function `foo(&quot;test&quot;)` is supposed to be called 4 times in a row. 
Is there a way to accomplish this without having to pass &quot;test&quot; to `repeat` instead of `foo`? 

How to pass an argument to a function pointer parameter?

Consider these two functions:

    void foo() {}
    void bar() {}
is it guaranteed that `&amp;foo != &amp;bar`?

Similarly,

    template&lt;class T&gt; void foo() { }
is it guaranteed that `&amp;foo&lt;int&gt; != &amp;foo&lt;double&gt;`?

---

There are two linkers I know of that fold function definitions together.

MSVC aggressively COMDAT folds functions, so two functions with the same implementation can be turned into one function.  As a side effect, the two functions share the same address.  I was under the impression that this was illegal, but I cannot find where in the standard it is made illegal.

[The Gold linker](http://research.google.com/pubs/pub36912.html) also folds functions, with both a `safe` and `all` setting.  `safe` means that if a function address is taken, it is not folded, while `all` folds even if the address is taken.  So gold&#39;s fold `safe` behaves as-if functions have distinct addresses.

While folding might be unexpected, and there is code that relies on distinct (identical implementation) functions having different addresses (so it can be dangerous to fold), is it actually illegal under the current C++ standard?  (C++14 at this point)  (Naturally as-if `safe` folding is legal)


Do distinct functions have distinct addresses?

Consider this javascript code:

    var bar = function () { alert(&quot;A&quot;); }
    var foo = bar;
    bar = function () { alert(&quot;B&quot;); };
    foo();

When running this code I get &quot;A&quot;. Is this behavior a part of javascript specification and can I rely on it?

Javascript Function-Pointer Assignment

I have a method that&#39;s about ten lines of code.  I want to create more methods that do exactly the same thing, except for a small calculation that&#39;s going to change one line of code.  This is a perfect application for passing in a function pointer to replace that one line, but Java doesn&#39;t have function pointers.  What&#39;s my best alternative?

What&#39;s the nearest substitute for a function pointer in Java?

I&#39;ve a little question.
I&#39;m trying to define an array of function pointers dynamically with `calloc`. 
But I don&#39;t know how to write the syntax.
Thanks a lot.

How define an array of function pointers in C

I have a pointer to function, assume any signature.
And I have 5 different functions with same signature.

At run time one of them gets assigned to the pointer, and that function is called.

Without inserting any print statement in those functions, how can I come to know the name of function which the pointer currently points to?





Determining to which function a pointer is pointing in C?

I have a void pointer returned by dlsym(), I want to call the function pointed by the void pointer.
So I do a type conversion by casting:

    void *gptr = dlsym(some symbol..) ;
    typedef void (*fptr)();
    fptr my_fptr = static_cast&lt;fptr&gt;(gptr) ;

I have also tried `reinterpret_cast` but no luck, although the C cast operator seems to work..


Function pointers casting in C++

Is it possible to pass a lambda function as a function pointer? If so, I must be doing something incorrectly because I am getting a compile error.

Consider the following example

    using DecisionFn = bool(*)();
    
    class Decide
    {
    public:
        Decide(DecisionFn dec) : _dec{dec} {}
    private:
        DecisionFn _dec;
    };
    
    int main()
    {
        int x = 5;
        Decide greaterThanThree{ [x](){ return x &gt; 3; } };
        return 0;
    }

When I [try to compile this](http://cpp.sh/5x5r), I get the following compilation error:

&lt;!-- language: lang-none --&gt;

    In function &#39;int main()&#39;:
    17:31: error: the value of &#39;x&#39; is not usable in a constant expression
    16:9:  note: &#39;int x&#39; is not const
    17:53: error: no matching function for call to &#39;Decide::Decide(&lt;brace-enclosed initializer list&gt;)&#39;
    17:53: note: candidates are:
    9:5:   note: Decide::Decide(DecisionFn)
    9:5:   note: no known conversion for argument 1 from &#39;main()::&lt;lambda()&gt;&#39; to &#39;DecisionFn {aka bool (*)()}&#39;
    6:7:   note: constexpr Decide::Decide(const Decide&amp;)
    6:7:   note: no known conversion for argument 1 from &#39;main()::&lt;lambda()&gt;&#39; to &#39;const Decide&amp;&#39;
    6:7:   note: constexpr Decide::Decide(Decide&amp;&amp;)
    6:7:   note: no known conversion for argument 1 from &#39;main()::&lt;lambda()&gt;&#39; to &#39;Decide&amp;&amp;&#39;

That&#39;s one heck of an error message to digest, but I think what I&#39;m getting out of it is that the lambda cannot be treated as a `constexpr` so therefore I cannot pass it as a function pointer? I&#39;ve tried making `x` constexpr as well, but that doesn&#39;t seem to help.

Passing capturing lambda as function pointer

Is there any way to print a pointer to a function in ANSI C? Of course this means you have to cast the function pointer to void pointer, but it appears that&#39;s not possible??

    #include &lt;stdio.h&gt;
    
    int main() {
        int (*funcptr)() = main;
    
        printf(&quot;%p\n&quot;, (void* )funcptr);
        printf(&quot;%p\n&quot;, (void* )main);
        
        return 0;
    }


&gt; $ gcc -ansi -pedantic -Wall test.c -o
&gt; test &lt;br/&gt; test.c: In function
&gt; &#39;main&#39;:&lt;br/&gt; test.c:6: warning: ISO C
&gt; forbids conversion of function pointer
&gt; to object pointer type&lt;br/&gt; test.c:7:
&gt; warning: ISO C forbids conversion of
&gt; function pointer to object pointer
&gt; type&lt;br/&gt; $ ./test&lt;br/&gt; 0x400518&lt;br/&gt;
&gt; 0x400518&lt;br/&gt;

It&#39;s &quot;working&quot;, but non-standard...

How to format a function pointer?

I&#39;m trying to store in a `std::tuple` a varying number of values, which will later be used as arguments for a call to a function pointer which matches the stored types.

I&#39;ve created a simplified example showing the problem I&#39;m struggling to solve:

    #include &lt;iostream&gt;
    #include &lt;tuple&gt;
    
    void f(int a, double b, void* c) {
      std::cout &lt;&lt; a &lt;&lt; &quot;:&quot; &lt;&lt; b &lt;&lt; &quot;:&quot; &lt;&lt; c &lt;&lt; std::endl;
    }
    
    template &lt;typename ...Args&gt;
    struct save_it_for_later {
      std::tuple&lt;Args...&gt; params;
      void (*func)(Args...);
    
      void delayed_dispatch() {
    	 // How can I &quot;unpack&quot; params to call func?
    	 func(std::get&lt;0&gt;(params), std::get&lt;1&gt;(params), std::get&lt;2&gt;(params));
    	 // But I *really* don&#39;t want to write 20 versions of dispatch so I&#39;d rather 
         // write something like:
    	 func(params...); // Not legal
      }
    };
    
    int main() {
      int a=666;
      double b = -1.234;
      void *c = NULL;
      
      save_it_for_later&lt;int,double,void*&gt; saved = {
                                     std::tuple&lt;int,double,void*&gt;(a,b,c), f};
      saved.delayed_dispatch();
    }

Normally for problems involving `std::tuple` or variadic templates I&#39;d write another template like `template &lt;typename Head, typename ...Tail&gt;` to recursively evaluate all of the types one by one, but I can&#39;t see a way of doing that for dispatching a function call.

The real motivation for this is somewhat more complex and it&#39;s mostly just a learning exercise anyway. You can assume that I&#39;m handed the tuple by contract from another interface, so can&#39;t be changed but that the desire to unpack it into a function call is mine. This rules out using `std::bind` as a cheap way to sidestep the underlying problem.
 
What&#39;s a clean way of dispatching the call using the `std::tuple`, or an alternative better way of achieving the same net result of storing/forwarding some values and a function pointer until an arbitrary future point?

&quot;unpacking&quot; a tuple to call a matching function pointer

I have always been a bit stumped when I read other peoples&#39; code which had typedefs for pointers to functions with arguments. I recall that it took me a while to get around to such a definition while trying to understand a numerical algorithm written in C a while ago. So, could you share your tips and thoughts on how to write good typedefs for pointers to functions (Do&#39;s and Do not&#39;s), as to why are they useful and how to understand others&#39; work? Thanks!

Understanding typedefs for function pointers in C

Why do the following work?

    void foo() {
        cout &lt;&lt; &quot;Foo to you too!\n&quot;;
    };

    int main() {
        void (*p1_foo)() = foo;
        void (*p2_foo)() = *foo;
        void (*p3_foo)() = &amp;foo;
        void (*p4_foo)() = *&amp;foo;
        void (*p5_foo)() = &amp;*foo;
        void (*p6_foo)() = **foo;
        void (*p7_foo)() = **********************foo;

        (*p1_foo)();
        (*p2_foo)();
        (*p3_foo)();
        (*p4_foo)();
        (*p5_foo)();
        (*p6_foo)();
        (*p7_foo)();
    }

Why do function pointer definitions work with any number of ampersands &#39;&amp;&#39; or asterisks &#39;*&#39;?

For one class I want to store some function pointers to member functions of the same class in one `map` storing `std::function` objects. But I fail right at the beginning with this code:

    #include &lt;functional&gt;

    class Foo {
        public:
            void doSomething() {}
            void bindFunction() {
                // ERROR
                std::function&lt;void(void)&gt; f = &amp;Foo::doSomething;
            }
    };

I receive `error C2064: term does not evaluate to a function taking 0 arguments` in `xxcallobj` combined with some weird template instantiation errors. Currently I am working on Windows 8 with Visual Studio 2010/2011 and on Win 7 with VS10 it fails too. The error must be based on some weird C++ rules i do not follow

Using generic std::function objects with member functions in one class

Is there a way to pass a call back function in a Java method?

The behavior I&#39;m trying to mimic is a .Net Delegate being passed to a function.

I&#39;ve seen people suggesting creating a separate object but that seems overkill, however I am aware that sometimes overkill is the only way to do things.

Callback functions in Java

I just saw a picture today and think I&#39;d appreciate explanations. So here is the picture:  

[![some c code][1]][1]

I found this confusing and wondered if such codes are ever practical. I googled the picture and found another picture in [this](https://www.reddit.com/r/ProgrammerHumor/comments/3yfpub/c_isnt_that_hard/cyd5f8d) reddit entry, and here is that picture:  

[![some interesting explanation][2]][2]

So this &quot;reading spirally&quot; is something valid? Is this how C compilers parse?  
It&#39;d be great if there are simpler explanations for this weird code.  
Apart from all, can these kind of codes be useful? If so, where and when?  

There is [a question](https://stackoverflow.com/questions/3707096/spiral-rule-and-declaration-follows-usage-for-parsing-c-and-c-declarations) about &quot;spiral rule&quot;, but I&#39;m not just asking about how it&#39;s applied or how expressions are read with that rule. I&#39;m questioning usage of such expressions and spiral rule&#39;s validity as well. Regarding these, some nice answers are already posted.


  [1]: https://i.stack.imgur.com/Qn5ZL.jpg
  [2]: https://i.stack.imgur.com/pcZs7.png

C isn&#39;t that hard: void ( *( *f[] ) () ) ()

How should I use array of function pointers in C?

How can I initialize them?

How can I use an array of function pointers?

This may be something common and trivial, but I seem to be having trouble finding a concrete answer. In C# there is a concept of delegates, which relates strongly to the idea of function pointers from C++. Is there a similar functionality in Java? Given that pointers are somewhat absent, what is the best way about this? And to be clear, we&#39;re talking first class here.

Function Pointers in Java

The question is the following: consider this piece of code:


    #include &lt;iostream&gt;
    
    
    class aClass
    {
    public:
    	void aTest(int a, int b)
    	{
    		printf(&quot;%d + %d = %d&quot;, a, b, a + b);
    	}
    };
    
    void function1(void (*function)(int, int))
    {
    	function(1, 1);
    }
    
    void test(int a,int b)
    {
    	printf(&quot;%d - %d = %d&quot;, a , b , a - b);
    }
    
    int main()
    {
    	aClass a;
    
    	function1(&amp;test);
    	function1(&amp;aClass::aTest); // &lt;-- How should I point to a&#39;s aClass::test function?
    }

How can I use the `a`&#39;s `aClass::test` as an argument to `function1`? I would like to access a member of the class.

How can I pass a member function where a free function is expected?

I&#39;ve found `C` code that [prints from 1 to 1000 without loops or conditionals][1] : 
But I don&#39;t understand how it works. Can anyone go through the code and explain each line?

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    
    void main(int j) {
      printf(&quot;%d\n&quot;, j);
      (&amp;main + (&amp;exit - &amp;main)*(j/1000))(j+1);
    }

  [1]: https://stackoverflow.com/questions/4568645/printing-1-to-1000-without-loop-or-conditionals/4583502#4583502

How does the C code that prints from 1 to 1000 without loops or conditional statements work?

How do I obtain a function pointer for a class member function, and later call that member function with a specific object?  I’d like to write:

    class Dog : Animal
    {
        Dog ();
        void bark ();
    }

    …
    Dog* pDog = new Dog ();
    BarkFunction pBark = &amp;Dog::bark;
    (*pBark) (pDog);
    …

Also, if possible, I’d like to invoke the constructor via a pointer as well:

    NewAnimalFunction pNew = &amp;Dog::Dog;
    Animal* pAnimal = (*pNew)();	

Is this possible, and if so, what is the preferred way to do this?


Calling C++ member functions via a function pointer

I have read that converting a function pointer to a data pointer and vice versa works on most platforms but is not guaranteed to work. Why is this the case? Shouldn&#39;t both be simply addresses into main memory and therefore be compatible?

Why are function pointers and data pointers incompatible in C/C++?

I was playing with C++ lambdas and their implicit conversion to function pointers. My starting example was using them as callback for the ftw function. This works as expected.

    #include &lt;ftw.h&gt;
    #include &lt;iostream&gt;
    
    using namespace std;
    
    int main()
    {
        auto callback = [](const char *fpath, const struct stat *sb,
            int typeflag) -&gt; int {
            cout &lt;&lt; fpath &lt;&lt; endl;
            return 0;
        };
        
        int ret = ftw(&quot;/etc&quot;, callback, 1);
        
        return ret;
    }

After modifying it to use captures:


    int main()
    {
    
        vector&lt;string&gt; entries;
    
        auto callback = [&amp;](const char *fpath, const struct stat *sb,
            int typeflag) -&gt; int {
            entries.push_back(fpath);
            return 0;
        };
        
        int ret = ftw(&quot;/etc&quot;, callback, 1);
    
        for (auto entry : entries ) {
            cout &lt;&lt; entry &lt;&lt; endl;
        }
    
        return ret;
    }

I got the compiler error:

    error: cannot convert ‘main()::&lt;lambda(const char*, const stat*, int)&gt;’ to ‘__ftw_func_t {aka int (*)(const char*, const stat*, int)}’ for argument ‘2’ to ‘int ftw(const char*, __ftw_func_t, int)’

After some reading. I learned that lambdas using captures **can&#39;t be implicitly converted** to function pointers.

Is there a workaround for this? Does the fact that they can&#39;t be &quot;implicitly&quot; converted mean s that they can &quot;explicitly&quot; converted? (I tried casting, without success). What would be a clean way to modify the working example so that I could append the entries to some object using lambdas?.




C++ lambda with captures as a function pointer

I&#39;d like to set up a function pointer as a member of a class that is a pointer to another function in the same class. The reasons why I&#39;m doing this are complicated.

In this example, I would like the output to be &quot;1&quot;

    class A {
    public:
     int f();
     int (*x)();
    }

    int A::f() {
     return 1;
    }
        
    
    int main() {
     A a;
     a.x = a.f;
     printf(&quot;%d\n&quot;,a.x())
    }


But this fails at compiling. Why?




Function pointer to member function

Let&#39;s say I have a function that accepts a `void (*)(void*)` function pointer for use as a callback:

    void do_stuff(void (*callback_fp)(void*), void* callback_arg);

Now, if I have a function like this:

    void my_callback_function(struct my_struct* arg);

Can I do this safely?

    do_stuff((void (*)(void*)) &amp;my_callback_function, NULL);

I&#39;ve looked at [this question][1] and I&#39;ve looked at some C standards which say you can cast to &#39;compatible function pointers&#39;, but I cannot find a definition of what &#39;compatible function pointer&#39; means.


  [1]: https://stackoverflow.com/questions/188839/function-pointer-cast-to-different-signature

Casting a function pointer to another type

It is necessary to me to use `std::function` but I don&#39;t know what the following syntax means.

```
std::function&lt;void()&gt; f_name = []() { FNAME(); };
```

What is the goal of using `std::function`? Is it to make a pointer to a function?

What is the purpose of std::function, and how to use it?

I&#39;m using an API that requires me to pass a function pointer as a callback. I&#39;m trying to use this API from my class but I&#39;m getting compilation errors. 

Here is what I did from my constructor:

    m_cRedundencyManager-&gt;Init(this-&gt;RedundencyManagerCallBack);

This doesn&#39;t compile - I get the following error: 

&gt; Error	 8 error C3867: &#39;CLoggersInfra::RedundencyManagerCallBack&#39;: function call missing argument list; use &#39;&amp;CLoggersInfra::RedundencyManagerCallBack&#39; to create a pointer to member

I tried the suggestion to use `&amp;CLoggersInfra::RedundencyManagerCallBack` - didn&#39;t work for me. 

Any suggestions/explanation for this??

I&#39;m using VS2008.

Thanks!!


How can I pass a class member function as a callback?

I cannot figure this out:

    int main() {
        int (*) (int *) = 5;
        return 0;
    }

The above assignment compiles with g++ c++11. I know that `int (*) (int *)` is a pointer to a function that accepts an `(int *)` as argument and returns an int, but I do not understand how you could equate it to 5. At first I thought it is a function that constantly returns 5 (from my recent learning in F#, probably, haha), then I thought, briefly, that the function pointer points to memory location 5, but that does not work, clearly, and neither does hex values.

Thinking that it could be because the function returns an int, and that assigning an int is ok (somehow), I also tried this:

    int * (*) (int *) = my_ptr

where `my_ptr` is of type `int *`, the same type as this second function pointer, as in the first case with type int. This does not compile. Assigning 5, or any int value, instead of `my_ptr`, doesn&#39;t compile for this function pointer either.

So what does the assignment mean?

**Update 1**

We have confirmation that it is a bug, as shown in the best answer. However, it is still not known what actually *happens* to the value that you assign to the function pointer, or what happens with the assignment. Any (good) explanations on that would be very much appreciated! Please refer to the edits below for more clarity on the problem.

**Edit 1**

I am using gcc version 4.8.2 (in Ubuntu 4.8.2)

**Edit 2**

Actually, equating it to anything works on my compiler. Even equating it to a std::string variable, or a function name that returns a double, works.

**Edit 2.1**

Interestingly, making it a function pointer to any function that returns a data type that is not a pointer, will let it compile, such as

    std::string (*) () = 5.6;

But as soon as the function pointer is to a function that returns some pointer, it does not compile, such as with

    some_data_type ** (*) () = any_value;

Meaning of int (*) (int *) = 5 (or any integer value)

I have a function name stored in a variable like this:

    myvar = &#39;mypackage.mymodule.myfunction&#39;

and I now want to call myfunction like this

    myvar(parameter1, parameter2)

What&#39;s the easiest way to achieve this?

Python function pointer

Why and how does dereferencing a function pointer just &quot;do nothing&quot;?

This is what I am talking about:

    #include&lt;stdio.h&gt;
    
    void hello() { printf(&quot;hello&quot;); }
    
    int main(void) { 
        (*****hello)(); 
    }


----------

From a comment over [here][1]:

&gt;  function pointers dereference just
&gt; fine, but the resulting function
&gt; designator will be immediately
&gt; converted back to a function pointer


----------
And from an answer [here][2]:

&gt; Dereferencing (in way you think) a
&gt; function&#39;s pointer means: accessing a
&gt; CODE memory as it would be a DATA
&gt; memory.
&gt; 
&gt; Function pointer isn&#39;t suppose to be
&gt; dereferenced in that way. Instead, it
&gt; is called.
&gt; 
&gt; I would use a name &quot;dereference&quot; side
&gt; by side with &quot;call&quot;. It&#39;s OK.
&gt; 
&gt; Anyway: C is designed in such a way
&gt; that both function name identifier as
&gt; well as variable holding function&#39;s
&gt; pointer mean the same: address to CODE
&gt; memory. And it allows to jump to that
&gt; memory by using call () syntax either
&gt; on an identifier or variable.


----------
**How *exactly* does dereferencing of a function pointer work?**

  [1]: https://stackoverflow.com/questions/2669971/how-does-this-hello-world-program-work/2669996#2669996
  [2]: https://stackoverflow.com/questions/944479/how-come-pointer-to-a-function-be-called-without-dereferencing/944539#944539

How does dereferencing of a function pointer happen?

In C++, when and how do you use a callback function?

**EDIT:**  
I would like to see a simple example to write a callback function.


Callback functions in C++

I&#39;m trying to do some testing with member function pointer. What is wrong with this code? The `bigCat.*pcat();` statement doesn&#39;t compile.

    class cat {
    public:
       void walk() {
          printf(&quot;cat is walking \n&quot;);
       }
    };
    
    int main(){
       cat bigCat;
       void (cat::*pcat)();
       pcat = &amp;cat::walk;
       bigCat.*pcat();
    }



How to call through a member function pointer?

I was just going through some code on the Internet and found this:

    float * (*(*foo())[SIZE][SIZE])()

How do I read this declaration? Is there a specific set of rules for reading such complex declarations?


Complex C declaration

I&#39;m trying to make a function that takes a character, then returns a pointer to a function depending on what the character was.  I just am not sure how to make a function return a pointer to a function.

How to make a function return a pointer to a function? (C++)

Often I find the need to write functions which return function pointers. Whenever I do, the basic format I use is:

    typedef int (*function_type)(int,int);
    
    function_type getFunc()
    {
       function_type test;
       test /* = ...*/;
       return test;
    }

However this can get cumbersome when dealing with a large number of functions so I would like to not have to declare a typedef for each one (or for each class of functions)

I can remove the typedef and declare the local variable returned in the function as:
`int (*test)(int a, int b);` making the function body look like this:

    {
    	 int (*test)(int a, int b);
    	 test /* = ...*/;
    	 return test;
    }

but then I do not know what to set for the return type of the function.
I have tried:

    int(*)(int,int) getFunc()
    {
    	int (*test)(int a, int b);
    	test /* = ...*/;
    	return test;
    }

but that reports a syntax error. How do I declare the return type for such a function without declaring a typedef for the function pointer. Is it even possible? Also note that I am aware that it seems like it would be cleaner to declare typedefs, for each of the functions, however, I am very careful to structure my code to be as clean and easy to follow as possible. The reason I would like to eliminate the typedefs is that they are often only used to declare the retrieval functions and therefore seem redundant in the code.

Returning function pointer type

I read about function pointers in C.
And everyone said that will make my program run slow.
Is it true?

I made a program to check it.
And I got the same results on both cases. (measure the time.)

So, is it bad to use function pointer?
Thanks in advance.

To response for some guys.
I said &#39;run slow&#39; for the time that I have compared on a loop.
like this:

    int end = 1000;
    int i = 0;

    while (i &lt; end) {
     fp = func;
     fp ();
    }

When you execute this, i got the same time if I execute this.

    while (i &lt; end) {
     func ();
    }

So I think that function pointer have no difference of time
and it don&#39;t make a program run slow as many people said.


Does Function pointer make the program slow?

I try to call a function which passed as function pointer with no argument, but I can&#39;t make it work.

    void *disconnectFunc;

    void D::setDisconnectFunc(void (*func)){
    	disconnectFunc = func;
    }

    void D::disconnected(){
    	*disconnectFunc;
    	connected = false;
    }

Function pointer as parameter

I had some experience lately with function pointers in C.

So going on with the tradition of answering your own questions, I decided to make a small summary of the very basics, for those who need a quick dive-in to the subject.

How do function pointers in C work?

How to get function&#39;s name from [function&#39;s pointer][1] in C?

Edit: The real case is: I&#39;m writing a linux kernel module and I&#39;m calling kernel functions. Some of these functions are pointers and I want to inspect the code of that function in the kernel source. But I don&#39;t know which function it is pointing to. I thought it could be done because, when the system fails (kernel panic) it prints out in the screen the current callstack with function&#39;s names. But, I guess I was wrong... am I?


  [1]: http://en.wikipedia.org/wiki/Function_pointer

How to get function&#39;s name from function&#39;s pointer in Linux kernel?

According to Scott Meyers, one area where C++ shines over C is that function objects are faster than function pointers. He says this is because function objects are inlined, which increases speed.

I have two questions about this:

 1. How can we verify that function objects are, in fact, inlined? Can we verify this in practice?

 2. Does the inlining of function objects depend on the compiler we use, or do all compilers behave like this?


Are functors actually faster than pointers to functions?

I am solving a binary exploitation challenge on picoCTF and came across this piece of code:

    ((void (*)())buf)();

where `buf` is a character array.

I solved the challenge but can&#39;t seem to understand what exactly it&#39;s doing. I looked at [this][1] thread but I couldn&#39;t make it out.

What does `((void (*)())buf)();` mean?

  [1]: https://stackoverflow.com/questions/9371171/what-does-void-void-mean-in-c

What does ((void (*)())buf)(); mean?

Arrays of function pointers can be created like so:

    typedef void(*FunctionPointer)();
    FunctionPointer functionPointers[] = {/* Stuff here */};

What is the syntax for creating a function pointer array without using the `typedef`?

What&#39;s the syntax for declaring an array of function pointers without using a separate typedef?

I have a variable that holds a callback, and by default it&#39;s value should be null. But this syntax doesn&#39;t seem to work.

    var callback1 : () -&gt; Unit = null
    var callback2 : ((a) -&gt; c, b) -&gt; Unit = null

My current solution is to make sure that callbacks have default implementations.

    var callback1 : () -&gt; Unit = { }
    var callback2 : ((a) -&gt; c, b) -&gt; Unit = { a, b -&gt; }


This, however, makes it hard to check whether or not the callback was set, and possibly default implementation comes at some cost (is that so?). How to assign a null value to a function type variable in Kotlin?

All Function Pointers Solutions on Gang of Coders

Total of 44 Function Pointers Solutions