C++ std::async() 在调用 future.get() 之前因异常终止

Question

我正在尝试创建一个在捕获异常时调用 std::terminate() 的包装器。 我希望这个包装器采用与 std::async() 相同的参数（它可以是对函数的调用以及对方法的调用）。 有人知道如何编译这段代码吗？

谢谢

http://ideone.com/tL7mTv

#include <iostream>
#include <functional>
#include <future>

template<class Fn, class... Args>
inline auto runTerminateOnException(Fn&& fn, Args&&... args) {
    try {
        return std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...)();
    } catch (...) {
        std::terminate();
    }
}

template<class Fn, class... Args>
inline auto runAsyncTerminateOnException(Fn&& fn, Args&&... args) {
    return std::async(std::launch::async, runTerminateOnException<Fn, Args&&...>, std::forward<Fn>(fn), std::forward<Args>(args)...);
}

struct Foo {
    void print() {
        printf("Foo::print()\n");
    }
};

int main() {
    Foo foo;
    std::future<void> future = runAsyncTerminateOnException(&Foo::print, &foo);
    // your code goes here
    return 0;
}

Answer 1

我个人认为你有点过于复杂了。您可以绑定调用并使用简单的 lambda 进行包装。

#include <iostream>
#include <future>
#include <functional>
#include <type_traits>

template<class Fn, class... Args>
inline auto runAsyncTerminateOnException(Fn&& fn, Args&&... args) {
    auto make_call = std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...);

    return std::async(std::launch::async, [=]() -> decltype(make_call()) {
        try {
            return make_call();
        } catch (...) {
            std::cout << "Terminate Called!" << std::endl;
            std::terminate();
        }
    });
}

struct Foo {
    void print() {
        printf("Foo::print()\n");
    }
    void print2() {
        printf("Foo::print2()\n");
        throw 1;
    }
};

int main() {
    Foo foo;
    std::future<void> future = runAsyncTerminateOnException(&Foo::print, &foo);
    std::future<void> future2 = runAsyncTerminateOnException(&Foo::print2, &foo);
    return 0;
}

See it live, with possible output.

---

我显然复制了第一个闭包，而不是执行将其移动到第二个闭包所需的步骤（就像在 c++11 中所做的那样）。您当然可以使用 c++14 中的特定移动捕获来移动它。

Answer 2

在 c++17 中，干净的方法是使用std::invoke。

我已经在这里破解了它来演示。

#include <iostream>
#include <future>
#include <functional>
#include <type_traits>

