Function passed as template argument

Question

I m looking for the rules involving passing C   templates functions as arguments   This is supported by C   as shown by an example here    include  lt iostream gt   void add1 int  amp v      v  1     void add2 int  amp v      v  2     template  lt void   T  int  amp   gt  void doOperation       int temp 0    T temp     std  cout  lt  lt   Result is    lt  lt  temp  lt  lt  std  endl     int main       doOperation lt add1 gt       doOperation lt add2 gt         Learning about this technique is difficult  however  Googling for  function as a template argument  doesn t lead to much  And the classic C   Templates The Complete Guide surprisingly also doesn t discuss it  at least not from my search    The questions I have are whether this is valid C    or just some widely supported extension    Also  is there a way to allow a functor with the same signature to be used interchangeably with explicit functions during this kind of template invocation   The following does not work in the above program  at least in Visual C    because the syntax is obviously wrong  It d be nice to be able to switch out a function for a functor and vice versa  similar to the way you can pass a function pointer or functor to the std  sort algorithm if you want to define a custom comparison operation      struct add3         void operator    int  amp v   v  3                  doOperation lt add3 gt       Pointers to a web link or two  or a page in the C   Templates book would be appreciated

User · Answer

Came here with the additional requirement, that also parameter/return types should vary. Following Ben Supnik this would be for some type T

typedef T(*binary_T_op)(T, T);

instead of

typedef int(*binary_int_op)(int, int);

The solution here is to put the function type definition and the function template into a surrounding struct template.

template <typename T> struct BinOp
{
    typedef T(*binary_T_op )(T, T); // signature for all valid template params
    template<binary_T_op op>
    T do_op(T a, T b)
    {
       return op(a,b);
    }
};


double mulDouble(double a, double b)
{
    return a * b;
}


BinOp<double> doubleBinOp;

double res = doubleBinOp.do_op<&mulDouble>(4, 5);

Alternatively BinOp could be a class with static method template do_op(...), then called as

double res = BinOp<double>::do_op<&mulDouble>(4, 5);

User · Answer

Edit  Passing the operator as a reference doesnt work  For simplicity  understand it as a function pointer  You just send the pointer  not a reference  I think you are trying to write something like this   struct Square       double operator   double number    return number   number        template  lt class Function gt  double integrate Function f  double a  double b  unsigned int intervals        double delta    b - a    intervals  sum   0 0       while a  lt  b                sum    f a    delta          a    delta             return sum           std  cout  lt  lt   interval      lt  lt  i  lt  lt  tab  lt  lt  tab  lt  lt   intgeration       lt  lt  integrate Square    0 0  1 0  10   lt  lt  std  endl

User · Answer

The reason your functor example does not work is that you need an instance to invoke the operator

User · Answer

In your template  template  lt void   T  int  amp   gt  void doOperation     The parameter T is a non-type template parameter  This means that the behaviour of the template function changes with the value of the parameter  which must be fixed at compile time  which function pointer constants are    If you want somthing that works with both function objects and function parameters you need a typed template  When you do this  though  you also need to provide an object instance  either function object instance or a function pointer  to the function at run time   template  lt class T gt  void doOperation T t      int temp 0    t temp     std  cout  lt  lt   Result is    lt  lt  temp  lt  lt  std  endl      There are some minor performance considerations  This new version may be less efficient with function pointer arguments as the particular function pointer is only derefenced and called at run time whereas your function pointer template can be optimized  possibly the function call inlined  based on the particular function pointer used  Function objects can often be very efficiently expanded with the typed template  though as the particular operator   is completely determined by the type of the function object

User · Answer

