Bir vektörden bir alt vektör almanın en iyi yolu?

Bir boyutum var std::vector(diyelim myVec) N. X ile Y arasındaki elemanların bir kopyasından oluşan yeni bir vektör oluşturmanın en basit yolu nedir, burada 0 <= X <= Y <= N-1? Örneğin, myVec [100000]içinden myVec [100999]boyutta bir vektör içinde 150000.

Bu bir vektör ile verimli bir şekilde yapılamazsa, bunun yerine kullanmam gereken başka bir STL veri türü var mı?

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

Yeni vektörü oluşturmak için O (N) işlemi, ama gerçekten daha iyi bir yol yok.

Sadece vektör yapıcısını kullanın.

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), sizin durumunuzda foo = std::vector<T>(myVec.begin () + 100000, myVec.begin () + 150000);, örneğin buraya bakın

Bugünlerde spans kullanıyoruz! Yani şunu yazardınız:

#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);

ile aynı türden 1000 öğeden oluşan bir yayılma alanı elde etmek myvec. Veya daha kısa bir form:

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

(ancak bunu sevmiyorum, çünkü her bir sayısal argümanın anlamı tamamen net değil; ve length ve start_pos aynı büyüklükte ise daha da kötüleşir.)

Her neyse, bunun bir kopya olmadığını, sadece vektördeki verilerin bir görünümü olduğunu unutmayın, bu yüzden dikkatli olun. Gerçek bir kopya istiyorsanız, şunları yapabilirsiniz:

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

Notlar:

• gslKılavuzlar Destek Kütüphanesi anlamına gelir. Hakkında daha fazla bilgi için gslbkz . Http://www.modernescpp.com/index.php/c-core-guideline-the-guidelines-support-library .
• Bir uygulaması için gslbkz. Https://github.com/Microsoft/GSL
• C ++ 20 uygulaması sağlar span. Kullanırsınız std::spanve #include <span>yerine #include <gsl/span>.
• Açıklıklar hakkında daha fazla bilgi için, bkz. "Açıklık" nedir ve ne zaman kullanmalıyım?
• std::vector Bir gazilyon kurucuya sahip, kullanmak istemediğiniz birine düşmek çok kolay, bu yüzden dikkatli olun.

Her iki modifiye edilecek değilseniz (hiç ürün ekleme / silme - Varolan değiştirerek sürece parçacığı konulara dikkat etmek olarak gayet), sadece etrafında geçebilir data.begin() + 100000ve data.begin() + 101000ve onlar olduklarını iddia begin()ve end()daha küçük bir vektör.

Ya da, vektör depolamanın bitişik olduğu garanti edildiğinden, 1000 öğelik bir dizinin etrafından geçebilirsiniz:

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

Her iki teknik de sabit zaman alır, ancak verilerin uzunluğunun artmamasını gerektirir ve yeniden tahsisi tetikler.

Bu tartışma oldukça eskidir, ancak listenin başlatılmasıyla en basitinden henüz bahsedilmemiştir :

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

C ++ 11 veya üstünü gerektirir.

Örnek kullanım:

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

Sonuç:

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;

Ne türden bahsetmediniz std::vector<...> myVec, ancak işaretçiler içermeyen basit bir tür veya yapı / sınıfsa ve en iyi verimliliği istiyorsanız, doğrudan bellek kopyası yapabilirsiniz (ki bence verilen diğer cevaplar). İşte bu durumda std::vector<type> myVecnerede olduğuna dair genel bir örnek :typeint

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

Sadece kullanabilirsin insert

vector<type> myVec { n_elements };

vector<type> newVec;

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

Sen kullanabilirsiniz STL kopyasını M subvector boyutudur zaman O (M) performansı ile.

Doğrusal olmayan bir koleksiyonu yansıtmanın tek yolu, sonuçta ortaya çıkan "vektör "'ün aslında orijinal koleksiyona delege olan bir alt tip olduğu tembel olarak yapmaktır. Örneğin, Scala'nınList#subseq yöntemi sabit zamanda bir alt dizi oluşturur. Ancak, bu sadece koleksiyon değişmezse ve temel dil çöp toplama sporu yapıyorsa çalışır.

Bunu sadece diğerleri için geç gönderiyoruz ... Bahse girerim ilk kodlayıcı şu ana kadar yapılıyor. Basit veri tipleri için kopyalamaya gerek yoktur, sadece eski C kodu yöntemlerine dönün.

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

Ardından p işaretçisini ve bir len'i bir alt sektöre ihtiyaç duyan herhangi bir şeye geçirin.

notelen olmalı !! len < myVec.size()-start

Belki GSL kütüphanesindeki array_view / span iyi bir seçenektir.

İşte aynı zamanda tek bir dosya uygulaması: array_view .

Öğeleri bir vektörden diğerine kolayca kopyalayın
Bu örnekte, anlaşılmasını kolaylaştırmak için bir çift vektör kullanıyorum
.

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)]

'
Eğer o zaman kullanırsınız örneğin 16 endeksi 10 öğeleri kopyalamak istiyorsanız kolayca başka bir vektör öğeleri kopyalayabilirsiniz görebileceğiniz gibi

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

ve dizin 10'dan bir dizinin sonuna kadar bazı öğeler istiyorsanız, bu durumda

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

umarım bu yardımcı olur, sadece son durumda hatırla v.end()-5 > v.begin()+10

Yine başka bir seçenek: Örneğin, yapıcıyı kullanamayacağınız a thrust::device_vectorve a arasında hareket ederken thrust::host_vectorkullanışlıdır.

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

Ayrıca karmaşıklık O (N) olmalıdır

Bunu üst anwer koduyla birleştirebilirsiniz

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