Pourquoi `std::forward` désactive-t-il la déduction des arguments du modèle ?

Désactivation de la déduction d'argument de modèle avec std::forward

Pourquoi la déduction d'argument de modèle est-elle désactivée avec std::forward ?

La fonction std::forward, dans certaines implémentations (par exemple, VS2010), utilise une métafonction de modèle appelée identité pour interdire la déduction des arguments de modèle. Ceci est fait pour maintenir un contrôle précis sur le comportement de std::forward dans des situations impliquant des références lvalue et des références const lvalue.

Implications de l'utilisation de la déduction d'argument de modèle

Si std::forward utilisait la déduction des arguments de modèle, cela entraînerait la déduction du paramètre de modèle (T) en fonction du type de l'argument d'entrée. Ce comportement devient problématique lorsque l'argument d'entrée est une lvalue ou une const lvalue (par exemple, des variables avec des noms). Dans de tels cas, la déduction de l'argument du modèle déduirait par erreur T comme une référence lvalue ou une référence const lvalue, conduisant à un transtypage de type incorrect.

Considérez l'exemple suivant :

<code class="cpp">template<typename T>
T&& forward_with_deduction(T&& obj)
{
    return static_cast<T&&>(obj);
}</code>

Lors du passage de variables nommées ou des constantes à forward_with_deduction, cela les interpréterait incorrectement comme des références lvalue ou des références const lvalue, ce qui entraînerait la déduction de T comme telle. Par conséquent, l'opération static_cast réduirait le type en une référence lvalue ou une référence const lvalue, malgré l'attente d'une référence universelle (T&&).

Exemple :

<code class="cpp">int x;
int&& z = std::move(x);

// Incorrectly deduces T to be int& and casts z as int&
forward_with_deduction(z); // calls test(int&) instead of test(int&&)</code>

Résolution dans std::forward

Pour garantir une bonne présentation des arguments dans tous les cas, std::forward utilise la métafonction d'identité. L'identité agit comme un type d'espace réservé qui empêche le compilateur de déduire le paramètre de modèle. Par conséquent, std::forward interprète toujours l'argument d'entrée comme une référence universelle, quel que soit son type réel.

En convertissant l'argument d'entrée en référence universelle, std::forward permet un transfert parfait des objets, même s'il s'agit de lvalues ​​ou de lvalues ​​const. Ce comportement garantit que le type de l'argument transmis reste une référence universelle tout au long du processus de transfert.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!