C++ 为分治算法c+连接两个向量+；

我试图得到一个分治算法，它返回一个向量，由于它是一个分治算法，它显然需要一次运行多个实例。问题是当它涉及到返回部分时

现在我有：

vector<MyObject> MyProgram(...){
    ...Code that's not important...
    return MyProgram(...) + MyProgram(...);
}

向量MyProgram（…）{ …不重要的代码。。。 返回MyProgram（…）+MyProgram（…）； }

---

不幸的是，显然我不能只使用+操作数。我知道可以通过将一个向量插入到另一个向量中或将一个向量复制到另一个向量中来连接向量，但是MyProgram将一个接一个地被调用，而不是同时被调用。

使用包装器。现在只需向该类添加一个重载的

操作符+

这样的包装可以如下所示：

class Wrapper
{
public:
       Wrapper(const vector<MyObject>& _vec) : vec(_vec) {}
       Wrapper operator+(Wrapper& rhs)
       {
           vector<MyObject> tmp(vec);
           tmp.insert(tmp.end(), rhs.vec.begin(), rhs.vec.end());
           return Wrapper(tmp);
       }

       operator const vector<MyObject>&(){return vec;}

private:
       vector<MyObject> vec;
};

---

请查看有关您当前设计的重要警告的评论。

我猜这就是您试图实现的目标，但这充其量只是猜测，因此请告诉我是否应该删除此答案，因为它不适用

下面定义了一个函数，如果参数为零，该函数将返回空向量。否则，is返回值为N的N个实例的向量，该值与在N-1处计算的函数连接在一起。连接是通过一个单独的线程异步完成的，因此提供了并发的可能性

#include <iostream>
#include <vector>
#include <future>

std::vector<unsigned int> MyFunction(unsigned arg)
{
    std::vector<unsigned int> result;
    if (arg == 0)
        return result;

    auto fc = std::async(std::launch::async, MyFunction, arg-1);

    for (unsigned int i=0; i<arg; ++i)
        result.emplace_back(arg);

    std::vector<unsigned int> theirs = fc.get();
    result.insert(result.begin(), theirs.begin(), theirs.end());
    return result;
}

int main()
{
    std::vector<unsigned int> res = MyFunction(8);
    for (auto x : res)
        std::cout << x << ' ';
    std::cout << std::endl;

    return 0;
}

每个微型序列在一个单独的线程上生成，第一个除外，在本例中是在主线程上生成的8序列

---

不管怎样，我希望它能给你一些想法。

MyProgram

是一个函数，所以它总是一个接一个地被调用。无论哪种方式，它都会被一个接一个地调用-事情同时发生的唯一方式是如果你使用多线程，您需要专门为其编写代码。对于并行编程，您需要设置多个线程来完成任务。这是一项复杂的任务。必须针对每种具体情况评估有效性。我怀疑你的情况也会是这样，因为你有一个递归函数。@andreaplanet:它没有那么复杂，但也不像OP想的那么简单。递归本身并不是它应该如此缓慢的原因，我认为主要的目标不是使向量连接并发，而是使整个MyProgram函数并行执行。顺便说一句，代码不错。@andreaplanet谢谢。正如我所说，我甚至很难理解到底发生了什么。上面的代码应该可以正确并行执行，但我经常会将未来的析构函数逻辑向后推，所以据我所知，我只是浪费了大量的时间=P。至少格式很好。如果我理解正确，您的建议也可以写成return MyProgram（…）+MyProgram（…）；替换为返回std:：async（std:：launch:：async，MyProgram，…）.get（）+std:：async（std:：launch:：async，MyProgram，…）.get（）@安德雷亚普兰，你可以。对临时工要小心，在这方面我通常会犯错误（如果不是很明显的话。但是如果启动程序什么都不做，只是等待两个线程都完成，那么就没有理由启动两个线程。最好在一个线程上完成一半的工作，在当前线程上完成另一个线程，这就是我希望在上面传达的目的。是的，在一开始我想给出一个更简单的答案关于多线程解决方案，我也意识到递归会创建很多线程，而我们不能创建太多线程。需要一个为递归函数优化的处理队列，因此我意识到它将比简单的独立线程并行执行更复杂。

#include <iostream>
#include <vector>
#include <future>

std::vector<unsigned int> MyFunction(unsigned arg)
{
    std::vector<unsigned int> result;
    if (arg == 0)
        return result;

    auto fc = std::async(std::launch::async, MyFunction, arg-1);

    for (unsigned int i=0; i<arg; ++i)
        result.emplace_back(arg);

    std::vector<unsigned int> theirs = fc.get();
    result.insert(result.begin(), theirs.begin(), theirs.end());
    return result;
}

int main()
{
    std::vector<unsigned int> res = MyFunction(8);
    for (auto x : res)
        std::cout << x << ' ';
    std::cout << std::endl;

    return 0;
}

1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8