What are C functors and their uses

Question

I keep hearing a lot about functors in C    Can someone give me an overview as to what they are and in what cases they would be useful

User · Answer

Functor can also be used to simulate defining a local function within a function. Refer to the question and another.

But a local functor can not access outside auto variables. The lambda (C++11) function is a better solution.

User · Answer

A Functor is a object which acts like a function  Basically  a class which defines operator     class MyFunctor      public       int operator   int x    return x   2      MyFunctor doubler  int x   doubler 5     The real advantage is that a functor can hold state    class Matcher      int target     public       Matcher int m    target m          bool operator   int x    return x    target      Matcher Is5 5    if  Is5 n         same as if  n    5

User · Answer

Except for used in callback  C   functors can also help to provide a Matlab liking access style  to a matrix  class  There is a example

User · Answer

Like has been repeated  functors are classes that can be treated as functions  overload operator       They are most useful for situations in which you need to associate some data with repeated or delayed calls to a function   For example  a linked-list of functors could be used to implement a basic low-overhead synchronous coroutine system  a task dispatcher  or interruptable file parsing  Examples      prints  this is a very simple and poorly used task queue     class Functor   public      std  string output      Functor const std  string amp  out   output out        operator     const               std  cout  lt  lt  output  lt  lt                 int main int argc  char   argv        std  list lt Functor gt  taskQueue      taskQueue push back Functor  this         taskQueue push back Functor  is a         taskQueue push back Functor  very simple         taskQueue push back Functor  and poorly used         taskQueue push back Functor  task queue         for std  list lt Functor gt   iterator it   taskQueue begin            it    taskQueue end      it                 it              return 0        prints the value stored in  i   then asks you if you want to increment it    int i  bool should increment  int doSomeWork         std  cout  lt  lt   i      lt  lt  i  lt  lt  std  endl      std  cout  lt  lt   increment   enter the number 1 to increment  0 otherwise   lt  lt  std  endl      std  cin  gt  gt  should increment      return 2    void doSensitiveWork            i       should increment   false    class BaseCoroutine   public      BaseCoroutine int stat   status stat   waiting false        void operator      status   perform          int getStatus   const   return status    protected      int status      bool waiting      virtual int perform     0      bool await status BaseCoroutine amp  other  int stat  int change                if  waiting                        waiting   true                    if other getStatus      stat                        status   change              waiting   false                    return  waiting           class MyCoroutine1  public BaseCoroutine   public      MyCoroutine1 BaseCoroutine amp  other   BaseCoroutine 1   partner other    protected      BaseCoroutine amp  partner      virtual int perform                 if getStatus      1              return doSomeWork            if getStatus      2                        if await status partner  1                   return 1              else if i    100                  return 0              else                 return 2                      class MyCoroutine2  public BaseCoroutine   public      MyCoroutine2 bool amp  work signal   BaseCoroutine 1   ready work signal     protected      bool amp  work signal      virtual int perform                 if i    100              return 0          if work signal                        doSensitiveWork                return 2                    return 1            int main          std  list lt BaseCoroutine   gt  coroutineList       MyCoroutine2  incrementer   new MyCoroutine2 should increment        MyCoroutine1  printer   new MyCoroutine1 incrementer         while coroutineList size                    for std  list lt BaseCoroutine   gt   iterator it   coroutineList begin                 it    coroutineList end      it                           it                 if  it getStatus      0                                  coroutineList erase it                                         delete printer       delete incrementer       return 0      Of course  these examples aren t that useful in themselves  They only show how functors can be useful  the functors themselves are very basic and inflexible and this makes them less useful than  for example  what boost provides

User · Answer

A functor is pretty much just a class which defines the operator    That lets you create objects which  look like  a function      this is a functor struct add x     add x int val    x val         Constructor   int operator   int y  const   return x   y     private    int x         Now you can use it like this  add x add42 42      create an instance of the functor class int i   add42 8      and  call  it assert i    50      and it added 42 to its argument  std  vector lt int gt  in     assume this contains a bunch of values  std  vector lt int gt  out in size        Pass a functor to std  transform  which calls the functor on every element     in the input sequence  and stores the result to the output sequence std  transform in begin    in end    out begin    add x 1     assert out i     in i    1      for all i   There are a couple of nice things about functors  One is that unlike regular functions  they can contain state  The above example creates a function which adds 42 to whatever you give it  But that value 42 is not hardcoded  it was specified as a constructor argument when we created our functor instance  I could create another adder  which added 27  just by calling the constructor with a different value  This makes them nicely customizable   As the last lines show  you often pass functors as arguments to other functions such as std  transform or the other standard library algorithms  You could do the same with a regular function pointer except  as I said above  functors can be  customized  because they contain state  making them more flexible  If I wanted to use a function pointer  I d have to write a function which added exactly 1 to its argument  The functor is general  and adds whatever you initialized it with   and they are also potentially more efficient  In the above example  the compiler knows exactly which function std  transform should call  It should call add x  operator    That means it can inline that function call  And that makes it just as efficient as if I had manually called the function on each value of the vector   If I had passed a function pointer instead  the compiler couldn t immediately see which function it points to  so unless it performs some fairly complex global optimizations  it d have to dereference the pointer at runtime  and then make the call

User · Answer

