Template et spécialisation partiel d'une méthode...

Je vous montre ce que j'aurais aimé faire :

#include <iostream>
#include <string>

using namespace std;

template <class T, bool b>
class Toto
{
public:
Toto(const T& t) : _t (t)
{
}

void tata(void);

private:
T _t;
};

template <class T, bool b>
void Toto<T, false>::tata(void)
{
cout << "void Toto<T, false>::tata(void)" << endl;
}

template <class T, bool b>
void Toto<T, true>::tata(void)
{
cout << "void Toto<T, true>::tata(void)" << endl;
}

int main(void)
{
Toto<int, true> t1 (5);
Toto<int, false> t2 (6);

t1.tata();
t2.tata();

return 0;
}

Mais g++ n'aime pas mon code :
$ g++ t.cc
t.cc:22: error: no `void Toto<T, false>::tata()' member function
declared in
class `Toto<T, false>'
t.cc:22: error: template definition of non-template `void Toto<T,
false>::tata()'
t.cc:28: error: no `void Toto<T, true>::tata()' member function
declared in
class `Toto<T, true>'
t.cc:28: error: template definition of non-template `void Toto<T,
true>::tata()'

Pour résoudre ce problème j'ai du utilisé la spécialisation
partiel :

"kanze" <kanze@gabi-soft.fr> a écrit dans le message de news:
1147245490.749188.300020@v46g2000cwv.googlegroups.com...
Etienne wrote:

Je vous montre ce que j'aurais aimé faire :

#include <iostream>
#include <string>

using namespace std;

template <class T, bool b>
class Toto
{
public:
Toto(const T& t) : _t (t)
{
}

void tata(void);

private:
T _t;
};

template <class T, bool b>
void Toto<T, false>::tata(void)
{
cout << "void Toto<T, false>::tata(void)" << endl;
}

template <class T, bool b>
void Toto<T, true>::tata(void)
{
cout << "void Toto<T, true>::tata(void)" << endl;
}

int main(void)
{
Toto<int, true> t1 (5);
Toto<int, false> t2 (6);

t1.tata();
t2.tata();

return 0;
}

Mais g++ n'aime pas mon code :
$ g++ t.cc
t.cc:22: error: no `void Toto<T, false>::tata()' member function
declared in
class `Toto<T, false>'
t.cc:22: error: template definition of non-template `void Toto<T,
false>::tata()'
t.cc:28: error: no `void Toto<T, true>::tata()' member function
declared in
class `Toto<T, true>'
t.cc:28: error: template definition of non-template `void Toto<T,
true>::tata()'

Pour résoudre ce problème j'ai du utilisé la spécialisation
partiel :

C'est en fait ce que tu veux, non ? Seulement, tu le veux sur la
fonction, et non sur la classe. Or, si j'ai bien compris, pour
les fonctions, on n'a pas de spécialisation partielle ; on
exploite plutôt la résolution du surcharge. Quelque chose du
genre :

template< bool b >
struct Discriminator {} ;

//...

template <class T, bool b>
class Toto
{
public:
void tata()
{
doTata( Discriminator< b >() ) ;
}
private:
void doTata( Discriminator< true > ) ;
void doTata( Discriminator< false > ) ;
} ;

template <class T, bool b>
void Toto<T, b>::doTata(Discriminator< false >)
{
cout << "void Toto<T, false>::tata(void)" << endl;
}

template <class T, bool b>
void Toto<T, b>::doTata(Discriminator< true>)
{
cout << "void Toto<T, true>::tata(void)" << endl;
}

Sinon, dans des cas aussi simple qu'ici, Tu peux mettre le code
dans le discriminateur même, et appeler :
Discriminator< b >::tata() ;
ou
Discriminator< b >().tata() ;
dans Toto<>::tata().

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung

"kanze" <kanze@gabi-soft.fr> a écrit dans le message de news:

j'ai a peu pret une question similaire sauf que c'est sur la
specialisation d'une fonction membre d'une classe.

