Callback functions in C

Question

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

User · Answer

The accepted answer is very useful and quite comprehensive. However, the OP states

I would like to see a simple example to write a callback function.

So here you go, from C++11 you have std::function so there is no need for function pointers and similar stuff:

#include <functional>
#include <string>
#include <iostream>

void print_hashes(std::function<int (const std::string&)> hash_calculator) {
    std::string strings_to_hash[] = {"you", "saved", "my", "day"};
    for(auto s : strings_to_hash)
        std::cout << s << ":" << hash_calculator(s) << std::endl;    
}

int main() {
    print_hashes( [](const std::string& str) {   /** lambda expression */
        int result = 0;
        for (int i = 0; i < str.length(); i++)
            result += pow(31, i) * str.at(i);
        return result;
    });
    return 0;
}

This example is by the way somehow real, because you wish to call function print_hashes with different implementations of hash functions, for this purpose I provided a simple one. It receives a string, returns an int (a hash value of the provided string), and all that you need to remember from the syntax part is std::function<int (const std::string&)> which describes such function as an input argument of the function that will invoke it.

User · Answer

There isn t an explicit concept of a callback function in C     Callback mechanisms are often implemented via function pointers  functor objects  or callback objects   The programmers have to explicitly design and implement callback functionality   Edit based on feedback   In spite of the negative feedback this answer has received  it is not wrong   I ll try to do a better job of explaining where I m coming from   C and C   have everything you need to implement callback functions   The most common and trivial way to implement a callback function is to pass a function pointer as a function argument   However  callback functions and function pointers are not synonymous   A function pointer is a language mechanism  while a callback function is a semantic concept   Function pointers are not the only way to implement a callback function - you can also use functors and even garden variety virtual functions   What makes a function call a callback is not the mechanism used to identify and call the function  but the context and semantics of the call   Saying something is a callback function implies a greater than normal separation between the calling function and the specific function being called  a looser conceptual coupling between the caller and the callee  with the caller having explicit control over what gets called   It is that fuzzy notion of looser conceptual coupling and caller-driven function selection that makes something a callback function  not the use of a function pointer   For example  the  NET documentation for IFormatProvider says that  GetFormat is a callback method   even though it is just a run-of-the-mill interface method   I don t think anyone would argue that all virtual method calls are callback functions   What makes GetFormat a callback method is not the mechanics of how it is passed or invoked  but the semantics of the caller picking which object s GetFormat method will be called   Some languages include features with explicit callback semantics  typically related to events and event handling   For example  C  has the event type with syntax and semantics explicitly designed around the concept of callbacks   Visual Basic has its Handles clause  which explicitly declares a method to be a callback function while abstracting away the concept of delegates or function pointers   In these cases  the semantic concept of a callback is integrated into the language itself   C and C    on the other hand  does not embed the semantic concept of callback functions nearly as explicitly   The mechanisms are there  the integrated semantics are not   You can implement callback functions just fine  but to get something more sophisticated which includes explicit callback semantics you have to build it on top of what C   provides  such as what Qt did with their Signals and Slots   In a nutshell  C   has what you need to implement callbacks  often quite easily and trivially using function pointers   What it does not have is keywords and features whose semantics are specific to callbacks  such as raise  emit  Handles  event     etc   If you re coming from a language with those types of elements  the native callback support in C   will feel neutered

User · Answer

Callback functions are part of the C standard  an therefore also part of C    But if you are working with C    I would suggest you use the observer pattern instead  http   en wikipedia org wiki Observer pattern

User · Answer

