Question

我在C ++ 11中有一个包装函数，设计用于lambdas，如下所示：

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

我可以这样称呼它：

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

生活还可以。但是，我想要做的是重载或专门化包装函数，这样当内部函数返回void时，外部函数返回默认值0，例如：

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

我可以在C ++ 11中实际执行此操作吗？我不能为我的生活想想如何。

Answer 1

您可以使用SFINAE：

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

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

可能有点过度设计，但你可以使用标签调度：

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

用法示例：

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

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

当然，您可以实施更短的调度：

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

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

2 个答案: