How Can Callbacks Enhance C Code Functionality?

Callbacks in C

Callbacks are callable objects accepted by a function or class, used to customize the current logic based on the callback.

When to use Callbacks:

• Writing generic code independent of the called function's logic.
• Enabling dynamic runtime behavior (e.g., changing button functionality in a game).
• Notifying callers of specific events.

Callables in C 11:

Callbacks can take various forms, all considered "callable":

• Function pointers
• std::function objects
• Lambda expressions
• Bind expressions
• Function objects (classes with overloaded function call operator)

Callback Notation:

1. Function Pointers

• typedef return_type (*f_int_t) (int);
• int (* foo_p)(int) = &foo;
• int foobar (int x, int (*moo)(int));
• int foobar (int x, f_int_t moo);

2. Pointer to Member Function

• typedef int (C::* f_C_int_t) (int x);
• int (C::* C_foo_p)(int) = &C::foo;
• int C_foobar (int x, C const &c, int (C::*moo)(int));
• int C_foobar (int x, C const &c, f_C_int_t moo);

3. std::function Objects

• std::function stdf_foo = &foo;
• int stdf_foobar (int x, std::function moo);

4. Templated Callbacks

This allows for more generic code.

• template void stdf_transform_every_int_templ(int * v, unsigned const n, std::function fp);
• template void transform_every_int_templ(int * v, unsigned const n, F f);

Compatible Callback Types:

• Function Pointers: Function pointers
• std::function Objects: Function pointers, lambda expressions, bind expressions, function objects
• Templated Callbacks: Any callable type (e.g., lambda expressions, bind expressions, function objects)

Examples:

• Function Pointer Example:

  void tranform_every_int(int * v, unsigned n, int (*fp)(int));
  int double_int(int x) { return 2*x; }
  int square_int(int x) { return x*x; }

• std::function Object Example:

  void stdf_tranform_every_int(int * v, unsigned n, std::function<int> fp);
  int a[5] = {1, 2, 3, 4, 5};
  stdf_tranform_every_int(&a[0], 5, Meow{8});</int>

• Templated Callback Example:

  int nine_x_and_y (int x, int y) { return 9*x + y; }
  using std::placeholders::_1;
  stdf_transform_every_int_templ(&a[0], 5, std::bind(nine_x_and_y, _1, 4));

The above is the detailed content of How Can Callbacks Enhance C Code Functionality?. For more information, please follow other related articles on the PHP Chinese website!