There is also the C way of doing callbacks  function pointers    Define a type for the callback signature    it is not necessary  but makes life easier    Function pointer called CallbackType that takes a float   and returns an int typedef int   CallbackType  float       void DoWork CallbackType callback      float variable   0 0f       Do calculations      Call the callback with the variable  and retrieve the     result   int result   callback variable        Do something with the result    int SomeCallback float variable      int result       Interpret variable    return result     int main int argc  char    argv        Pass in SomeCallback to the DoWork   DoWork  amp SomeCallback       Now if you want to pass in class methods as callbacks  the declarations to those function pointers have more complex declarations  example     Declaration  typedef int  ClassName   CallbackType  float      This method performs work using an object instance void DoWorkObject CallbackType callback        Class instance to invoke it through   ClassName objectInstance       Invocation   int result    objectInstance  callback  1 0f        This method performs work using an object pointer void DoWorkPointer CallbackType callback        Class pointer to invoke it through   ClassName   pointerInstance       Invocation   int result    pointerInstance- gt  callback  1 0f      int main int argc  char    argv        Pass in SomeCallback to the DoWork   DoWorkObject  amp ClassName  Method     DoWorkPointer  amp ClassName  Method

User · Answer

Boost s signals2 allows you to subscribe generic member functions  without templates   and in a threadsafe way      Example  Document-View Signals can be used to implement flexible   Document-View architectures  The document will contain a signal to   which each of the views can connect  The following Document class   defines a simple text document that supports mulitple views  Note that   it stores a single signal to which all of the views will be connected    class Document   public      typedef boost  signals2  signal lt void    gt   signal t   public      Document                  Connect a slot to the signal which will be emitted whenever       text is appended to the document         boost  signals2  connection connect const signal t  slot type  amp subscriber                return m sig connect subscriber              void append const char  s                m text    s          m sig               const std  string amp  getText   const               return m text         private      signal t    m sig      std  string m text          Next  we can begin to define views  The following TextView class   provides a simple view of the document text    class TextView   public      TextView Document amp  doc   m document doc                m connection   m document connect boost  bind  amp TextView  refresh  this                TextView                 m connection disconnect               void refresh   const               std  cout  lt  lt   TextView     lt  lt  m document getText    lt  lt  std  endl        private      Document amp                m document      boost  signals2  connection  m connection

User · Answer

