¿Cuánto es demasiado con la palabra clave automática C ++ 11?

He estado usando la nueva autopalabra clave disponible en el estándar C ++ 11 para tipos de plantillas complicados, para lo cual creo que fue diseñada. Pero también lo estoy usando para cosas como:

auto foo = std::make_shared<Foo>();

Y más escépticamente por:

auto foo = bla(); // where bla() return a shared_ptr<Foo>

No he visto mucha discusión sobre este tema. Parece que autopodría usarse en exceso, ya que un tipo es a menudo una forma de documentación y controles de sanidad. ¿Dónde trazas la línea de uso autoy cuáles son los casos de uso recomendados para esta nueva característica?

Para aclarar: no estoy pidiendo una opinión filosófica; Solicito el uso previsto de esta palabra clave por parte del comité estándar, posiblemente con comentarios sobre cómo se realiza ese uso previsto en la práctica.

Nota al margen: esta pregunta se trasladó a SE.Programmers y luego a Stack Overflow. La discusión sobre esto se puede encontrar en esta meta pregunta .

Creo que uno debe usar la autopalabra clave siempre que sea difícil decir cómo escribir el tipo a primera vista, pero el tipo del lado derecho de una expresión es obvio. Por ejemplo, usando:

my_multi_type::nth_index<2>::type::key_type::composite_key_type::
    key_extractor_tuple::tail_type::head_type::result_type

para obtener el tipo de clave compuesta boost::multi_index, aunque sepa que es así int. No puedes simplemente escribir intporque podría cambiarse en el futuro. Yo escribiría autoen este caso.

Entonces, si la autopalabra clave mejora la legibilidad en un caso particular, úsela. Puede escribir autocuando sea obvio para el lector qué tipo autorepresenta.

Aquí hay unos ejemplos:

auto foo = std::make_shared<Foo>();   // obvious
auto foo = bla();                     // unclear. don't know which type `foo` has

const size_t max_size = 100;
for ( auto x = max_size; x > 0; --x ) // unclear. could lead to the errors
                                      // since max_size is unsigned

std::vector<some_class> v;
for ( auto it = v.begin(); it != v.end(); ++it )
                                      // ok, since I know that `it` has an iterator type
                                      // (don't really care which one in this context)

Úselo autodonde pueda, especialmente const autopara que los efectos secundarios sean menos preocupantes. No tendrá que preocuparse por los tipos, excepto en los casos obvios, pero todavía serán verificados estáticamente por usted y puede evitar algunas repeticiones. Donde autono sea factible, puede usarlo decltypepara expresar tipos semánticamente como contratos basados ​​en expresiones. Su código se verá diferente, pero será un cambio positivo.

Fácil. Úselo cuando no le importa cuál es el tipo. Por ejemplo

