Pulisci il vettore ogni iterazione del ciclo. Qual è il modo più efficiente di memoria?

Question

Ho una domanda sullo std :: vector.

Ho un algoritmo molto intensivo di memoria in cui prevedo che prevedere le dimensioni dei vettori e riservare abbastanza memoria per i vettori in anticipo mi aiuterà molto a ridurre l'utilizzo della memoria.

Quale dei seguenti è meglio:

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

O questo:

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

La prego di dirmi che è meglio, o se c'è un modo migliore di fare le cose.

Grazie mille in anticipo!

Answer 1

Con la prima variante si rialloca il buffer del vettore su ogni iterazione, che di solito è piuttosto costoso. Con la seconda variante si rialloca solo occasionalmente. La seconda variante è migliore poiché la velocità è una priorità per te.

Non è chiaro da voi la domanda da dove il numero di elementi è noto. Forse si può anche calcolare rapidamente il numero massimo di elementi per tutte le iterazioni, impostare come dimensione del buffer e non avere riallocazione.

Answer 2

Il secondo potrebbe essere leggermente più veloce, ma trovo il primo pulitore.

Answer 3

Poiché le differenze nel codice sono banali, perché non testare entrambi gli approcci e vedere quale funziona meglio per la particolare applicazione?

Answer 4

Dipende un po 'da come il Tipo deve essere costruito/distrutto, direi. Se è un POD che non richiede distruzione, è possibile saltare la chiara(), che chiama tutti i distruttori in un ciclo, e usarlo come una matrice statica invece:

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

(Caveat: codice non testato)

Answer 5

... riservare memoria sufficiente per le vettori in anticipo mi aiuterà molto con la riduzione dell'utilizzo della memoria

err ... cosa ?! Non ha assolutamente senso. La prenotazione della memoria non aiuta a ridurre l'utilizzo della memoria in alcun modo. Impedisce la necessità di una riallocazione costante che rende le cose più veloci, ma per quanto riguarda l'utilizzo di non si ottiene alcun beneficio.

Answer 6

Vedo che predire le dimensioni dei vettori e riservare abbastanza memoria per i vettori in anticipo mi aiuterà molto a ridurre l'utilizzo della memoria.

Cerca di comportarti come un ingegnere e non come un indovino. Crea un test e misura la differenza.

Answer 7

Se è necessario eseguire molti accodamenti, utilizzare std :: deque anziché std :: vector e utilizzare semplicemente "push_back".

Answer 8

che ne dici?

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

Answer 9

La seconda userà la memoria massima di tutti gli usi di essa attraverso l'anello, cioè la dimensione massima dei tipi di stuff_count. std::vector::clear() does not necessarily free memory. Ad esempio, se si chiama std::vector::capacity() prima e dopo std::vector::clear(), un'implementazione conforme standard potrebbe restituire lo stesso valore.

Nella migliore delle ipotesi, si riduce il numero di volte che si alloca memoria con lo schema precedente. Ma certamente non ridurrai l'impronta della memoria in nessun punto. Se si desidera ridurre la quantità riservata della memoria, è necessario utilizzare l'idioma vettore swap:

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

O il vostro prima soluzione, dal momento che l'effetto complessivo sarà lo stesso.