Найкращий спосіб дістати субвектор з вектора?

Припустимо, я маю std::vector(назвемо так myVec) розмір N. Який найпростіший спосіб побудувати новий вектор, що складається з копії елементів X через Y, де 0 <= X <= Y <= N-1? Наприклад, myVec [100000]через myVec [100999]вектор у розмірі 150000.

Якщо це неможливо зробити ефективно з вектором, чи є інший тип даних STL, який я повинен використовувати замість цього?

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

Це операція O (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), у вашому випадку foo = std::vector<T>(myVec.begin () + 100000, myVec.begin () + 150000);дивіться, наприклад, тут

У ці дні ми використовуємо spans! Отже, ви б написали:

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

щоб отримати проміжок 1000 елементів того ж типу, що і myvecs. Або більш лаконічна форма:

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

(але мені це не дуже подобається, оскільки значення кожного числового аргументу не зовсім зрозуміло; і стає гірше, якщо довжина та start_pos мають однаковий порядок.)

У будь-якому випадку пам’ятайте, що це не копія, це лише перегляд даних у векторі, тому будьте обережні. Якщо ви хочете отримати фактичну копію, ви можете зробити:

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

Примітки:

• gslрозшифровується як Бібліотека підтримки керівних принципів. Для отримання додаткової інформації про те gsl, див .: http://www.modernescpp.com/index.php/c-core-guideline-the-guidelines-support-library .
• Про одну реалізацію gslдив. На веб-сторінці : https://github.com/Microsoft/GSL
• C ++ 20 забезпечує реалізацію span. Ви могли б використовувати std::spanі #include <span>замість #include <gsl/span>.
• Для отримання додаткової інформації про проміжки дивіться: Що таке "проміжок" і коли я повинен його використовувати?
• std::vector має газильйон конструкторів, потрапити в той, який ви не збиралися використовувати, дуже просто, тому будьте обережні.

Якщо обидва не будуть змінено (без додавання / видалення елементів - зміна існуючих добре до тих пір , поки ви звернути увагу на багатопотокові питання), ви не можете просто пройти навколо data.begin() + 100000і data.begin() + 101000, і вдавати , що вони є begin()і end()меншим вектором.

Або оскільки векторне зберігання гарантовано є суміжним, ви можете просто пройти навколо масиву 1000 елементів:

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

Обидві ці методи займають постійний час, але вимагають, щоб довжина даних не збільшувалася, викликаючи перерозподіл.

Ця дискусія досить стара, але найпростіша ще не згадується із ініціалізацією списку :

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

Він вимагає c ++ 11 або вище.

Приклад використання:

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

Результат:

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;

Ви не згадали, що це за тип std::vector<...> myVec, але якщо це простий тип або структура / клас, який не включає вказівники, і вам потрібна найкраща ефективність, то ви можете зробити пряму копію пам'яті (що, на мою думку, буде швидше, ніж інші відповіді надано). Ось загальний приклад того, std::vector<type> myVecде typeв цьому випадку 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

Ви можете просто використовувати insert

vector<type> myVec { n_elements };

vector<type> newVec;

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

Ви можете використовувати копію STL з продуктивністю O (M), коли M - розмір субвектора.

Єдиний спосіб спроектувати колекцію, яка не є лінійним часом, - це зробити ліниво, де отриманий "вектор" насправді є підтипом, який делегує оригінальній колекції. Наприклад, List#subseqметод Скали створює підряд в постійному часі. Однак це працює лише в тому випадку, якщо збір є непорушним і якщо основний мовний спортивний збір сміття.

Розміщення цього пізнього лише для інших. Я ставлю ставку, що перший кодер вже зроблений. Для простих типів даних копія не потрібна, просто поверніться до старих хороших методів коду C.

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

Потім переведіть покажчик p і len на все, що потребує субвектора.

примітка повинна бути !! len < myVec.size()-start

Можливо, array_view / span у бібліотеці GSL є хорошим варіантом.

Ось також реалізація одного файлу: array_view .

Копіювати елементи з одного вектора в інший Легко
У цьому прикладі я використовую вектор пар, щоб полегшити розуміння
`

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

"
Як ви бачите, ви можете легко копіювати елементи з одного вектора в інший, наприклад, якщо ви хочете скопіювати елементи з індексу 10 до 16, наприклад, ми б використали

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

і якщо ви хочете елементи від індексу 10 до деякого індексу з кінця, то в цьому випадку

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

сподіваюся, що це допоможе, просто згадайте в останньому випадку v.end()-5 > v.begin()+10

Ще один варіант: корисний, наприклад, при переміщенні між a thrust::device_vectorі a thrust::host_vector, де ви не можете використовувати конструктор.

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

Також має бути складність O (N)

Ви можете комбінувати це з найвищим кодом

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