je ne sais pas si on peut faire ce genre de chose : (
j'utilise VC++ 6 )

dans un .h
class A
{
A();
~A()

void methode();

template < long T>
void autre_methode( ... );
};

donc dans le cpp

A::A()
{
}

A::~A()
{
}

void A::methode()
{
...
}

template <long T>
void A::autre_methode( ... )
{
....
} // Ceci est accepté par le
compilateur, mais je n'ai pas teste son fonctionnement ...

// si j'en veux une specialisation, comment je dois la declarer ?

template<>
void A::autre_methode<SPECIALISATION>( ... ) // fatal error
C1001: INTERNAL COMPILER ERROR
{
...
}

ou

template <>
void A<SPECIALISATION>::autre_methode( ... ) // syntax error :
missing ';' before '<'
{
...
}

Est ce que c'est faisable ???

gbaudin wrote:

"kanze" <kanze@gabi-soft.fr> a écrit dans le message de news:

[...]

j'ai a peu pret une question similaire sauf que c'est sur la
specialisation d'une fonction membre d'une classe.

C'était l'exemple même. Il voulait en fait une spécialisation partielle
d'une fonction. Ça n'existe pas : c'est la spécialisation
partielle pour les classes, et le surcharge pour les fonctions.

je ne sais pas si on peut faire ce genre de chose : (
j'utilise VC++ 6 )

dans un .h
class A
{
A();
~A()

void methode();

template < long T>
void autre_methode( ... );
};

donc dans le cpp

A::A()
{
}

A::~A()
{
}

void A::methode()
{
...
}

template <long T>
void A::autre_methode( ... )
{
....
} // Ceci est accepté par le
compilateur, mais je n'ai pas teste son fonctionnement ...

// si j'en veux une specialisation, comment je dois la declarer ?

template<>
void A::autre_methode<SPECIALISATION>( ... ) // fatal error
C1001: INTERNAL COMPILER ERROR
{
...
}

A priori, c'est correct. (Et le compilateur t'as dit qu'il y a
une erreur chez lui, non dans ton code.) Dans le cas d'une
fonction libre, en tout cas, il y a même un exemple à peu près
identique dans la norme :
template<> void sort<char*>(Array<char*>& v) { /*...*/ }
G++ accepte aussi la même chose quand la fonction est un membre.

Note que si le type figure parmi les paramètres, tu peux aussi
écrire simplement :
template<>
void A::autre_methode( ... ) { ... }
avec le paramètre explicité.

ou

template <>
void A<SPECIALISATION>::autre_methode( ... ) // syntax error :
missing ';' before '<'
{
...
}

Là, c'est clair. Tu as démandé une spécialisation d'une fonction
non-templatéee dans une classe templatée. Ou plutôt... Du fait
que A n'est pas un template, le '<' qui en suit le nom signifie
l'opérateur « inférieur à ». Ce qui n'est pas légal dans ce
contexte.

Est ce que c'est faisable ???

Le code suivant marche avec g++. Je dirais qu'il y a une erreur
dans ton compilateur. (En général, si tu vois le message
« internal compiler error », ou quelque chose du genre, tu peux
partir du principe qu'il y a une erreur dans le compilateur.
Peut-être aussi dans ton code aussi, mais sûrement dans le
compilateur.)

#include <iostream>
#include <ostream>

struct A
{
template< typename T >
void f()
{
std::cout << "A::f() générique" << std::endl ;
}
template< typename T >
void g( T const& )
{
std::cout << "A::g() générique" << std::endl ;
}
} ;

template<>
void A::f< int >()
{
std::cout << "A::f() spécialisée" << std::endl ;
}

template<>
void A::g( int const& )
{
std::cout << "A::g() spécialisée" << std::endl ;
}

int
main()
{
A a ;
a.f< double >() ;
a.f< int >() ;
a.g( 1.3 ) ;
a.g( 2 ) ;
return 0 ;
}

Faute d'autre chose, pour avancer, donne un paramètre bidon
(avec une valeur par défaut) à la fonction, et utiliser le
format qui m'a servi pour g(), ci-dessus, pour la
spécialisation. Avec un peu de chance, tu contourneras l'erreur
du compilateur.

--
James Kanze kanze.james@neuf.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34

gbaudin wrote:

"kanze" <kanze@gabi-soft.fr> a écrit dans le message de news:

[...]

j'ai a peu pret une question similaire sauf que c'est sur la
specialisation d'une fonction membre d'une classe.

C'était l'exemple même. Il voulait en fait une spécialisation partielle
d'une fonction. Ça n'existe pas : c'est la spécialisation
partielle pour les classes, et le surcharge pour les fonctions.

je ne sais pas si on peut faire ce genre de chose : (
j'utilise VC++ 6 )

dans un .h
class A
{
A();
~A()

void methode();

template < long T>
void autre_methode( ... );
};

donc dans le cpp

A::A()
{
}

A::~A()
{
}

void A::methode()
{
...
}

template <long T>
void A::autre_methode( ... )
{
....
} // Ceci est accepté par le
compilateur, mais je n'ai pas teste son fonctionnement ...

// si j'en veux une specialisation, comment je dois la declarer ?

template<>
void A::autre_methode<SPECIALISATION>( ... ) // fatal error
C1001: INTERNAL COMPILER ERROR
{
...
}

A priori, c'est correct. (Et le compilateur t'as dit qu'il y a
une erreur chez lui, non dans ton code.) Dans le cas d'une
fonction libre, en tout cas, il y a même un exemple à peu près
identique dans la norme :
template<> void sort<char*>(Array<char*>& v) { /*...*/ }
G++ accepte aussi la même chose quand la fonction est un membre.

Note que si le type figure parmi les paramètres, tu peux aussi
écrire simplement :
template<>
void A::autre_methode( ... ) { ... }
avec le paramètre explicité.

ou

template <>
void A<SPECIALISATION>::autre_methode( ... ) // syntax error :
missing ';' before '<'
{
...
}

Là, c'est clair. Tu as démandé une spécialisation d'une fonction
non-templatéee dans une classe templatée. Ou plutôt... Du fait
que A n'est pas un template, le '<' qui en suit le nom signifie
l'opérateur « inférieur à ». Ce qui n'est pas légal dans ce
contexte.

Est ce que c'est faisable ???

Le code suivant marche avec g++. Je dirais qu'il y a une erreur
dans ton compilateur. (En général, si tu vois le message
« internal compiler error », ou quelque chose du genre, tu peux
partir du principe qu'il y a une erreur dans le compilateur.
Peut-être aussi dans ton code aussi, mais sûrement dans le
compilateur.)

#include <iostream>
#include <ostream>

struct A
{
template< typename T >
void f()
{
std::cout << "A::f() générique" << std::endl ;
}
template< typename T >
void g( T const& )
{
std::cout << "A::g() générique" << std::endl ;
}
} ;

template<>
void A::f< int >()
{
std::cout << "A::f() spécialisée" << std::endl ;
}

template<>
void A::g( int const& )
{
std::cout << "A::g() spécialisée" << std::endl ;
}

int
main()
{
A a ;
a.f< double >() ;
a.f< int >() ;
a.g( 1.3 ) ;
a.g( 2 ) ;
return 0 ;
}

Faute d'autre chose, pour avancer, donne un paramètre bidon
(avec une valeur par défaut) à la fonction, et utiliser le
format qui m'a servi pour g(), ci-dessus, pour la
spécialisation. Avec un peu de chance, tu contourneras l'erreur
du compilateur.

--
James Kanze kanze.james@neuf.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34