Template interdite.

**adel_dz** · 09/04/2006, 11h22

Bonjour a tous.
Voila comme je ne suis pas tres "templatiste" j'aurai besoin de vote aide pour resoudre un petit pb:

Soit la class suivante:

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
template<typename T,int Base>
class IntegerTrait
{
   public:
      const bool IsSigned;
      const T Max;
      const T Min;
 
      .../...
 
      IntegerTrait(T);
 
      std::string ToString() const;
 
 
      ../..      
};

Il s'agit d'une classe qui regroupe les caracteristiques des entiers en fonction de une base "Base"

J'aimerai trouve un moyen pour interdire l'utilisation de cette classe pour certaines valeur de Base notamment 0 et 1.
merci

**Laurent Gomila** · 09/04/2006, 11h53

Tu peux par exemple spécialiser partiellement ta classe pour ces valeurs, et faire en sorte que ces spécialisations génèrent une erreur de compilation si on tente de les utiliser. Par exemple tu peux ne rien mettre dedans, ou déclarer le constructeur privé, etc...

Après tu peux aussi imaginer des choses un peu plus poussées, afin d'afficher un message d'erreur qui soit plus explicite pour l'utilisateur.

**adel_dz** · 09/04/2006, 14h17

Simple et elegant!!!
Tres bonne idee merci.

**adel_dz** · 09/04/2006, 14h32

Salut
J'ai un autre pb.En compilant (sur VC7):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
//specialization for <int,Base>
 
template<int Base>
const bool TyIntegerTrait<int,Base>::IsSigned = true;
//----------------------------------------------------------------------
 
//specialization for <unsigned,Base>
 
template<int Radix>
const bool TyIntegerTrait<unsigned,Base>::IsSigned = false;
//--------------------------------------------------------------------------

j'obtient une erreur de compilation:

d:\Mes Documents\My Projects\Include\BKacl\IntegerTrait.h(97): error C2086: 'const bool bklib::TyIntegerTrait<Ty,>::IsSigned' : redefinition

J'obtient ce meme message por l'ensemble des specialisations (short unsigned short,char ...)

Heeeeeeeeelp

**Laurent Gomila** · 09/04/2006, 15h29

Une spécialisation doit redéfinir entièrement la classe, pas seulement ce qui t'arrange

**adel_dz** · 09/04/2006, 15h49

La je n'ai pas bien saisi.

Redefinir toute la classe dans le sens:

Code :

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

1
2
3
template<>
class IntegerTrait<int,Base>
{.../...};

ou alors tous les parametres:

Code :

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

1
2
3
4
5
6
7
template<>
const bool IntegerTrait<int,10>::IsSigned = true;
 
template<>
const bool IntegerTrait<int,16>::IsSigned = true;
 
.../..

A savoir qu'une specialisation parielle de la cte IsSigned du genre

Code :

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

1
2
template<typename Base>
const bool IntergerTrait<int,Base>::IsSigned = true;

se compile correctement tant qu'aucune autre specialisation (autre que pour T = int) n'est definie.

**Matthieu Brucher** · 09/04/2006, 15h56

Si tu regardes bien ton code, tu a écrit deux fois la même chose avec juste isSigned qui change, donc ça ne va pas. Si tu veux spécialiser ton template, spécialise-le vraiment, ne change pas juste le nom - qui n'existera pas au moment de l'instantiation : si tu fais IntegerTraits<2>, il doit prendre quel template ??

**Laurent Gomila** · 09/04/2006, 15h58

Redefinir toute la classe dans le sens:

Code :

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

1
2
3
template<>
class IntegerTrait<int,Base>
{.../...};

Oui.

**Matthieu Brucher** · 09/04/2006, 17h55

Bon, quant à moi, j'ai mal regardé le code

En tout cas, dans la deuxième spécialisation, tu as un template int Radix qui n'est jamais utilisé, juste un Base qui lui n'est pas défini.

**adel_dz** · 10/04/2006, 12h04

Envoyé par Miles

Bon, quant à moi, j'ai mal regardé le code

En tout cas, dans la deuxième spécialisation, tu as un template int Radix qui n'est jamais utilisé, juste un Base qui lui n'est pas défini.

Desole c'une faute de frappe.

Donc apparament pas moyen de specialiser unquement les ctes.bien.

