Penalità delle prestazioni utilizzando la parola chiave 'auto' in Visual Studio 2010

Question

L'utilizzo della nuova parola chiave auto ha ridotto i tempi di esecuzione del codice. Ho ristretto il problema al seguente frammento di codice semplice:

#include <iostream> 
#include <map> 
#include <vector> 
#include <deque> 
#include <time.h> 

using namespace std; 

void func1(map<int, vector<deque<float>>>& m) 
{ 
    vector<deque<float>>& v = m[1]; 
} 

void func2(map<int, vector<deque<float>>>& m) 
{ 
    auto v = m[1]; 
} 

void main() { 

    map<int, vector<deque<float>>> m; 
    m[1].push_back(deque<float>(1000,1)); 

    clock_t begin=clock(); 
    for(int i = 0; i < 100000; ++i) func1(m); 
    cout << "100000 x func1: " << (((double)(clock() - begin))/CLOCKS_PER_SEC) << " sec." << endl; 

    begin=clock(); 
    for(int i = 0; i < 100000; ++i) func2(m); 
    cout << "100000 x func2: " << (((double)(clock() - begin))/CLOCKS_PER_SEC) << " sec." << endl; 

} 

L'uscita ricevo sul mio i7/macchina Win7 (modalità di rilascio; VS2010) è:

100000 x func1: 0.001 sec. 
100000 x func2: 3.484 sec. 

Qualcuno può spiegare perché utilizzando auto risultati in tempi di esecuzione così diversi?

Ovviamente, vi è una soluzione semplice, vale a dire, smettere di utilizzare auto del tutto, ma spero che ci sia un modo migliore per superare questo problema.

Answer 1

Si sta copiando il vettore su v.

Prova a modificare per creare un riferimento

auto& v = ... 

Answer 2

Come ha detto Bo, è necessario utilizzare auto& invece di auto (Nota, che esiste anche auto* per altri casi). Qui è una versione aggiornata del codice:

#include <functional> 
#include <iostream> 
#include <map> 
#include <vector> 
#include <deque> 
#include <time.h> 

using namespace std; 

typedef map<int, vector<deque<float>>> FooType; // this should have a meaningful name 

void func1(FooType& m) 
{ 
    vector<deque<float>>& v = m[1]; 
} 

void func2(FooType& m) 
{ 
    auto v = m[1]; 
} 

void func3(FooType& m) 
{ 
    auto& v = m[1]; 
} 

void measure_time(std::function<void(FooType&)> func, FooType& m) 
{ 
    clock_t begin=clock(); 
    for(int i = 0; i < 100000; ++i) func(m); 
    cout << "100000 x func: " << (((double)(clock() - begin))/CLOCKS_PER_SEC) << " sec." << endl; 
} 

void main() 
{ 
    FooType m; 
    m[1].push_back(deque<float>(1000,1)); 

    measure_time(func1, m); 
    measure_time(func2, m); 
    measure_time(func3, m); 
} 

Sul mio computer, ha pronunciato la seguente uscita:

100000 x func: 0 sec. 
100000 x func: 3.136 sec. 
100000 x func: 0 sec.