SFINAE and detecting if a C++ function object returns void

Question

I've read the various authorities on this, include Dewhurst and yet haven't managed to get anywhere with this seemingly simple question.

What I want to do is to call a C++ function object, (basically, anything you can call, a pure function or a class with ()), and return its value, if that is not void, or "true" otherwise.

using std:

struct Foo {
  void operator()() { cout << "Foo/"l; }
};
struct Bar {
  bool operator()() { cout << "Bar/"; return true; }
};

Foo foo;
Bar bar;
bool baz() { cout << "baz/"; return true; }
void bang() { cout << "bang/"; }

const char* print(bool b) { cout << b ? "true/" : "false/"; }

template <typename Functor> bool magicCallFunction(Functor f) {
  return true;  // Lots of template magic occurs here 
                // that results in the functor being called.
}

int main(int argc, char** argv) {
  print(magicCallFunction(foo));
  print(magicCallFunction(bar));
  print(magicCallFunction(baz));
  print(magicCallFunction(bang));
  printf("\n");
}
// Results:  Foo/true/Bar/true/baz/true/bang/true

UPDATE

Thanks for the thoughts and ideas!

Based on this, I actually decided to bring up all my templating one level - so instead I have:

bool eval(bool (*f)()) { return (*f)(); }

bool eval(void (*f)()) { (*f)(); return true; }

template <typename Type>
bool eval(Type* obj, bool (Type::*method)()) { return (obj->*method)(); }

template <typename Type>
bool eval(Type* obj, void (Type::*method)()) { (obj->*method)(); return true; }

and generic classes to carry the various objects and methods around. Thanks to Mr.Ree for the code that pushed me in that direction!

score 6 · Answer 1 · answered Apr 05 '11 at 14:24

To detect a void return value at compile time, the standard trick is to overload operator,. The cool thing with the comma operator is that it can take a void parameter, and in this case it defaults to the built in operator,. In code:

template <typename> tag {};

template <typename T>
tag<T> operator,(T, tag<void>);

Now, expr, tag<void>() has type tag<typeof(expr)> even if expr has type void. You can then catch this with usual tricks:

char (&test(tag<void>))[1];
template <typename T> char (&test(tag<T>))[2];

template <typename F>
struct nullary_functor_traits
{
    static const bool returns_void = sizeof(test((factory()(), tag<void>()))) == 1;
private:
    static F factory();    
};

Öö Tiib · Answer 2 · 2010-12-26T22:25:48.123

1

Perhaps you can use the fact that void& does not make sense as type but void* makes.

edited Dec 26 '10 at 22:25

answered Dec 26 '10 at 22:12

Öö Tiib

10,809
25
44

Mr.Ree · Accepted Answer · 2010-12-27T03:35:08.260

Wouldn't it be easier to implement an overloaded no-op version of print(void)?

Ahh well. Function templates and overloading will easily handle this at runtime.

It gets somewhat stickier if you had wanted to handle this at compile time, for use with #if macros or static-compile-time-asserts.

But since you only want the former, may I suggest something like this as a starting point:

(Tested under (GCC) 3.4.4 & 4.0.1. -- I know, I need to upgrade!)

#include <iostream>
using namespace std;

struct Foo {
  void operator()() {}
};
struct Bar {
  bool operator()() { return false; }
};
Foo foo;
Bar bar;
bool baz() { return false; }
void bang() {}


struct IsVoid
{
  typedef char YES[1];
  typedef char NO[2];

        /* Testing functions for void return value. */

  template <typename T>
  static IsVoid::NO  & testFunction( T (*f)() );

  static IsVoid::YES & testFunction( void (*f)() );

  static IsVoid::NO  & testFunction( ... );

        /* Testing Objects for "void operator()()" void return value. */

  template <typename C, void (C::*)()>
  struct hasOperatorMethodStruct { };

