L'appel de fonction de modèle sans <>; l'inférence de type

Si j'ai un modèle de fonction avec typename T, où le compilateur peut définir le type en lui-même, je n'ai pas à écrire le type de manière explicite lorsque j'appelle la fonction comme:

template < typename T > 
T min( T v1, T v2 ) {
   return ( v1 < v2 ) ? v1: v2;
}
int i1 = 1, i2 = 2; int i3 = min( i1, i2 ); //no explicit <type>

Mais si j'ai un modèle de fonction avec deux typenames comme:

template < typename TOut, typename TIn >
TOut round( TIn v ) {
   return (TOut)( v + 0.5 );
}
double d = 1.54;
int i = round<int>(d); //explicit <int>

Est-il vrai que j'ai toujours spécifier au moins 1 typename? Je suppose que la raison est parce que le C++ ne peut pas distinguer les fonctions entre les différents types de retour.

Mais si j'utilise une fonction void et la remise d'une référence, encore une fois je ne doit pas spécifier explicitement le retour typename:

template < typename TOut, typename TIn > 
void round( TOut & vret, TIn vin ) {
   vret = (TOut)(vin + 0.5);
}
   double d = 1.54;
   int i; round(i, d); //no explicit <int>

Si la conclusion est d'éviter de fonctions avec le retour et la plus préfèrent void fonctions qui renvoient par l'intermédiaire d'une référence lors de l'écriture de modèles? Ou est-il une possibilité pour éviter écrivant explicitement le type de retour? Quelque chose comme "l'inférence de type" pour les modèles. Est "l'inférence de type" possible en C++0x?

La conversion entre les types de l'inférence de type idée difficile à gérer, vous ne pouvez donc pas de surcharge sur les types de retour et doit spécifier quand c'est un paramètre du modèle.
Vous pourriez vouloir travailler sur votre algorithme arrondi. Ce qui devrait -1.54 en sortir? Et: que faire si vous voulez obtenir un arrondi double de la valeur?

OriginalL'auteur OlimilOops | 2010-05-14

  1. 16

    Résolution de surcharge se fait uniquement basée sur des arguments de la fonction; la valeur de retour n'est pas utilisée du tout. Si le type de retour ne peut pas être déterminée sur la base des arguments, vous devrez le spécifier explicitement.

    Je n'irais pas sur le chemin du retour" d'une valeur via un paramètre de référence; qui rend le code d'appel clair. Par exemple, je préfère ceci:

    double x = round<double>(y);

    au cours de cette:

    double x;
round(x, y);

    parce que dans le dernier cas, il est facile de confondre l'entrée et la sortie, et il n'est pas clair du tout que x est en cours de modification.

    Dans le cas particulier de round, vous avez probablement besoin de seulement un ou deux types de TOut de toute façon, alors vous pouvez simplement laisser que l'argument de modèle:

    template<typename TIn>
int roundToInt(TIn v) {
    return (int)(v + 0.5);
}

    Je trouve roundToInt(x) un peu plus clair que round<int>(x) parce qu'il est clair que la int type est utilisé pour.

    Concernant la clarté: round_to<int>(x)? 😉
    Yep, ça pourrait être sympa aussi.

    OriginalL'auteur Thomas

  2. 3

    la conclusion d'éviter fonctions avec retour et plus préfèrent annuler les fonctions qui renvoient par l'intermédiaire d'une référence lors de la rédaction de modèles de

    Non, pourquoi? Que gagnez-vous? Seulement l'inférence de type (donc moins de code à écrire). Mais vous perdre beaucoup plus logique de la syntaxe de l'attribution d'une valeur (et, par conséquent, plus de code à écrire). Donc, une chose acquise, une autre a perdu. Je ne vois pas l'intérêt en général.

    Il peut même aider d'avoir à spécifier le type de modèle explicitement: prenons le cas de lexical_cast. En ne spécifiant pas le retour type de modèle serait source de confusion.

    OriginalL'auteur Konrad Rudolph

  3. 2

    Permettez-moi d'ajouter à ce que les autres ont dit en disant que vous devriez préférer C++ casting sur C-style casting.

    vret = (TOut)(vin + 0.5);

    contre

    vret = static_cast<TOut>(vin + 0.5);

    statique plâtre sera toujours voués à l'échec si vous essayez de convertir sans rapport avec les types. Cela peut être utile pour le débogage.

    Et vous aurez le temps de compilation des avertissements/erreurs trop, beaucoup mieux que de trouver au moment de l'exécution.
    Quelles seraient les types qui y participent doivent être, de sorte qu'un static_cast donnerait un résultat différent de celui d'une C-style coulé dans ce modèle? (Oui, dans une fonction d'utilité que vous pourriez faire des efforts pour améliorer son style, mais je ne vois pas beaucoup d'avantages dans la pure mathématique du code de la conversion entre les types de numéro - pour justifier un post, et peut-être pas un commentaire.)
    Vous pouvez peut-être sur ce post, mais j'ai eu à carillon. Si vous utilisez un static_cast, un message d'erreur signifie que l'objet ou exécutable ne peut même pas exister, alors la réciproque est vraie, c'est, si vous avez un objet ou exécutable, vous savez que le static_cast était valable entre les types. Comme vous aller plus loin dans le modèle de la métaprogrammation, vous aurez besoin de plus de contrôle sur les types à l'intérieur de leur héritage arbres, par exemple, dans le PFI.

    OriginalL'auteur wheaties