[c++] ¿Puede el uso de C ++ 11 'auto' mejorar el rendimiento?


Answers

Debido a que auto deduce el tipo de la expresión de inicialización, no hay conversión de tipo implicada. Combinado con algoritmos con plantillas, esto significa que puede obtener un cálculo más directo que si creara un tipo usted mismo, especialmente cuando se trata de expresiones cuyo tipo no puede nombrar.

Un ejemplo típico proviene de (ab) usando std::function :

std::function<bool(T, T)> cmp1 = std::bind(f, _2, 10, _1);  // bad
auto cmp2 = std::bind(f, _2, 10, _1);                       // good
auto cmp3 = [](T a, T b){ return f(b, 10, a); };            // also good

std::stable_partition(begin(x), end(x), cmp?);

Con cmp2 y cmp3 , todo el algoritmo puede alinear la llamada de comparación, mientras que si construye un objeto std::function , no solo la llamada no estará en línea, sino que también debe pasar por la búsqueda polimórfica en el interior borrado de tipo de la envoltura de la función.

Otra variante de este tema es que puedes decir:

auto && f = MakeAThing();

Esta es siempre una referencia, vinculada al valor de la expresión de llamada de función, y nunca construye ningún objeto adicional. Si no conocía el tipo del valor devuelto, podría verse obligado a construir un objeto nuevo (quizás como un elemento temporal) a través de algo como T && f = MakeAThing() . (Además, auto && incluso funciona cuando el tipo de devolución no es movible y el valor de retorno es un valor pr.)

Question

Puedo ver por qué el tipo auto en C ++ 11 mejora la corrección y la facilidad de mantenimiento. He leído que también puede mejorar el rendimiento ( Almost Always Auto de Herb Sutter), pero extraño una buena explicación.

  • ¿Cómo puede mejorar el rendimiento auto ?
  • ¿Alguien puede dar un ejemplo?



Las tres respuestas existentes brindan ejemplos en los que el uso de auto ayudas auto "hace que sea menos probable que pesimismo involuntariamente" lo que lo hace "mejorar el rendimiento".

Hay una cara opuesta a la moneda. El uso de auto con objetos que tienen operadores que no devuelven el objeto básico puede dar como resultado un código incorrecto (aún compilable y ejecutable). Por ejemplo, esta pregunta se pregunta cómo usar auto dio resultados diferentes (incorrectos) usando la biblioteca Eigen, es decir , las siguientes líneas

const auto    resAuto    = Ha + Vector3(0.,0.,j * 2.567);
const Vector3 resVector3 = Ha + Vector3(0.,0.,j * 2.567);

std::cout << "resAuto = " << resAuto <<std::endl;
std::cout << "resVector3 = " << resVector3 <<std::endl;

dio lugar a diferentes resultados. Es cierto que esto se debe principalmente a la evaluación perezosa de Eigens, pero ese código es / debería ser transparente para el usuario (de la biblioteca).

Si bien el rendimiento no se ha visto muy afectado aquí, el uso de auto para evitar una pesimización involuntaria puede clasificarse como una optimización prematura, o al menos incorrecta;).






Links