Note  Most of the answers cover function pointers which is one possibility to achieve  callback  logic in C    but as of today not the most favourable one I think   What are callbacks    and why to use them     A callback is a callable  see further down  accepted by a class or function  used to customize the current logic depending on that callback   One reason to use callbacks is to write generic code which is independant from the logic in the called function and can be reused with different callbacks   Many functions of the standard algorithms library  lt algorithm gt  use callbacks  For example the for each algorithm applies an unary callback to every item in a range of iterators   template lt class InputIt  class UnaryFunction gt  UnaryFunction for each InputIt first  InputIt last  UnaryFunction f      for    first    last    first        f  first         return f      which can be used to first increment and then print a vector by passing appropriate callables for example   std  vector lt double gt  v  1 0  2 2  4 0  5 5  7 2    double r   4 0  std  for each v begin    v end      amp   double  amp  v    v    r      std  for each v begin    v end       double v    std  cout  lt  lt  v  lt  lt             which prints  5 6 2 8 9 5 11 2   Another application of callbacks is the notification of callers of certain events which enables a certain amount of static   compile time flexibility   Personally  I use a local optimization library that uses two different callbacks    The first callback is called if a function value and the gradient based on a vector of input values is required  logic callback  function value determination   gradient derivation   The second callback is called once for each algorithm step and receives certain information about the convergence of the algorithm  notification callback     Thus  the library designer is not in charge of deciding what happens with the information that is given to the programmer  via the notification callback and he needn t worry about how to actually determine function values because they re provided by the logic callback  Getting those things right is a task due to the library user and keeps the library slim and more generic    Furthermore  callbacks can enable dynamic runtime behaviour   Imagine some kind of game engine class which has a function that is fired  each time the users presses a button on his keyboard and a set of functions that control your game behaviour  With callbacks you can  re decide at runtime which action will be taken   void player jump    void player crouch     class game core       std  array lt void       total num keys gt  actions              void key pressed unsigned key id                if actions key id   actions key id                  update keybind from menu     void update keybind unsigned key id  void  new action                   actions key id    new action             Here the function key pressed uses the callbacks stored in actions to obtain the desired behaviour when a certain key is pressed  If the player chooses to change the button for jumping  the engine can call  game core instance update keybind newly selected key   amp player jump     and thus change the behaviour of a call to key pressed  which the calls player jump  once this button is pressed the next time ingame   What are callables in C   11    See C   concepts  Callable on cppreference for a more formal description   Callback functionality can be realized in several ways in C   11  since several different things turn out to be callable     Function pointers  including pointers to member functions  std  function objects Lambda expressions Bind expressions Function objects  classes with overloaded function call operator operator        Note  Pointer to data members are callable as well but no function is called at all   Several important ways to write callbacks in detail   X 1  Writing  a callback in this post means the syntax to declare and name the callback type  X 2  Calling  a callback refers to the syntax to call those objects  X 3  Using  a callback means the syntax when passing arguments to a function using a callback    Note  As of C  17  a call like f      can be written as std  invoke f       which also handles the pointer to member case   1  Function pointers  A function pointer is the  simplest   in terms of generality  in terms of readability arguably the worst  type a callback can have   Let s have a simple function foo   int foo  int x    return 2 x      1 1 Writing a function pointer   type notation  A function pointer type has the notation   return type     parameter type 1  parameter type 2  parameter type 3     i e  a pointer to foo has the type  int     int    where a named function pointer type will look like  return type    name   parameter type 1  parameter type 2  parameter type 3      i e  f int t is a type  function pointer taking one int argument  returning int typedef int   f int t   int        foo p is a pointer to function taking int returning int    initialized by pointer to function foo taking int returning int int    foo p  int     amp foo      can alternatively be written as  f int t foo p    amp foo    The using declaration gives us the option to make things a little bit more readable  since the typedef for f int t can also be written as   using f int t   int    int     Where  at least for me  it is clearer that f int t is the new type alias and recognition of the function pointer type is also easier  And a declaration of a function using a callback of function pointer type will be       foobar having a callback argument named moo of type     pointer to function returning int taking int as its argument int foobar  int x  int   moo  int       if f int is the function pointer typedef from above we can also write foobar as  int foobar  int x  f int t moo     1 2 Callback call notation  The call notation follows the simple function call syntax   int foobar  int x  int   moo  int         return x   moo x      function pointer moo called using argument x      analog int foobar  int x  f int t moo        return x   moo x      function pointer moo called using argument x     1 3 Callback use notation and compatible types  A callback function taking a function pointer can be called using function pointers   Using a function that takes a function pointer callback is rather simple    int a   5   int b   foobar a  foo      call foobar with pointer to foo as callback     can also be  int b   foobar a   amp foo      call foobar with pointer to foo as callback   1 4 Example  A function ca be written that doesn t rely on how the callback works   void tranform every int int   v  unsigned n  int   fp  int       for  unsigned i   0  i  lt  n    i          v i    fp v i            where possible callbacks could be  int double int int x    return 2 x    int square int int x    return x x      used like  int a 5     1  2  3  4  5   tranform every int  amp a 0   5  double int      now a     2  4  6  8  10   tranform every int  amp a 0   5  square int      now a     4  16  36  64  100     2  Pointer to member function  A pointer to member function  of some class C  is a special type of  and even more complex  function pointer which requires an object of type C to operate on   struct C       int y      int foo int x  const   return x y         2 1 Writing pointer to member function   type notation  A pointer to member function type for some class T has the notation      can have more or less parameters return type  T     parameter type 1  parameter type 2  parameter type 3     i e  a pointer to C  foo has the type int  C      int    where a named pointer to member function will -in analogy to the function pointer- look like this   return type  T    name   parameter type 1  parameter type 2  parameter type 3      i e  a type  f C int  representing a pointer to member function of  C     taking int returning int is  typedef int  C    f C int t   int x        The type of C foo p is a pointer to member function of C taking int returning int    Its value is initialized by a pointer to foo of C int  C    C foo p  int     amp C  foo     which can also be written using the typedef  f C int t C foo p    amp C  foo    Example  Declaring a function taking a pointer to member function callback as one of its arguments      C foobar having an argument named moo of type pointer to member function of C    where the callback returns int taking int as its argument    also needs an object of type c int C foobar  int x  C const  amp c  int  C   moo  int       can equivalently declared using the typedef above  int C foobar  int x  C const  amp c  f C int t moo     2 2 Callback call notation  The pointer to member function of C can be invoked  with respect to an object of type C by using member access operations on the dereferenced pointer  Note  Parenthesis required   int C foobar  int x  C const  amp c  int  C   moo  int         return x    c  moo  x      function pointer moo called for object c using argument x      analog int C foobar  int x  C const  amp c  f C int t moo        return x    c  moo  x      function pointer moo called for object c using argument x     Note  If a pointer to C is available the syntax is equivalent  where the pointer to C must be dereferenced as well    int C foobar 2  int x  C const   c  int  C   meow  int         if   c  return x         function pointer meow called for object  c using argument x     return x      c   meow  x         or equivalent  int C foobar 2  int x  C const   c  int  C   meow  int         if   c  return x         function pointer meow called for object  c using argument x     return x    c- gt  meow  x        2 3 Callback use notation and compatible types  A callback function taking a member function pointer of class T can be called using a member function pointer of class T   Using a function that takes a pointer to member function callback is -in analogy to function pointers- quite simple as well    C my c 2      aggregate initialization  int a   5   int b   C foobar a  my c   amp C  foo      call C foobar with pointer to foo as its callback   3  std  function objects  header  lt functional gt    The std  function class is a polymorphic function wrapper to store  copy or invoke callables   3 1 Writing a std  function object   type notation  The type of a std  function object storing a callable looks like   std  function lt return type parameter type 1  parameter type 2  parameter type 3  gt      i e  using the above function declaration of foo  std  function lt int int  gt  stdf foo    amp foo     or C  foo  std  function lt int const C amp   int  gt  stdf C foo    amp C  foo    3 2 Callback call notation  The class std  function has operator   defined which can be used to invoke its target   int stdf foobar  int x  std  function lt int int  gt  moo        return x   moo x      std  function moo called      or  int stdf C foobar  int x  C const  amp c  std  function lt int C const  amp   int  gt  moo        return x   moo c  x      std  function moo called using c and x     3 3 Callback use notation and compatible types  The std  function callback is more generic than function pointers or pointer to member function since different types can be passed and implicitly converted into a std  function object   3 3 1 Function pointers and pointers to member functions  A function pointer  int a   2  int b   stdf foobar a   amp foo      b    6   2    2 2      or a pointer to member function  int a   2  C my c 7      aggregate initialization int b   stdf C foobar a  c   amp C  foo      b    11      2    7 2      can be used   3 3 2 Lambda expressions  An unnamed closure from a lambda expression can be stored in a std  function object   int a   2  int c   3  int b   stdf foobar a   c  int x  - gt  int   return 7 c x         b    15     a    7 c a     2    7 3 2    3 3 3 std  bind expressions  The result of a std  bind expression can be passed  For example by binding parameters to a function pointer call   int foo 2  int x  int y    return 9 x   y    using std  placeholders   1   int a   2  int b   stdf foobar a  std  bind foo 2   1  3       b    23    2     9 2   3   int c   stdf foobar a  std  bind foo 2  5   1       c    49    2     9 5   2     Where also objects can be bound as the object for the invocation of pointer to member functions   int a   2  C const my c 7      aggregate initialization int b   stdf foobar a  std  bind  amp C  foo  my c   1       b    1    2     2   7     3 3 4 Function objects  Objects of classes having a proper operator   overload can be stored inside a std  function object  as well   struct Meow     int y   0    Meow int y     y y        int operator   int x    return y   x       int a   11  int b   stdf foobar a  Meow 8       b    99    11     8   11     3 4 Example  Changing the function pointer example to use std  function  void stdf tranform every int int   v  unsigned n  std  function lt int int  gt  fp      for  unsigned i   0  i  lt  n    i          v i    fp v i            gives a whole lot more utility to that function because  see 3 3  we have more possibilities to use it      using function pointer still possible int a 5     1  2  3  4  5   stdf tranform every int  amp a 0   5  double int      now a     2  4  6  8  10       use it without having to write another function by using a lambda stdf tranform every int  amp a 0   5     int x  - gt  int   return x 2         now a     1  2  3  4  5   again     use std  bind   int nine x and y  int x  int y    return 9 x   y    using std  placeholders   1     calls nine x and y for every int in a with y being 4 every time stdf tranform every int  amp a 0   5  std  bind nine x and y   1  4       now a     13  22  31  40  49     4  Templated callback type  Using templates  the code calling the callback can be even more general than using std  function objects   Note that templates are a compile-time feature and are a design tool for compile-time polymorphism  If runtime dynamic behaviour is to be achieved through callbacks  templates will help but they won t induce runtime dynamics   4 1 Writing  type notations  and calling templated callbacks  Generalizing i e  the std ftransform every int code from above even further can be achieved by using templates   template lt class R  class T gt  void stdf transform every int templ int   v    unsigned const n  std  function lt R T  gt  fp      for  unsigned i   0  i  lt  n    i          v i    fp v i            with an even more general  as well as easiest  syntax for a callback type being a plain  to-be-deduced templated argument   template lt class F gt  void transform every int templ int   v     unsigned const n  F f      std  cout  lt  lt   transform every int templ lt         lt  lt  type name lt F gt     lt  lt    gt  n     for  unsigned i   0  i  lt  n    i          v i    f v i            Note  The included output prints the type name deduced for templated type F  The implementation of type name is given at the end of this post   The most general implementation for the unary transformation of a range is part of the standard library  namely std  transform   which is also templated with respect to the iterated types   template lt class InputIt  class OutputIt  class UnaryOperation gt  OutputIt transform InputIt first1  InputIt last1  OutputIt d first    UnaryOperation unary op      while  first1    last1         d first     unary op  first1           return d first      4 2 Examples using templated callbacks and compatible types  The compatible types for the templated std  function callback method stdf transform every int templ are identical to the above mentioned types  see 3 4    Using the templated version however  the signature of the used callback may change a little      Let int foo  int x    return 2 x    int muh  int const  amp x    return 3 x    int  amp  woof  int  amp x    x    4  return x     int a 5     1  2  3  4  5   stdf transform every int templ lt int int gt   amp a 0   5   amp foo      a     3  4  5  6  7  stdf transform every int templ lt int  int const  amp  gt   amp a 0   5   amp muh      a     6  7  8  9  10  stdf transform every int templ lt int  int  amp  gt   amp a 0   5   amp woof     Note  std ftransform every int  non templated version  see above  does work with foo but not using muh      Let void print int int   p  unsigned const n      bool f  true      for  unsigned i   0  i  lt  n    i          std  cout  lt  lt   f              lt  lt  p i        f   false        std  cout  lt  lt    n       The plain templated parameter of transform every int templ can be every possible callable type   int a 5      1  2  3  4  5    print int a  5   transform every int templ  amp a 0   5  foo   print int a  5   transform every int templ  amp a 0   5  muh   print int a  5   transform every int templ  amp a 0   5  woof   print int a  5   transform every int templ  amp a 0   5     int x  - gt  int   return x   x   x      print int a  5   transform every int templ  amp a 0   5  Meow  4     print int a  5   using std  placeholders   1  transform every int templ  amp a 0   5  std  bind foo 2   1  3    print int a  5   transform every int templ  amp a 0   5  std  function lt int int  gt   amp foo    print int a  5     The above code prints   1 2 3 4 5 transform every int templ  lt int    int  gt  3 4 5 6 7 transform every int templ  lt int    int amp   gt  6 8 10 12 14 transform every int templ  lt int amp      int amp   gt  9 11 13 15 17 transform every int templ  lt main   lambda int  1   gt  27 33 39 45 51 transform every int templ  lt Meow gt  108 132 156 180 204 transform every int templ  lt std   Bind lt int   std   Placeholder lt 1 gt   int   int  int  gt  gt  975 1191 1407 1623 1839 transform every int templ  lt std  function lt int int  gt  gt  977 1193 1409 1625 1841   type name implementation used above   include  lt type traits gt   include  lt typeinfo gt   include  lt string gt   include  lt memory gt   include  lt cxxabi h gt   template  lt class T gt  std  string type name       typedef typename std  remove reference lt T gt   type TR    std  unique ptr lt char  void    void   gt  own      abi    cxa demangle typeid TR  name    nullptr      nullptr  nullptr   std  free     std  string r   own    nullptr own get   typeid TR  name      if  std  is const lt TR gt   value      r      const     if  std  is volatile lt TR gt   value      r      volatile     if  std  is lvalue reference lt T gt   value      r       amp      else if  std  is rvalue reference lt T gt   value      r       amp  amp      return r

User · Answer

Scott Meyers gives a nice example   class GameCharacter  int defaultHealthCalc const GameCharacter amp  gc    class GameCharacter   public    typedef std  function lt int  const GameCharacter amp   gt  HealthCalcFunc     explicit GameCharacter HealthCalcFunc hcf   defaultHealthCalc      healthFunc hcf           int healthValue   const   return healthFunc  this      private    HealthCalcFunc healthFunc       I think the example says it all    std  function lt  gt  is the  modern  way of writing C   callbacks

User · Answer

A Callback function is a method that is passed into a routine  and called at some point by the routine to which it is passed   This is very useful for making reusable software   For example  many operating system APIs  such as the Windows API  use callbacks heavily     For example  if you wanted to work with files in a folder - you can call an API function  with your own routine  and your routine gets run once per file in the specified folder   This allows the API to be very flexible

User · Answer

See the above definition where it states that a callback function is passed off to some other function and at some point it is called   In C   it is desirable to have callback functions call a classes method   When you do this you have access to the member data   If you use the C way of defining a callback you will have to point it to a static member function   This is not very desirable   Here is how you can use callbacks in C     Assume 4 files   A pair of  CPP  H files for each class   Class C1 is the class with a method we want to callback   C2 calls back to C1 s method   In this example the callback function takes 1 parameter which I added for the readers sake   The example doesn t show any objects being instantiated and used   One use case for this implementation is when you have one class that reads and stores data into temporary space and another that post processes the data   With a callback function  for every row of data read the callback can then process it   This technique cuts outs the overhead of the temporary space required   It is particularly useful for SQL queries that return a large amount of data which then has to be post-processed                                                                            C1 H file  class C1       public      C1            C1           void CALLBACK F1 int i                                                                                C1 CPP file  void CALLBACK C1  F1 int i       Do stuff with C1  its methods and data  and even do stuff with the passed in parameter                                                                             C2 H File  class C1     Forward declaration  class C2       typedef void  CALLBACK C1    pfnCallBack  int i   public      C2            C2            void Fn C1   pThat pfnCallBack pFn                                                                                C2 CPP File  void C2  Fn C1   pThat pfnCallBack pFn           Call a non-static method in C1     int i   1       pThat- gt  pFn  i