Soint

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
template<typename Ty,int Radix>
class IntegerTrait
{
   public:
      static const bool IsSigned;
      static const Ty Max;
      static const Ty Min;
      .../...
 
      const std::string ToString() const;
 
   protected:
   private:
      static const wchar_t char_set[Radix];
};
 
 
//Specialisation for Ty = int
 
template<int radix>
class IntegerTrait
{
   public:
      static const bool IsSigned;
      static const int Max;
      static const int Min;
      .../...
 
      const std::string ToString() const;
 
   protected:
   private:
      static const wchar_t char_set[Radix];
};
 
template<int Radix>
const bool
IntegerTrait<Radix>::IsSigned = true;
 
template<int Radix>
const wchar_t
IntegerTrait<Radix>::char_set[] = ?? //1
 
 
.../...
 
//----------
//Specialisation for Radix= 4
 
template<typename Ty>
class IntegerTrait
{
   public:
      static const bool IsSigned;
      static const int Max;
      static const int Min;
      .../...
 
      const std::string ToString() const;
 
   protected:
   private:
      static const wchar_t char_set[4];
};
 
template<typename Ty>
const wchar_t
IntegerTrait<Ty>::char_set[] = {0,1,2,3};
 
template<typename Ty>
const bool
IntegerTrait<Ty>::IsSigned = ?? //2

Comment initaliser 1 et 2?
Ensuite si je fais IntegerTrait<int,4> le compileur se plains d'une ambiguite (entre les 2 specialisations). comment faire?
Merci de votre patience

**Matthieu Brucher** · 10/04/2006, 13h14

Tu peux créer une autre classe qui contiendra tes constantes et tu ajoutes cette classe comme membre de ta classe parente ou tu en hérites.
Ensuite, ton 1 et ton 2 sont à nouveau bizarre. Radix, OK, ce sera un entier. Ty, c'est quoi ?

**Laurent Gomila** · 10/04/2006, 13h22

Ta syntaxe est encore incorrecte, là tu ne spécialises rien du tout.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// Définition la plus générique
template<typename Ty,int Radix>
class IntegerTrait;
 
// Specialisation for Ty = int
template<int radix>
class IntegerTrait<int, radix>;
 
// Specialisation for Radix = 4
template<typename Ty>
class IntegerTrait<Ty, 4>;

Du coup ça t'aidera sûrement à répondre à tes questions.

**adel_dz** · 10/04/2006, 14h25

Ok j'ai saisi le truc.

Maintenat si je declare ma class IntegerTrait<Ty,Radix> et qlq specialisations de cette classe (ex IntegerTrait<int,10>,..).

1-Suis - je oblige de definir tous les membres de ctte classe. (Disons je laisse certaines cte sans initialisation).

2-Si je derive une autre classe :

ex:

Code :

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

1
2
class LongTrait: public IntegerTrait<long,10>
{}

et que je redefinisse un membre de ma classe base:
ex:

Code :

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

1
2
3
4
5
6
7
8
//dans IntegerTrait.h
 
template<typename Ty,int Radix>
const bool 
IntgerTrait<Ty,Radix>::IsSigned = true; //IsSigned est static
 
//dans LongTrait.cpp
const bool LongTrait::IsSigned = false;

Est ce que cette "redifinition" est consideree comme une specialisation ou s'agit d'une surcharge de variable.

Merci

**Matthieu Brucher** · 10/04/2006, 14h28

Et là, attention, si tu veux de l'<int, 4>, il ne pourra pas décider lequel prendre dans ce cas

**Laurent Gomila** · 10/04/2006, 14h45

1/ Si tu ne les redéfinis pas, elles n'existeront pas. Donc si tu n'en as pas besoin OK, sinon il faut le faire.

2/ Redéfinir une variable membre statique d'une classe de base à partir d'une dérivée est interdit en C++. Donc tu ne pourras jamais définir un LongTrait::IsSigned.

Et là, attention, si tu veux de l'<int, 4>, il ne pourra pas décider lequel prendre dans ce cas

Oui, attention à ça aussi

En fait j'ai l'impression que tu t'y prends mal. Est-ce que ce ne serait pas plus facile et correct de définir deux classes templates, une pour le type et une pour la base ? Parce que là, quel lien fais-tu entre les caractéristiques d'un type, et les choses relatives à la base ? Est-ce que tu ne fais pas un mix barbare qui n'a rien à faire là ?

Template interdite.

Langage C++

Discussions similaires

Partager

Partager