¿Debo usar la nueva función 'auto' de C ++ 11, especialmente en bucles?

¿Cuáles son las ventajas y desventajas de utilizar la autopalabra clave, especialmente en bucles for?

for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->something();
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->second->something();
}

for(auto it = x.begin(); it != x.end(); it++ )
{
   it->??
}

Parece como si no sabe si tiene un iterador para un mapa o un vector no vas a saber si se debe utilizar firsto secondo sólo directamente propiedades de acceso del objeto, ¿no?

Esto me recuerda el debate de C # sobre si usar la palabra clave var. La impresión que tengo hasta ahora es que en el mundo de C ++ la gente está lista para adoptar la autopalabra clave con menos pelea que varen el mundo de C #. Para mí, mi primer instinto es que me gusta saber el tipo de variable para poder saber qué operaciones puedo realizar en ella.

Las motivaciones en C ++ son más extremas, ya que los tipos pueden volverse mucho más intrincados y complejos que los tipos C # debido a la metaprogramación y otras cosas. autoes más rápido de escribir y leer y más flexible / mantenible que un tipo explícito. Quiero decir, ¿quieres empezar a escribir?

boost::multi_map<NodeType, indexed_by<ordered_unique<identity<NodeType>>, hashed_non_unique<identity<NodeType>, custom_hasher>>::iterator_type<0> it

Eso ni siquiera es el tipo completo. Me perdí un par de argumentos de plantilla.

En tu ejemplo:

for(auto it = x.begin(); it != x.end(); i++)
{
  it->??
}

Tiene que haber una declaración para xvisible. Por lo tanto, el tipo de itdebe ser obvio. Si el tipo de xno es obvio, entonces el método es demasiado largo o la clase es demasiado grande.

¡ Objeción ! Pregunta cargada.

¿Me puede explicar por qué el tercer código tiene ??, pero el primero y el segundo no? Para ser justos, su código debe leer lo siguiente:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->???
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->second->???
}

Allí. Mismo problema aunque no lo hayas usado auto.

Y en todos los casos, la respuesta es la misma: el contexto importa . No se puede hablar de manera significativa sobre un fragmento de código de forma aislada. Incluso si no hubiera utilizado plantillas pero algún tipo concreto, esto solo habría trasladado el problema a otro lugar, ya que el lector de su código tendría que saber sobre la declaración de dicho tipo.

Si el uso autoen esas situaciones hace que su código sea ilegible, debe tratar esto como una señal de advertencia de que hay algo mal con el diseño de su código. Por supuesto, hay casos en los que los detalles de bajo nivel son importantes (como cuando se trata de operaciones de bits o API heredadas) en los que un tipo explícito podría ayudar a la legibilidad. Pero en general, no.

En cuanto a var(ya que lo mencionaste explícitamente), también hay un gran consenso en la comunidad de C # para usar var. Los argumentos en contra de su uso generalmente se basan en falacias .

PRO

Tu codigo :

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

no se va a compilar, debido al nombre dependiente de la plantilla.

Esta es la sintaxis correcta:

for( typename std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

Ahora mire cuánto dura la declaración de tipo. Esto explica por qué autose introdujo la palabra clave. Esta :

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

Es más conciso. Entonces, esto es un profesional.

ESTAFA

Tienes que tener un poco de cuidado. Con la palabra clave auto, obtienes el tipo que declaraste.

Por ejemplo :

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto it : v )
{
  ++ it;   // ops modifying copies of vector's elements
}

vs

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto & it : v )   // mind the reference
{
  ++ it;   // ok, vector's elements modified
}

Para concluir: sí, debería hacerlo, pero no usarlo en exceso. Algunas personas tienden a usarlo demasiado y a poner el auto en todas partes, como en el siguiente ejemplo:

auto i = 0;

vs

int i = 0;

¡Si deberías! autono borra el tipo; incluso si "no sabe" qué x.begin()es, el compilador lo sabe e informará de un error si intenta utilizar el tipo incorrectamente. Además, no es inusual emular mapcon a vector<pair<Key,Value>>, por lo que el uso del código autofuncionará para ambas representaciones de diccionario.

Sí, debe usar autocomo regla predeterminada. Tiene ventajas crudas sobre especificar explícitamente el tipo:

• No te hace escribir cosas que el compilador ya conoce.
• Hace que el tipo de variables "siga" cualquier cambio en los tipos de valores de retorno.
• Al hacerlo, evita la introducción silenciosa de conversiones implícitas y el corte en la inicialización de variables locales.
• Elimina la necesidad de algunos cálculos de tipo explícito en las plantillas.
• Elimina la necesidad de nombrar tipos de retorno con nombres largos. (los que copia y pega del diagnóstico del compilador)

Aquí es donde puedes elegir. También hay casos en los que no tienes otra opción:

• Permite la declaración de variables de tipos indescriptibles, como el tipo de una lambda.

Siempre que sepa exactamente lo que autohace, no tiene inconvenientes.