Surcharge de fonction template

Version imprimable

Bien le bonjour, :D

J'ai un code qui ressemble à ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 template<typename S, typename T> bool foo(S const & s, T & t); template<typename S, typename T> void foo(my_class<S> & ts, T & t); template<typename S> void foo(my_class<S> & ts, int & i); template<typename S> void foo(my_class<S> & ts, S & s);
Je me demandais à quel genre de surprise je pourrais m'attendre avec toutes ces surcharges. A priori le compilo accepte.
Merci pour vos commentaires.

06/05/2011, 16h47
alecool

En particulier, les questions que ton code me font me poser:
-Quelle fonction est appelée si S est un int

Il me semble me souvenir de la règle selon laquelle la fonction la plus spécifique sera appelée, donc la troisième dans ton cas, mais je n'ai pas le temps de vérifier par l'exemple.
06/05/2011, 17h28
nowahn
Bonjour,

Quelques remarques sans faire de tests:

Il me semble que ce qui peut provoquer des surprises c'est le premier argument de la fonction: le template général prend un S const& (référence constante), les spécialisations partielles prennent un my_class<S>& (référence non constante).
- Je penses que si tu passes une référence constante a un my_class<S>, le compilateur sélectionnera le template général (alors que peut-être que tu t’attends à ce qu'une spécialisation partielle soit sélectionnée).
- Je ne sais pas ce qui se passe si tu passe un objet temporaire de type my_class<S>:
  1. Le compilateur sélection le template général, et signale une erreur car tu prends une référence non constante sur un temporaire
  2. Le compilateur sélection une spécialisation partielle (pas de problème)
  Je penses qu'une spécialisation partielle devrait être sélectionnée, mais je n’en suis pas sûr (pas essayé).
09/05/2011, 11h25
camboui
Merci pour vos éponses :D

Je pense qu'il n'y a pas de spécialization partielle pour les fonctions template, on parle simplement de surcharge. C'est juste de la terminologie mais je crois qu'il faut le rappeler ;)

Les essais effectués semblent fonctionner comme je le souhaite dans les cas simples que j'ai codé. Mais je risque de me trouver confronté à des situations complexes et ambigües. Je vais renommer la première fonction qui est un peu hors contexte.
Reste les trois autres:
Code:

1 2 3 4 5 6 7 8 template<typename S, typename T> void foo(my_class<S> & ts, T & t); template<typename S> void foo(my_class<S> & ts, int & i); template<typename S> void foo(my_class<S> & ts, S & s);
La première code un cas général qui ne devrait pas être appelé si un cas spécifique existe. Ça fonctionne (pas avec MSVC6) pour peu qu'il n'y ait pas de conversion implicite de type.