Question

大家早上好。

我是C ++ 11多线程主题的新手，正在尝试编写代码以异步方式添加两个大小相等的向量。这意味着，如果我有两个向量：

vector<int> fisrt = {1, 2, 3};
vector<int> second = {3, 2, 1};
first += second; // first = {4, 4, 4}

我写了Paginator类，它用适当的page_size在“页面”上分割向量。我接下来以异步方式添加向量的想法是：在选择了page_size的页面上拆分向量，并以异步方式添加第一和第二向量的页面。

Paginator类的实现

template<class Iter>
class IterRange {
public:
    explicit IterRange(Iter first, Iter last) : first_(first), last_(last) {}

    Iter begin() { return first_; }
    const Iter begin() const { return first_; }

    Iter end() { return last_; }
    const Iter end() const { return last_; }

private:
    Iter first_;
    Iter last_;
};

template<class Iter>
IterRange<Iter> MakeIterRange(Iter first, Iter last) {
    return IterRange<Iter> {first, last };
}

template<class Iter>
class Paginator {
public:
    Paginator(Iter first, Iter last, size_t page_size) : page_size_(page_size) {
        size_t pages_count = static_cast<size_t> (floor((double)distance(first, last) / page_size_));
        pages_.reserve(pages_count);

        size_t page_id = 0u;
        Iter begin_page = first;
        for (page_id, begin_page; page_id < pages_count; ++page_id, begin_page += page_size_) {
            pages_.push_back(MakeIterRange( begin_page,  begin_page + page_size ));
        }

        // If some elements less than page_size_ is left
        if (begin_page != last) {
            pages_.push_back(MakeIterRange(begin_page, begin_page + distance(begin_page, last)));
        }
    }

    auto begin() { return pages_.begin(); }
    auto begin() const { return pages_.begin(); }

    auto end() { return pages_.end(); }
    auto end() const { return pages_.end(); }

private:
    size_t page_size_;
    vector<IterRange<Iter>> pages_;
};

template<class Iter>
Paginator<Iter> MakePaginator(Iter first, Iter last, size_t page_size) {
    return{ first, last, page_size };
}

template<class Container> // And the same for non constant Container
auto Paginate(const Container & c, size_t page_size) {
    return MakePaginator(begin(c), end(c), page_size);
}

此分页过程在Matrix类的operator + =中使用。

矩阵类字段为：

分别沿Ox和Oy方向的矩阵大小： size_t nx _ ， size_t ny _ 。
（nx_ * ny_）大小的向量，它将所有元素存储在矩阵中：向量body _ 。

矩阵的运算符+ =

模板内联Matrix和Matrix :: operator + =（const Matrix等）{

size_t threads_numb = thread::hardware_concurrency();
size_t page_size = static_cast<size_t> (ceil((double)body_.size() / threads_numb));
    vector<future<void>> futures;

    auto page_1 = page::Paginate(body_, page_size);
    auto page_2 = page::Paginate(other.body_, page_size);

    auto it_2 = page_2.begin();

    for (auto it = page_1.begin(); it != page_1.end(); ++it, ++it_2) {
        futures.push_back(
            async([it, it_2] { transform(it->begin(), it->end(), it_2->begin(), it->begin(), plus<T>()); })
        );
    }

    return *this;
}

但是结果是我得到了迭代器超出范围的错误！我该如何解决？

P.S。抱歉，运算符+ =中的第一个字符串表示不正确。无法解决此问题：（

C ++如何异步添加两个向量

0 个答案: