Qual è il modo più veloce per ripristinare ogni valore di std::vector<int>
a 0 e mantenere la dimensione iniziale dei vettori?
Un ciclo for con l'operatore []?
Qual è il modo più veloce per ripristinare ogni valore di std::vector<int>
a 0 e mantenere la dimensione iniziale dei vettori?
Un ciclo for con l'operatore []?
Risposte:
std::fill(v.begin(), v.end(), 0);
v = std::vector<int>(vec_size,0)
) sembra leggermente più veloce rispetto fill
alla mia macchina
assign
.
Come sempre quando chiedi il più veloce: misura! Usando i metodi sopra (su un Mac usando Clang):
Method | executable size | Time Taken (in sec) |
| -O0 | -O3 | -O0 | -O3 |
------------|---------|---------|-----------|----------|
1. memset | 17 kB | 8.6 kB | 0.125 | 0.124 |
2. fill | 19 kB | 8.6 kB | 13.4 | 0.124 |
3. manual | 19 kB | 8.6 kB | 14.5 | 0.124 |
4. assign | 24 kB | 9.0 kB | 1.9 | 0.591 |
usando 100000 iterazioni su un vettore di 10000 ints.
Modifica: se la modifica di questi numeri modifica plausibilmente i tempi risultanti, si può avere una certa sicurezza (non buona come ispezionare il codice dell'assemblaggio finale) che il benchmark artificiale non è stato completamente ottimizzato. Naturalmente è meglio messaggiare le prestazioni in condizioni reali. fine Modifica
per riferimento il codice utilizzato:
#include <vector>
#define TEST_METHOD 1
const size_t TEST_ITERATIONS = 100000;
const size_t TEST_ARRAY_SIZE = 10000;
int main(int argc, char** argv) {
std::vector<int> v(TEST_ARRAY_SIZE, 0);
for(size_t i = 0; i < TEST_ITERATIONS; ++i) {
#if TEST_METHOD == 1
memset(&v[0], 0, v.size() * sizeof v[0]);
#elif TEST_METHOD == 2
std::fill(v.begin(), v.end(), 0);
#elif TEST_METHOD == 3
for (std::vector<int>::iterator it=v.begin(), end=v.end(); it!=end; ++it) {
*it = 0;
}
#elif TEST_METHOD == 4
v.assign(v.size(),0);
#endif
}
return EXIT_SUCCESS;
}
Conclusione: usare std::fill
(perché, come altri hanno già detto più idiomatico)!
assign
è più lento, tranne per le piccole capacità su libc++
. CODICE coliru / paste
fill
sembra terribile. È due ordini di grandezza più lenti in questo test.
Che ne dici della assign
funzione membro?
some_vector.assign(some_vector.size(), 0);
Se è solo un vettore di numeri interi, prima proverei:
memset(&my_vector[0], 0, my_vector.size() * sizeof my_vector[0]);
Non è molto C ++, quindi sono sicuro che qualcuno fornirà il modo corretto di farlo. :)
::std::fill
metodo si espande in qualcosa che è piuttosto dannatamente veloce, anche se un po 'sul lato del codice bloaty poiché è tutto in linea. Lo userei comunque perché è molto più bello da leggere.
Avevo la stessa domanda, ma piuttosto breve vector<bool>
(afaik lo standard consente di implementarlo internamente in modo diverso rispetto a una semplice serie continua di elementi booleani). Quindi ho ripetuto i test leggermente modificati di Fabio Fracassi. I risultati sono i seguenti (tempi, in secondi):
-O0 -O3
-------- --------
memset 0.666 1.045
fill 19.357 1.066
iterator 67.368 1.043
assign 17.975 0.530
for i 22.610 1.004
Quindi apparentemente per queste dimensioni, vector<bool>::assign()
è più veloce. Il codice utilizzato per i test:
#include <vector>
#include <cstring>
#include <cstdlib>
#define TEST_METHOD 5
const size_t TEST_ITERATIONS = 34359738;
const size_t TEST_ARRAY_SIZE = 200;
using namespace std;
int main(int argc, char** argv) {
std::vector<int> v(TEST_ARRAY_SIZE, 0);
for(size_t i = 0; i < TEST_ITERATIONS; ++i) {
#if TEST_METHOD == 1
memset(&v[0], false, v.size() * sizeof v[0]);
#elif TEST_METHOD == 2
std::fill(v.begin(), v.end(), false);
#elif TEST_METHOD == 3
for (std::vector<int>::iterator it=v.begin(), end=v.end(); it!=end; ++it) {
*it = 0;
}
#elif TEST_METHOD == 4
v.assign(v.size(),false);
#elif TEST_METHOD == 5
for (size_t i = 0; i < TEST_ARRAY_SIZE; i++) {
v[i] = false;
}
#endif
}
return EXIT_SUCCESS;
}
Ho usato il compilatore GCC 7.2.0 su Ubuntu 17.10. La riga di comando per la compilazione:
g++ -std=c++11 -O0 main.cpp
g++ -std=c++11 -O3 main.cpp