c++ - ¿Puede el uso del 'auto' de C ++ 11 mejorar el rendimiento?




2 Answers

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

Un ejemplo típico viene 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 puede estar en línea, sino que también debe pasar por la búsqueda polimórfica en el interior borrado de tipo de la función wrapper.

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 de valor devuelto, puede que se vea obligado a construir un nuevo objeto (quizás como temporal) a través de algo como T && f = MakeAThing() . (Además, auto && incluso funciona cuando el tipo de retorno no es móvil y el valor de retorno es un prvalue).

c++ performance c++11 auto

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

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



Las tres respuestas existentes ofrecen ejemplos en los que el uso de auto ayudas auto "hace que sea menos probable que pesimarse involuntariamente", lo que hace que "mejore el rendimiento".

Hay una otra cara de la moneda. El uso auto con objetos que tienen operadores que no devuelven el objeto básico puede resultar en un código incorrecto (aún compilable y ejecutable). Por ejemplo, esta pregunta pregunta cómo el uso de 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 afectado en gran medida aquí, el uso del auto para evitar pesimismo involuntario podría clasificarse como optimización prematura, o al menos incorrecto;).




Related