User · Answer

The accepted answer is comprehensive but related to the question i just want to put an simple example here  I had a code that i d written it a long time ago  i wanted to traverse a tree with in-order way  left-node then root-node then right-node  and whenever i reach to one Node i wanted to be able to call a arbitrary function so that it could do everything   void inorder traversal Node  p  void  out  void   callback  Node  in  void  out         if  p    NULL          return      inorder traversal p- gt left  out  callback       callback p  out      call callback function like this      inorder traversal p- gt right  out  callback          Function like bellow can be used in callback of inorder traversal  void foo Node  t  void  out   NULL           You can just leave the out variable and working with specific node of tree  like bellow         cout  lt  lt  t- gt item         Or        You can assign value to out variable like below        Mention that the type of out is void   so that you must firstly cast it to your proper out         int   out     1       This function use inorder travesal function to count the number of nodes existing in the tree  void number nodes Node  t        int sum   0      inorder traversal t   amp sum  foo       cout  lt  lt  sum      int main          Node  root   NULL         What These functions perform is inserting an integer into a Tree data-structure      root   insert tree root  6       root   insert tree root  3       root   insert tree root  8       root   insert tree root  7       root   insert tree root  9       root   insert tree root  10       number nodes root

[c++] Callback functions in C++

Examples related to c++

Examples related to callback

Examples related to function-pointers