Function pointers can be passed as template parameters  and this is part of standard C     However in the template they are declared and used as functions rather than pointer-to-function  At template instantiation one passes the address of the function rather than just the name   For example   int i    void add1 int amp  i    i    1     template lt void op int amp   gt  void do op fn ptr tpl int amp  i    op i      i   0  do op fn ptr tpl lt  amp add1 gt  i     If you want to pass a functor type as a template argument   struct add2 t     void operator   int amp  i    i    2        template lt typename op gt  void do op fntr tpl int amp  i      op o    o i      i   0  do op fntr tpl lt add2 t gt  i     Several answers pass a functor instance as an argument   template lt typename op gt  void do op fntr arg int amp  i  op o    o i      i   0  add2 t add2      This has the advantage of looking identical whether     you pass a functor or a free function  do op fntr arg i  add1   do op fntr arg i  add2     The closest you can get to this uniform appearance with a template argument is to define do op twice- once with a non-type parameter and once with a type parameter      non-type  function pointer  template parameter template lt void op int amp   gt  void do op int amp  i    op i         type  functor class  template parameter template lt typename op gt  void do op int amp  i      op o     o i       i   0  do op lt  amp add1 gt  i      still need address-of operator in the function pointer case  do op lt add2 t gt  i     Honestly  I really expected this not to compile  but it worked for me with gcc-4 8 and Visual Studio 2013

User · Answer

Yes  it is valid   As for making it work with functors as well  the usual solution is something like this instead   template  lt typename F gt  void doOperation F f      int temp 0    f temp     std  cout  lt  lt   Result is    lt  lt  temp  lt  lt  std  endl      which can now be called as either   doOperation add2   doOperation add3       See it live  The problem with this is that if it makes it tricky for the compiler to inline the call to add2  since all the compiler knows is that a function pointer type void     int  amp   is being passed to doOperation   But add3  being a functor  can be inlined easily  Here  the compiler knows that an object of type add3 is passed to the function  which means that the function to call is add3  operator    and not just some unknown function pointer

User · Answer

Template parameters can be either parameterized by type  typename T  or by value  int X    The  traditional  C   way of templating a piece of code is to use a functor - that is  the code is in an object  and the object thus gives the code unique type   When working with traditional functions  this technique doesn t work well  because a change in type doesn t indicate a specific function - rather it specifies only the signature of many possible functions   So   template lt typename OP gt  int do op int a  int b  OP op      return op a b     int add int a  int b    return a   b         int c   do op 4 5 add     Isn t equivalent to the functor case   In this example  do op is instantiated for all function pointers whose signature is int X  int  int    The compiler would have to be pretty aggressive to fully inline this case    I wouldn t rule it out though  as compiler optimization has gotten pretty advanced    One way to tell that this code doesn t quite do what we want is   int    func ptr  int  int    add  int c   do op 4 5 func ptr     is still legal  and clearly this is not getting inlined   To get full inlining  we need to template by value  so the function is fully available in the template   typedef int  binary int op  int  int      signature for all valid template params template lt binary int op op gt  int do op int a  int b     return op a b     int add int a  int b    return a   b        int c   do op lt add gt  4 5     In this case  each instantiated version of do op is instantiated with a specific function already available   Thus we expect the code for do op to look a lot like  return a   b     Lisp programmers  stop your smirking    We can also confirm that this is closer to what we want because this   int    func ptr  int int    add  int c   do op lt func ptr gt  4 5     will fail to compile   GCC says   error   func ptr  cannot appear in a constant-expression   In other words  I can t fully expand do op because you haven t given me enough info at compiler time to know what our op is   So if the second example is really fully inlining our op  and the first is not  what good is the template   What is it doing   The answer is  type coercion   This riff on the first example will work   template lt typename OP gt  int do op int a  int b  OP op    return op a b     float fadd float a  float b    return a b        int c   do op 4 5 fadd     That example will work    I am not suggesting it is good C   but      What has happened is do op has been templated around the signatures of the various functions  and each separate instantiation will write different type coercion code   So the instantiated code for do op with fadd looks something like   convert a and b from int to float  call the function ptr op with float a and float b  convert the result back to int and return it    By comparison  our by-value case requires an exact match on the function arguments

[c++] Function passed as template argument

Examples related to c++

Examples related to templates

Examples related to code-generation

Examples related to functor