Cách tốt nhất để trích xuất một subvector từ một vector?

Giả sử tôi có một std::vector(hãy gọi nó myVec) kích thước N. Cách đơn giản nhất để xây dựng một vectơ mới bao gồm một bản sao của các phần tử X đến Y, trong đó 0 <= X <= Y <= N-1? Ví dụ, myVec [100000]thông qua myVec [100999]một vectơ kích thước 150000.

Nếu điều này không thể được thực hiện hiệu quả với một vectơ, thì có một kiểu dữ liệu STL khác mà tôi nên sử dụng thay thế không?

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

Đây là một hoạt động O (N) để xây dựng vectơ mới, nhưng thực sự không có cách nào tốt hơn.

Chỉ cần sử dụng các hàm tạo vector.

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), trong trường hợp của bạn foo = std::vector<T>(myVec.begin () + 100000, myVec.begin () + 150000);, xem ví dụ ở đây

Những ngày này, chúng tôi sử dụng spans! Vì vậy, bạn sẽ viết:

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

để có được khoảng 1000 phần tử cùng loại với myvec's. Hoặc một hình thức ngắn gọn hơn:

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

(nhưng tôi không thích điều này nhiều vì ý nghĩa của từng đối số số không hoàn toàn rõ ràng; và sẽ tệ hơn nếu độ dài và start_pose có cùng độ lớn.)

Dù sao, hãy nhớ rằng đây không phải là bản sao, nó chỉ là chế độ xem dữ liệu trong vectơ, vì vậy hãy cẩn thận. Nếu bạn muốn có một bản sao thực sự, bạn có thể làm:

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

Ghi chú:

• gsllà viết tắt của Hướng dẫn Hỗ trợ Thư viện. Để biết thêm thông tin về gsl, xem: http://www.modernescpp.com/index.php/c-core-guideline-the-guferences-support-l Library .
• Để biết cách triển khai gsl, hãy xem: https://github.com/Microsoft/GSL
• C ++ 20 cung cấp một triển khai span. Bạn sẽ sử dụng std::spanvà #include <span>hơn là #include <gsl/span>.
• Để biết thêm thông tin về các nhịp, hãy xem: "span" là gì và khi nào tôi nên sử dụng một nhịp?
• std::vector có một nhà xây dựng đáng kinh ngạc, thật dễ dàng để rơi vào một người bạn không có ý định sử dụng, vì vậy hãy cẩn thận.

Nếu cả hai sẽ không được sửa đổi (không thêm / xóa các mục - sửa đổi những cái hiện có là tốt miễn là bạn trả tiền chú ý đến các vấn đề luồng), bạn chỉ có thể vượt qua xung quanh data.begin() + 100000và data.begin() + 101000, và giả vờ rằng họ là nhữngbegin() và end()của một vector nhỏ hơn.

Hoặc, vì lưu trữ vector được đảm bảo liền kề nhau, bạn chỉ cần chuyển qua một mảng 1000 mục:

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

Cả hai kỹ thuật này đều mất thời gian liên tục, nhưng yêu cầu độ dài của dữ liệu không tăng lên, gây ra sự phân bổ lại.

Cuộc thảo luận này khá cũ, nhưng cuộc thảo luận đơn giản nhất chưa được đề cập, với việc khởi tạo danh sách :

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

Nó đòi hỏi c ++ 11 trở lên.

Ví dụ sử dụng:

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

Kết quả:

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;

Bạn đã không đề cập đến loại nào std::vector<...> myVec, nhưng nếu đó là loại đơn giản hoặc cấu trúc / lớp không bao gồm con trỏ và bạn muốn có hiệu quả tốt nhất, thì bạn có thể thực hiện sao chép bộ nhớ trực tiếp (mà tôi nghĩ sẽ nhanh hơn câu trả lời khác được cung cấp). Dưới đây là một ví dụ chung của std::vector<type> myVecnơi typetrong trường hợp này là 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

Bạn chỉ có thể sử dụng insert

vector<type> myVec { n_elements };

vector<type> newVec;

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

Bạn có thể sử dụng bản sao STL với hiệu suất O (M) khi M là kích thước của bộ con.

Cách duy nhất để chiếu một bộ sưu tập không phải là thời gian tuyến tính là làm một cách lười biếng, trong đó "vectơ" kết quả thực sự là một kiểu con mà ủy nhiệm cho bộ sưu tập ban đầu. Ví dụ, List#subseqphương pháp của Scala tạo ra một chuỗi con trong thời gian không đổi. Tuy nhiên, điều này chỉ hoạt động nếu bộ sưu tập là bất biến và nếu ngôn ngữ cơ bản là bộ sưu tập rác thể thao.

Gửi bài này muộn chỉ cho người khác..Tôi cá là lập trình viên đầu tiên được thực hiện ngay bây giờ. Đối với các kiểu dữ liệu đơn giản, không cần sao chép, chỉ cần hoàn nguyên các phương thức mã C cũ.

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

Sau đó chuyển con trỏ p và len tới bất cứ thứ gì cần một bộ con.

phải là notelen !! len < myVec.size()-start

Có lẽ mảng_view / span trong thư viện GSL là một lựa chọn tốt.

Đây cũng là một triển khai tập tin duy nhất: Array_view .

Sao chép các phần tử từ vectơ này sang vectơ khác một cách dễ dàng
Trong ví dụ này, tôi đang sử dụng một vectơ cặp để dễ hiểu
`

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

'
Như bạn thấy, bạn có thể dễ dàng sao chép các phần tử từ vectơ này sang vectơ khác, nếu bạn muốn sao chép các phần tử từ chỉ mục 10 đến 16 chẳng hạn thì chúng tôi sẽ sử dụng

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

và nếu bạn muốn các phần tử từ chỉ mục 10 đến một số chỉ mục từ cuối, thì trong trường hợp đó

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

Hy vọng điều này sẽ giúp, chỉ cần nhớ trong trường hợp cuối cùng v.end()-5 > v.begin()+10

Một tùy chọn khác: Chẳng hạn hữu ích khi di chuyển giữa a thrust::device_vectorvà a thrust::host_vector, trong đó bạn không thể sử dụng hàm tạo.

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

Cũng nên phức tạp O (N)

Bạn có thể kết hợp điều này với mã anwer hàng đầu

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