Захватите «суб» -вектор и «конкатенируйте» векторы - PullRequest
Новая
       45

Захватите «суб» -вектор и «конкатенируйте» векторы

0 голосов
/ 30 марта 2012

Итак, я пишу параллельную программу (boost.mpi) и хочу передать части вектора (как в std :: vector), которые можно собрать для создания целого вектора.

Длячтобы сделать это, я хочу иметь возможность сделать 2 вещи:

  1. захватить часть вектора - то есть, скажем, вектор имеет 800 элементов, что является лучшим способом сделатьсубвектор, который содержит элементы 200-299 (или произвольные индексы, определенные 2 переменными типа int)?

  2. Я хочу создать оператор, который позволит мне добавлять векторы вместе, чтобы создать новый, более длинныйвектор.По сути, мне нужна та же функциональность, которую предоставляет std :: plus () (может объединять строки), но для векторов.Мне нужно будет передать этот оператор как бинарный оператор (он должен иметь тот же тип, что и std :: plus ()).

Любая помощь вообще с этимбудет высоко ценится.

1 Ответ

0 голосов
/ 30 марта 2012

Первая часть может быть достигнута с помощью следующего векторного конструктора: 

template <class InputIterator>
vector( InputIterator first, InputIterator last, 
        const Allocator& alloc = Allocator() );

Вторая часть может быть достигнута с помощью vector::insert, но, возможно, есть лучший способ. Я дал образец каждого ниже. 

#include <vector>
using std::vector;

template <typename T>
vector<T> operator+ (const vector<T> &lhs, const vector<T> &rhs)
{
    vector<T> ret (lhs);
    ret.insert (ret.end(), rhs.begin(), rhs.end());
    return ret;
}

/// new //create a structure like std::plus that works for our needs, could probably turn vector into another template argument to allow for other templated classes
template <typename T>
struct Plus
{
    vector<T> operator() (const vector<T> &lhs, const vector<T> &rhs)
    {
        return lhs + rhs;
    }
};
/// end new

#include <iostream>
using std::cout;

/// new
#include <numeric>
using std::accumulate;
/// end new

template <typename T>
void print (const vector<T> &v)
{
    for (const T &i : v)
        cout << i << ' ';

    cout << '\n';
}

int main()
{
    vector<int> vMain {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; //syntax only available in C++11
    vector<int> vSub (vMain.begin() + 3, vMain.begin() + 6); //vMain[0+3]=4, vMain[0+6]=7
    vector<int> vCat = vMain + vSub;

    /// new
    vector<vector<int>> vAdd {vMain, vMain}; //create vector of vector of int holding two vMains
    /// end new

    print (vMain);
    print (vSub);
    print (vCat);

    /// new //accumulate the vectors in vAdd, calling vMain + vMain, starting with an empty vector of ints to hold the result
    vector<int> res = accumulate (vAdd.begin(), vAdd.end(), (vector<int>)(0));//, Plus<int>());
    print (res); //print accumulated result
    /// end new
}

Выход: 

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

EDIT: У меня действительно плохое предчувствие, как я это сделал, но я обновил код для работы с такими вещами, как std::accumulate.

...