Ergreifen Sie einen "sub" -Vektor und "verketten" Vektoren

Question

Also schreibe ich ein paralleles Programm (boost.mpi) und ich möchte Teile eines Vektors übergeben (wie in std :: vector), die zusammengebaut werden können ein ganzer Vektor.

Um dies zu tun, ich möchte 2 Dinge zu tun in der Lage:

1. greifen ein Stück eines vector- also sagen, ein Vektor 800 Elemente hat, was der beste Weg ist, um dann zu machen ein Subvektor, der die Elemente 200-299 enthält (oder beliebige Indizes, die durch 2 int-Variablen definiert sind)?

2. Ich möchte einen Operator erstellen, mit dem ich Vektoren hinzufügen kann, um einen neuen, längeren Vektor zu erstellen. Grundsätzlich möchte ich die gleiche Funktionalität, die std :: plus() (kann verketten Strings) gibt, aber für Vektoren. Ich muss in der Lage sein, diesen Operator als einen binären Operator zu übergeben (er müsste den gleichen Typ wie std :: plus() haben).

Jede Hilfe mit diesem würde sehr geschätzt werden. kann

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

Der zweite Teil erreicht werden vector::insert verwenden, aber es ist wahrscheinlich eine bessere Art und Weise:

Answer 1

Der erste Teil kann mit Hilfe des folgenden Vektor Konstruktor erreicht werden. Ich habe eine Probe von jedem unten gegeben.

#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 
} 

Ausgang:

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: ich wirklich ein schlechtes Gefühl haben, wie ich das tat, aber ich habe den Code aktualisiert mit Dingen wie std::accumulate zu arbeiten.