Dois-je utiliser la nouvelle fonctionnalité "auto" de C ++ 11, en particulier dans les boucles?

Quels sont les avantages / inconvénients de l'utilisation du automot - clé, en particulier dans les boucles 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->??
}

On dirait que si vous ne savez pas si vous avez un itérateur pour une carte ou un vecteur vous ne savez pas si vous souhaitez utiliser firstou secondou seulement des propriétés d'accès directement de l'objet, non?

Cela me rappelle le débat C # sur l'opportunité d'utiliser le mot clé var. L'impression que j'ai jusqu'à présent est que dans le monde C ++, les gens sont prêts à adopter le automot - clé avec moins de combat que vardans le monde C #. Pour moi, mon premier instinct est que j'aime connaître le type de la variable afin que je puisse savoir quelles opérations je peux m'attendre à y effectuer.

Les motivations en C ++ sont plus extrêmes, car les types peuvent devenir beaucoup plus compliqués et complexes que les types C # en raison de la métaprogrammation et d'autres choses. autoest plus rapide à écrire et à lire et plus flexible / maintenable qu'un type explicite. Je veux dire, voulez-vous commencer à taper

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

Ce n'est même pas le type complet. J'ai raté quelques arguments de modèle.

Dans votre exemple:

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

il doit y avoir une déclaration pour xvisible. Par conséquent, le type de itdoit être évident. Si le type de xn'est pas évident, la méthode est trop longue ou la classe est trop grande.

Objection ! Question chargée.

Pouvez-vous m'expliquer pourquoi le troisième code contient ??, mais pas le premier et le deuxième? Par souci d'équité, votre code doit se lire comme suit:

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->???
}

Là. Même problème même si vous ne l'avez pas utilisé auto.

Et dans tous les cas, la réponse est la même: le contexte compte . Vous ne pouvez pas parler de manière significative d'un morceau de code de manière isolée. Même si vous n'aviez pas utilisé de modèles mais un type concret, cela n'aurait fait que déplacer le problème ailleurs, car le lecteur de votre code devrait connaître la déclaration dudit type.

Si l'utilisation de autodans ces situations rend votre code illisible, vous devez considérer cela comme un signe d'avertissement qu'il y a un problème avec la conception de votre code. Bien sûr, il y a des cas où des détails de bas niveau sont importants (comme pour les opérations sur les bits ou les API héritées), auquel cas un type explicite peut faciliter la lisibilité. Mais en général - non.

En ce qui concerne var(puisque vous l'avez mentionné explicitement), il existe également un vaste consensus dans la communauté C # pour l' utilisation var. Les arguments contre son utilisation reposent généralement sur des erreurs .

PRO

Votre code :

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

ne va pas compiler, en raison du nom dépendant du modèle.

Voici la syntaxe correcte:

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

Regardez maintenant la longueur de la déclaration de type. Cela explique pourquoi le automot clé a été introduit. Cette :

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

est plus concis. Donc, c'est un pro.

CON

Vous devez être un peu prudent. Avec le mot-clé auto, vous obtenez le type que vous avez déclaré.

Par exemple :

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

contre

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

Pour conclure: oui, vous devriez le faire, mais pas en abuser. Certaines personnes ont tendance à trop l'utiliser et à mettre l'auto partout, comme dans l'exemple suivant:

auto i = 0;

contre

int i = 0;

Oui tu devrais! auton'efface pas le type; même si vous "ne savez pas" ce qui x.begin()est, le compilateur sait et signalera une erreur si vous essayez d'utiliser le type incorrectement. De plus, il n'est pas inhabituel d'émuler mapavec un vector<pair<Key,Value>>, donc le code utilisant autofonctionnera pour les deux représentations de dictionnaire.

Oui, vous devez utiliser autocomme règle par défaut. Il présente des avantages bruts par rapport à la spécification explicite du type:

• Cela ne vous oblige pas à taper des choses que le compilateur connaît déjà.
• Il fait que le type de variables "suit" tout changement dans les types de valeur de retour.
• Ce faisant, il empêche l' introduction silencieuse de conversions implicites et de découpage dans l'initialisation de variable locale.
• Il supprime la nécessité de certains calculs de type explicites dans les modèles.
• Il supprime le besoin de nommer les types de retour avec des noms longs. (ceux que vous copiez-collez à partir des diagnostics du compilateur)

C'est là que vous avez le choix. Il y a aussi des cas où vous n'avez pas le choix:

• Il permet la déclaration de variables de types inexprimables, comme le type d'un lambda.

Pourvu que vous sachiez exactement ce autoque cela fait, cela n'a aucun inconvénient.