  template <typename C>
  static YES & testMethod( hasOperatorMethodStruct<C, &C::operator()> * );

  template <typename C>
  static NO & testMethod( ... );


        /* Function object method to call to perform test. */
  template <typename T>
  bool operator() (T & t)
  {
    return (    ( sizeof(IsVoid::testFunction(t))  == sizeof(IsVoid::YES) )
             || ( sizeof(IsVoid::testMethod<T>(0)) == sizeof(IsVoid::YES) ) );
  }
};


#define BOUT(X) cout << # X " = " << boolToString(X) << endl;

const char * boolToString( int theBool )
{
  switch ( theBool )
  {
    case true:   return "true";
    case false:  return "false";
    default:     return "unknownvalue";
  }
}

int main()
{
  IsVoid i;

  BOUT( IsVoid()(foo) );
  BOUT( IsVoid()(bar) );
  BOUT( IsVoid()(baz) );
  BOUT( IsVoid()(bang) );
  cout << endl;

  BOUT( i(foo) );
  BOUT( i(bar) );
  BOUT( i(baz) );
  BOUT( i(bang) );
}

Okay, I begin to see more of the problem.

While we can do something along the lines of this:

#include <iostream>
using namespace std;

struct FooA {
  void operator()() {}
};
struct FooB {
  bool operator()() { return false; }
};
struct FooC {
  int operator()() { return 17; }
};
struct FooD {
  double operator()() { return 3.14159; }
};
FooA fooA;
FooB fooB;
FooC fooC;
FooD fooD;

void   barA() {}
bool   barB() { return false; }
int    barC() { return 17; }
double barD() { return 3.14159; }


namespace N
{
        /* Functions */

  template <typename R>
  R    run( R (*f)() )    { return (*f)(); }

  bool run( void (*f)() ) { (*f)();  return true; }


        /* Methods */

  template <typename T, typename R>
  R    run( T & t, R (T::*f)() ) { return (t .* f) (); }

  template <typename T>
  bool run( T & t, void (T::*f)() ) { (t .* f) (); return true; }
};


#define SHOW(X) cout << # X " = " << (X) << endl;
#define BOUT(X) cout << # X " = " << boolToString(X) << endl;

const char * boolToString( int theBool )
{
  switch ( theBool )
  {
    case true:   return "true";
    case false:  return "false";
    default:     return "unknownvalue";
  }
}


int main()
{
  SHOW( N::run( barA ) );
  BOUT( N::run( barA ) );
  SHOW( N::run( barB ) );
  BOUT( N::run( barB ) );
  SHOW( N::run( barC ) );
  SHOW( N::run( barD ) );
  cout << endl;

  SHOW( N::run(fooA,&FooA::operator()));
  BOUT( N::run(fooA,&FooA::operator()));
  SHOW( N::run(fooB,&FooB::operator()));
  BOUT( N::run(fooB,&FooB::operator()));
  SHOW( N::run(fooC,&FooC::operator()));
  SHOW( N::run(fooD,&FooD::operator()));
}

You do still have that nasty need to feed &CLASS::operator() in as an argument.

Ultimately, while we can determine whether the object's operator() method returns a void, we cannot normally overload based on return types.

We can get around that overloading limitation via template specialization. But then we get into this uglyness wherein we still need to specify types... Especially the return type! Either manually, or by passing in a suitable argument from which we can extract the necessary types.

BTW: #define macros won't help either. Tools like ?: require the same type for both the ? and : part.

So this is the best I can do...

Of course...

If you don't need the return type...

If you are just passing the result to another function...

You can do something like this:

#include <iostream>
using namespace std;

struct FooA {
  void operator()() {}
};
struct FooB {
  bool operator()() { return false; }
};
struct FooC {
  int operator()() { return 17; }
};
struct FooD {
  double operator()() { return 3.14159; }
};
FooA fooA;
FooB fooB;
FooC fooC;
FooD fooD;

