Is it possible to pass a function as a parameter in C++?

Question

Is there any way to pass a function as a parameter in C++, like the way that functions can be passed as parameters in C? I know that it's possible to pass a function as a parameter in C using function pointers, and I want to know whether the same is possible in C++.

Answer 1

You can do it like in C. But you can also do it the C++ way (C++11, to be exact):

// This function takes a function as an argument, which has no
// arguments and returns void.
void foo(std::function<void()> func)
{
    // Call the function.
    func();
}

You can pass a normal function to foo()

void myFunc();
// ...
foo(myFunc);

but you can also pass a lambda expression. For example:

foo([](){ /* code here */ });

You can also pass a function object (an object that overloads the () operator.) In general, you can pass anything that can be called with the () operator.

If you instead use the C way, then the only thing you can pass are normal function pointers.

Answer 2

It's possible in C++ just as in C to pass functions as parameters but with a few differences: we can use function references instead of pointers, templates types in addition to variadic template arguments. For example:

Function references:

In C, we don't have the ability to pass objects by reference. This however is possible in C++:

void f( void (&)() ) {}

f( h );

The difference between references are pointers is subtle, but important. For instance, we can't pass NULL or 0 to a function expecting a reference; the argument must be satisfied with its type immediately. References are usually preferred in most cases over pointers.

Templates:

Templates allow us to generically pass functions with variable type attributes as parameters:

template <class T, class U>
void f( T (&)( U ) ) {}

The above signature accepts a function with any return type or parameter list (the only setback is that the function must take one argument).

In addition to this feature, we can also utilize varaidic templates to allow functions with variable-length parameter lists:

template <class T, class ...U>
void f( T (&)( U... ) ) {}

int h(int, int) { .. }
bool g(std::string) { .. }


f( h );
f( g );

The implementation of f can also use perfect forwarding if we are using U&&:

template <class T, class ...U>
void f( T (&fun)( U&&...) ) {

    // ...
    fun( std::forward<U>(u)... );

}

There are also lambdas which are commonly bound with std::function<T(U)>.

Answer 3

Yes, function pointers work exactly the same way in C++ as in C.

Answer 4

Yes, like this:

#include <stdio.h>

typedef void (*my_func)(int);

void do_something (my_func f) 
{   
   f (10); 
}

void square (int j) 
{   
   printf ("squared: %d\n", j * j); 
}

void cube (int j) 
{   
    printf ("cubed: %d\n", j * j * j); 
}

int main (int argc, char *argv[]) 
{   
   do_something (square);   
   do_something (cube); 
}

The output is:

squared: 100
cubed: 1000

The typedef is to make the syntax for do_something() a bit more readable.

I would like to point out that, since you are using C++ already, it is much easier ways to achieve the same with virtual functions.

Answer 5

Yes, it is possible.

I found a working example program (which can be tested and edited online, and illustrates the concept well): http://ideone.com/6kSTrp#view_edit_box

//this was taken from http://www.cprogramming.com/tutorial/function-pointers.html
#include <stdio.h>
void my_int_func(int x)
{
    printf( "%d\n", x );
}


int main()
{
    void (*foo)(int); //pointer to an int function
    foo = &my_int_func;

    /* call my_int_func (note that you do not need to write (*foo)(2) ) */
    foo( 2 );
    /* but if you want to, you may */
    (*foo)( 2 );

    return 0;
}