In C++ 11, how do I specialize a function template that takes a function object based on return type?

Question

I have a wrapper function in C++ 11, designed to be used with lambdas, like so:

template<typename Func>
int WrapExceptions(Func&& f)
{
  try
  {
    return f();
  }
  catch(std::exception)
  {
    return -1;
  }
}

And I can call it like so:

int rc = WrapExceptions([&]{
  DoSomething();
  return 0;
});
assert(rc == 0);

And life is OK. What I want to do, though, is overload or specialize the wrapper function such that when the inner function returns void, the outer function returns a default value of 0, e.g.:

int rc = WrapExceptions([&]{
  DoSomething();
});
assert(rc == 0);

Can I actually do this in C++ 11? I cannot for the life of me think of how.

Answer 1

You may use SFINAE:

• with std::result_of

  template<typename Func>
  typename std::enable_if<
      std::is_convertible<typename std::result_of<Func()>::type, int>::value,
      int
      >::type
  WrapExceptions(Func&& f)
  {
    try { return f(); }
    catch(std::exception) { return -1; }
  }
  
  template<typename Func>
  typename std::enable_if<
      std::is_same<void, typename std::result_of<Func()>::type>::value,
      int
      >::type
  WrapExceptions(Func&& f)
  {
    try { f(); return 0; /* default value */ }
    catch(std::exception) { return -1; }
  }
  

• with decltype:

  template<typename Func>
  auto
  WrapExceptions(Func&& f)
  -> typename std::enable_if<
      std::is_convertible<decltype(f()), int>::value,
      int
      >::type
  {
    try { return f(); }
    catch(std::exception) { return -1; }
  }
  
  template<typename Func>
  auto
  WrapExceptions(Func&& f)
  -> typename std::enable_if<
      std::is_same<void, decltype(f())>::value,
      int
      >::type
  {
    try { f(); return 0; }
    catch(std::exception) { return -1; }
  }
  

Answer 2

Maybe a bit over-engineered, but you can use tag dispatch:

#include <stdexcept>
#include <type_traits>
#include <utility>

namespace detail
{
    struct returns_convertible_to_int {};
    struct returns_void {};

    template<typename Func>
    int WrapException_dispatch(Func&& f, returns_convertible_to_int)
    {
        return f();
    }

    template<typename Func>
    int WrapException_dispatch(Func&& f, returns_void)
    {
        f();
        return 0;
    }

    template<typename T, typename dummy = void>
    struct dispatch
    {
        static_assert(std::is_same<T, void>::value,
                      "Incompatible return type");
    };

    template<typename T>
    struct dispatch<T,
        typename std::enable_if< std::is_convertible<T, int>{} >::type>
    {
        using type = returns_convertible_to_int;
    };

    template<typename T>
    struct dispatch<T,
        typename std::enable_if< std::is_same<T, void>{} >::type>
    // alt: template<> struct dispatch<void,void>
    {
        using type = returns_void;
    };
}

template<typename Func>
int WrapException(Func&& f)
{
    try
    {
        return detail::WrapException_dispatch( std::forward<Func>(f),
            typename detail::dispatch<decltype(f())>::type{} );
    }
    catch(std::exception const&) { return -1; }
}

Usage example:

int foo() { return 42; }
void bar() {}

int main()
{
    WrapException(foo);
    WrapException(bar);
}

---

You can, of course, implement a shorter dispatch:

namespace detail
{
    template<typename Func>
    auto WrapException_dispatch(Func&& f, int)
    -> typename std::enable_if<
           std::is_convertible<decltype(f()), int>::value, int
       >::type
    {
        return f();
    }

    template<typename Func>
    int WrapException_dispatch(Func&& f, ...)
    {
        f();
        return 0;
    }
}

template<typename Func>
int WrapException(Func&& f)
{
    try
    {
        return detail::WrapException_dispatch( std::forward<Func>(f), 0 );
    }
    catch(std::exception const&) { return -1; }
}