Limpe vector cada iteração do loop. Qual é a maneira mais eficiente de memória?

Question

Eu tenho uma pergunta sobre o std :: vector.

Eu tenho um algoritmo muito intensivo de memória onde eu forsee que prevendo tamanhos vetoriais e reservando memória suficiente para os vetores com antecedência vai me ajudar muito com a redução de uso de memória.

Qual das seguintes é melhor:

for ( ... ) {
  std::vector<Type> my_vector;
  my_vector.reserve(stuff_count);
  // Do stuff , and append stuff to my_vector.
}

Ou este:

std::vector my_vector;
for ( ... ) {
  my_vector.clear();
  my_vector.reserve(stuff_count);
  // Do stuff , and append stuff to my_vector.
}

Por favor me diga qual é o melhor, ou se existe uma maneira ainda melhor de fazer coisas.

Muito obrigado antecipadamente!

Answer 1

Com a primeira variante você realocar o buffer do vetor em cada iteração - que é geralmente muito caro. Com a segunda variante só realocar ocasionalmente. A segunda variante é melhor já que a velocidade é uma prioridade para você.

Não está claro de você questionar onde o número de elementos é saber de. Talvez você ainda pode calcular rapidamente o número máximo de elementos para todas as iterações, defina-o para ser o tamanho do buffer e não têm realocação.

Answer 2

Eu forsee que prevendo tamanhos vetoriais e reservando memória suficiente para os vetores com antecedência vai me ajudar muito com a redução de uso de memória.

Tente e agir como um engenheiro não uma cartomante. Criar um teste, e medir a diferença.

Answer 3

O segundo poderia ser um pouco mais rápido, mas eu encontrar o primeiro aspirador.

Answer 4

Como as diferenças no código são triviais, por que não testar ambas as abordagens e ver qual funciona melhor para sua aplicação particular?

Answer 5

Depende um pouco sobre como Tipo precisa ser construído / destruído, eu diria. Se é um POD que não requer a destruição, você pode ignorar a clear (), que chama todos os destruidores em um loop, e usá-lo como uma matriz estática em vez disso:

std::vector<Type> my_vector(size);
for (...)
{
  int index = 0;
  // Do stuff
  my_vector[index] = some_value;
}

(Advertência: código não testado)

Answer 6

... reservando memória suficiente para o vetores de antecedência vai me ajudar muito com a redução do uso de memória

err ... o quê ?! Isso não faz sentido em tudo. Reserva de memória não ajudar a reduzir o uso de memória de forma alguma. Ela impede que a necessidade de realocação constante que torna as coisas mais rápido, mas tão longe como uso vai você recebe nenhum benefício.

Answer 7

O segundo irá usar o máximo de memória de todas as utilizações do mesmo através do loop, ou seja, o tamanho máximo de tipos de stuff_count. std::vector::clear() não necessariamente livre memória. Ou seja, se você chamar std::vector::capacity() antes e depois std::vector::clear() Uma implementação conforme norma poderia retornar o mesmo valor.

Na melhor das hipóteses, você vai reduzir o número de vezes que você alocar memória com o esquema acima. Mas você certamente não será reduzindo o consumo de memória em qualquer ponto. Se você deseja reduzir a quantidade reservada da memória, você deve usar o idioma vector swap:

std::vector<type>().swap(my_vector);
my_vector.reserve(stuff_count); 

Ou a sua primeira solução, uma vez que o efeito global será o mesmo.

Answer 8

Se você precisa fazer um monte de Anexa usar std :: deque em vez de std :: vector e usar apenas "push_back".

Answer 9

como sobre?

std::vector<DataType> my_vector;
my_vector.resize(sizeof(yourData));
memcpy(reinterpret_cast<char*>(&my_vector), &yourData, sizeof(yourData));