void   barA() {}
bool   barB() { return false; }
int    barC() { return 17; }
double barD() { return 3.14159; }


#define SHOW(X) cout << # X " = " << (X) << endl;

namespace N
{
  template <typename T, typename R>
  R    run( T & t, R (T::*f)() ) { return (t .* f) (); }

  template <typename T>
  bool run( T & t, void (T::*f)() ) { (t .* f) (); return true; }


  template <typename T>
  void R( T & t )
  {
    SHOW( N::run( t, &T::operator() ) );
  }

  template <typename T>
  void R( T (*f)() )
  {
    SHOW( (*f)() );
  }

  void R( void (*f)() )
  {
    (*f)();
    SHOW( true );
  }
};


int main()
{
  N::R( barA );
  N::R( barB );
  N::R( barC );
  N::R( barD );
  N::R( fooA );
  N::R( fooB );
  N::R( fooC );
  N::R( fooD );
}

The "print" is just to demo what's going on... what I'm doing is wrapping methods and functions to pass to someone else's asynch callback mechanism. Most of my methods and functions return void - sometimes I need to be able to return a boolean to the third-party async callback. — Tom Swirly, Dec 27 '10 at 02:30
This is very slick! There are not one or two but three tricks I didn't get right - one being the two NO cases in the overload of testFunction, one being the hasOperatorMethodStruct fiddle, and one being the way of combining these two conditions! Very educational, I owe you a refreshing beverage of your choice. — Tom Swirly, Dec 27 '10 at 02:39
OK, sorry if I'm dense here - but now I'm attempting to fit it in, I still don't see how to generically *call* the function. — Tom Swirly, Dec 27 '10 at 02:45
I see now why print(void) doesn't work. The *calling* part proved challenging. Perhaps my latest addition to this will prove more helpful, even if it is quite kludgy... — Mr.Ree, Dec 27 '10 at 03:20
You led me to a better overall solution. See my comment in the original posting... an impressive performance on your part! — Tom Swirly, Dec 27 '10 at 03:26
Glad to help. I think we may have been converging on the solution there... (See my latest addition...) — Mr.Ree, Dec 27 '10 at 03:37

score 0 · Answer 4 · answered Dec 27 '10 at 00:38

0

With C++0x you could do that easily by using decltype.

answered Dec 27 '10 at 00:38

peoro

25,562
20
98
150

score 0 · Answer 5 · answered Dec 27 '10 at 01:36

If you can use Boost, the following code will serve probably. I presume all the functions/functors are nullary as in your question. However, in order to use this, result_type has to be defined in all the functors(function class).

#include <boost/utility/result_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits.hpp>
using namespace boost; // Sorry, for brevity

template< class F >
// typename result_of< F() >::type
typename disable_if<
  is_void< typename result_of< F() >::type >
, typename result_of< F() >::type
>::type
f( F const& x )
{
  return x();
}

template< class F >
typename enable_if<
  is_void< typename result_of< F() >::type >, bool
>::type
f( F const& x )
{
  x();
  return true;
}

template< class T >
T f( T x() )
{
  return x();
}

bool f( void x() )
{
  x();
  return true;
}

static void void_f() {}
static int int_f() { return 1; }

struct V {
  typedef void result_type;
  result_type operator()() const {}
};

struct A {
  typedef int result_type;
  result_type operator()() const { return 1; }
};

int main()
{
  A  a;
  V  v;
  f( void_f );
  f( int_f );
  f( a );
  f( v );
}

Hope this helps

score -1 · Answer 6 · answered Dec 26 '10 at 22:34

-1

try to specialize for void return type:

template<class F>
class traits;

template<class F, class T>
class traits<T (F)()>;

template<class F>
class traits<void (F)()>;

i think ...

answered Dec 26 '10 at 22:34

Anycorn

50,217
42
167
261

SFINAE and detecting if a C++ function object returns void

6 Answers6

Linked