C++

Spécialisation des templates

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : Spécialisation des templates

Taz

bisounours-codeur

l'intéret c'est d'avoir une version générique passe partout, et des versions spécialisées pour certains types, souvent pour permettre des optimisations.

par exemple std::swap est muni de spécialisation pour les types de la STL. par exemple: quand on veut permuter 2 std::vector, il serait bête de procéder à plusieurs recopies (c'est à dire le swap de base, avec un variable temporaire) alors qu'on pourrait seulement se contenter de permuter 2 pointeurs (on permute les implémentations)

le code parle de lui même, petit exemple clef en main

Code :

#include <iostream>
#include <typeinfo>
using namespace std;
class Bar{};
template<class T>
class Foo
{
T item;
public:
static void say_hello()
{
cout << "Foo " << typeid(T).name() << " générique" << endl;
}
};
// spécialisation pour un type donné
template<>
class Foo<Bar>
{
public:
static void say_hello()
{
cout << "FooBar" << endl;
}
};
// spécialisation partielle pour tout type de pointeur
template<class T>
class Foo< T* >
{
T *item;
public:
static void say_hello()
{
cout << "Foo " << typeid(T).name() << " spécialisé pointeur" << endl;
}
};
// spécialisation pour les pointeurs de void
template <>
class Foo<void*>
{
void *item;
public:
static void say_hello()
{
cout << "Foo " << typeid(void).name() << " spécialisé pointeur" << endl;
}
};
int main()
{
Foo<int>::say_hello();
Foo<Bar>::say_hello();
Foo<bool*>::say_hello();
Foo<void*>::say_hello();
}

autre exemple

Code :

template<unsigned Dim, typename T>
struct Dot;
template<typename T>
struct Dot<1, T>
{
static inline T dot(const T *a, const T *b)
{
return *a * *b;
}
};
template<unsigned Dim, typename T>
struct Dot
{
static inline T dot(const T *a, const T *b)
{
return (*a * *b) + Dot<Dim-1, T>::dot(a+1, b+1);
}
};
template<unsigned Dim, typename T>
inline T dot(const T *a, const T *b)
{
return Dot<Dim, T>::dot(a, b);
}

et encore un

Code :

template<unsigned m, unsigned n>
struct Ackermann;
template<unsigned n>
struct Ackermann<0, n>
{
static const unsigned value = n+1;
};
template<unsigned m>
struct Ackermann<m, 0>
{
static const unsigned value = Ackermann<m-1, 1>::value;
};
template<unsigned m, unsigned n>
struct Ackermann
{
static const unsigned value = Ackermann<m-1, Ackermann<m, n-1>::value >::value;
};
#include <iostream>
using namespace std;
int main()
{
cout << Ackermann<3, 4>::value << endl;
}

Message édité par Taz le 05-10-2003 à 14:53:29

Publicité

blackgoddess

vive le troll !

ah, c interressant, je vais travailler ca, merci

---------------
-( BlackGoddess )-

Evadream -jbd-

Bonjour tout le monde !

J'ai hésite à créer un nouveau topic pour ma question. Taz, si tu penses que ca n'a pas sa place ici vu que je débute avec cà, je créerai un topic.

Ma question porte sur la spécialisation partielle des fonctions membres. Par exemple, voici un début de classe Matrix :

Code :

template<class T, unsigned short i_row, unsigned short i_column>
class CMatrix { /* Ligne 18 */
public:
CMatrix() ;
~CMatrix() ;
void fill(const T=0) ;
void show() const ;
T computedet() const ;
inline bool isSquare() { return (row==column) ; }
private:
valarray<T> elements;
unsigned short row ;
unsigned short column ;
T det ;
};

Mon but est ici de créer une classe permettant de manipuler des matrices d'un type T, de taille i_row * i_column.

J'aimerais pouvoir spécialiser quelques fonctions membres suivant le couple i_row et i_column, pour par exemple la fonction de calcul du déterminant.

D'abord, je définis une fonction générique :

Code :

template<class T, unsigned short i_row, unsigned short i_column>
T CMatrix<T, i_row, i_column>::computedet() const {
// ...
}

Je souhaiterais pouvoir spécialiser le calcul de déterminant pour des valeurs particulières de i_row et i_column, par exemple 2. J'ai essayé cà :

Code :

template<class T>
T CMatrix<T, 2, 2>::computedet() const { /* Ligne 80 */
// ...
}

Mais le compilateur me fait comprendre bien gentiment que c'est pas bon :

CMatrix.h:80: invalid use of undefined type `class CMatrix<T, 2, 2>'
CMatrix.h:18: declaration of `class CMatrix<T, 2, 2>'
CMatrix.h:80: template definition of non-template `T CMatrix<T, 2, 2>::computedet() const'

Je m'en suis sorti un temps à l'aide du polymorphisme et de l'héritage en changeant de point de vue, mais j'aimerais comprendre ici pourquoi ca ne fonctionne pas, mon but étant avant tout d'apprendre à manipuler les template

Merci à vous !

Message édité par Evadream -jbd- le 05-10-2003 à 13:51:26

Taz

bisounours-codeur

je lis à l'instant ta question : je te trouverais la référence, mais la spécialisation partielle de fonction n'est pas possible, donc idem pour les fonctions membres

Message édité par Taz le 10-02-2004 à 10:43:03

Evadream -jbd-

Ok, au moins la réponse a le mérite d'être courte. De toute facon il me semblait plus cohérent d'utiliser le polymorphisme et l'héritage pour arriver à mes fins dans ce problème précis.

Je suis très intéressé par la référence, si tu tombes dessus

Encore merci à toi pour ta réponse !

Taz

bisounours-codeur

non, reste avec les templates. seulement, défni une classe d'aide, avec une unique fonction membre static que tu spécialises autant que tu veux

Taz

bisounours-codeur

la référence dans cet autre sujet (vers la fin) http://forum.hardware.fr/forum2.ph [...] 218&cat=10

Evadream -jbd-

Taz a écrit :

non, reste avec les templates. seulement, défni une classe d'aide, avec une unique fonction membre static que tu spécialises autant que tu veux

Ok je vais voir dans cette direction ! Et merci pour la référence !

@+

schnapsmann

Zaford Beeblefect

Evadream -jbd- a écrit :

Ok je vais voir dans cette direction ! Et merci pour la référence !

@+

ou alors tu spécialise toute la classe (template<class T> class CMatrix<T,2,2> ), à toi de voir.

---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"

Evadream -jbd-

Mmm pourquoi pas, mais ca me semble être une solution de "facilité", non ? Enfin j'ai pas trop de recul vis à vis de ces problèmes, je vais explorer les deux voies

Merci à toi pour la proposition !

Message édité par Evadream -jbd- le 05-10-2003 à 16:05:57

Publicité

Taz

bisounours-codeur

ce n'est pas une solution de facilité, c'est une très bonne solution. d'ailleurs ça me fait penser à un truc ...

Evadream -jbd-

Taz > Je vais utiliser la solution de SchnapsMann mais je garde ta solution sous la main. Je me laisse un peu de temps pour la mettre en place, si j'ai des soucis, je te demanderais

Merci encore !

Evadream -jbd-

Taz a écrit :

ce n'est pas une solution de facilité

Toutes mes confuses, il faut que j'arrête d'écrire tout ce que je pense =)

Taz

bisounours-codeur

tant pis pour toi je t'aurais prévenu ... tu vas devoir te cogner toute la définition de la classe ...

Evadream -jbd-

Question : la spécialisation de la classe toute entière m'oblige t'elle à réecrire toutes les fonctions membres du modèle ?

Evadream -jbd-

Excellent, cross posting. Bon je laisse ma réponse pour la postérité.

Evadream -jbd-

J'ai du mal :|

J'ai essayé de procéder de la sorte, ds ma class CMatrix, est-ce correct ?

Code :

template<class T, unsigned short i_row, unsigned short i_column>
class CMatrix {
// ...
template<unsigned short a, unsigned short b>
static void computedet() ;
// ...

Par exemple, je veux spécialiser cette fonction pour les matrices 2,2, comment dois m'y prendre ? :

Code :

template<class T, unsigned short i_row, unsigned short i_column>
template<>
T CMatrix<T, i_row, i_column>::computedet<2,2>() {
// ...
}

seulement, défini une classe d'aide, avec une unique fonction membre static que tu spécialises autant que tu veux

Je ne vois pas comment faire Comment produire une fonction générique, et des fonctions spécialisées en utilisant ce mécanisme ?

Désolé de pas comprendre au quart de tour, malgré la qualité de tes topics.

Message édité par Evadream -jbd- le 05-10-2003 à 17:34:20

Taz

bisounours-codeur

ça t'arrive de lire ?

Citation :

la spécialisation partielle de fonction n'est pas possible

[:quoted]

Taz

bisounours-codeur

car c'est une sorte de spécialisation. ça va pouvoir marcher, mais tu vas dupliquer trop de code.
donc fais une classe extérieure pour calculer les det

Evadream -jbd-

Taz a écrit :

non, reste avec les templates. seulement, défni une classe d'aide, avec une unique fonction membre static que tu spécialises autant que tu veux

Je pensais que tu me proposais ici une solution pour pouvoir retrouver un mécanisme de spécialisation partiel pour des fonctions membres.

Lorsque j'ai utilisé la solution de SchnapsMann, tu as laissé entendre qu'il existait une meilleure solution

tant pis pour toi je t'aurais prévenu ... tu vas devoir te cogner toute la définition de la classe ...

C'est cà que j'essaye en vain de réaliser, c'est tout

Evadream -jbd-

Taz a écrit :

donc fais une classe extérieure pour calculer les det

Ok ! Merci !

Taz

bisounours-codeur

Evadream -jbd- a écrit :

Je pensais que tu me proposais ici une solution pour pouvoir retrouver un mécanisme de spécialisation partiel pour des fonctions membres.

c'est le cas. une classe avec une seule fonction statique entièrement dédiée au calcul d'une fonction. tu peux la spécialiser dans tous les sens, tu réécris tout le code à chaque fois, ce qui n'est pas plus volumineux qu'une hypotétique spécialisation partielle de fonctions

Evadream -jbd-

/me n'avait remarqué que tu avais édité ton premier post pour y ajouter des exemples ! Merci !

blackgoddess

vive le troll !

il est possible de spécialiser un destructeur virtuel ?

(je remonte un vieux topic, mais il me semble que ce soit la place de la question )

j'ai essayer de faire ca :

Code :

template<typename T>
class list
{
// ...
virtual ~list()
{
}
};
// spéclialisation pointeur
template<typename T>
virtual list<T*>::~list()
{
}

mais ca compile pas ...

---------------
-( BlackGoddess )-

Kristoph

BlackGoddess a écrit :

il est possible de spécialiser un destructeur virtuel ?

(je remonte un vieux topic, mais il me semble que ce soit la place de la question )

j'ai essayer de faire ca :

Code :

template<typename T>
class list
{
// ...
virtual ~list()
{
}
};
// spéclialisation pointeur
template<typename T>
virtual list<T*>::~list()
{
}

mais ca compile pas ...

Il me semble que tu ne peux pas spécialiser juste une fonction membre seule. Tu dois commencer par spécialiser la classe elle même et à l'interrieur la fonction membre.

Code :

template<typename T>
class list
{
// ...
virtual ~list()
{
}
};
// spéclialisation pointeur
template<typename T>
class list<T*>
{
virtual list<T*>::~list()
{
}
};

Edit : corrections pour que ça compile.

Message édité par Kristoph le 09-02-2004 à 20:33:57

blackgoddess

vive le troll !

pourtant ceci compile :
(chez moi, je ne sais pas si c'est standard ...)

Code :

template<bool bcrypt = false>
class client_sock
{
void open()
{
}
};
template<>
void client_sock<true>::open()
{
}

---------------
-( BlackGoddess )-

Taz

bisounours-codeur

ça l'est

blackgoddess

vive le troll !

ca ne fonctionne pas pareil pour les destructeurs virtuels ?

Message édité par blackgoddess le 09-02-2004 à 21:24:32

---------------
-( BlackGoddess )-

blackgoddess

vive le troll !

apparement la spécialisation fonctionne (chez moi toujours) uniquement pour une spécialisation autre que les pointeurs...
est-ce un cas général ou est-ce mon compilo qui a du mal ?

---------------
-( BlackGoddess )-

Taz

bisounours-codeur

c'est quoi ton compilateur ?
les (destructeurs) virtuels ça n'existe pas

blackgoddess

vive le troll !

vc++7

en fait

toujours avec

Code :

template<typename T>
class list
{
// ...
virtual ~list()
{
}
};

Code :

template<>
list<int>::~list()
{
}

fonctionne, mais pas

Code :

template<typename T>
list<T*>::~list()
{
}

j'ai fait un autre test :

Code :

template<typename T>
void t()
{
}
template<typename T>
void t<T*>()
{ // error C2768: 't<`template-parameter-257' *>' : explicit template arguments were not expected to be associated with this declaration
}
int main()
{
t<void>();
t<void*>();
}