Little addition  You can use boost  function  to create functors from functions and methods  like this   class Foo   public      void operator     int i    printf  Foo  d   i        void Bar int i    printf  Bar  d   i     Foo foo  boost  function lt void  int  gt  f foo    wrap functor f 1    prints  Foo 1  boost  function lt void  int  gt  b  amp Bar    wrap normal function b 1    prints  Bar 1    and you can use boost  bind to add state to this functor  boost  function lt void    gt  f1   boost  bind foo  2   f1     no more argument  function argument stored in f1   and this print  Foo 2       and normal function boost  function lt void    gt  b1   boost  bind  amp Bar  2   b1      print  Bar 2    and most useful  with boost  bind and boost  function you can create functor from class method  actually this is a delegate   class SomeClass       std  string state   public      SomeClass const char  s    state  s          void method  std  string param                 std  cout  lt  lt  state   lt  lt  param  lt  lt  std  endl           SomeClass  inst   new SomeClass  Hi  i am     boost  function lt  void  std  string   gt  callback  callback   boost  bind  amp SomeClass  method  inst   1    create delegate    1 is a placeholder it holds plase for parameter callback  useless     prints  Hi  i am useless    You can create list or vector of functors  std  list lt  boost  function lt void  EventArg e  gt   gt  events    add some events        call them std  for each          events begin    events end             boost  bind  boost  apply lt void gt      1  e      There is one problem with all this stuff  compiler error messages is not human readable

User · Answer

Like others have mentioned  a functor is an object that acts like a function  i e  it overloads the function call operator   Functors are commonly used in STL algorithms  They are useful because they can hold state before and between function calls  like a closure in functional languages  For example  you could define a MultiplyBy functor that multiplies its argument by a specified amount   class MultiplyBy   private      int factor   public      MultiplyBy int x    factor x               int operator     int other  const           return factor   other             Then you could pass a MultiplyBy object to an algorithm like std  transform   int array 5     1  2  3  4  5   std  transform array  array   5  array  MultiplyBy 3       Now  array is  3  6  9  12  15    Another advantage of a functor over a pointer to a function is that the call can be inlined in more cases  If you passed a function pointer to transform  unless that call got inlined and the compiler knows that you always pass the same function to it  it can t inline the call through the pointer

User · Answer

A big advantage of implementing functions as functors is that they can maintain and reuse state between calls  For example  many dynamic programming algorithms  like the Wagner-Fischer algorithm for calculating the Levenshtein distance between strings  work by filling in a large table of results  It s very inefficient to allocate this table every time the function is called  so implementing the function as a functor and making the table a member variable can greatly improve performance   Below is an example of implementing the Wagner-Fischer algorithm as a functor  Notice how the table is allocated in the constructor  and then reused in operator    with resizing as necessary    include  lt string gt   include  lt vector gt   include  lt algorithm gt   template  lt typename T gt  T min3 const T amp  a  const T amp  b  const T amp  c       return std  min std  min a  b   c      class levenshtein distance        mutable std  vector lt std  vector lt unsigned int gt   gt  matrix    public      explicit levenshtein distance size t initial size   8            matrix  initial size  std  vector lt unsigned int gt  initial size                    unsigned int operator   const std  string amp  s  const std  string amp  t  const               const size t m   s size            const size t n   t size               The distance between a string and the empty string is the string s length         if  m    0                return n                    if  n    0                return m                       Size the matrix as necessary         if  matrix  size    lt  m   1                matrix  resize m   1  matrix  0                      if  matrix  0  size    lt  n   1                for  auto amp  mat   matrix                     mat resize n   1                                      The top row and left column are prefixes that can be reached by            insertions and deletions alone         unsigned int i  j          for  i   1   i  lt   m    i                matrix  i  0    i                    for  j   1  j  lt   n    j                matrix  0  j    j                       Fill in the rest of the matrix         for  j   1  j  lt   n    j                for  i   1  i  lt   m    i                    unsigned int substitution cost   s i - 1     t j - 1    0   1                  matrix  i  j                        min3 matrix  i - 1  j    1                     Deletion                     matrix  i  j - 1    1                          Insertion                     matrix  i - 1  j - 1    substitution cost      Substitution                                 return matrix  m  n

User · Answer

Little addition  You can use boost  function  to create functors from functions and methods  like this   class Foo   public      void operator     int i    printf  Foo  d   i        void Bar int i    printf  Bar  d   i     Foo foo  boost  function lt void  int  gt  f foo    wrap functor f 1    prints  Foo 1  boost  function lt void  int  gt  b  amp Bar    wrap normal function b 1    prints  Bar 1    and you can use boost  bind to add state to this functor  boost  function lt void    gt  f1   boost  bind foo  2   f1     no more argument  function argument stored in f1   and this print  Foo 2       and normal function boost  function lt void    gt  b1   boost  bind  amp Bar  2   b1      print  Bar 2    and most useful  with boost  bind and boost  function you can create functor from class method  actually this is a delegate   class SomeClass       std  string state   public      SomeClass const char  s    state  s          void method  std  string param                 std  cout  lt  lt  state   lt  lt  param  lt  lt  std  endl           SomeClass  inst   new SomeClass  Hi  i am     boost  function lt  void  std  string   gt  callback  callback   boost  bind  amp SomeClass  method  inst   1    create delegate    1 is a placeholder it holds plase for parameter callback  useless     prints  Hi  i am useless    You can create list or vector of functors  std  list lt  boost  function lt void  EventArg e  gt   gt  events    add some events        call them std  for each          events begin    events end             boost  bind  boost  apply lt void gt      1  e      There is one problem with all this stuff  compiler error messages is not human readable

User · Answer

For the newbies like me among us  after a little research I figured out what the code jalf posted did   A functor is a class or struct object which can be  called  like a function  This is made possible by overloading the    operator  The    operator  not sure what its called  can take any number of arguments  Other operators only take two i e  the   operator can only take two values  one on each side of the operator  and return whatever value you have overloaded it for  You can fit any number of arguments inside a    operator which is what gives it its flexibility   To create a functor first you create your class  Then you create a constructor to the class with a parameter of your choice of type and name  This is followed in the same statement by an initializer list  which uses a single colon operator  something I was also new to  which constructs the class member objects with the previously declared parameter to the constructor  Then the    operator is overloaded  Finally you declare the private objects of the class or struct you have created   My code  I found jalf s variable names confusing   class myFunctor        public             myFunctor is the constructor  parameterVar is the parameter passed to            the constructor    is the initializer list operator  myObject is the            private member object of the myFunctor class  parameterVar is passed            to the    operator which takes it and adds it to myObject in the            overloaded    operator function             myFunctor  int parameterVar    myObject  parameterVar                  the  operator  word is a keyword which indicates this function is an             overloaded operator function  The    following this just tells the            compiler that    is the operator being overloaded  Following that is            the parameter for the overloaded operator  This parameter is actually            the argument  parameterVar  passed by the constructor we just wrote             The last part of this statement is the overloaded operators body            which adds the parameter passed to the member object             int operator    int myArgument    return myObject   myArgument         private           int myObject    Our private member object        If any of this is inaccurate or just plain wrong feel free to correct me

