Vector limpio cada iteración de bucle. ¿Cuál es la forma más eficiente de memoria?

Question

Tengo una pregunta sobre el std :: vector.

Tengo un algoritmo que hace un uso intensivo de la memoria, en el que veo que predecir los tamaños de los vectores y reservar suficiente memoria para los vectores de antemano me ayudará mucho a reducir el uso de la memoria.

Cuál de los siguientes es mejor:

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

O esto:

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

Por favor, dime cuál es la mejor, o si hay una mejor manera de hacer las cosas.

¡Muchas gracias de antemano!

Answer 1

Con la primera variante, reasigna el búfer del vector en cada iteración, lo que suele ser bastante costoso. Con la segunda variante solo se reasignan ocasionalmente. La segunda variante es mejor ya que la velocidad es una prioridad para ti.

No está claro por su pregunta de dónde se sabe la cantidad de elementos. Tal vez incluso puedas calcular rápidamente el número máximo de elementos para todas las iteraciones, configúralo para que sea el tamaño del búfer y no se reasigne.

Answer 2

  

Observo que predecir el tamaño de los vectores y reservar suficiente memoria para los vectores por adelantado me ayudará mucho a reducir el uso de la memoria.

Intenta actuar como un ingeniero, no como un adivino. Crea una prueba y mide la diferencia.

Answer 3

El segundo podría ser un poco más rápido, pero el primero me parece más limpio.

Answer 4

Como las diferencias en el código son triviales, ¿por qué no probar ambos enfoques y ver cuál funciona mejor para su aplicación en particular?

Answer 5

Depende un poco de cómo se debe construir / destruir el Tipo, diría yo. Si es un POD que no requiere destrucción, puede omitir el clear (), que llama a todos los destructores en un bucle, y usarlo como una matriz estática:

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

(Advertencia: código no probado)

Answer 6

  

... reservando suficiente memoria para el   Los vectores de antemano me ayudarán mucho.   con la reducción del uso de memoria

err ... ¡¿qué ?! Eso no tiene sentido en absoluto. Reservar la memoria no ayuda a reducir el uso de la memoria de ninguna manera. Evita la necesidad de una reasignación constante, lo que hace que las cosas sean más rápidas, pero en lo que respecta a uso , no obtiene ningún beneficio.

Answer 7

El segundo usará la memoria máxima de todos los usos de la misma a través del bucle, es decir, el tamaño máximo de los tipos de stuff_count. std :: vector :: clear () no necesariamente libera memoria . Es decir, si llama a std :: vector :: capacity () antes y después de std :: vector :: clear () , una implementación de conformidad estándar podría devolver el mismo valor.

En el mejor de los casos, reducirá el número de veces que asigna memoria con el esquema anterior. Pero ciertamente no reducirás la huella de memoria en ningún momento. Si desea reducir la cantidad de memoria reservada, debe utilizar el lenguaje de intercambio de vectores:

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

O su primera solución, ya que el efecto general será el mismo.

Answer 8

Si necesitas hacer muchos apéndices, usa std :: deque en lugar de std :: vector y solo usa " push_back " ;.

Answer 9

¿qué tal?

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