Der beste Weg, um einen Subvektor aus einem Vektor zu extrahieren?

Angenommen, ich habe eine Größe std::vector(nennen wir es myVec) N. Was ist der einfachste Weg, einen neuen Vektor zu konstruieren, der aus einer Kopie der Elemente X bis Y besteht, wobei 0 <= X <= Y <= N-1? Zum Beispiel myVec [100000]durch myVec [100999]in einem Vektor der Größe 150000.

Wenn dies mit einem Vektor nicht effizient durchgeführt werden kann, gibt es einen anderen STL-Datentyp, den ich stattdessen verwenden sollte?

vector<T>::const_iterator first = myVec.begin() + 100000;
vector<T>::const_iterator last = myVec.begin() + 101000;
vector<T> newVec(first, last);

Es ist eine O (N) -Operation, um den neuen Vektor zu konstruieren, aber es gibt keinen besseren Weg.

Verwenden Sie einfach den Vektorkonstruktor.

std::vector<int>   data();
// Load Z elements into data so that Z > Y > X

std::vector<int>   sub(&data[100000],&data[101000]);

std::vector<T>(input_iterator, input_iterator), in Ihrem Fall foo = std::vector<T>(myVec.begin () + 100000, myVec.begin () + 150000);, sehen Sie zum Beispiel hier

In diesen Tagen verwenden wir spans! Sie würden also schreiben:

#include <gsl/span>

...
auto start_pos = 100000;
auto length = 1000;
auto span_of_myvec = gsl::make_span(myvec);
auto my_subspan = span_of_myvec.subspan(start_pos, length);

um eine Spanne von 1000 Elementen des gleichen Typs wie myvec's zu erhalten. Oder eine knappere Form:

auto my_subspan = gsl::make_span(myvec).subspan(1000000, 1000);

(aber ich mag das nicht so sehr, da die Bedeutung jedes numerischen Arguments nicht ganz klar ist; und es wird schlimmer, wenn die Länge und start_pos in der gleichen Größenordnung liegen.)

Denken Sie jedoch daran, dass dies keine Kopie ist, sondern nur eine Ansicht der Daten im Vektor. Seien Sie also vorsichtig. Wenn Sie eine tatsächliche Kopie wünschen, können Sie Folgendes tun:

std::vector<T> new_vec(my_subspan.cbegin(), my_subspan.cend());

Anmerkungen:

• gslsteht für Guidelines Support Library. Weitere Informationen gslfinden Sie unter: http://www.modernescpp.com/index.php/c-core-guideline-the-guidelines-support-library .
• Eine Implementierung von gslfinden Sie unter: https://github.com/Microsoft/GSL
• C ++ 20 bietet eine Implementierung von span. Sie würden std::spanund #include <span>eher als #include <gsl/span>.
• Weitere Informationen zu Spannweiten finden Sie unter: Was ist eine "Spannweite" und wann sollte ich eine verwenden?
• std::vector hat eine Unmenge von Konstruktoren, es ist super einfach, in einen zu fallen, den Sie nicht verwenden wollten, seien Sie also vorsichtig.

Wenn beide nicht geändert werden sollen (kein Hinzufügen / Löschen von Elementen - das Ändern vorhandener Elemente ist in Ordnung, solange Sie auf Threading-Probleme achten), können Sie einfach data.begin() + 100000und weitergeben data.begin() + 101000und so tun, als wären sie das begin()und end()eines kleineren Vektors.

Da die Vektorspeicherung garantiert zusammenhängend ist, können Sie einfach ein Array mit 1000 Elementen übergeben:

T *arrayOfT = &data[0] + 100000;
size_t arrayOfTLength = 1000;

Beide Techniken benötigen eine konstante Zeit, erfordern jedoch, dass die Datenlänge nicht zunimmt, was eine Neuzuweisung auslöst.

Diese Diskussion ist ziemlich alt, aber die einfachste erwähnte noch nicht, mit list-Initialisierung :

 vector<int> subvector = {big_vector.begin() + 3, big_vector.end() - 2}; 

Es erfordert c ++ 11 oder höher.

Anwendungsbeispiel:

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(){

    vector<int> big_vector = {5,12,4,6,7,8,9,9,31,1,1,5,76,78,8};
    vector<int> subvector = {big_vector.begin() + 3, big_vector.end() - 2};

    cout << "Big vector: ";
    for_each(big_vector.begin(), big_vector.end(),[](int number){cout << number << ";";});
    cout << endl << "Subvector: ";
    for_each(subvector.begin(), subvector.end(),[](int number){cout << number << ";";});
    cout << endl;
}

