Pourquoi « std::forward » désactive-t-il la déduction des arguments de modèle dans Visual Studio 2010 ?

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

Énoncé du problème

Visual Studio 2010 définit std::forward to désactiver la déduction des arguments du modèle. Pourquoi cette désactivation est-elle intentionnelle ?

Réponse

La déduction de l'argument du modèle entraînerait une détermination de type incorrecte et un comportement erroné dans std::forward. Voici comment :

Cas sans déduction d'argument de modèle

Sans déduction d'argument de modèle, std::forward est défini comme :

<code class="cpp">template<class _Ty> inline
_Ty&amp;&amp; forward(typename identity<_Ty>::type&amp; _Arg) {
    return ((_Ty&amp;&amp;)_Arg);
}</code>

Cas avec déduction d'argument de modèle

Si std::forward utilisait la déduction d'argument de modèle, les scénarios suivants se présenteraient :

• Pour une référence rvalue à un objet de type X (par exemple, func() ou 7), la déduction d'argument de modèle déterminerait correctement T comme X.
• Pour une lvalue ou une lvalue const (par exemple, des objets avec des noms), la déduction d'argument de modèle déterminerait incorrectement T comme lvalue référence ou référence const lvalue.

Implications d'une détermination de type incorrecte

Dans le transfert parfait, l'argument passé à std::forward est une lvalue. Si la déduction des arguments de modèle était activée, le type déduit T serait une référence lvalue. Cependant, "transfert parfait" implique une référence rvalue.

Le cast dans std::forward, static_cast(arg), se réduirait toujours à une référence lvalue, même lorsque l'argument d'origine était une rvalue. Cela entraînerait une conversion incorrecte et un dysfonctionnement du mécanisme de transfert parfait.

Exemple

Le code suivant illustre les problèmes liés à la déduction des arguments de modèle :

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

int main() {
    int x;
    int& y = x;
    int&& z = std::move(x);

    forward_with_deduction(7); // Correctly calls forward(int&&)
    forward_with_deduction(y); // Incorrectly calls forward(int&)

    std::forward<int&>(y); // Correctly calls forward(int&)
}</code>

Conclusion

La désactivation de la déduction des arguments de modèle dans std::forward est cruciale pour que le transfert parfait fonctionne correctement. Il empêche une détermination de type erronée et garantit que les références rvalue sont correctement transmises en tant que références rvalue.

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!