for (const auto & i : some_container) {
   ...

Todo lo que me importa aquí es que isea ​​lo que haya en el contenedor.

Es un poco como typedefs.

typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;

En este caso, no me importa si hy wson flotadores o dobles, sólo que son cualquier tipo es adecuado para expresar alturas y pesos .

O considerar

for (auto i = some_container .begin (); ...

Aquí todo lo que me importa es que es un iterador adecuado, compatible operator++(), es como escribir un pato a este respecto.

Además, el tipo de lambdas no se puede deletrear, por lo que auto f = []...es un buen estilo. La alternativa es emitir std::functionpero eso viene con gastos generales.

Realmente no puedo concebir un "abuso" de auto. Lo más cercano que puedo imaginar es privarte de una conversión explícita a algún tipo significativo, pero no lo usarías autopara eso, construirías un objeto del tipo deseado.

Si puede eliminar algo de redundancia en su código sin introducir efectos secundarios, entonces debe ser bueno hacerlo.

Contraejemplos (tomados de las respuestas de otra persona):

auto i = SomeClass();
for (auto x = make_unsigned (y); ...)

Aquí nos importa cuál es el tipo, por lo que debemos escribir Someclass i;yfor(unsigned x = y;...

Ve a por ello. Úselo en autocualquier lugar que facilite la escritura de código.

Cada nueva característica en cualquier idioma será utilizada en exceso por al menos algunos tipos de programadores. Es solo a través del uso excesivo moderado por algunos programadores experimentados (no novatos) que el resto de los programadores experimentados aprenden los límites del uso adecuado. El uso excesivo extremo suele ser malo, pero podría ser bueno porque dicho uso excesivo puede conducir a mejoras en la función o una mejor función para reemplazarla.

Pero si estuviera trabajando en código con más de unas pocas líneas como

auto foo = bla();

donde el tipo se indica cero veces, es posible que desee cambiar esas líneas para incluir tipos. El primer ejemplo es excelente ya que el tipo se indica una vez y autonos ahorra tener que escribir dos tipos de plantillas desordenadas. ¡Hurra por C ++++! Pero mostrar explícitamente el tipo cero veces, si no es fácilmente visible en una línea cercana, me pone nervioso, al menos en C ++ y sus sucesores inmediatos. Para otros lenguajes diseñados para trabajar en un nivel superior con más abstracción, polimorfismo y genérico, está bien.

En C ++ y más allá de 2012 en el panel Ask Us Anything , hubo un intercambio fantástico entre Andrei Alexandrescu, Scott Meyers y Herb Sutter hablando sobre cuándo usar y no usarauto . Pase al minuto 25:03 para una discusión de 4 minutos. Los tres altavoces ofrecen excelentes puntos que deben tenerse en cuenta para cuándo no usar auto.

Recomiendo encarecidamente a las personas que lleguen a su propia conclusión, pero mi objetivo fue usarlo en autotodas partes a menos que :

1. Duele la legibilidad
2. Existe preocupación acerca de la conversión automática de tipos (por ejemplo, de constructores, asignación, tipos intermedios de plantilla, conversión implícita entre anchos enteros)

El uso liberal de explicitayuda a reducir la preocupación por el segundo, lo que ayuda a minimizar la cantidad de tiempo que el primero es un problema.

Reformulando lo que dijo Herb, "si no estás haciendo X, Y y Z, usa auto. Aprende qué son X, Y y Z y ve y usa en autotodas partes".

Sí, se puede usar en exceso en detrimento de la legibilidad. Sugiero usarlo en los contextos donde los tipos exactos son largos, indescifrables o no importantes para la legibilidad, y las variables son de corta duración. Por ejemplo, el tipo de iterador generalmente es largo y no es importante, por autolo que funcionaría:

   for(auto i = container.begin(); i != container.end(); ++i);

auto aquí no hace daño a la legibilidad.

Otro ejemplo es el tipo de regla del analizador, que puede ser largo y complicado. Comparar:

   auto spaces = space & space & space;

con

r_and_t<r_and_t<r_char_t<char>&, r_char_t<char>&>, r_char_t<char>&> spaces = 
   space & space & space;

Por otro lado, cuando se conoce el tipo y es simple, es mucho mejor si declara explícitamente:

int i = foo();

más bien que

auto i = foo();

auto puede ser muy peligroso en combinación con plantillas de expresión que se usan mucho en bibliotecas de álgebra lineal como Eigen u OpenCV.

auto A = Matrix(...);
auto B = Matrix(...);
auto C = A * B; // C is not a matrix. It is a matrix EXPRESSION.
cout << C; // The expression is evaluated and gives the expected result.
... // <code modifying A or B>
cout << C; // The expression is evaluated AGAIN and gives a DIFFERENT result.

Los errores causados ​​por este tipo de errores son un gran dolor para depurar. Un posible remedio es emitir explícitamente el resultado al tipo esperado si está empeñado en usar auto para el estilo de declaración de izquierda a derecha.

auto C = Matrix(A * B); // The expression is now evaluated immediately.

Utilizo autosin restricción y no tuve ningún problema. Incluso a veces termino usándolo para tipos simples como int. Esto hace que c ++ sea un lenguaje de nivel superior para mí, y permite declarar variables en c ++ como en python. Después de escribir el código de Python, incluso a veces escribo, por ejemplo

auto i = MyClass();

en vez de

MyClass i;

Este es un caso en el que diría que es un abuso de la autopalabra clave.

A menudo no me importa cuál es el tipo exacto del objeto, estoy más interesado en su funcionalidad, y como los nombres de las funciones generalmente dicen algo sobre los objetos que devuelven, autono duele: por ejemplo auto s = mycollection.size(), puedo suponer que sserá una especie de número entero, y en el raro caso en que me preocupe el tipo exacto, verifiquemos el prototipo de la función (quiero decir, prefiero tener que verificar cuando necesito la información, en lugar de a priori cuando se escribe el código, solo en caso de que sea útil algún día, como en int_type s = mycollection.size()).

Con respecto a este ejemplo de la respuesta aceptada:

for ( auto x = max_size; x > 0; --x )

En mi código todavía lo uso autoen este caso, y si quiero xestar sin firmar, entonces uso una función de utilidad, llamada say make_unsigned, que expresa claramente mis preocupaciones:

for ( auto x = make_unsigned(max_size); x > 0; --x )

Descargo de responsabilidad: ¡acabo de describir mi uso, no soy competente para dar consejos!

Uno de los principales problemas con el programa C ++ es que le permite usar la variable no inicializada . Esto nos lleva a un comportamiento desagradable del programa no determinista. Cabe señalar que el compilador moderno ahora arroja mensajes de advertencia apropiados / mensaje si el programa se cansa de usarlo.

Solo para ilustrar esto, considere el siguiente programa c ++:

int main() {
    int x;
    int y = 0;
    y += x;
}

Si compilo este programa usando el compilador moderno (GCC), me da la advertencia. Tal advertencia puede no ser muy obvia si estamos trabajando con el código de producción complejo real.

main.cpp: en la función 'int main ()':

main.cpp: 4: 8: advertencia : 'x' se usa sin inicializar en esta función [-Wuninitialized]

y + = x;

    ^

================================================== =============================== Ahora si cambiamos nuestro programa que usa auto , compilamos y obtenemos lo siguiente:

int main() {
    auto x;
    auto y = 0;
    y += x;
}

main.cpp: en la función 'int main ()':

main.cpp: 2: 10: error : la declaración de 'auto x' no tiene inicializador

 auto x;

      ^

Con auto, no es posible usar la variable no inicializada. Esta es una gran ventaja que podemos obtener (gratis), si comenzamos a usar auto .

Este concepto y otro gran gran concepto moderno de C ++ es explicado por Herb Shutter, experto en C ++, en su charla CppCon14 :

¡De vuelta a lo basico! Elementos esenciales del estilo moderno de C ++

Un peligro que he notado es en términos de referencias. p.ej

MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; // ?

El problema es que another_ref no es realmente una referencia en este caso, es MyBigObject en lugar de MyBigObject &. Terminas copiando un objeto grande sin darte cuenta.

Si obtiene una referencia directamente de un método, es posible que no piense en qué es realmente.

auto another_ref = function_returning_ref_to_big_object();

necesitaría "auto &" o "const auto &"

MyBigObject& ref_to_big_object= big_object;
auto& another_ref = ref_to_big_object;
const auto& yet_another_ref = function_returning_ref_to_big_object();

Use autodonde tenga sentido que se infiera un tipo. Si tiene algo que sabe que es un número entero, o sabe que es una cadena, simplemente use int / std :: string, etc. No me preocuparía por "usar en exceso" una característica del lenguaje a menos que llegue al punto de ridículo, u ofusca el código.

Esa es mi opinión de todos modos.

autoLa palabra clave solo se puede usar para variables locales, no para argumentos o miembros de clase / estructura. Por lo tanto, es seguro y viable usarlos en cualquier lugar que desee. Los uso mucho. El tipo se deduce en el momento de la compilación, el depurador muestra el tipo durante la depuración, lo sizeofinforma correctamente, decltypedaría el tipo correcto, no hay daño. ¡No cuento autocomo sobreutilizado, nunca!

TL; DR: Vea la regla general en la parte inferior.

La respuesta aceptada sugiere la siguiente regla general:

Úselo autosiempre que sea difícil decir cómo escribir el tipo a primera vista, pero el tipo del lado derecho de una expresión es obvio.

Pero yo diría que es demasiado restrictivo. A veces no me importan los tipos, ya que la declaración es lo suficientemente informativa sin que me moleste en tomarme el tiempo para resolver el tipo. ¿Qué quiero decir con eso? Considere el ejemplo que ha aparecido en algunas de las respuestas:

auto x = f();

¿Qué hace de esto un ejemplo de mal uso de auto? ¿Es mi ignorancia del f()tipo de retorno de? Bueno, de hecho puede ayudar si lo supiera, pero esa no es mi principal preocupación. Lo que es un problema mucho mayor es eso xy no f()tienen mucho sentido. Si tuvieramos:

auto nugget = mine_gold();

en cambio, generalmente no me importa si el tipo de retorno de la función es obvio o no. Al leer la declaración, sé lo que estoy haciendo y sé lo suficiente sobre la semántica del valor de retorno para no sentir que necesito saber también su tipo.

Entonces mi respuesta es: usar autosiempre que el compilador lo permita, a menos que:

• Siente que el nombre de la variable junto con la expresión de inicialización / asignación no proporciona suficiente información sobre lo que está haciendo la declaración.
• Siente que el nombre de la variable junto con la expresión de inicialización / asignación proporciona información "engañosa" sobre cuál debería ser el tipo, es decir, si tuviera que adivinar lo que viene en lugar del auto, podría adivinar, y sería mal, y esta suposición falsa tiene repercusiones más adelante en el código.
• Desea forzar un tipo diferente (por ejemplo, una referencia).

Y también:

• Prefiere dar un nombre significativo (que no contiene el nombre del tipo, por supuesto) antes de reemplazarlo autopor el tipo concreto.

Una de mis amargas experiencias autoes usarlo con expresiones lambda :

auto i = []() { return 0; };
cout<<"i = "<<i<<endl; // output: 1 !!!

En realidad, aquí ise resuelve funcionar el puntero de int(*)(). Esto es simple cout, pero imagínese qué tipo de errores de compilación / tiempo de ejecución incorrectos puede causar cuando se usa template.

Debe evitar auto con tales expresiones y poner un returntipo apropiado (o controlado decltype())

El uso correcto para el ejemplo anterior sería,

auto i = []() { return 0; }(); // and now i contains the result of calling the lambda