Y a-t-il un inconvénient à déclarer des variables avec auto en C ++?

Il semble que autoc'était une fonctionnalité assez importante à ajouter dans C ++ 11 qui semble suivre un grand nombre des nouveaux langages. Comme avec un langage comme Python, je n'ai vu aucune déclaration de variable explicite (je ne sais pas si c'est possible en utilisant les standards Python).

Y a-t-il un inconvénient à utiliser autopour déclarer des variables au lieu de les déclarer explicitement?

Vous avez seulement posé des questions sur les inconvénients, alors j'en souligne certains. Lorsqu'il est bien utilisé, il autoprésente également plusieurs avantages. Les inconvénients résultent de la facilité des abus et du potentiel accru du code à se comporter de manière non intentionnelle.

Le principal inconvénient est qu'en utilisant auto, vous ne connaissez pas nécessairement le type d'objet en cours de création. Il y a aussi des occasions où le programmeur peut s'attendre à ce que le compilateur déduise un type, mais le compilateur en déduit catégoriquement un autre.

Étant donné une déclaration comme

auto result = CallSomeFunction(x,y,z);

vous ne savez pas forcément quel type result s'agit. Cela pourrait être un int. Cela pourrait être un indicateur. Cela pourrait être autre chose. Tous ces éléments prennent en charge différentes opérations. Vous pouvez également modifier considérablement le code par un changement mineur comme

auto result = CallSomeFunction(a,y,z);

car, en fonction des surcharges existantes, CallSomeFunction()le type de résultat peut être complètement différent - et le code suivant peut donc se comporter complètement différemment de ce qui est prévu. Vous pourriez soudainement déclencher des messages d'erreur dans le code ultérieur (par exemple, essayer de déréférencer un int, essayer de changer quelque chose qui est maintenant const). Le changement le plus sinistre est celui où votre changement passe devant le compilateur, mais le code suivant se comporte de manière différente et inconnue - peut-être boguée.

Ne pas avoir de connaissance explicite du type de certaines variables rend donc plus difficile de justifier rigoureusement une affirmation selon laquelle le code fonctionne comme prévu. Cela signifie plus d'efforts pour justifier les allégations de «convenance à l'usage» dans les domaines de haute criticité (par exemple, critiques pour la sécurité ou la mission).

L'autre inconvénient, plus courant, est la tentation pour un programmeur d'utiliser autocomme un instrument brutal pour forcer le code à se compiler, plutôt que de penser à ce que le code fait et de travailler pour le faire correctement.

Ce n'est pas autoexactement un inconvénient de principe, mais en termes pratiques, cela semble être un problème pour certains. Fondamentalement, certaines personnes: a) se traitent autocomme un sauveur pour les types et bloquent leur cerveau lorsqu'elles l'utilisent, ou b) oublient que cela autodéduit toujours des types de valeur. Cela amène les gens à faire des choses comme ceci:

auto x = my_obj.method_that_returns_reference();

Oups, nous venons de copier en profondeur un objet. C'est souvent un bug ou un échec de performance. Ensuite, vous pouvez également basculer dans l'autre sens:

const auto& stuff = *func_that_returns_unique_ptr();

Maintenant, vous obtenez une référence pendante. Ces problèmes ne sont pas causés parauto , donc je ne les considère pas comme des arguments légitimes contre cela. Mais il semble que autoces problèmes soient plus courants (d'après mon expérience personnelle), pour les raisons que j'ai énumérées au début.

Je pense qu'avec le temps, les gens s'adapteront et comprendront la division du travail: en autodéduit le type sous-jacent, mais vous voulez toujours penser à la référence et à la constance. Mais cela prend un peu de temps.

D'autres réponses mentionnent des inconvénients comme «vous ne savez pas vraiment quel est le type d'une variable». Je dirais que cela est largement lié à une convention de dénomination bâclée dans le code. Si vos interfaces sont clairement nommées, vous ne devriez pas avoir à vous soucier du type exact. Bien sûr, auto result = callSomeFunction(a, b);ça ne vous dit pas grand chose. Mais auto valid = isValid(xmlFile, schema);vous en dit assez pour l'utiliser validsans avoir à vous soucier de son type exact. Après tout, avec juste if (callSomeFunction(a, b)), vous ne sauriez pas non plus le type. La même chose avec tous les autres objets temporaires de sous-expression. Je ne considère donc pas cela comme un réel inconvénient auto.

Je dirais que son principal inconvénient est que parfois, le type de retour exact n'est pas celui avec lequel vous voulez travailler. En effet, le type de retour réel diffère parfois du type de retour "logique" en tant que détail d'implémentation / d'optimisation. Les modèles d'expression en sont un excellent exemple. Disons que nous avons ceci:

SomeType operator* (const Matrix &lhs, const Vector &rhs);

Logiquement, nous nous attendrions SomeTypeà l'être Vector, et nous voulons absolument le traiter comme tel dans notre code. Cependant, il est possible qu'à des fins d'optimisation, la bibliothèque d'algèbre que nous utilisons implémente des modèles d'expression, et le type de retour réel est le suivant:

MultExpression<Matrix, Vector> operator* (const Matrix &lhs, const Vector &rhs);

Maintenant, le problème est que MultExpression<Matrix, Vector>, selon toute vraisemblance, stockera un const Matrix&et en const Vector&interne; il s'attend à ce qu'il se convertisse en a Vectoravant la fin de son expression complète. Si nous avons ce code, tout va bien:

extern Matrix a, b, c;
extern Vector v;

void compute()
{
  Vector res = a * (b * (c * v));
  // do something with res
}

Cependant, si nous avions utilisé autoici, nous pourrions avoir des ennuis:

void compute()
{
  auto res = a * (b * (c * v));
  // Oops! Now `res` is referring to temporaries (such as (c * v)) which no longer exist
}

L'un des inconvénients est que parfois vous ne pouvez pas déclarer const_iteratoravec auto. Vous obtiendrez un itérateur ordinaire (non const) dans cet exemple de code tiré de cette question :

map<string,int> usa;
//...init usa
auto city_it = usa.find("New York");

Cela rend votre code un peu plus difficile ou fastidieux à lire. Imaginez quelque chose comme ça:

auto output = doSomethingWithData(variables);

Maintenant, pour déterminer le type de sortie, vous devez rechercher la signature de la doSomethingWithDatafonction.

Comme ce développeur, je déteste auto. Ou plutôt, je déteste la façon dont les gens abusentauto .

Je suis d'avis (fort) que autoc'est pour vous aider à écrire du code générique, pas pour réduire la frappe .
C ++ est un langage dont le but est de vous permettre d'écrire du code robuste, pas de minimiser le temps de développement.
Ceci est assez évident à partir de nombreuses fonctionnalités de C ++, mais malheureusement quelques-unes des plus récentes commeauto celle-ci réduisent la saisie en erreur en leur faisant croire qu'elles devraient commencer à être paresseuses avec la frappe.

Auparavant auto, les gens utilisaient typedefs, ce qui était génial parce que cela typedef permettait au concepteur de la bibliothèque de vous aider à déterminer quel devrait être le type de retour, afin que leur bibliothèque fonctionne comme prévu. Lorsque vous utilisez auto, vous enlevez ce contrôle au concepteur de la classe et demandez à la place au compilateur de déterminer quel doit être le type, ce qui supprime l'un des outils C ++ les plus puissants de la boîte à outils et risque de casser son code.

En général, si vous utilisez auto, cela devrait être parce que votre code fonctionne pour n'importe quel type raisonnable , pas parce que vous êtes simplement trop paresseux pour écrire le type avec lequel il devrait fonctionner. Si vous utilisez autocomme outil pour aider à la paresse, alors ce qui se passe, c'est que vous commencez finalement à introduire des bogues subtils dans votre programme, généralement causés par des conversions implicites qui ne se sont pas produites parce que vous avez utilisé auto.

Malheureusement, ces bogues sont difficiles à illustrer dans un court exemple ici parce que leur brièveté les rend moins convaincants que les exemples réels qui surviennent dans un projet utilisateur - cependant, ils se produisent facilement dans un code lourd en modèle qui s'attend à certaines conversions implicites. prennent endroit.

Si vous voulez un exemple, il y en a un ici . Une petite note cependant: avant d'être tenté de sauter et de critiquer le code: gardez à l'esprit que de nombreuses bibliothèques bien connues et matures ont été développées autour de telles conversions implicites, et elles sont là parce qu'elles résolvent des problèmes qui peuvent être difficiles voire impossibles à résoudre autrement. Essayez de trouver une meilleure solution avant de les critiquer.

auton'a pas d'inconvénients en soi , et je recommande de l'utiliser (à la main) partout dans le nouveau code. Il permet à votre code de vérifier systématiquement le type et d'éviter systématiquement le découpage silencieux. (Si Bdérive de Aet qu'une fonction retournant Asoudainement retourne B, alorsauto se comporte comme prévu pour stocker sa valeur de retour)

Cependant, le code hérité pré-C ++ 11 peut s'appuyer sur des conversions implicites induites par l'utilisation de variables explicitement typées. Changer une variable explicitement typée en autopeut changer le comportement du code , vous feriez donc mieux d'être prudent.

Le mot-clé autodéduit simplement le type de la valeur de retour. Par conséquent, ce n'est pas équivalent avec un objet Python, par exemple

# Python
a
a = 10       # OK
a = "10"     # OK
a = ClassA() # OK

// C++
auto a;      // Unable to deduce variable a
auto a = 10; // OK
a = "10";    // Value of const char* can't be assigned to int
a = ClassA{} // Value of ClassA can't be assigned to int
a = 10.0;    // OK, implicit casting warning

Comme il autoest déduit lors de la compilation, il n'aura aucun inconvénient à l'exécution.

Ce que personne n'a mentionné ici jusqu'à présent, mais en soi, vaut une réponse si vous me le demandez.

Depuis (même si tout le monde doit savoir que C != C++ ) le code écrit en C peut facilement être conçu pour fournir une base pour le code C ++ et donc être conçu sans trop d'effort pour être compatible C ++, cela pourrait être une exigence de conception.

Je connais certaines règles dont certaines constructions bien définies ne Csont pas valides C++et vice versa. Mais cela entraînerait simplement des exécutables cassés et la clause UB connue s'applique, ce qui est la plupart du temps remarqué par des boucles étranges entraînant des plantages ou autre (ou même peut rester non détecté, mais cela n'a pas d'importance ici).

Mais autoc'est la première fois ¹ ce changement!

Imaginez que vous utilisiez auparavant autocomme spécificateur de classe de stockage et que vous transfériez le code. Il ne serait même pas nécessairement (selon la manière dont il était utilisé) "casser"; il pourrait en fait modifier silencieusement le comportement du programme.

C'est quelque chose qu'il faut garder à l'esprit.

¹ _{Au moins la première fois que je suis au courant.}

Une raison à laquelle je peux penser est que vous perdez l'occasion de contraindre la classe qui est renvoyée. Si votre fonction ou méthode a renvoyé un long 64 bits et que vous ne vouliez qu'un 32 entier non signé, vous perdez l'opportunité de contrôler cela.

Comme je l'ai décrit dans cette réponse, cela auto peut parfois entraîner des situations géniales auxquelles vous n'aviez pas l'intention. Vous devez dire explicitement auto&avoir un type de référence tout en faisant simplement autopouvoir créer un type de pointeur. Cela peut entraîner une confusion en omettant le spécificateur tous ensemble, ce qui entraîne une copie de la référence au lieu d'une référence réelle.

Un autre exemple irritant:

for (auto i = 0; i < s.size(); ++i)

génère un avertissement ( comparison between signed and unsigned integer expressions [-Wsign-compare]), car iest un entier signé. Pour éviter cela, vous devez écrire par exemple

for (auto i = 0U; i < s.size(); ++i)

ou peut-être mieux:

for (auto i = 0ULL; i < s.size(); ++i)

Je pense que autoc'est bon lorsqu'il est utilisé dans un contexte localisé, où le lecteur peut facilement et évidemment déduire son type, ou bien documenté avec un commentaire de son type ou un nom qui en déduit le type réel. Ceux qui ne comprennent pas comment cela fonctionne pourraient le prendre de la mauvaise manière, comme l'utiliser à la place templateou similaire. Voici quelques bons et mauvais cas d'utilisation à mon avis.

void test (const int & a)
{
    // b is not const
    // b is not a reference

    auto b = a;

    // b type is decided by the compiler based on value of a
    // a is int
}

Bonnes utilisations

Itérateurs

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int> v();

..

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int>::iterator it = v.begin();

// VS

auto vi = v.begin();

Pointeurs de fonction

int test (ClassWithLongName1 a, ClassWithLongName2 b, int c)
{
    ..
}

..

int (*fp)(ClassWithLongName1, ClassWithLongName2, int) = test;

// VS

auto *f = test;

Mauvaises utilisations

Flux de données

auto input = "";

..

auto output = test(input);

Signature de fonction

auto test (auto a, auto b, auto c)
{
    ..
}

Cas triviaux

for(auto i = 0; i < 100; i++)
{
    ..
}

Je suis surpris que personne n'ait mentionné cela, mais supposons que vous calculiez la factorielle de quelque chose:

#include <iostream>
using namespace std;

int main() {
    auto n = 40;
    auto factorial = 1;

    for(int i = 1; i <=n; ++i)
    {
        factorial *= i;
    }

    cout << "Factorial of " << n << " = " << factorial <<endl;   
    cout << "Size of factorial: " << sizeof(factorial) << endl; 
    return 0;
}

Ce code affichera ceci:

Factorial of 40 = 0
Size of factorial: 4

Ce n'était certainement pas le résultat escompté. C'est arrivé parce queauto déduit le type de la variable factorielle comme intparce qu'elle était affectée 1.