User · Answer

A Functor is a object which acts like a function  Basically  a class which defines operator     class MyFunctor      public       int operator   int x    return x   2      MyFunctor doubler  int x   doubler 5     The real advantage is that a functor can hold state    class Matcher      int target     public       Matcher int m    target m          bool operator   int x    return x    target      Matcher Is5 5    if  Is5 n         same as if  n    5

User · Answer

A Functor is a object which acts like a function  Basically  a class which defines operator     class MyFunctor      public       int operator   int x    return x   2      MyFunctor doubler  int x   doubler 5     The real advantage is that a functor can hold state    class Matcher      int target     public       Matcher int m    target m          bool operator   int x    return x    target      Matcher Is5 5    if  Is5 n         same as if  n    5

User · Answer

Except for used in callback  C   functors can also help to provide a Matlab liking access style  to a matrix  class  There is a example

User · Answer

To add on  I have used function objects to fit an existing legacy method to the command pattern   only place where the beauty of OO paradigm true OCP I felt    Also adding here the related function adapter pattern  Suppose your method has the signature  int CTask  ThreeParameterTask int par1  int par2  int par3   We will see how we can fit it for the Command pattern - for this  first  you have to write a member function adapter so that it can be called as a function object  Note - this is ugly  and may be you can use the Boost bind helpers etc   but if you can t or don t want to  this is one way     a template class for converting a member function of the type int        function int int int    to be called as a function object template lt typename  Ret typename  Class typename  arg1 typename  arg2 typename  arg3 gt  class mem fun3 t     public  explicit mem fun3 t  Ret   Class    Pm   arg1  arg2  arg3        m Ptr  Pm    okay here we store the member function pointer for later use           this operator call comes from the bind method  Ret operator    Class   P   arg1 arg1   arg2 arg2   arg3 arg3  const       return    P- gt  m Ptr  arg1 arg2 arg3      private   Ret   Class   m Ptr   arg1  arg2  arg3     method pointer signature     Also  we need a helper method mem fun3 for the above class to aid in calling  template lt typename  Ret typename  Class typename  arg1 typename  arg2 typename  arg3 gt  mem fun3 t lt  Ret  Class  arg1  arg2  arg3 gt  mem fun3    Ret   Class    Pm             arg1  arg2  arg3        return  mem fun3 t lt  Ret  Class  arg1  arg2  arg3 gt   Pm       Now  in order to bind the parameters  we have to write a binder function  So  here it goes  template lt typename  Func typename  Ptr typename  arg1 typename  arg2 typename  arg3 gt  class binder3   public    This is the constructor that does the binding part binder3  Func fn  Ptr ptr  arg1 i  arg2 j  arg3 k       m ptr ptr  m fn fn  m1 i  m2 j  m3 k        and this is the function object   void operator     const            m fn m ptr m1 m2 m3    that calls the operator       private       Ptr m ptr       Func m fn       arg1 m1   arg2 m2   arg3 m3      And  a helper function to use the binder3 class - bind3    a helper function to call binder3 template  lt typename  Func  typename  P1 typename  arg1 typename  arg2 typename  arg3 gt  binder3 lt  Func   P1   arg1   arg2   arg3 gt  bind3  Func func   P1 p1  arg1 i  arg2 j  arg3 k        return binder3 lt  Func   P1   arg1   arg2   arg3 gt   func  p1 i j k      Now  we have to use this with the Command class  use the following typedef  typedef binder3 lt mem fun3 t lt int T int int int gt   T   int int int gt  F3    and change the signature of the ctor   just to illustrate the usage with a method signature taking more than one parameter explicit Command T  pObj F3  p method long timeout const char  key  long priority   PRIO NORMAL    m objptr pObj  m timeout timeout  m key key  m value priority  method1 0  method0 0   method 0        method3   p method     Here is how you call it  F3 f3   PluginThreadPool  bind3  PluginThreadPool  mem fun3          amp CTask  ThreeParameterTask   task1 2122 23     Note  f3    will call the method task1- gt ThreeParameterTask 21 22 23    The full context of this pattern at the following link

User · Answer

Little addition  You can use boost  function  to create functors from functions and methods  like this   class Foo   public      void operator     int i    printf  Foo  d   i        void Bar int i    printf  Bar  d   i     Foo foo  boost  function lt void  int  gt  f foo    wrap functor f 1    prints  Foo 1  boost  function lt void  int  gt  b  amp Bar    wrap normal function b 1    prints  Bar 1    and you can use boost  bind to add state to this functor  boost  function lt void    gt  f1   boost  bind foo  2   f1     no more argument  function argument stored in f1   and this print  Foo 2       and normal function boost  function lt void    gt  b1   boost  bind  amp Bar  2   b1      print  Bar 2    and most useful  with boost  bind and boost  function you can create functor from class method  actually this is a delegate   class SomeClass       std  string state   public      SomeClass const char  s    state  s          void method  std  string param                 std  cout  lt  lt  state   lt  lt  param  lt  lt  std  endl           SomeClass  inst   new SomeClass  Hi  i am     boost  function lt  void  std  string   gt  callback  callback   boost  bind  amp SomeClass  method  inst   1    create delegate    1 is a placeholder it holds plase for parameter callback  useless     prints  Hi  i am useless    You can create list or vector of functors  std  list lt  boost  function lt void  EventArg e  gt   gt  events    add some events        call them std  for each          events begin    events end             boost  bind  boost  apply lt void gt      1  e      There is one problem with all this stuff  compiler error messages is not human readable

