Discussion :

[MatRem]

Bonjour,

Je me demande pourquoi mes compilateurs (gcc 4.3, et cl de visual c++ 2005) m'instancie cette fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void f(int & val)
{
   std::cout << val << std::endl;
}

dans ce cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <iostream>
 
template<typename T>
void f(T & val)
{
   std::cout << val << std::endl;
}
 
int main()
{
   f(int(0));
}

Forcément, avec cette instanciation le code ne peux pas compiler.
Pourquoi le compilateur n'instancie pas cette fonction quand on lui passe un temporaire ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void f(int const & val)
{
   std::cout << val << std::endl;
}

Avec ce comportement, mes compilateurs m'obligent à fournir deux versions de fonction template pour gérer le cas du temporaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
template<typename T>
void f(T & val)
{
   std::cout << val << std::endl;
}
template<typename T>
void f(T const & val)
{
   std::cout << val << std::endl;
}

Y'a t il un moyen de factoriser ce genre de code ?

ps : ma fonction f n'est qu'un exemple ultra simplifié ... et effectivement dans ce cas précis la version const suffirait, mais ma question porte sur le cas général

[3DArchi]

Bonjour,
Je vais répondre de biais :
1/si tu n'as pas besoin de modifier val, pourquoi déclarer la version non const ? Sachant qu'il existe (dans boost) des moyens de supprimer le qualificateur const s'il est déjà présent dans T.
2/ Si tu as besoin de modifier val, alors c'est que tu dois distinguer les 2 comportements.

[MatRem]

En fait il faut prendre f comme une fonction générique au sens ou elle est indépendante du fait que t soit const ou pas.
Elle appelle seulement des fonctions sur t, et dans T ses fonctions ont des version const et non const (*).

Peut être que je peux donner un exemple si mon explication n'est pas assez concrète ...

(*) : ou pas, et dans ce cas le compilateur pourra effectivement se plaindre de façon justifiée . Par exemple si on passe un temporaire à f et que seules les fonctions non const sont définies dans T.

[3DArchi]

En fait il faut prendre f comme une fonction générique

Ma réponse était générique

Elle appelle seulement des fonctions sur t, et dans T ses fonctions ont des version const et non const (*).

Soit la fonction suppose qu'elle ne modifie pas l'objet, donc elle n'est supposée qu'appeler des fonctions const et alors le paramètre doit être aussi en const.

Peut être que je peux donner un exemple si mon explication n'est pas assez concrète ...

Je veux bien. Ca éclairera peut être un peu plus le besoin.

[Médinoc]

Que se passe-t-il si tu tentes d'invoquer explicitement f<const int>(0) ?

[MatRem]

Voiilà un exemple qui permet de comprendre le principe.
Par contre il ne compile pas puisque je ne fournis pas les deux versions de f et que j'utilise un temporaire (c'est fait exprès pour bien voir que dans ce cas je ne devrais pas avoir besoin de fournir les deux) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template<typename T>
void f(T & t)
{
   t.call_the_right_function();
}
 
struct S
{
   void call_the_right_function();
   void call_the_right_function() const;
};
 
int main()
{
   f(S()); //Ne compile pas
 
   S const s;
   f(s); //compile trés bien puisque la fonction instanciée est bien void f(T const &)
 
   f<S const>(S()); //fonctionne aussi trés bien
}