C++, auto et decltype

Plop,

Je trouve étrange de parler d’exception dans la déduction d’un type plein, alors que c’est le comportement naturel pour le passage de paramètre: une copie n’a de qualificateurs qu’à la condition d’en mettre explicitement.

Idem pour les rvalues. En expliquant ce qui se passe dans une accumulation de référence on se retrouve sans exceptions: & + && = & (T1 = int&; T2 = T1&& = int&).

Il manque les const dans les commentaires du chapitre "Les rvalues references".

2 trucs pour savoir le type d’un template sans passé par boost:

• __PRETTY_FUNCTION__
• Une erreur de compilation avec un code comme template<class> S{}; /*...*/ S<T>{} = 1;. Je l’utilise régulièrement, principalement dans les tests de vérifier de type (S<decltype(f(...))>{} = S<int&>{}).

Pas de ressources, je crois bien avoir inventé quelque chose (yééé… \o/)

Dans l’idée je vois la chose comme ci-dessous:

• le passage de paramètres n’existe que sous forme de référence (lvalue ou rvalue)¹. C’est important puisque que pour int * p; foo(p), ParamType = int * &.
• à moins de le préciser, les modificateurs sont ignorés (const, volatile, &, &&).
• les parties explicitement citées sont "soustraites" de T:
• T & avec param = int &. On enlève & -> T = int.
• T && avec param = int &. Pas de commun, T = int &, la fonction attend int & &&, la lvalue prévaut, la rvalue est enlevée.
• T && avec param = int &&. On enlève && -> T = int.
• T & avec param = int &&. Pas de commun, T = int &&. la fonction attend int && &, la lvalue prévaut, la rvalue est enlevée (= int &). La fonction attend une lvalue, le paramètre est une rvalue = la fonction ne peut pas matcher, c’est ok, on est bien sur une erreur.
• T const & avec param = int &&. Pas de commun, T = int &&. la fonction attend int && const &, la lvalue prévaut, la rvalue est enlevée (param attendu: int const &, T = int (on enlève aussi la rvalue)). le paramètre passé (int &&) peut être convertie en int const &, c’est ok.

Pour faire une règle générale, il faut synthétiser les étapes du dernier points qui sont aussi valides pour les précédents.

• Éliminer les modificateurs communs entre type passé et T.
• S’il y a une référence du genre & &&/&& & dans le paramètre attendu, enlever && du paramètre attendu et de T (il peut ne pas y en avoir dans T).
• Vérifier que la fonction est toujours appelable, sinon ce n’est pas une surcharge valide.

¹ Une autre idée est de considérer toutes expression comme une rvalue lors de la création et qu’y attacher une variable les transforment en lvalue. Une expression qui retourne une lvalue serait en fait une rvalue sur une lvalue simplifié en lvalue :p.