Discussion :

[victor_gasgas]

Bonjour, j'aimerais votre avis car je ne sais pas comment spécialiser une classe à l'intérieur d'un classe elle même template, sur g++ :

Code :

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

1
2
3
4
5
6
7
template<typename T>
struct Foo
{
    template<typename U>
    void f() { /* Plein de code ici... */ }
 
};

Comment faire ici pour spécialiser la fonction A::f() pour les int par exemples? Car si je le fais à l'intérieur de la classe j'ai une erreur de g++ qui dis que c'est impossible "error: invalid explicit specialization before '>' token" et je trouve pas de solution.

Et je n'arrive pas à le faire en dehors de la classe.

Merci d'avance ppour votre aide!

[regis.portalez]

Bonjour,
Si tu veux seulement spécialiser la fonction template en gardant le patron de classe généralisé, ce n'est pas possible.
Il faut que tu spécialise ta classe dans laquelle tu pourras spécialiser à son tour la méthode : exemple :

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
22
23
 
#include <iostream>
 
using namespace std ;
 
template <typename T>
struct foo
{
	template <typename U>
	static void bar () ;
};
 
template<> template <>
void foo<float>::bar<int> () { cout << "float, int" << endl ;}
 
template <> template <>
void foo<double>::bar<float> () { cout << "double, float" << endl ;}
int main ()
{
	foo<float>::bar<int>() ;
	foo<double>::bar<float> () ;
	cout << "zou !" << endl ;
}

Code :

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

1
2
3
4
5
 
float, int
double, float
zou !
Press any key to continue . . .

[Emmanuel Deloget]

(efface, efface, efface)

Regis a répondu avant moi.

Tu peux faire un peu plus fun cependant : si f() appelle une fonction statique dans une classe template, cette classe peut être spécialisée selon le paramètre template de f().

Exemple :

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
22
23
24
25
26
27
28
29
30
 
#include <iostream>
 
namespace details
{
  template <class U>
  struct Fimpl
  {
    static void impl() { std::cout << "non spécialisé" << std::endl; }
  };
 
  template <>
  struct Fimpl<int>
  {
    static void impl() { std::cout << "<int>" << std::endl; }
  };
}
 
template <class T>
struct A
{
  template <class U>
  void f() { details::Fimpl<U>::impl(); }
};
 
int main()
{
  A<float>().f<char>();
  A<float>().f<int>();
}

C'est la technique que j'utilise pour spécialiser partiellement les méthodes (puisque ce n'est pas censé être possible).

[regis.portalez]

très joli emmanuel

[victor_gasgas]

merci c'est bien les astuces auquel je ne pouvais pas penser

En tout cas merci beaucoup à vous deux!

[méphistopheles]

[...]

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
22
23
24
25
26
27
28
29
30
 
#include <iostream>
 
namespace details
{
  template <class U>
  struct Fimpl
  {
    static void impl() { std::cout << "non spécialisé" << std::endl; }
  };
 
  template <>
  struct Fimpl<int>
  {
    static void impl() { std::cout << "<int>" << std::endl; }
  };
}
 
template <class T>
struct A
{
  template <class U>
  void f() { details::Fimpl<U>::impl(); }
};
 
int main()
{
  A<float>().f<char>();
  A<float>().f<int>();
}

C'est la technique que j'utilise pour spécialiser partiellement les méthodes (puisque ce n'est pas censé être possible).

Ici, il y a un problème: la méthode spécialisée n'a pas accès aux paremètre template parent (ie celui de la classe A).

il faudrait probablement donner deux paramètres à U et utiliser une spécialisation partielle pour obtenir un résultat similaire à une spécialisation partielle de méthode.

merci c'est bien les astuces auquel je ne pouvais pas penser

En tout cas merci beaucoup à vous deux!

noublie pas la balise

[victor_gasgas]

Oui oui j'oublie jamais la balise résolu en temps normal, mais je suis bien confronté au problème que tu cites à savoir ne pas avoir accès au paramètres templates de l'appelant.

Et je n'arrive pas à mettre en œuvre t'as dernières techniques énoncer.

Je sais que j'en demande un peu beaucoup mais la métaprog. reste encore obscure pour moi. Encore merci.

[méphistopheles]

en reprennant le code d'Emmanuel Deloget, on obtient ça:

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
22
23
24
25
26
27
28
29
30
31
#include <iostream>
#include <typeinfo>
 
namespace details
{
  template <class T,class U>
  struct Fimpl
  {
    static void impl() { std::cout << "non spécialisé" << std::endl;}
  };
 
  template <class T>
  struct Fimpl<T,int>
  {
    static void impl() { std::cout << "<int>" << std::endl;
                           std::cout << "le deuxieme type est " <<typeid(T).name()<<std::endl; }
  };
}
 
template <class T>
struct A
{
  template <class U>
  void f() { details::Fimpl<T,U>::impl(); }
};
 
int main()
{
  A<double>().f<char>();
  A<double>().f<int>();
}

voilà

bonne chance pour la suite

[victor_gasgas]

Merci beaucoup c'est exactement ce qu'il me fallait

Bonne journée à tous!

[Emmanuel Deloget]

Ici, il y a un problème: la méthode spécialisée n'a pas accès aux paremètre template parent (ie celui de la classe A).

il faudrait probablement donner deux paramètres à U et utiliser une spécialisation partielle pour obtenir un résultat similaire à une spécialisation partielle de méthode.

Judicieux ! Je n'y avait pas pensé, mais c'est vrai que c'est très logique