C++ 如何在卡萨布兰卡捕获多个任务的异常

我试图使用of任务连接两个pplx任务，其中两个子任务都可以抛出异常

我从中了解到，我可以在最终的基于任务的延续中捕获异常。这在卡萨布兰卡也适用。 然而，在最后的继续中，我只能捕捉到一个异常。如果两个子任务都抛出，则其中一个子任务保持未处理状态

下面是一个简单的例子来说明我的问题：

#包括
#包括
int main（int argc，char*argv[]）
{
int a=0；int b=0；
auto t1=pplx:：create_任务（[a]{返回a+1；}）
然后（[]（inta）{throw std:：runtime_error（“a”）；
返回a+1；}）；
auto t2=pplx:：创建_任务（[b]{return b+1；}）
然后（[]（intb）{throw std:：runtime_error（“b”）；
返回b+1；}）；
（t1和t2）
。然后（[]（std:：vector）{/*…*/}）
.然后（[]（pplx:：task prev）{
试一试{
prev.get（）；
}捕获（标准：：运行时错误e）{
std：：cout您必须为每个子任务添加最后一个基于任务的延续。
我建议您重新抛出捕获到的任何异常，但是，这可能是一个坏主意，因为continuation任务没有意识到这两个异常是等效的，请参见下面的示例以获取证据。

输出：

抓住了一个

捕获最后一个

捕获b

此外，如果删除睡眠，您将收到“跟踪/断点陷阱”异常

#include <pplx/pplxtasks.h>
#include <iostream>

int main(int argc, char *argv[])
{
    int a = 0; int b = 2;

    auto t1 = pplx::create_task([a] { return a+1; })
    .then([](int a) { throw std::runtime_error("a"); return a+1; })
    .then([] (pplx::task<int> prev)
    {
        int retVal = -1;
        try
        {
            retVal = prev.get();
        }
        catch (std::runtime_error e)
        {
            std::cout << "caught " << e.what() << std::endl;
            throw e;
        }

        return retVal;
    });

    auto t2 = pplx::create_task([b] { return b+1; })
    .then([](int b) { throw std::runtime_error("b"); return b+1; })
    .then([] (pplx::task<int> prev)
    {
        int retVal = -1;
        try
        {
            sleep(1);
            retVal = prev.get();
        }
        catch (std::runtime_error e)
        {
            std::cout << "caught " << e.what() << std::endl;
            throw e;
        }

        return retVal;
    });

    (t1 && t2)
    .then([] (std::vector<int> v) { for(int i : v) { std::cout << i << std::endl; } })
    .then([] (pplx::task<void> prev)
    {
        try
        {
            prev.get();
        }
        catch (std::runtime_error e)
        {
            std::cout << "caught final " << e.what() << std::endl;
        }
    }).get();
}

#包括
#包括
int main（int argc，char*argv[]）
{
INTA=0；INTB=2；
auto t1=pplx:：create_任务（[a]{返回a+1；}）
。然后（[]（int a）{throw std:：runtime_error（“a”）；返回a+1；}）
.然后（[]（pplx:：task prev）
{
int-retVal=-1；
尝试
{
retVal=prev.get（）；
}
捕获（标准：：运行时错误e）
{
标准：：cout
#include <pplx/pplxtasks.h>
#include <iostream>

int main(int argc, char *argv[])
{
    int a = 0; int b = 2;

    auto t1 = pplx::create_task([a] { return a+1; })
    .then([](int a) { throw std::runtime_error("a"); return a+1; })
    .then([] (pplx::task<int> prev)
    {
        int retVal = -1;
        try
        {
            retVal = prev.get();
        }
        catch (std::runtime_error e)
        {
            std::cout << "caught " << e.what() << std::endl;
            throw e;
        }

        return retVal;
    });

    auto t2 = pplx::create_task([b] { return b+1; })
    .then([](int b) { throw std::runtime_error("b"); return b+1; })
    .then([] (pplx::task<int> prev)
    {
        int retVal = -1;
        try
        {
            sleep(1);
            retVal = prev.get();
        }
        catch (std::runtime_error e)
        {
            std::cout << "caught " << e.what() << std::endl;
            throw e;
        }

        return retVal;
    });

    (t1 && t2)
    .then([] (std::vector<int> v) { for(int i : v) { std::cout << i << std::endl; } })
    .then([] (pplx::task<void> prev)
    {
        try
        {
            prev.get();
        }
        catch (std::runtime_error e)
        {
            std::cout << "caught final " << e.what() << std::endl;
        }
    }).get();
}