C++ function pointer: syntax, callbacks and examples

A C++ function pointer is a variable that holds the address of a function, so a program can choose at run time which function to call. int (*op)(int, int) = add; declares one named op for any function that takes two ints and returns an int; op(2, 3) then calls the function it points to.

The smallest whole program aims op at two functions in turn:

#include <iostream>

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    int (*op)(int, int) = add;
    std::cout << op(2, 3) << '\n';  // 5

    op = subtract;
    std::cout << op(2, 3) << '\n';  // -1
}

It printed 5, then -1: the same call, op(2, 3), ran add and then subtract.

The samples are C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and every call printed the same result on all four. Since When lists the standard and compiler releases each C++ feature needs.

How do you declare, assign and call a function pointer?

Write the return type, then (*name), then the parameter types in parentheses: a function declaration with (*op) where the function’s name would be. Read it from the name outwards: (*op) says op is a pointer, (int, int) lists the parameters of what it points to, and int is what that returns. The parentheses around *op are required:

int (*op)(int, int) = &add;  // the same as = add;
int* wrong(int, int);        // no parentheses: a function

static_assert(std::is_pointer_v<decltype(op)>);
static_assert(std::is_function_v<decltype(wrong)>);

std::cout << std::boolalpha << (add == &add) << '\n';  // true
std::cout << op(2, 3) << ' ' << (*op)(2, 3) << '\n';   // 5 5

Without them, int* wrong(int, int); declares a function that returns int*. add == &add printed true: a function’s name converts to its address by itself (the function-to-pointer conversion, [conv.func]), so = add and = &add store the same thing. Calling needs no * either: op(2, 3) and (*op)(2, 3) both printed 5.

How do you make function pointer syntax readable?

Name the type once with using (or the older typedef), then declare variables and parameters with that name like any other type:

using Operation = int (*)(int, int);
typedef int (*OldOperation)(int, int);  // the older spelling

static_assert(std::is_same_v<Operation, OldOperation>);

void show(Operation op) {
    std::cout << op(6, 3) << '\n';
}

int main() {
    Operation op = add;
    show(op);        // 9
    show(multiply);  // 18
}

It printed 9 and 18. The static_assert confirms that the two spellings name the same type; in the typedef, the new name sits where a variable’s name would. For a variable, auto op = add; deduces the same type, int (*)(int, int); parameters and arrays still need it spelled out.

How do you pass a function to another function?

Give the receiving function a parameter of function pointer type. It calls back whichever function it was given, which is why a function passed this way is called a callback:

int apply(Operation op, int a, int b) {
    return op(a, b);  // calls back the function it was given
}
// ...
std::cout << apply(add, 6, 3) << ' '
          << apply(subtract, 6, 3) << ' '
          << apply(multiply, 6, 3) << '\n';  // 9 3 18

It printed 9 3 18. The standard library takes callbacks too: given the plain function bool shorter(const std::string& x, const std::string& y), the call std::sort(words.begin(), words.end(), shorter) put subtract, add, divide and plus in the order add, plus, divide, subtract. Sorting with std::sort covers custom comparisons.

What is an array of function pointers?

An array whose elements are function pointers of one type, so an index picks the function to call: a dispatch table in place of a switch.

const Operation table[] = {add, subtract, multiply};
const char* const names[] = {"add", "subtract", "multiply"};

for (std::size_t i = 0; i < std::size(table); ++i) {
    std::cout << names[i] << ' ' << table[i](6, 3) << '\n';
}

std::size_t choice = 2;
std::cout << table[choice](7, 6) << '\n';  // multiply: 42

It printed add 9, subtract 3 and multiply 18, then 42: index 2 picked multiply.

Can a lambda be a function pointer?

Yes, when its capture list is empty. A lambda (an unnamed function written where it is used) with an empty capture list, [], converts to a function pointer by itself (lambda expressions):

Operation op = [](int a, int b) { return a * b; };
std::cout << op(6, 3) << '\n';  // 18

It printed 18. A lambda that captures a local variable, here keeping its own copy of bonus, does not convert:

int bonus = 10;
Operation op = [bonus](int a, int b) { return a + b + bonus; };

All four compilers rejected the second line. GCC 16.2 put it most plainly: error: cannot convert 'main()::<lambda(int, int)>' to 'Operation' {aka 'int (*)(int, int)'} in initialization. No message names the capture as the cause. The cause: a capturing lambda carries its captured values with it, and a plain function pointer has nowhere to keep them.

Function pointer, std::function or a template: which should you use?

Choose by what has to be accepted: a function pointer takes only plain functions, static member functions and captureless lambdas, while std::function and a template parameter take any callable. The same job, written three ways:

int run_pointer(Operation op, int a, int b) {
    return op(a, b);
}

int run_function(const std::function<int(int, int)>& op,
                 int a, int b) {
    return op(a, b);
}

template<class F>
int run_template(F op, int a, int b) {
    return op(a, b);
}

All three ran add and printed 9. The capturing lambda of the previous section went through run_function and run_template (19 from each); it would not convert to the Operation that run_pointer takes.

A function pointer was the size of a pointer in every build; a std::function was larger on all three standard libraries, by a different amount on each. What std::function costs and what to use instead goes further.

How do you point to a member function?

With a pointer to member function: a plain function pointer holds only non-member and static member functions (C++23 adds explicit object member functions). The member kind puts the class name before the *, takes its address with &Counter::add, and needs an object to call it on, through .*. Since C++17, std::invoke from <functional> makes the same call without that syntax. Here Counter::add(int n) adds n to a running total and returns it, and Counter::sum is static:

Counter counter;
int (Counter::*method)(int) = &Counter::add;

std::cout << (counter.*method)(5) << '\n';             // 5
std::cout << std::invoke(method, counter, 5) << '\n';  // 10
// ...
Operation op = &Counter::sum;  // static: a plain pointer will do
std::cout << op(6, 3) << '\n';  // 9

It printed 5, 10 and 9: std::invoke called add on the same counter, whose total went from 5 to 10, and the static sum went into a plain Operation.

A function pointer cheat sheet

More answers about the core language are in Language.