Discussion :

[méphistopheles]

Bonjour.

J'ai créé une classe template avec deux paramètres T1 et T2 et j'aurais aimé garantir que sizeof(T2)>sizeof(T1). Malheureusement, je ne vois pas comment faire.

En effet, j'ai tout d'abord essayé d'autiliser une sous class prenant un unsigned, mais je n'ai pas l'erreur à la compilation..

Code :

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

1
2
3
4
5
6
7
8
9
10
template <class T1, class T2>
class A
{
   private:
   template<unsigned int T>
   class B
   {
   };
   B<sizeof(T2)-sizeof(T1)> ex;
};

Je me trouve donc un peu bloqué... si quelqu'un avait une idée...

merci

[3DArchi]

Salut,
Boost::enable_if:

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 <boost/utility/enable_if.hpp>
 
template <class T1, class T2, class dummyT=typename boost::enable_if_c<(sizeof(T1)>sizeof(T2))>::type>
struct A
{
};
 
struct B1
{
   unsigned char uc;
};
struct B2
{
   unsigned char uc[2];
};
 
int main()
{
   A<B2,B1> a1;
//   A<B1,B2> a1; --> Error
   return 0;
}

Ou :

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
template<bool> struct enable_if_c;
template<> struct enable_if_c<true>
{
   typedef void type;
};
 
template <class T1, class T2, class dummyT=typename enable_if_c<(sizeof(T1)>sizeof(T2))>::type>
struct A
{
};
 
struct B1
{
   unsigned char uc;
};
struct B2
{
   unsigned char uc[2];
};
 
int main()
{
   A<B2,B1> a1;
//   A<B1,B2> a1;
   return 0;
}

Cependant, j'aurais tendance à dire que comparer la taille de 2 types n'est pertinent que dans un cadre de méta-prog si les 2 types sont liés entre eux (typiquement pour du sfinae).

[méphistopheles]

Cependant, j'aurais tendance à dire que comparer la taille de 2 types n'est pertinent que dans un cadre de méta-prog si les 2 types sont liés entre eux (typiquement pour du sfinae).

Je dois reconnaitre que je n'utilise que des types numériques et leurs dérivés munis des opérations +, -, *, = et ==. le véritable test "mathématique" devrais porter sur l'inclusion de l'ensemble T1 dans l'ensemble T2, mais je me suis dit qu'une simple comparaisons de types serait sufisante... a moins qu tu voie autre chose....


Sinon, vis à vis de ton exemple, il serait peut-être plus pertinent d'instancier A dans une classe contenante histoire d'éviter que l'utilisateur puisse spécifier le paramètre dummyT non ?

merci

[3DArchi]

Sinon, vis à vis de ton exemple, il serait peut-être plus pertinent d'instancier A dans une classe contenante histoire d'éviter que l'utilisateur puisse spécifier le paramètre dummyT non ?

Effectivement. Instancier pose le problème d'ajouter un membre qui ne sert à rien. Vaut mieux utiliser un héritage privé (qui ne sert à rien) mais que le compilo optimise pour n'utiliser pas plus d'espace :

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
 
namespace details{ 
   struct dummy{};
}
template<bool,typename T> struct enable_if_c;
template<typename T> struct enable_if_c<true,T>
{
   typedef T type;
};
 
template <class T1, class T2>
struct A : private enable_if_c<(sizeof(T1)>sizeof(T2)),details::dummy>::type
{
};
 
struct B1
{
   unsigned char uc;
};
struct B2
{
   unsigned char uc[2];
};
 
int main()
{
   A<B2,B1> a1;
   //A<B1,B2> a2; //--> Error
   return 0;
}

Je dois reconnaitre que je n'utilise que des types numériques et leurs dérivés munis des opérations +, -, *, = et ==. le véritable test "mathématique" devrais porter sur l'inclusion de l'ensemble T1 dans l'ensemble T2, mais je me suis dit qu'une simple comparaisons de types serait sufisante... a moins qu tu voie autre chose....

En jouant avec std::limits : à l'exécution avec std::numeric_limits<>::min ou à la compilation avec l'enable_if et std::numeric_limits<>::digits10. Mais ça reste un peu de la bidouille.
Mais ton problème ne peut-il se résoudre avec les Boost.numeric cast ?

[méphistopheles]

Code :

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

1
2
3
4
5
6
 
template<bool,typename T> struct enable_if_c;
template<typename T> struct enable_if_c<true,T>
{
   typedef T type;
};

Heu... à quoi sert le type T ? il n'est pas essentiel si ? (à moins qu'on ne puisse hériter de void)...

En jouant avec std::limits : à l'exécution avec std::numeric_limits<>::min ou à la compilation avec l'enable_if et std::numeric_limits<>::digits10. Mais ça reste un peu de la bidouille.
Mais ton problème ne peut-il se résoudre avec les Boost.numeric cast ?

A vrai dire, ce sont de types numériques mais certains étant définis par l'utilisateur , je ne suis pas sûr qu'ils soient standards donc boost risque de tomber sur un os...


Je vais par contre rester sur la première solution.


Merci beaucoup

[3DArchi]

Heu... à quoi sert le type T ? il n'est pas essentiel si ? (à moins qu'on ne puisse hériter de void)...

Effectivement, on ne peut hériter de void (ni de int, ni de char, etc.)