namespace std
{
template<class T>
static constexpr bool is_member_pointer_v = std::is_member_pointer<T>::value;
template<class T>
static constexpr bool is_function_v = std::is_function<T>::value;
template<class B, class T>
static constexpr bool is_base_of_v = std::is_base_of<B, T>::value;
namespace detail {
template <class T>
struct is_reference_wrapper : std::false_type {};
template <class U>
struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
template <class T>
constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;

template <class Base, class T, class Derived, class... Args>
auto INVOKE(T Base::*pmf, Derived&& ref, Args&&... args)
    noexcept(noexcept((std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...)))
 -> std::enable_if_t<std::is_function_v<T> &&
                     std::is_base_of_v<Base, std::decay_t<Derived>>,
    decltype((std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...))>
{
      return (std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...);
}

template <class Base, class T, class RefWrap, class... Args>
auto INVOKE(T Base::*pmf, RefWrap&& ref, Args&&... args)
    noexcept(noexcept((ref.get().*pmf)(std::forward<Args>(args)...)))
 -> std::enable_if_t<std::is_function_v<T> &&
                     is_reference_wrapper_v<std::decay_t<RefWrap>>,
    decltype((ref.get().*pmf)(std::forward<Args>(args)...))>

{
      return (ref.get().*pmf)(std::forward<Args>(args)...);
}

template <class Base, class T, class Pointer, class... Args>
auto INVOKE(T Base::*pmf, Pointer&& ptr, Args&&... args)
    noexcept(noexcept(((*std::forward<Pointer>(ptr)).*pmf)(std::forward<Args>(args)...)))
 -> std::enable_if_t<std::is_function_v<T> &&
                     !is_reference_wrapper_v<std::decay_t<Pointer>> &&
                     !std::is_base_of_v<Base, std::decay_t<Pointer>>,
    decltype(((*std::forward<Pointer>(ptr)).*pmf)(std::forward<Args>(args)...))>
{
      return ((*std::forward<Pointer>(ptr)).*pmf)(std::forward<Args>(args)...);
}

template <class Base, class T, class Derived>
auto INVOKE(T Base::*pmd, Derived&& ref)
    noexcept(noexcept(std::forward<Derived>(ref).*pmd))
 -> std::enable_if_t<!std::is_function_v<T> &&
                     std::is_base_of_v<Base, std::decay_t<Derived>>,
    decltype(std::forward<Derived>(ref).*pmd)>
{
      return std::forward<Derived>(ref).*pmd;
}

template <class Base, class T, class RefWrap>
auto INVOKE(T Base::*pmd, RefWrap&& ref)
    noexcept(noexcept(ref.get().*pmd))
 -> std::enable_if_t<!std::is_function_v<T> &&
                     is_reference_wrapper_v<std::decay_t<RefWrap>>,
    decltype(ref.get().*pmd)>
{
      return ref.get().*pmd;
}

template <class Base, class T, class Pointer>
auto INVOKE(T Base::*pmd, Pointer&& ptr)
    noexcept(noexcept((*std::forward<Pointer>(ptr)).*pmd))
 -> std::enable_if_t<!std::is_function_v<T> &&
                     !is_reference_wrapper_v<std::decay_t<Pointer>> &&
                     !std::is_base_of_v<Base, std::decay_t<Pointer>>,
    decltype((*std::forward<Pointer>(ptr)).*pmd)>
{
      return (*std::forward<Pointer>(ptr)).*pmd;
}

template <class F, class... Args>
auto INVOKE(F&& f, Args&&... args)
    noexcept(noexcept(std::forward<F>(f)(std::forward<Args>(args)...)))
 -> std::enable_if_t<!std::is_member_pointer_v<std::decay_t<F>>,
    decltype(std::forward<F>(f)(std::forward<Args>(args)...))>
{
      return std::forward<F>(f)(std::forward<Args>(args)...);
}
} // namespace detail

template< class F, class... ArgTypes >
auto invoke(F&& f, ArgTypes&&... args)
    // exception specification for QoI
    noexcept(noexcept(detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...)))
 -> decltype(detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...))
{
    return detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...);
}
}

template<class Fn, class... Args>
inline auto runAsyncTerminateOnException(Fn&& fn, Args&&... args) {

    return std::async(std::launch::async, [=]() -> decltype(auto) {
        try {
            return std::invoke(fn, args...);
        } catch (...) {
            std::cout << "Terminate Called!" << std::endl;
            std::terminate();
        }
    });
}

struct Foo {
    void print() {
        printf("Foo::print()\n");
    }
    void print2() {
        printf("Foo::print2()\n");
        throw 1;
    }
};

int main() {
    Foo foo;
    std::future<void> future = runAsyncTerminateOnException(&Foo::print, &foo);
    std::future<void> future2 = runAsyncTerminateOnException(&Foo::print2, &foo);
    return 0;
}

调用模板化成员函数时出错：

错误是这个<source>: In instantiation of 'runAsyncTerminateOnException(Fn&&, Args&& ...)::<lambda()> [with Fn = void (Foo::*)(int&&); Args = {Foo*, int}]':

暗示 Foo::print 要求int&& 当然是。那是你写的：

void print(Args&&... args)

打印函数要求对象的所有权是不合理的。声明它应该是：

struct Foo {
    template<class... Args>
    void print(const Args&... args) {
        printf("Foo::print(%d)\n", args...);
    }
};

Answer 3

我找到了 c++17 的解决方案。 它只有在我们不使用 auto 作为 runTerminateOnException() 的返回类型时才有效。

template<class Fn, class... Args>
inline std::result_of_t<Fn&&(Args&&...)> runTerminateOnException(Fn&& fn, Args&&... args) {
    try {
        return std::invoke(std::forward<Fn>(fn), std::forward<Args>(args)...);
    } catch (...) {
        std::terminate();
    }
}

template<class Fn, class... Args>
inline auto runAsyncTerminateOnException(Fn&& fn, Args&&... args) {
    return std::async(std::launch::async, runTerminateOnException<Fn, Args&&...>, std::forward<Fn>(fn), std::forward<Args>(args)...);
}