User · Answer

To add on  I have used function objects to fit an existing legacy method to the command pattern   only place where the beauty of OO paradigm true OCP I felt    Also adding here the related function adapter pattern  Suppose your method has the signature  int CTask  ThreeParameterTask int par1  int par2  int par3   We will see how we can fit it for the Command pattern - for this  first  you have to write a member function adapter so that it can be called as a function object  Note - this is ugly  and may be you can use the Boost bind helpers etc   but if you can t or don t want to  this is one way     a template class for converting a member function of the type int        function int int int    to be called as a function object template lt typename  Ret typename  Class typename  arg1 typename  arg2 typename  arg3 gt  class mem fun3 t     public  explicit mem fun3 t  Ret   Class    Pm   arg1  arg2  arg3        m Ptr  Pm    okay here we store the member function pointer for later use           this operator call comes from the bind method  Ret operator    Class   P   arg1 arg1   arg2 arg2   arg3 arg3  const       return    P- gt  m Ptr  arg1 arg2 arg3      private   Ret   Class   m Ptr   arg1  arg2  arg3     method pointer signature     Also  we need a helper method mem fun3 for the above class to aid in calling  template lt typename  Ret typename  Class typename  arg1 typename  arg2 typename  arg3 gt  mem fun3 t lt  Ret  Class  arg1  arg2  arg3 gt  mem fun3    Ret   Class    Pm             arg1  arg2  arg3        return  mem fun3 t lt  Ret  Class  arg1  arg2  arg3 gt   Pm       Now  in order to bind the parameters  we have to write a binder function  So  here it goes  template lt typename  Func typename  Ptr typename  arg1 typename  arg2 typename  arg3 gt  class binder3   public    This is the constructor that does the binding part binder3  Func fn  Ptr ptr  arg1 i  arg2 j  arg3 k       m ptr ptr  m fn fn  m1 i  m2 j  m3 k        and this is the function object   void operator     const            m fn m ptr m1 m2 m3    that calls the operator       private       Ptr m ptr       Func m fn       arg1 m1   arg2 m2   arg3 m3      And  a helper function to use the binder3 class - bind3    a helper function to call binder3 template  lt typename  Func  typename  P1 typename  arg1 typename  arg2 typename  arg3 gt  binder3 lt  Func   P1   arg1   arg2   arg3 gt  bind3  Func func   P1 p1  arg1 i  arg2 j  arg3 k        return binder3 lt  Func   P1   arg1   arg2   arg3 gt   func  p1 i j k      Now  we have to use this with the Command class  use the following typedef  typedef binder3 lt mem fun3 t lt int T int int int gt   T   int int int gt  F3    and change the signature of the ctor   just to illustrate the usage with a method signature taking more than one parameter explicit Command T  pObj F3  p method long timeout const char  key  long priority   PRIO NORMAL    m objptr pObj  m timeout timeout  m key key  m value priority  method1 0  method0 0   method 0        method3   p method     Here is how you call it  F3 f3   PluginThreadPool  bind3  PluginThreadPool  mem fun3          amp CTask  ThreeParameterTask   task1 2122 23     Note  f3    will call the method task1- gt ThreeParameterTask 21 22 23    The full context of this pattern at the following link

User · Answer

Here s an actual situation where I was forced to use a Functor to solve my problem   I have a set of functions  say  20 of them   and they are all identical  except each calls a different specific function in 3 specific spots   This is incredible waste  and code duplication   Normally I would just pass in a function pointer  and just call that in the 3 spots   So the code only needs to appear once  instead of twenty times    But then I realized  in each case  the specific function required a completely different parameter profile  Sometimes 2 parameters  sometimes 5 parameters  etc   Another solution would be to have a base class  where the specific function is an overridden method in a derived class  But do I really want to build all of this INHERITANCE  just so I can pass a function pointer      SOLUTION   So what I did was  I made a wrapper class  a  Functor   which is able to call any of the functions I needed called   I set it up in advance  with its parameters  etc  and then I pass it in instead of a function pointer   Now the called code can trigger the Functor  without knowing what is happening on the inside  It can even call it multiple times  I needed it to call 3 times      That s it -- a practical example where a Functor turned out to be the obvious and easy solution  which allowed me to reduce code duplication from 20 functions to 1

User · Answer

Like others have mentioned  a functor is an object that acts like a function  i e  it overloads the function call operator   Functors are commonly used in STL algorithms  They are useful because they can hold state before and between function calls  like a closure in functional languages  For example  you could define a MultiplyBy functor that multiplies its argument by a specified amount   class MultiplyBy   private      int factor   public      MultiplyBy int x    factor x               int operator     int other  const           return factor   other             Then you could pass a MultiplyBy object to an algorithm like std  transform   int array 5     1  2  3  4  5   std  transform array  array   5  array  MultiplyBy 3       Now  array is  3  6  9  12  15    Another advantage of a functor over a pointer to a function is that the call can be inlined in more cases  If you passed a function pointer to transform  unless that call got inlined and the compiler knows that you always pass the same function to it  it can t inline the call through the pointer

User · Answer

