Combien est trop avec C ++0 x mot clé auto

Question

J'ai été en utilisant le nouveau auto de mots clés disponibles dans le C++0x standard pour les complexes basées sur des modèles de types qui est ce que je crois qu'il a été conçu. Mais je suis aussi de l'utiliser pour des choses comme:

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

Et de plus en plus sceptique pour:

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

Je n'ai pas vu beaucoup de discussions sur ce sujet. Il semble que l'auto pourrait être galvaudé, car un type est souvent une forme de la documentation et des contrôles d'intégrité. Où puisez-vous la ligne à l'aide d' auto et ce sont recommandés en cas d'utilisation de cette nouvelle fonctionnalité?

Pour clarifier: je ne suis pas à demander une opinion philosophique; je demande pour l'utilisation de ce mot-clé par le comité des normes, avec éventuellement des commentaires sur la façon dont l'utilisation prévue est réalisée dans la pratique.

Remarque: Cette question a été déplacé à SE.Les programmeurs et puis retour à Débordement de Pile. Discussion sur ce qui peut être trouvé dans cette méta question.

Answer 1

Je pense que l'on devrait utiliser l' auto mot-clé à chaque fois qu'il est difficile de dire comment écrire le type à première vue, mais le type de la main droite, à côté d'une expression est évidente. Par exemple, en utilisant:

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

pour obtenir la clé composite de type en boost::multi_index, même si vous savez qu'il est int. Vous ne pouvez pas écrire int , car il pourrait être modifié dans le futur. Je voudrais écrire auto dans ce cas.

Donc, si l' auto mot-clé améliore la lisibilité dans un cas particulier, puis l'utiliser. Vous pouvez écrire auto alors qu'il est évident pour le lecteur de ce type auto représente.

Voici quelques exemples:

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)

Answer 2

Utilisation partout où vous pouvez, en particulier pour que les effets secondaires sont moins préoccupants. Vous n’aurez pas à vous soucier de types sauf dans les cas évidents, mais ils vont encore être vérifiés statiquement pour vous, et vous pouvez éviter des répétitions. Où n’est pas possible, vous pouvez utiliser pour exprimer les types sémantiquement comme contrats basés sur des expressions. Votre code sera différent, mais ce sera un changement positif.

Answer 3

Facile. L'utiliser lorsque vous n'avez pas de soins de quel type est. Par exemple

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

Tout ce qui m'intéresse ici, c'est que i est tout ce qui est dans le conteneur.

C'est un peu comme les typedefs.

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

Ici, je ne se soucient pas si h et w sont des flotteurs ou doubles, seulement qu'ils sont, quel que soit le type est approprié pour exprimer la taille et le poids.

Ou envisager

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

Ici tout ce qui m'intéresse c'est qu'il est approprié d'itérateur, en soutenant operator++(), c'est un peu comme le canard de taper à cet égard.

Aussi le type de lambdas ne peut pas être dit, de sorte auto f = []... est un bon style. L'alternative est la conversion en std::function mais qui vient avec des frais généraux.

Je ne peux pas vraiment imaginer un "abus" de auto. Le plus proche que je peux imaginer c'est se priver d'une conversion explicite pour certains type -- mais vous ne pouvez pas utiliser auto pour que, vous feriez construire un objet du type désiré.

Si vous pouvez supprimer une certaine redondance dans votre code, sans introduire des effets secondaires, alors il doit être bon de le faire.

Mais des contre-exemples (emprunté à quelqu'un d'autre réponses):

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

Ici, nous FAISONS attention à ce que le type est, donc, nous devrions écrire Someclass i; et for(unsigned x = y;...

Answer 4

Aller pour elle. Utiliser "auto" partout où il permet d'écrire du code plus facile.

Chaque nouvelle fonctionnalité dans n'importe quelle langue va se galvaudé par au moins certains types de programmeurs. C'est seulement grâce à modérée, l'utilisation excessive par certains programmeurs expérimentés (pas les noobs) que le reste de l'programmeurs expérimentés apprendre les limites de l'utilisation appropriée. Extrême surutilisation est généralement mauvais, mais pourrait être bonne, car une telle utilisation excessive peut mener à des améliorations de la fonctionnalité ou une meilleure fonctionnalité pour le remplacer.

Mais si je devais travailler sur le code avec plus de quelques lignes comme

auto foo = bla();

lorsque le type est indiqué zéro fois, je souhaiterez peut-être modifier ces lignes à inclure les types suivants. Le premier exemple est grande puisque le type est indiqué une fois, et 'auto' qui nous sauve de devoir écrire en désordre basée sur des modèles types à deux reprises. Hourra pour C++++. Mais montrant explicitement le type zéro fois, si il n'est pas facilement visible à proximité de la ligne, me rend nerveux, au moins en C++ et de ses successeurs immédiats. Pour les autres langues conçu pour fonctionner à un niveau supérieur avec plus d'abstraction, de polymorphisme et de la genericity, c'est la fin.

Answer 5

Oui, il peut être galvaudé au détriment de la lisibilité. Je suggère de l'utiliser dans les contextes où les types exacts sont longues, ou de l'indicible, ou pas important pour des raisons de lisibilité, et les variables sont de courte durée. Par exemple, l'itérateur de type est généralement long et n'est pas important, de sorte auto devrait fonctionner:

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

auto ici ne fait pas de mal la lisibilité.

Un autre exemple est un analyseur de type de règle, ce qui peut être long et alambiqué. Comparer:

   auto spaces = space & space & space;

avec

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

D'autre part, quand le type est connu et est simple, il est beaucoup mieux si elle a déclaré explicitement:

int i = foo();

plutôt que de

auto i = foo();