Лучший способ извлечь субвектор из вектора?

Предположим, у меня есть 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 элементов того же типа, что myvecи s. Или более краткая форма:

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 у вас есть gazillion конструкторов, очень легко попасть в тот, который вы не собирались использовать, так что будьте осторожны.

Если оба не будут изменено (без добавления / удаления элементов - изменение существующих хорошо до тех пор , пока вы обратить внимание на многопоточные вопросы), вы не можете просто пройти вокруг 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метод Scala создает подпоследовательность за постоянное время. Тем не менее, это работает только в том случае, если коллекция является неизменной и если базовый язык использует сборку мусора.

Опубликовать это поздно только для других ... Бьюсь об заклад, первый кодер уже сделан. Для простых типов данных копирование не требуется, просто вернитесь к старым добрым методам кода Си.

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

Затем передайте указатель p и len для всего, что нуждается в подвекторе.

notelen должно быть !! 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));