A functor is a higher-order function that applies a function to the parametrized ie templated  types  It is a generalization of the map higher-order function  For example  we could define a functor for std  vector like this   template lt class F  class T  class U decltype std  declval lt F gt    std  declval lt T gt      gt  std  vector lt U gt  fmap F f  const std  vector lt T gt  amp  vec        std  vector lt U gt  result      std  transform vec begin    vec end    std  back inserter result   f       return result      This function takes a std  vector lt T gt  and returns std  vector lt U gt  when given a function F that takes a T and returns a U  A functor doesn t have to be defined over container types  it can be defined for any templated type as well  including std  shared ptr   template lt class F  class T  class U decltype std  declval lt F gt    std  declval lt T gt      gt  std  shared ptr lt U gt  fmap F f  const std  shared ptr lt T gt  amp  p        if  p    nullptr  return nullptr      else return std  shared ptr lt U gt  new U f  p         Heres a simple example that converts the type to a double   double to double int x        return x     std  shared ptr lt int gt  i new int 3    std  shared ptr lt double gt  d   fmap to double  i    std  vector lt int gt  is     1  2  3    std  vector lt double gt  ds   fmap to double  is     There are two laws that functors should follow  The first is the identity law  which states that if the functor is given an identity function  it should be the same as applying the identity function to the type  that is fmap identity  x  should be the same as identity x    struct identity f       template lt class T gt      T operator   T x  const               return x           identity f identity        std  vector lt int gt  is     1  2  3       These two statements should be equivalent     is1 should equal is2 std  vector lt int gt  is1   fmap identity  is   std  vector lt int gt  is2   identity is     The next law is the composition law  which states that if the functor is given a composition of two functions  it should be the same as applying the functor for the first function and then again for the second function  So  fmap std  bind f  std  bind g   1    x  should be the same as fmap f  fmap g  x     double to double int x        return x     struct foo       double x      foo to foo double x        foo r      r x   x      return r     std  vector lt int gt  is     1  2  3       These two statements should be equivalent     is1 should equal is2 std  vector lt foo gt  is1   fmap std  bind to foo  std  bind to double   1    is   std  vector lt foo gt  is2   fmap to foo  fmap to double  is

User · Answer

Functor can also be used to simulate defining a local function within a function. Refer to the question and another.

But a local functor can not access outside auto variables. The lambda (C++11) function is a better solution.

User · Answer

Name  functor  has been traditionaly used in category theory long before C   appeared on the scene  This has nothing to do with C   concept of functor  It s better to use name function object instead of what we call  functor  in C    This is how other programming languages call similar constructs   Used instead of plain function   Features    Function object may have state Function object fits into OOP  it behaves like every other object     Cons    Brings more complexity to the program      Used instead of function pointer   Features    Function object often may be inlined   Cons    Function object can not be swapped with other function object type during runtime  at least unless it extends some base class  which therefore gives some overhead      Used instead of virtual function   Features    Function object  non-virtual  doesn t require vtable and runtime dispatching  thus it is more efficient in most cases   Cons    Function object can not be swapped with other function object type during runtime  at least unless it extends some base class  which therefore gives some overhead

User · Answer

A Functor is a object which acts like a function  Basically  a class which defines operator     class MyFunctor      public       int operator   int x    return x   2      MyFunctor doubler  int x   doubler 5     The real advantage is that a functor can hold state    class Matcher      int target     public       Matcher int m    target m          bool operator   int x    return x    target      Matcher Is5 5    if  Is5 n         same as if  n    5

User · Answer

Like others have mentioned  a functor is an object that acts like a function  i e  it overloads the function call operator   Functors are commonly used in STL algorithms  They are useful because they can hold state before and between function calls  like a closure in functional languages  For example  you could define a MultiplyBy functor that multiplies its argument by a specified amount   class MultiplyBy   private      int factor   public      MultiplyBy int x    factor x               int operator     int other  const           return factor   other             Then you could pass a MultiplyBy object to an algorithm like std  transform   int array 5     1  2  3  4  5   std  transform array  array   5  array  MultiplyBy 3       Now  array is  3  6  9  12  15    Another advantage of a functor over a pointer to a function is that the call can be inlined in more cases  If you passed a function pointer to transform  unless that call got inlined and the compiler knows that you always pass the same function to it  it can t inline the call through the pointer

User · Answer

A functor is pretty much just a class which defines the operator    That lets you create objects which  look like  a function      this is a functor struct add x     add x int val    x val         Constructor   int operator   int y  const   return x   y     private    int x         Now you can use it like this  add x add42 42      create an instance of the functor class int i   add42 8      and  call  it assert i    50      and it added 42 to its argument  std  vector lt int gt  in     assume this contains a bunch of values  std  vector lt int gt  out in size        Pass a functor to std  transform  which calls the functor on every element     in the input sequence  and stores the result to the output sequence std  transform in begin    in end    out begin    add x 1     assert out i     in i    1      for all i   There are a couple of nice things about functors  One is that unlike regular functions  they can contain state  The above example creates a function which adds 42 to whatever you give it  But that value 42 is not hardcoded  it was specified as a constructor argument when we created our functor instance  I could create another adder  which added 27  just by calling the constructor with a different value  This makes them nicely customizable   As the last lines show  you often pass functors as arguments to other functions such as std  transform or the other standard library algorithms  You could do the same with a regular function pointer except  as I said above  functors can be  customized  because they contain state  making them more flexible  If I wanted to use a function pointer  I d have to write a function which added exactly 1 to its argument  The functor is general  and adds whatever you initialized it with   and they are also potentially more efficient  In the above example  the compiler knows exactly which function std  transform should call  It should call add x  operator    That means it can inline that function call  And that makes it just as efficient as if I had manually called the function on each value of the vector   If I had passed a function pointer instead  the compiler couldn t immediately see which function it points to  so unless it performs some fairly complex global optimizations  it d have to dereference the pointer at runtime  and then make the call

User · Answer

