在C ++ 11中，如何根据返回类型对一个函数对象进行专门化？

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, eg:

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; }
}