la doc de l'erreur sur les msdn : http://msdn.microsoft.com/library/ [...] rC2768.asp

serait-ce un défaut du compilo pour cette spécialisation ?

(g bcp de mal a trouver de la doc sur la spécialisation pour pointeur sur le net ...)

---------------
-( BlackGoddess )-

Taz

bisounours-codeur

pas de spécialization partielle de fonction template

blackgoddess

vive le troll !

erf ca a deja été dit ...

Code :

template<typename T>
struct dtor
{
void del()
{
}
};
template<typename T>
struct dtor<T*>
{
void del()
{
}
};

compile pas non plus ...

j'ai lu que vc++7.1 devait supporter les spécialisations partielles de classes templates, je vais l'installer, on a changé recemment les licenses au taff ...

---------------
-( BlackGoddess )-

Taz

bisounours-codeur

pourtant c'est parfaitement correct./

il donne quoi mon premier exemple (premier message) ?

blackgoddess

vive le troll !

il fait les mêmes erreurs que mon précédent bout de code, une erreur de syntaxe sur le '>' de 'class Foo< T* >' suivie de quelques autres erreurs qui dérivent de celle la

---------------
-( BlackGoddess )-

Taz

bisounours-codeur

ben tu vas ici http://forum.hardware.fr/hardwaref [...] -46017.htm