Functors are used in gtkmm to connect some GUI button to an actual C   function or method     If you use the pthread library to make your app multithreaded  Functors can help you  To start a thread  one of the arguments of the pthread create     is the function pointer to be executed on his own thread   But there s one inconvenience  This pointer can t be a pointer to a method  unless it s a static method  or unless you specify it s class  like class  method  And another thing  the interface of your method can only be   void  method void  something    So you can t run  in a simple obvious way   methods from your class in a thread without doing something extra     A very good way of dealing with threads in C    is creating your own Thread class  If you wanted to run methods from MyClass class  what I did was  transform those methods into Functor derived classes     Also  the Thread class has this method  static void  startThread void  arg  A pointer to this method will be used as an argument to call pthread create         And what startThread     should receive in arg is a void  casted reference to an instance in heap of any Functor derived class  which will be casted back to Functor  when executed  and then called it s run   method

User · Answer

Functors are used in gtkmm to connect some GUI button to an actual C   function or method     If you use the pthread library to make your app multithreaded  Functors can help you  To start a thread  one of the arguments of the pthread create     is the function pointer to be executed on his own thread   But there s one inconvenience  This pointer can t be a pointer to a method  unless it s a static method  or unless you specify it s class  like class  method  And another thing  the interface of your method can only be   void  method void  something    So you can t run  in a simple obvious way   methods from your class in a thread without doing something extra     A very good way of dealing with threads in C    is creating your own Thread class  If you wanted to run methods from MyClass class  what I did was  transform those methods into Functor derived classes     Also  the Thread class has this method  static void  startThread void  arg  A pointer to this method will be used as an argument to call pthread create         And what startThread     should receive in arg is a void  casted reference to an instance in heap of any Functor derived class  which will be casted back to Functor  when executed  and then called it s run   method

User · Answer

A functor is pretty much just a class which defines the operator    That lets you create objects which  look like  a function      this is a functor struct add x     add x int val    x val         Constructor   int operator   int y  const   return x   y     private    int x         Now you can use it like this  add x add42 42      create an instance of the functor class int i   add42 8      and  call  it assert i    50      and it added 42 to its argument  std  vector lt int gt  in     assume this contains a bunch of values  std  vector lt int gt  out in size        Pass a functor to std  transform  which calls the functor on every element     in the input sequence  and stores the result to the output sequence std  transform in begin    in end    out begin    add x 1     assert out i     in i    1      for all i   There are a couple of nice things about functors  One is that unlike regular functions  they can contain state  The above example creates a function which adds 42 to whatever you give it  But that value 42 is not hardcoded  it was specified as a constructor argument when we created our functor instance  I could create another adder  which added 27  just by calling the constructor with a different value  This makes them nicely customizable   As the last lines show  you often pass functors as arguments to other functions such as std  transform or the other standard library algorithms  You could do the same with a regular function pointer except  as I said above  functors can be  customized  because they contain state  making them more flexible  If I wanted to use a function pointer  I d have to write a function which added exactly 1 to its argument  The functor is general  and adds whatever you initialized it with   and they are also potentially more efficient  In the above example  the compiler knows exactly which function std  transform should call  It should call add x  operator    That means it can inline that function call  And that makes it just as efficient as if I had manually called the function on each value of the vector   If I had passed a function pointer instead  the compiler couldn t immediately see which function it points to  so unless it performs some fairly complex global optimizations  it d have to dereference the pointer at runtime  and then make the call

User · Answer

Little addition  You can use boost  function  to create functors from functions and methods  like this   class Foo   public      void operator     int i    printf  Foo  d   i        void Bar int i    printf  Bar  d   i     Foo foo  boost  function lt void  int  gt  f foo    wrap functor f 1    prints  Foo 1  boost  function lt void  int  gt  b  amp Bar    wrap normal function b 1    prints  Bar 1    and you can use boost  bind to add state to this functor  boost  function lt void    gt  f1   boost  bind foo  2   f1     no more argument  function argument stored in f1   and this print  Foo 2       and normal function boost  function lt void    gt  b1   boost  bind  amp Bar  2   b1      print  Bar 2    and most useful  with boost  bind and boost  function you can create functor from class method  actually this is a delegate   class SomeClass       std  string state   public      SomeClass const char  s    state  s          void method  std  string param                 std  cout  lt  lt  state   lt  lt  param  lt  lt  std  endl           SomeClass  inst   new SomeClass  Hi  i am     boost  function lt  void  std  string   gt  callback  callback   boost  bind  amp SomeClass  method  inst   1    create delegate    1 is a placeholder it holds plase for parameter callback  useless     prints  Hi  i am useless    You can create list or vector of functors  std  list lt  boost  function lt void  EventArg e  gt   gt  events    add some events        call them std  for each          events begin    events end             boost  bind  boost  apply lt void gt      1  e      There is one problem with all this stuff  compiler error messages is not human readable

User · Answer

Name  functor  has been traditionaly used in category theory long before C   appeared on the scene  This has nothing to do with C   concept of functor  It s better to use name function object instead of what we call  functor  in C    This is how other programming languages call similar constructs   Used instead of plain function   Features    Function object may have state Function object fits into OOP  it behaves like every other object     Cons    Brings more complexity to the program      Used instead of function pointer   Features    Function object often may be inlined   Cons    Function object can not be swapped with other function object type during runtime  at least unless it extends some base class  which therefore gives some overhead      Used instead of virtual function   Features    Function object  non-virtual  doesn t require vtable and runtime dispatching  thus it is more efficient in most cases   Cons    Function object can not be swapped with other function object type during runtime  at least unless it extends some base class  which therefore gives some overhead

User · Answer