Ergebnis:

Big vector: 5;12;4;6;7;8;9;9;31;1;1;5;76;78;8;
Subvector: 6;7;8;9;9;31;1;1;5;76;

Sie haben nicht erwähnt, um welchen Typ es sich std::vector<...> myVechandelt, aber wenn es sich um einen einfachen Typ oder eine Struktur / Klasse handelt, die keine Zeiger enthält, und Sie die beste Effizienz erzielen möchten, können Sie eine direkte Speicherkopie erstellen (die meiner Meinung nach schneller ist als die andere Antworten). Hier ist ein allgemeines Beispiel dafür, std::vector<type> myVecwo typein diesem Fall ist int:

typedef int type; //choose your custom type/struct/class
int iFirst = 100000; //first index to copy
int iLast = 101000; //last index + 1
int iLen = iLast - iFirst;
std::vector<type> newVec;
newVec.resize(iLen); //pre-allocate the space needed to write the data directly
memcpy(&newVec[0], &myVec[iFirst], iLen*sizeof(type)); //write directly to destination buffer from source buffer

Sie könnten einfach verwenden insert

vector<type> myVec { n_elements };

vector<type> newVec;

newVec.insert(newVec.begin(), myVec.begin() + X, myVec.begin() + Y);

Sie können die STL-Kopie mit O (M) -Leistung verwenden, wenn M die Größe des Subvektors ist.

Die einzige Möglichkeit, eine Sammlung zu projizieren, die keine lineare Zeit ist, besteht darin, dies träge zu tun, wobei der resultierende "Vektor" tatsächlich ein Subtyp ist, der an die ursprüngliche Sammlung delegiert. Zum Beispiel erstellt die List#subseqMethode von Scala eine Teilsequenz in konstanter Zeit. Dies funktioniert jedoch nur, wenn die Sammlung unveränderlich ist und wenn die zugrunde liegende Sprache eine Speicherbereinigung enthält.

Ich wette, der erste Codierer ist jetzt fertig. Für einfache Datentypen ist keine Kopie erforderlich. Setzen Sie einfach auf gute alte C-Code-Methoden zurück.

std::vector <int>   myVec;
int *p;
// Add some data here and set start, then
p=myVec.data()+start;

Übergeben Sie dann den Zeiger p und a len an alles, was einen Subvektor benötigt.

notelen muss sein !! len < myVec.size()-start

Vielleicht ist array_view / span in der GSL-Bibliothek eine gute Option.

Hier ist auch eine einzelne Dateiimplementierung : array_view .

Kopieren Sie Elemente von einem Vektor zu einem anderen leicht
In diesem Beispiel verwende ich einen Vektor von Paaren zu machen , leicht zu verstehen ,
`

vector<pair<int, int> > v(n);

//we want half of elements in vector a and another half in vector b
vector<pair<lli, lli> > a(v.begin(),v.begin()+n/2);
vector<pair<lli, lli> > b(v.begin()+n/2, v.end());


//if v = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
//then a = [(1, 2), (2, 3)]
//and b = [(3, 4), (4, 5), (5, 6)]

//if v = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7)]
//then a = [(1, 2), (2, 3), (3, 4)]
//and b = [(4, 5), (5, 6), (6, 7)]

„
Wie Sie sehen, können Sie Elemente problemlos von einem Vektor in einen anderen kopieren. Wenn Sie beispielsweise Elemente aus Index 10 bis 16 kopieren möchten, verwenden wir diese

vector<pair<int, int> > a(v.begin()+10, v.begin+16);

und wenn Sie Elemente von Index 10 bis zu einem Index von Ende möchten, dann in diesem Fall

vector<pair<int, int> > a(v.begin()+10, v.end()-5);

Ich hoffe, das hilft. Denken Sie nur an den letzten Fall v.end()-5 > v.begin()+10

Noch eine Option: Nützlich zum Beispiel beim Wechseln zwischen a thrust::device_vectorund a thrust::host_vector, wo Sie den Konstruktor nicht verwenden können.

std::vector<T> newVector;
newVector.reserve(1000);
std::copy_n(&vec[100000], 1000, std::back_inserter(newVector));

Sollte auch Komplexität O (N) sein

Sie können dies mit dem oberen Antwortcode kombinieren

vector<T>::const_iterator first = myVec.begin() + 100000;
vector<T>::const_iterator last = myVec.begin() + 101000;
std::copy(first, last, std::back_inserter(newVector));