et tu leur dis que j'avais bien raison dans mon dernier message

blackgoddess

vive le troll !

j'ai suivi le topic oui

ils parlaient de vc++7.1, v l'installer pour voir si ca résoud le pb.

---------------
-( BlackGoddess )-

chrisbk

taz a écrit :

ben tu vas ici http://forum.hardware.fr/hardwaref [...] -46017.htm

et tu leur dis que j'avais bien raison dans mon dernier message

tu t'en es pas remis hein ?
accroches toi, paske :

Code :

template<typename T>
struct dtor
{
void del()
{
}
};
template<typename T>
struct dtor<T*>
{
void del()
{
}
};

compile tres bien

chrisbk

D'ailleurs tous tes exemples compilent...

Dis, fais pas d'actes desperés hein ? Tu sais, ainsi va le monde, tout change, tout evolue, les vérités deviennent inexactes et tout ca...

blackgoddess

vive le troll !

fiou, install finie

la spécialisation partielle de fonction membres ne fonctionne toujours pas

Code :

template<typename T>
class list
{
void del_list()
{
}
};
template<typename T>
void list<T*>::del_list() // erreur
{
}

par contre ce qu'a ecrit chrisbk compile en effet, je m'en suis donc tiré comme ca :

Code :

template<typename T>
class list
{
template<typename T>
struct tdtor
{
void del()
{
// ...
}
};
template<typename T>
struct tdtor<T*>
{
void del()
{
// ...
}
};
tdtor<T> dtor;
public:
virtual ~list()
{
dtor.del();
}
};

Message édité par blackgoddess le 10-02-2004 à 00:59:43

---------------
-( BlackGoddess )-

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

C++

Spécialisation des templates

Sujets relatifs
Spécialisation template & Pétage de plomb	les templates
Chtite question de Templates VS bête tableau en PHP.	Question con sur smarty (templates)
[ASP] Templates	[C++] Bizarre ces templates ....
[C/C++] inline ds les templates	Templates PhpBB...
phplib templates : block dans un block	Génération de pages html - templates
Plus de sujets relatifs à : Spécialisation des templates

Page générée en 0.170 secondes