Melhor maneira de extrair um subvetor de um vetor?

Suponha que eu tenha um tamanho std::vector(vamos chamá-lo myVec) N. Qual é a maneira mais simples de construir um novo vetor que consiste em uma cópia dos elementos X a Y, onde 0 <= X <= Y <= N-1? Por exemplo, myVec [100000]através myVec [100999]de um vetor de tamanho 150000.

Se isso não puder ser feito eficientemente com um vetor, existe outro tipo de dados STL que eu deveria usar?

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

É uma operação O (N) para construir o novo vetor, mas não há realmente uma maneira melhor.

Basta usar o construtor de vetores.

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), no seu caso foo = std::vector<T>(myVec.begin () + 100000, myVec.begin () + 150000);, veja por exemplo aqui

Hoje em dia, usamos spans! Então você escreveria:

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

para obter um intervalo de 1000 elementos do mesmo tipo que myvec's. Ou uma forma mais concisa:

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

(mas não gosto muito disso, pois o significado de cada argumento numérico não é totalmente claro; e fica pior se o tamanho e o start_pos forem da mesma ordem de magnitude.)

De qualquer forma, lembre-se de que não é uma cópia, é apenas uma visão dos dados no vetor, portanto, tenha cuidado. Se você quiser uma cópia real, poderá:

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

Notas:

• gslsignifica Biblioteca de suporte a diretrizes. Para obter mais informações gsl, consulte: http://www.modernescpp.com/index.php/c-core-guideline-the-guidelines-support-library .
• Para uma implementação de gsl, consulte: https://github.com/Microsoft/GSL
• C ++ 20 fornece uma implementação de span. Você usaria std::spane #include <span>não #include <gsl/span>.
• Para obter mais informações sobre extensões, consulte: O que é uma "extensão" e quando devo usar uma?
• std::vector tem um zilhão de construtores, é super fácil cair em um que você não pretendia usar; portanto, tenha cuidado.

Se ambos não vão ser modificadas (sem adição / exclusão de itens - modificar os já existentes é bom, desde que você preste atenção aos problemas de threading), você pode simplesmente passar em torno data.begin() + 100000e data.begin() + 101000, e fingir que eles são o begin()e end()de um vector menor.

Ou, como é garantido que o armazenamento vetorial seja contíguo, você pode simplesmente transmitir uma matriz de 1000 itens:

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

Ambas as técnicas levam tempo constante, mas exigem que o comprimento dos dados não aumente, desencadeando uma realocação.

Essa discussão é bastante antiga, mas a mais simples ainda não foi mencionada, com a inicialização da lista :

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

Requer c ++ 11 ou superior.

Exemplo de uso:

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

Resultado:

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;

Você não mencionou o tipo std::vector<...> myVec, mas se é um tipo ou estrutura / classe simples que não inclui ponteiros e deseja a melhor eficiência, pode fazer uma cópia direta da memória (que eu acho que será mais rápida que a outras respostas fornecidas). Aqui está um exemplo geral de std::vector<type> myVeconde type, neste caso, é 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

Você poderia apenas usar insert

vector<type> myVec { n_elements };

vector<type> newVec;

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

Você pode usar a cópia STL com desempenho O (M) quando M é o tamanho do subvetor.

A única maneira de projetar uma coleção que não é tempo linear é fazê-lo preguiçosamente, onde o "vetor" resultante é na verdade um subtipo que delega à coleção original. Por exemplo, o List#subseqmétodo de Scala cria uma sub-sequência em tempo constante. No entanto, isso funciona apenas se a coleção é imutável e se o idioma subjacente ostenta a coleta de lixo.

Postando esta tarde apenas para outras pessoas ... aposto que o primeiro codificador já está pronto. Para tipos de dados simples, nenhuma cópia é necessária, basta reverter para bons métodos antigos de código C.

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

Em seguida, passe o ponteiro pe um len para qualquer coisa que precise de um subvetor.

notelen deve ser !! len < myVec.size()-start

Talvez o array_view / span na biblioteca GSL seja uma boa opção.

Aqui também está uma implementação de arquivo único: array_view .

Copie elementos de um vetor para outro facilmente
Neste exemplo, estou usando um vetor de pares para facilitar a compreensão de
`

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

'
Como você pode ver, pode copiar facilmente elementos de um vetor para outro, se quiser copiar elementos do índice 10 para 16, por exemplo, usaríamos

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

e se você quiser elementos do índice 10 para algum índice do final, nesse caso

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

Espero que isso ajude, basta lembrar no último caso v.end()-5 > v.begin()+10

Outra opção: Útil, por exemplo, ao se mover entre a thrust::device_vectore a thrust::host_vector, onde você não pode usar o construtor.

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

Também deve ser complexidade O (N)

Você pode combinar isso com o melhor código da resposta

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