Type de retour déduit lors du passage de la fonction par le modèle

Question

Ma question concerne le fait que le compilateur déduise le type de retour d'une fonction en fonction du type de retour d'une fonction transmise par le modèle.

Est-il possible que je peux appeler comme

foo<bar>(7.3) 

au lieu de

foo<double, int, bar>(7.3) 

dans cet exemple:

#include <cstdio> 
template <class T, class V, V (*func)(T)> 
V foo(T t) { return func(t); } 

int bar(double j) { return (int)(j + 1); } 

int main() { 
    printf("%d\n", foo<double, int, bar>(7.3)); 
} 

Answer 1

Si vous voulez garder bar comme modèle argument, je crains que vous ne pouvez vous approcher t o que:

#include <cstdio> 

template<typename T> 
struct traits { }; 

template<typename R, typename A> 
struct traits<R(A)> 
{ 
    typedef R ret_type; 
    typedef A arg_type; 
}; 

template <typename F, F* func> 
typename traits<F>::ret_type foo(typename traits<F>::arg_type t) 
{ return func(t); } 

int bar(double j) { return (int)(j + 1); } 

int main() 
{ 
    printf("%d\n", foo<decltype(bar), bar>(7.3)); 
} 

Vous pouvez également définir une macro si vous voulez éviter de répéter le nom de » bar:

#define FXN_ARG(f) decltype(f), f 

int main() 
{ 
    printf("%d\n", foo<FXN_ARG(bar)>(7.3)); 
} 

Sinon, vous pouvez laisser bar devenir un argument fonction , ce qui pourrait faire votre vie plus facile:

#include <cstdio> 

template<typename T> 
struct traits { }; 

template<typename R, typename A> 
struct traits<R(A)> 
{ 
    typedef R ret_type; 
    typedef A arg_type; 
}; 

template<typename R, typename A> 
struct traits<R(*)(A)> 
{ 
    typedef R ret_type; 
    typedef A arg_type; 
}; 

template <typename F> 
typename traits<F>::ret_type foo(F f, typename traits<F>::arg_type t) 
{ return f(t); } 

int bar(double j) { return (int)(j + 1); } 

int main() 
{ 
    printf("%d\n", foo(bar, 7.3)); 
}