Discussion :

[Boumbata]

Hello all !!


La norme C++11 ajoute le mot-clef 'auto' (oui je sais je suis à la bourre mais mieux vaut tard que jamais ) qui permet de laisser déduire le type de retour. Mais personnellement je ne vois pas trop l'intérêt de ce mot-clef
En fait si j'ai bien compris cela permet d'éviter, surtout dans le cas des variables à faible durée de vie , de se taper 45 mots juste pour déclarer le type de la variable (genre std::vector<std::vector<std::tuple<int, int, std::string> > >::const_iterator ), chose que le typedef permettait de vaguement contourner (bon je reconnais que c'est un peu exagéré mais y a de l'idée).

En fait je trouve que ce mot-clef sacrifie la clarté et la compréhension de code pour pondre du code de manière plus "simple", et je pense que son ajout risque d'entraîner, auprès des nouvelles recrues (ceux et celles qui vont découvrir le C++ via C++11 en tout cas), une sorte de laisser-aller dans le développement de nouvelles fonctions.
Dans ma tête j'imagine une nouvelle personne qui va utiliser des fonctions qu'il vient juste de découvrir et qui va utiliser à tout-va des 'auto' dans les types de retour afin d'éviter de mater la doc, et va donc se rendre compte de son erreur qu'au moment de la compilation. Ce que je veux dire c'est qu'il y a risque d'utilisation du mot-clef 'auto' non seulement dans le cas des variables à faible durée de vie, mais aussi plus loin (genre attributs). Après je crois savoir que la norme interdit l'emploi combiné des mots-clefs 'auto' et 'static' et c'est déjà pas mal. Mais jusqu'où peut-on aller avec 'auto' ?

C'est pour cela que je trouve l'ajout de ce mot-clef plus dangereux qu'utile, et j'évite de l'utiliser. Mais après je n'ai que très peu d'expériences dans le domaine, je pense que mon idée sur la question est assez vague et j'espère avoir votre avis sur la question pour me trancher une meilleure opinion sur ce point.

Qu'en pensez-vous ?

Merci encore

[ternel]

Pour moi, auto est très utile avec les foncteurs, et pour les boucles simplifiées, tout particulièrement dans les templates.

Pour le reste, l'usage est un peu moins avantageux.
Chaque fois que auto laisse le code clair sur ce qu'on manipule, j'accepte de l'utiliser.

[white_tentacle]

auto est assez indispensable quand tu fais de la programmation générique. On pourrait s’en passer dans ce contexte en utilisant decltype à la place, mais auto est beaucoup plus lisible.

Sinon, pour des itérateurs de boucle, le gain en lisibilité est aussi énorme.

Enfin, mais c’est un argument à double tranchant, auto permet d’améliorer la compatibilité source lors de certains changements dans le code (attention par contre à la compatibilité binaire).

[Iradrille]

Hello,

Pareil, quand ça simplifie le code (itérateurs, range based loop) ou que le type réel n'a pas d'intérêt ou est évident je l'utilise, sinon j'écris le nom du type.

[the Hound]

Bonjour,

Le mot-clé auto a été créé pour des raisons de lisibilité, comme d'autres l'ont dit, mais pas que.
S'il permet d'éviter les duplications inutiles, exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
toto foo;
 
// Sachant que make_widget renvoie widget<T> et prend T&
// Avant  C++11 :
widget<toto> bar = make_widget(foo);
// On sait déjà que foo est de type toto, et le compilo le sait aussi, alors pourquoi le rappeler ?
 
// Après :
auto bar = make_widget(foo);

... dans certains cas, il est impossible de s'en passer.

Prenons la classe std::function, qui peut être bound to (une traduction en Français, quelqu'un ?) une fonction ou un objet fonction (ou fonction objet ?).
Un objet fonction est un objet qui définit operator() ; d'ailleurs, d'après les concepteurs du langage, un objet ne devrait définir operator() que si sémantiquement il se comporte comme une fonction, donc tous les objets qui peuvent être appelés de cette manière : f(), sont considérés comme des fonctions.

Avec les templates, on peut récupérer le type de retour et ceux des paramètres d'une fonction ou une fonction membre, mais les choses se compliquent si on passe non pas une fonction mais un objet fonction. Il faudrait alors faire la même chose avec operator() ... imaginez la gueule du code pour prendre tous les cas possibles, même avec des templates variadiques (cas où c'est une fonction membre, où c'est une fonction membre const, où c'est un objet fonction, où operator() est const, où toto titi tata, etc.).
Mais ce qui est encore plus problématique, c'est dans le cas de surcharges de fonctions. Considérons :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int toto(float);
char toto(char*);
 
auto f = make_function(toto); // KO

Le compilateur n'est pas en mesure de déterminer de quelle surcharge on "parle". Pareil si c'est un objet fonction qui implémente plusieurs surcharges de operator().

La solution à ça, c'est decltype :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
decltype(toto(.42f)) x; // x est de type int
decltype(toto("hello")) y; // y est de type char

decltype() renvoie le type d'une expression ; toto(.42f) est de type int, alors que toto("hello") est de type char.

On pourrait utiliser decltype pour récupérer le type de retour d'une fonction surchargée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template <typename... Args>
  decltype(f(args...)) call_function(Args... args) { /* ... */ } // !!!

... mais écrire un tel code violerait une règle des langages C et C++ qui dit, en gros, qu'un symbole n'est valide que s'il a été défini avant dans l'unité de compilation actuelle. Ici, on utilise args dans le decltype() qui apparaît avant les paramètres de la fonction et donc la déclaration de args (Args... args). C'est interdit.

Et c'est là où auto intervient : on peut écrire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template <typename... Args>
  auto call_function(Args... args) -> decltype(f(args...)) { /* ... */ } // OK

Ici, la combinaison de auto et decltype() est très efficace, puisqu'elle permet de traiter à peu près n'importe quoi : que f soit une fonction, une fonction membre, une fonction membre const, un objet fonction (auquel cas l'expression dans decltype() appelle f.operator()), etc. Et ça fonctionne avec les surcharges.

Bref, comme le type bool, auto a été créé pour des raisons de simplicité, mais aussi pour combler certaines lacunes du langage.

Pour les curieux, voici un exemple d'implémentation de function :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <typename T>
  class function
  {
      T _f;
    public:
      function(T f):_f(f) {}
 
      template <typename... Args>
        auto operator () (Args&&... args)
        -> decltype(_f(args...))
        {
          return _f(args...);
        }
  };

Le code est incomplet (pas de std::move() par exemple) et je n'ai pas testé, mais l'idée est là. Remarquez comme ce code est concis. Pas une spécialisation, là où en C++ avant 2011 on aurait pondu 1500 lignes de code pour gérer un quart des cas que ce code peut traiter.

[oodini]

Prenons la classe std::function, qui peut être bound to (une traduction en Français, quelqu'un ?)

"lié à"

une fonction ou un objet fonction (ou fonction objet ?).

"foncteur" ou "objet fonctionnel"

Les fonctions et les foncteurs étant tous deux des entités appelables.

[the Hound]

"lié à"


"foncteur" ou "objet fonctionnel"

Les fonctions et les foncteurs étant tous deux des entités appelables.

Merci. Ça m'apprendra à lire des articles en anglais