Discussion :

[Flo.]

Bonjour

j'ai une classe Job

Code :

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

template<typename T, int n> class Job;

et une fonction work

Code :

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

template<class T> void work(T & job);

Je voudrais spécialiser work pour la classe Job<T, 1> quelque soit T.

j'ai essayé toute une ribambelle de choses mais j'avoue que je m'y perds là :

Code :

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

1
2
template<> template<typename T> void work< Job<T, 1> >(Job<T, 1> & job);
template<> void work< template<typename T> Job<T, 1> >(Job<T, 1> & job);

D'ailleurs est-ce que c'est possible ?

(Au passage c'est aussi difficile de trouver un titre à la discussion ...)

Merci.

Flo.

[Goten]

La spécialisation partielle de fonction libre est interdite.

[Flo.]

C'est considéré comme une spécialisation partielle de fonction ? Pourtant c'est l'argument template qui est partiellement spécialisée par la finction elle-même ... Bon mais si tu le dis ...

Par ailleurs, je me rends compte que je ne sais pas comment traiter le cas pour une spécialisation totale de cette même fonction pour Job<T, n>. C'est à dire spécialiser work pour Job<T, n> quelque soit T et n.

Flo.

[Flob90]

Je crois que tu te méprends sur la syntaxe des templates et la spécialisation.

La syntaxe de base est : template<parameters> declaration Ou parameters est la listes des paramètre templates et declaration respecte la même syntaxe qu'une déclaration classique en utilisant éventuellement les paramètres templates.

La spécialisation est une technique qui permet de donner une code spécifique pour des paramètres templates spécifique, elle est totales si tout les paramètres sont fixés.

Avec des exemples :

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
 
//Declaration d'une fonction template
template<class T>
void foo(const T&)
{/*code*/}
 
//Spécialisation totale pour int
template<>
void foo<int>(const int&)
{/*autre code*/}
//On voit ici que les paramètres sont fixé : <int>
 
//On peut aussi écrire (dans certains cas)
template<>
void foo(const int&)
{/*autre code*/}

Une spécialisation partielle pour les fonctions serait (n'existe pas pour les fonctions)

Code :

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

1
2
3
4
5
6
 
template<class T> struct MyTemplateClass {};
 
template<class T>
void foo<MyTemplateClass<T> >(const MyTemplateClass<T>&)
{}

A noter qu'il me semble que la spécialisation totale de fonction est déconseillé et qu'on préfère déclarer une fonction non-template qui serait trouvé avant la fonction template lors de la recherche de l'identifiant. Par contre je n'ai pas l'explication du pourquoi. (Et je ne me souvient pas où j'ai lu ceci).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
template<class T>
void foo(const T&)
{/*code*/}
 
void foo(const int&)
{/*autre code*/}
 
//On peut dans ce cas "optimiser" le type du paramètre
void foo(int)
{/*autre code*/}

[Flo.]

Merci pour cette longue réponse ...

Non non je ne me méprends pas ... (enfin je crois !)

Je veux une fonction libre templatée avec un fonctionnement générique et spécialiser son fonctionnement uniquement pour certaines valeurs de l'argument du template. Ce que je ne peux pas avoir avec une fonction libre non templatée.

Je veux une fonction libre pour pouvoir l'appeler de manière implicite (sans préciser l'argument du template). Et j'ai pas réussi à appeler une méthode statique non templatée de classe templatée de manière implicite.

Voilà, après c'est pas dit que c'était tout bien clair dans ma tête.

Flo.

[Flob90]

Oui mais tu ne peux pas faire ceci comme ca. Une spécialisation totale (et on ne peut faire que ca pour des fonctions) c'est pour des types fixés, à partir du moment où tu dis pour tout les types de la forme MyTemplateClass<T>, ce n'est plus un type fixé.

Tu pourrais faire une surcharge de ta fonction template avec une autre fonction template :

Code :

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

1
2
3
4
5
6
7
8
 
template<class T>
void foo(const T&)
{/*Code*/}
 
template<class T>
void foo(const MyTemplateClass<T>&)
{/*Code*/}

Par contre fais attention, il y a des cas où ca ne marchera pas car il y aura ambiguité entre les deux surcharges et le compilateur n'arrivera pas à déterminer laquelle appeler (pas dans ton cas ceci dit).