A functor is a higher-order function that applies a function to the parametrized ie templated  types  It is a generalization of the map higher-order function  For example  we could define a functor for std  vector like this   template lt class F  class T  class U decltype std  declval lt F gt    std  declval lt T gt      gt  std  vector lt U gt  fmap F f  const std  vector lt T gt  amp  vec        std  vector lt U gt  result      std  transform vec begin    vec end    std  back inserter result   f       return result      This function takes a std  vector lt T gt  and returns std  vector lt U gt  when given a function F that takes a T and returns a U  A functor doesn t have to be defined over container types  it can be defined for any templated type as well  including std  shared ptr   template lt class F  class T  class U decltype std  declval lt F gt    std  declval lt T gt      gt  std  shared ptr lt U gt  fmap F f  const std  shared ptr lt T gt  amp  p        if  p    nullptr  return nullptr      else return std  shared ptr lt U gt  new U f  p         Heres a simple example that converts the type to a double   double to double int x        return x     std  shared ptr lt int gt  i new int 3    std  shared ptr lt double gt  d   fmap to double  i    std  vector lt int gt  is     1  2  3    std  vector lt double gt  ds   fmap to double  is     There are two laws that functors should follow  The first is the identity law  which states that if the functor is given an identity function  it should be the same as applying the identity function to the type  that is fmap identity  x  should be the same as identity x    struct identity f       template lt class T gt      T operator   T x  const               return x           identity f identity        std  vector lt int gt  is     1  2  3       These two statements should be equivalent     is1 should equal is2 std  vector lt int gt  is1   fmap identity  is   std  vector lt int gt  is2   identity is     The next law is the composition law  which states that if the functor is given a composition of two functions  it should be the same as applying the functor for the first function and then again for the second function  So  fmap std  bind f  std  bind g   1    x  should be the same as fmap f  fmap g  x     double to double int x        return x     struct foo       double x      foo to foo double x        foo r      r x   x      return r     std  vector lt int gt  is     1  2  3       These two statements should be equivalent     is1 should equal is2 std  vector lt foo gt  is1   fmap std  bind to foo  std  bind to double   1    is   std  vector lt foo gt  is2   fmap to foo  fmap to double  is

User · Answer

Like has been repeated  functors are classes that can be treated as functions  overload operator       They are most useful for situations in which you need to associate some data with repeated or delayed calls to a function   For example  a linked-list of functors could be used to implement a basic low-overhead synchronous coroutine system  a task dispatcher  or interruptable file parsing  Examples      prints  this is a very simple and poorly used task queue     class Functor   public      std  string output      Functor const std  string amp  out   output out        operator     const               std  cout  lt  lt  output  lt  lt                 int main int argc  char   argv        std  list lt Functor gt  taskQueue      taskQueue push back Functor  this         taskQueue push back Functor  is a         taskQueue push back Functor  very simple         taskQueue push back Functor  and poorly used         taskQueue push back Functor  task queue         for std  list lt Functor gt   iterator it   taskQueue begin            it    taskQueue end      it                 it              return 0        prints the value stored in  i   then asks you if you want to increment it    int i  bool should increment  int doSomeWork         std  cout  lt  lt   i      lt  lt  i  lt  lt  std  endl      std  cout  lt  lt   increment   enter the number 1 to increment  0 otherwise   lt  lt  std  endl      std  cin  gt  gt  should increment      return 2    void doSensitiveWork            i       should increment   false    class BaseCoroutine   public      BaseCoroutine int stat   status stat   waiting false        void operator      status   perform          int getStatus   const   return status    protected      int status      bool waiting      virtual int perform     0      bool await status BaseCoroutine amp  other  int stat  int change                if  waiting                        waiting   true                    if other getStatus      stat                        status   change              waiting   false                    return  waiting           class MyCoroutine1  public BaseCoroutine   public      MyCoroutine1 BaseCoroutine amp  other   BaseCoroutine 1   partner other    protected      BaseCoroutine amp  partner      virtual int perform                 if getStatus      1              return doSomeWork            if getStatus      2                        if await status partner  1                   return 1              else if i    100                  return 0              else                 return 2                      class MyCoroutine2  public BaseCoroutine   public      MyCoroutine2 bool amp  work signal   BaseCoroutine 1   ready work signal     protected      bool amp  work signal      virtual int perform                 if i    100              return 0          if work signal                        doSensitiveWork                return 2                    return 1            int main          std  list lt BaseCoroutine   gt  coroutineList       MyCoroutine2  incrementer   new MyCoroutine2 should increment        MyCoroutine1  printer   new MyCoroutine1 incrementer         while coroutineList size                    for std  list lt BaseCoroutine   gt   iterator it   coroutineList begin                 it    coroutineList end      it                           it                 if  it getStatus      0                                  coroutineList erase it                                         delete printer       delete incrementer       return 0      Of course  these examples aren t that useful in themselves  They only show how functors can be useful  the functors themselves are very basic and inflexible and this makes them less useful than  for example  what boost provides

User · Answer

A functor is pretty much just a class which defines the operator    That lets you create objects which  look like  a function      this is a functor struct add x     add x int val    x val         Constructor   int operator   int y  const   return x   y     private    int x         Now you can use it like this  add x add42 42      create an instance of the functor class int i   add42 8      and  call  it assert i    50      and it added 42 to its argument  std  vector lt int gt  in     assume this contains a bunch of values  std  vector lt int gt  out in size        Pass a functor to std  transform  which calls the functor on every element     in the input sequence  and stores the result to the output sequence std  transform in begin    in end    out begin    add x 1     assert out i     in i    1      for all i   There are a couple of nice things about functors  One is that unlike regular functions  they can contain state  The above example creates a function which adds 42 to whatever you give it  But that value 42 is not hardcoded  it was specified as a constructor argument when we created our functor instance  I could create another adder  which added 27  just by calling the constructor with a different value  This makes them nicely customizable   As the last lines show  you often pass functors as arguments to other functions such as std  transform or the other standard library algorithms  You could do the same with a regular function pointer except  as I said above  functors can be  customized  because they contain state  making them more flexible  If I wanted to use a function pointer  I d have to write a function which added exactly 1 to its argument  The functor is general  and adds whatever you initialized it with   and they are also potentially more efficient  In the above example  the compiler knows exactly which function std  transform should call  It should call add x  operator    That means it can inline that function call  And that makes it just as efficient as if I had manually called the function on each value of the vector   If I had passed a function pointer instead  the compiler couldn t immediately see which function it points to  so unless it performs some fairly complex global optimizations  it d have to dereference the pointer at runtime  and then make the call

