Pourquoi `std::make_pair` échoue-t-il avec les arguments de modèle explicites dans C 11 ?

Démêler l'énigme : std::make_pair L'énigme avec les paramètres de modèle explicites

Dans le domaine du C, la fonction std::make_pair s'est imposée comme une solution pratique outil pour créer des paires. Cependant, un problème particulier survient lorsque l'on tente d'utiliser cette fonction avec des paramètres de modèle explicitement spécifiés dans C 11. Cet article se penche sur le comportement énigmatique derrière cette situation.

Erreur à portée de main

Considérez ce qui suit extrait de code qui tente de créer une paire d'une chaîne et d'un entier avec des arguments de modèle explicites :

std::pair<std::string, int>& b = std::make_pair<std::string, int>(s, 7);

Au lieu de l'attendu succès de la compilation, un message d'erreur énigmatique apparaît :

error: no matching function for call to 'make_pair(std::string&, int)'

Dévoilement du mystère

La source de cette erreur réside dans l'utilisation incorrecte de std::make_pair. La fonction a été conçue pour déduire les paramètres du modèle en fonction des arguments fournis. L'indication explicite de ces paramètres entrave ce processus d'inférence.

Sous le capot

L'implémentation C 11 de std::make_pair prend deux paramètres de type T&& et U&&, où T et U sont des paramètres de type modèle. . Lors de la spécification explicite des arguments du modèle, comme le montre le code problématique, aucune déduction d'argument n'a lieu. Au lieu de cela, les types spécifiés sont directement substitués dans la déclaration du modèle, ce qui donne ce qui suit :

make_pair(std::string&& argT, int&& argU);

Le rôle crucial des références Rvalue

Notez que les deux paramètres du modèle explicitement spécifié sont des rvalue références (&&), qui ne peuvent se lier qu’à des expressions rvalue. Dans le code fourni, s est une lvalue (non temporaire et non déplacée). Par conséquent, le modèle de fonction ne parvient pas à faire correspondre les arguments, ce qui entraîne une erreur de compilation.

Pourquoi cela fonctionne sans arguments explicites

Lors de l'omission des arguments explicites du modèle, une déduction des arguments a lieu. En raison de la nature particulière des paramètres de référence rvalue dans les modèles (réduction des références), un paramètre de référence rvalue de type A&&, où A est un paramètre de type de modèle, peut se lier à n'importe quel type de A. Que A soit une lvalue, une rvalue, qualifiée ou non, un A&& peut s'y lier.

Dans l'exemple de code, s est une lvalue de type std::string et 7 est une rvalue de type int. Le compilateur déduit que T est std::string& et U est int, permettant à s et 7 de se lier avec succès aux types de paramètres déduits.

Conclusion

Pour éviter de telles erreurs, respectez les principe suivant : si un argument de modèle peut être déduit des arguments de la fonction, autorisez le compilateur à effectuer la déduction. Fournir explicitement des arguments est souvent inutile et peut conduire à des résultats inattendus. En exploitant la puissance de la déduction argumentative, les programmeurs peuvent simplifier leur code et améliorer sa lisibilité tout en conservant son exactitude.

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!