Calling a null argument template function pointer with a Variadic template argument?
Here is a code snippet from the Functional C ++ blog post describing how generic function evaluation can be implemented.
My question is, how can you declare a template function pointer f as R (C :: * f) () with no arguments and still be able to call it using Args ...?
// functions, functors, lambdas, etc.
template<
class F, class... Args,
class = typename std::enable_if<!std::is_member_function_pointer<F>::value>::type,
class = typename std::enable_if<!std::is_member_object_pointer<F>::value>::type
>
auto eval(F&& f, Args&&... args) -> decltype(f(std::forward<Args>(args)...))
{
return f(std::forward<Args>(args)...);
}
// const member function
template<class R, class C, class... Args>
auto eval(R(C::*f)() const, const C& c, Args&&... args) -> R
{
return (c.*f)(std::forward<Args>(args)...);
}
template<class R, class C, class... Args>
auto eval(R(C::*f)() const, C& c, Args&&... args) -> R
{
return (c.*f)(std::forward<Args>(args)...);
}
// non-const member function
template<class R, class C, class... Args>
auto eval(R(C::*f)(), C& c, Args&&... args) -> R
{
return (c.*f)(std::forward<Args>(args)...);
}
// member object
template<class R, class C>
auto eval(R(C::*m), const C& c) -> const R&
{
return c.*m;
}
template<class R, class C>
auto eval(R(C::*m), C& c) -> R&
{
return c.*m;
}
struct Bloop
{
int a = 10;
int operator()(){return a;}
int operator()(int n){return a+n;}
int triple(){return a*3;}
};
int add_one(int n)
{
return n+1;
}
int main()
{
Bloop bloop;
// free function
std::cout << eval(add_one,0) << "\n";
// lambda function
std::cout << eval([](int n){return n+1;},1) << "\n";
// functor
std::cout << eval(bloop) << "\n";
std::cout << eval(bloop,4) << "\n";
// member function
std::cout << eval(&Bloop::triple,bloop) << "\n";
// member object
eval(&Bloop::a,bloop)++; // increment a by reference
std::cout << eval(&Bloop::a,bloop) << "\n";
return 0;
}
For example, when I try:
struct Bloop
{
int a = 10;
int operator()(){return a;}
int operator()(int n){return a+n;}
int triple(){return a*3;}
int foo(int n) {return n;}
};
template <typename R, typename C, typename... Args>
void eval (R(C::*func)(), C& c, Args... args) {
(c.*func)(args...);
}
int main()
{
Bloop bloop;
eval(&Bloop::foo, bloop, 5);
return 0;
}
I am getting this error:
main.cpp: In function 'int main()':
main.cpp:27:31: error: no matching function for call to 'eval(int (Bloop::*)(int), Bloop&, int)'
eval(&Bloop::foo, bloop, 5);
^
main.cpp:27:31: note: candidate is:
main.cpp:19:6: note: template<class R, class C, class ... Args> void eval(R (C::*)(), C&, Args ...)
void eval (R(C::*func)(), C& c, Args... args) {
^
main.cpp:19:6: note: template argument deduction/substitution failed:
main.cpp:27:31: note: candidate expects 1 argument, 2 provided
eval(&Bloop::foo, bloop, 5);
^
And if I declare func
as R(C::*func)(int)
, it compiles.
source to share
The code in the blog post is incorrect (or at least incomplete); it only works for functions with no arguments. You could write eval
more correctly:
template<class R, class C, class... T, class... Args>
auto eval(R(C::*f)(T...), C& c, Args&&... args) -> R
{
return (c.*f)(std::forward<Args>(args)...);
}
Notice the parameter package T...
for the arguments to the member function type pointer. This is a separate package of types from Args&&...
, because the two packages can be inferred differently.
source to share
This code could be made both simpler and more general at the same time by avoiding parsing member pointer types and member pointer types and simply accepting everything for which calls are well defined:
#define RETURNS(...) \
-> decltype(__VA_ARGS__) { \
return (__VA_ARGS__); \
}
// Function object type
template<class F, class... Args>
auto eval(F&& f, Args&&... args)
RETURNS(std::forward<F>(f)(std::forward<Args>(args)...))
// pointer to member function, object reference
template<class PMF, class C, class... Args>
auto eval(PMF&& pmf, C&& c, Args&&... args)
RETURNS((std::forward<C>(c).*std::forward<PMF>(pmf))(std::forward<Args>(args)...))
// pointer to member data, object reference
template<class PMD, class C>
auto eval(PMD&& pmd, C&& c)
RETURNS(std::forward<C>(c).*std::forward<PMD>(pmd))
while we're at it, we can also support omitted pointer-to-member cases with object pointers in addition to object references for completeness, especially given that the code sample requires them to evaluate eval(&Bloop::a,&bloop)++
:
// pointer to member data, object pointer
template<class PMD, class P>
auto eval(PMD&& pmd, P&& p)
RETURNS((*std::forward<P>(p)).*std::forward<PMD>(pmd))
// pointer to member function, object pointer
template<class PMF, class P, class... Args>
auto eval(PMF&& pmf, P&& p, Args&&... args)
RETURNS(((*std::forward<P>(p)).*std::forward<PMF>(pmf))(std::forward<Args>(args)...))
(Okay, maybe "simpler" was a bad phrase. "Shorter" or "concise" would probably be more accurate.)
source to share