User · Answer

Like others have mentioned  a functor is an object that acts like a function  i e  it overloads the function call operator   Functors are commonly used in STL algorithms  They are useful because they can hold state before and between function calls  like a closure in functional languages  For example  you could define a MultiplyBy functor that multiplies its argument by a specified amount   class MultiplyBy   private      int factor   public      MultiplyBy int x    factor x               int operator     int other  const           return factor   other             Then you could pass a MultiplyBy object to an algorithm like std  transform   int array 5     1  2  3  4  5   std  transform array  array   5  array  MultiplyBy 3       Now  array is  3  6  9  12  15    Another advantage of a functor over a pointer to a function is that the call can be inlined in more cases  If you passed a function pointer to transform  unless that call got inlined and the compiler knows that you always pass the same function to it  it can t inline the call through the pointer

User · Answer

A big advantage of implementing functions as functors is that they can maintain and reuse state between calls  For example  many dynamic programming algorithms  like the Wagner-Fischer algorithm for calculating the Levenshtein distance between strings  work by filling in a large table of results  It s very inefficient to allocate this table every time the function is called  so implementing the function as a functor and making the table a member variable can greatly improve performance   Below is an example of implementing the Wagner-Fischer algorithm as a functor  Notice how the table is allocated in the constructor  and then reused in operator    with resizing as necessary    include  lt string gt   include  lt vector gt   include  lt algorithm gt   template  lt typename T gt  T min3 const T amp  a  const T amp  b  const T amp  c       return std  min std  min a  b   c      class levenshtein distance        mutable std  vector lt std  vector lt unsigned int gt   gt  matrix    public      explicit levenshtein distance size t initial size   8            matrix  initial size  std  vector lt unsigned int gt  initial size                    unsigned int operator   const std  string amp  s  const std  string amp  t  const               const size t m   s size            const size t n   t size               The distance between a string and the empty string is the string s length         if  m    0                return n                    if  n    0                return m                       Size the matrix as necessary         if  matrix  size    lt  m   1                matrix  resize m   1  matrix  0                      if  matrix  0  size    lt  n   1                for  auto amp  mat   matrix                     mat resize n   1                                      The top row and left column are prefixes that can be reached by            insertions and deletions alone         unsigned int i  j          for  i   1   i  lt   m    i                matrix  i  0    i                    for  j   1  j  lt   n    j                matrix  0  j    j                       Fill in the rest of the matrix         for  j   1  j  lt   n    j                for  i   1  i  lt   m    i                    unsigned int substitution cost   s i - 1     t j - 1    0   1                  matrix  i  j                        min3 matrix  i - 1  j    1                     Deletion                     matrix  i  j - 1    1                          Insertion                     matrix  i - 1  j - 1    substitution cost      Substitution                                 return matrix  m  n

User · Answer

Here s an actual situation where I was forced to use a Functor to solve my problem   I have a set of functions  say  20 of them   and they are all identical  except each calls a different specific function in 3 specific spots   This is incredible waste  and code duplication   Normally I would just pass in a function pointer  and just call that in the 3 spots   So the code only needs to appear once  instead of twenty times    But then I realized  in each case  the specific function required a completely different parameter profile  Sometimes 2 parameters  sometimes 5 parameters  etc   Another solution would be to have a base class  where the specific function is an overridden method in a derived class  But do I really want to build all of this INHERITANCE  just so I can pass a function pointer      SOLUTION   So what I did was  I made a wrapper class  a  Functor   which is able to call any of the functions I needed called   I set it up in advance  with its parameters  etc  and then I pass it in instead of a function pointer   Now the called code can trigger the Functor  without knowing what is happening on the inside  It can even call it multiple times  I needed it to call 3 times      That s it -- a practical example where a Functor turned out to be the obvious and easy solution  which allowed me to reduce code duplication from 20 functions to 1

User · Answer

For the newbies like me among us  after a little research I figured out what the code jalf posted did   A functor is a class or struct object which can be  called  like a function  This is made possible by overloading the    operator  The    operator  not sure what its called  can take any number of arguments  Other operators only take two i e  the   operator can only take two values  one on each side of the operator  and return whatever value you have overloaded it for  You can fit any number of arguments inside a    operator which is what gives it its flexibility   To create a functor first you create your class  Then you create a constructor to the class with a parameter of your choice of type and name  This is followed in the same statement by an initializer list  which uses a single colon operator  something I was also new to  which constructs the class member objects with the previously declared parameter to the constructor  Then the    operator is overloaded  Finally you declare the private objects of the class or struct you have created   My code  I found jalf s variable names confusing   class myFunctor        public             myFunctor is the constructor  parameterVar is the parameter passed to            the constructor    is the initializer list operator  myObject is the            private member object of the myFunctor class  parameterVar is passed            to the    operator which takes it and adds it to myObject in the            overloaded    operator function             myFunctor  int parameterVar    myObject  parameterVar                  the  operator  word is a keyword which indicates this function is an             overloaded operator function  The    following this just tells the            compiler that    is the operator being overloaded  Following that is            the parameter for the overloaded operator  This parameter is actually            the argument  parameterVar  passed by the constructor we just wrote             The last part of this statement is the overloaded operators body            which adds the parameter passed to the member object             int operator    int myArgument    return myObject   myArgument         private           int myObject    Our private member object        If any of this is inaccurate or just plain wrong feel free to correct me

[c++] What are C++ functors and their uses?

Examples related to c++

Examples related to functor

Examples related to function-object

Examples related to function-call-operator