Penalización de rendimiento con la palabra clave 'auto' en Visual Studio 2010

Question

El uso de la nueva palabra clave auto ha reducido mis tiempos de ejecución de código. Entrecerré el problema con el siguiente fragmento de código simple:

#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; 

} 

La salida de recibo en mi i7/máquina Win7 (modo de lanzamiento; VS2010) es:

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

¿Puede alguien explicar por qué el uso auto resultados en tiempos de ejecución tan diferentes?

Obviamente, hay una solución simple, es decir, dejar de usar auto en conjunto, pero espero que haya una mejor manera de solucionar este problema.

Answer 1

Estás copiando el vector a v.

probar este lugar para crear una referencia

auto& v = ... 

Answer 2

Como dijo Bo, usted tiene que utilizar en lugar de auto&auto (Tenga en cuenta, que también es auto* para otros casos). Aquí es una versión actualizada de su código:

#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); 
} 

En mi ordenador, se da el siguiente resultado:

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