decltype(auto) combine le mécanisme de déduction de type de decltype avec la commodité de la syntaxe auto. Alors que auto applique des règles de déduction des arguments de modèle qui dégradent les tableaux en pointeurs et retirent les cv-qualifiers et références au niveau supérieur, decltype(auto) préserve le type exact de l'expression d'initialisation. Plus précisément, si l'expression est un nom de variable sans parenthèses, decltype renvoie le type déclaré ; si c'est une expression lvalue entre parenthèses, elle renvoie une référence lvalue. Cela permet aux fonctions de transmettre parfaitement leurs valeurs de retour sans spécifier explicitement des expressions decltype ou se soucier des complexités de l'effondrement de références.
Nous devions mettre en œuvre un wrapper générique pour un accès à une base de données qui retourne conditionnellement soit une référence à un enregistrement mis en cache, soit une valeur par défaut nouvellement construite. L'exigence critique était de préserver la sémantique exacte du type de retour : les références doivent rester des références pour éviter de copier de grands objets, tandis que les valeurs doivent être déplacées ou copiées selon le besoin.
Une solution candidate a utilisé un type de retour explicite final avec decltype et std::declval, spécifiant decltype(std::declval<Accessor>()(key)). Avantages : Cela documente explicitement la transformation de type et fonctionne en C++11. Inconvénients : La syntaxe est longue, nécessite un transfert parfait des arguments vers std::declval et devient ingérable lorsqu'il s'agit de plusieurs surcharges ou de logique conditionnelle.
Une autre approche a utilisé un simple auto comme type de retour, supposant que le compilateur déduirait le type approprié. Avantages : C'est concis et lisible. Inconvénients : Auto applique des règles de dégradation, convertissant Record& en Record et retirant les cv-qualifiers, ce qui entraîne des copies profondes inutiles et viole la const-correctness lorsque l'appelant attend une référence en lecture seule.
Nous avons choisi decltype(auto) pour le type de retour, qui applique les règles de préservation de type de decltype à l'expression retournée. Ce choix a éliminé le code répétitif tout en garantissant que les références lvalue, les cv-qualifiers et les références rvalue se propagent correctement à l'appelant. Le résultat était une façade générique sans surcharge qui gère à la fois les retours de valeurs et de références sans duplication de code ni conversions implicites, réduisant la latence lors des recherches en cache à haute fréquence.
Pourquoi decltype((var)) produit-il un type de référence lvalue alors que decltype(var) produit le type déclaré, et comment cela affecte-t-il les déclarations de retour decltype(auto) ?
decltype fonctionne selon deux règles distinctes : pour une id-expression non parenthésée (comme var), elle produit le type déclaré pour cette entité ; pour toute autre expression, y compris les expressions parenthésées comme (var), elle renvoie le type de cette expression, qui est un type de référence lvalue si l'expression est une lvalue. Lors de l'utilisation de decltype(auto), retourner (var) crée une référence à une variable locale, entraînant des références pendantes lors de la sortie de la fonction. Par conséquent, il faut éviter les parenthèses inutiles dans les instructions de retour lors de l'utilisation de decltype(auto), car les parenthèses supplémentaires changent la catégorie de l'expression d'une id-expression à une expression lvalue.
Comment decltype(auto) interagit-il avec les xvalues (valeurs expirantes) par rapport aux prvalues ?
decltype(auto) préserve les catégories de valeurs en suivant précisément la sémantique de decltype. Si une fonction renvoie une xvalue (par exemple, std::move(obj)), decltype(auto) déduit le type comme une référence rvalue (T&&), tandis que auto déduirait le type comme T. Cette distinction est critique lors de la mise en œuvre de fonctions de fabrication à perfect-forwarding qui doivent préserver la sémantique de mouvement des temporaires retournés sans forcer des copies ou nécessiter des annotations explicites std::move au site d'appel.
Que se passe-t-il lorsque decltype(auto) est utilisé avec des listes d'initialisation entre accolades, et pourquoi cela diffère-t-il de la déduction auto ?
Lors de l'initialisation avec une liste d'initialisation entre accolades comme {1, 2, 3}, auto déduit std::initializer_list<int>, mais decltype(auto) tente de déduire la liste d'initialisation entre accolades elle-même comme type, ce qui est un contexte non déduit pour decltype et entraîne un code mal formé. Cela empêche l'utilisation de decltype(auto) pour retourner directement des listes d'initialisation entre accolades, contrairement à auto, qui peut déduire le temporaire std::initializer_list. Cette subtile différence découle du fait que decltype préserve exactement le type d'expression, y compris les contextes non déduits où l'expression n'est ni une variable ni un appel de fonction.