Pourquoi la sortie de ce code : est p> < BlockQuote>
Général Le troisième est surprenant car la fonction a été spécialisée exactement pour modifier: Je sais que la surcharge pourrait être une solution appropriée. Je veux juste apprendre la logique derrière elle. P> p>
Général
Général P>
BlockQuote> int & code> p>
3 Réponses :
Une référence est juste un alias, pas un type. Donc, lorsque vous appelez f (z), il correspond à la première version avec T = INT, qui est une meilleure option que t = int &. Si vous changez t vers T &, alors INT et INT & ARGuments appelleront la deuxième version. P>
Si je change t à t &, j'ai une erreur de compilateur lorsque f (2) code> ou
f ("texte") code>
Le type de l'expression Ainsi, dans les deux cas, Qu'est-ce qui est important à noter (autre que vous devriez vraiment utiliser une surcharge, comme un autre gars a dit), est que vous avez un paramètre de fonction non-références dans votre modèle. Avant toute déduction de y code> et l'expression
z code> est
int code>. Une référence apparaissant dans une expression ne conserve pas le type de référence. Au lieu de cela, le type de l'expression sera le type référencé, l'expression étant une lvalue. p>
t code> est déduit à
int code>, et donc la spécialisation explicite n'est pas utilisée du tout. p>
t code> contre le type d'argument est effectué, le type d'argument sera converti de tableaux à un pointeur à son premier élément (pour les fonctions, des arguments seront convertis en pointes de fonction). Donc, un modèle de fonction avec un paramètre de fonction de non-référence ne permet aucune déduction précise de toute façon. p>
+1 (et merci d'avoir repéré l'erreur dans ma propre réponse pendant que je suis dessus)
À propos de votre deuxième phrase: D'où vient cette règle? Je vous fais confiance, mais avez-vous une source expliquant ce point? Merci.
Je sais que ce n'est pas la réponse, mais je peux essayer cela, avec un trait comme une approche dans une structure:
Peut-être parce que const int & est préféré à int &?
@Settagram: const int &?
Je ne sais pas si cela aide, mais si vous modifiez le modèle pour accepter un
t & code>, alors
f (y) code> et
f (z) < / Code> Appelez la version
int & code>.
@Daniel Gallagher: Ensuite, vous avez une erreur de compilateur avec
f (2); code>. De plus, la sortie de
f (y) code> est
int & code>.
Le meilleur moyen est d'utiliser une surcharge
Void F (int & param) code> gotw .ca / Publications / Mill17.htm
Vous pouvez passer à
const t & code> et
const int & code> pour faire
f (2) code> travail, mais oui,
f (y) code>,
f (z) code> et
f (2) code> appellera tous la version
const int & code>.
@JohnsyWeb: Ideone.com/lrck6
Votre code ne devrait pas compiler. La spécification de modèle de fonction correcte ressemble à:
modèle <> vide F (int & bla) ... code>
@NOAH ROBERTS: C'était une réponse à un commentaire supprimé;
@sad_man - hein? Je ne parlais pas de votre commentaire.