Relation d'ordre entre paramètres template.

Version imprimable

09/11/2009, 11h54
méphistopheles

Relation d'ordre entre paramètres template.
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:

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 ;)

Salut,
Boost::enable_if:

Code:

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:

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).

09/11/2009, 13h46
méphistopheles

Citation:

Envoyé par 3DArchi

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

Citation:

Envoyé par méphistopheles

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:

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; }
Citation:

Envoyé par méphistopheles

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 ?

09/11/2009, 14h21
méphistopheles
Citation:
Envoyé par 3DArchi

Code:

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)...

Citation:

Envoyé par 3DArchi

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 :D
09/11/2009, 14h22
3DArchi

Citation:

Envoyé par méphistopheles

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.)

Citation:

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

J'était justement entrain de me demander pourquoi utiliser enable_if(qui nous embête avec ce type T) et pas BOOST_STATIC_ASSERT?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template <class T1, class T2> struct A { BOOST_STATIC_ASSERT(sizeof(T1)>sizeof(T2)); }; //Ou éventuellement, pour profiter de l'héritage privé: template<bool> struct StaticAssert; template<> struct StaticAssert<true>{}; template <class T1, class T2> struct A : StaticAssert<sizeof(T1)>sizeof(T2)> { };

10/11/2009, 13h19
méphistopheles

J'ai finalement utilisé la méthode de nogame qui marche parfaitement.

Merci encore à tous
10/11/2009, 14h16
3DArchi

Effectivement, c'est le plus simple. J'ai pas eu le réflexe du static assert mais c'est dans ce cas peut être plus aisé à mettre en œuvre.

Salut

Le fait est que BOOST_STATIC_ASSERT fait exactement la même chose ce ce que ce que 3D fait avec son enable_if_c...:

on a, en effet:
Code:

1 2 3 4 5 6 template <bool x> struct STATIC_ASSERTION_FAILURE; template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; }; // HP aCC cannot deal with missing names for template value parameters template<int x> struct static_assert_test{};
comme structure ayant certaines spécialisation et
Code:

1 2 3 #define BOOST_STATIC_ASSERT( B ) \ enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \ = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) }
pour les tests à coup de BOOST_STATIC_ASSERT

10/11/2009, 16h49
JulienDuSud

Note: Tu peux également utiliser static_assert de C++0x

Code:

static_assert( sizeof( T1 ) < sizeof( T2 ), "sizeof( T1 ) doit être plus petit que sizeof(T2) !" );
10/11/2009, 16h59
koala01
Citation:

Envoyé par JulienDuSud

Note: Tu peux également utiliser static_assert de C++0x

Code:

static_assert( sizeof( T1 ) < sizeof( T2 ), "sizeof( T1 ) doit être plus petit que sizeof(T2) !" );

Oui, mais bon...
1. C++0x n'est pas encore officiellement accepté, et les compilateurs ne le respectent pas par défaut
2. Son static_assert (celui de C++0x) est, très certainement, basé sur celui de boost (ou un quelconque similaire)
3. Cela revient, de toutes manières, strictement au même que les deux possibilités envisagées jusqu'à présent, avec une restriction supplémentaire (quid si ton programme doit être compilé avec un compilo plus ancien :question:)
Dans trois ans, quand la norme aura été finalisée et que les compilateurs actuels la suivront par défaut, je ne dis pas...

Mais, à l'heure d'écrire ces lignes, je ne suis pas absolument certain que le fait d'utiliser C++0x en production soit réellement une bonne idée :P
11/11/2009, 01h10
JulienDuSud
Citation:
Envoyé par koala01

Oui, mais bon...

C++0x n'est pas encore officiellement accepté, et les compilateurs ne le respectent pas par défaut
Son static_assert (celui de C++0x) est, très certainement, basé sur celui de boost (ou un quelconque similaire)
Cela revient, de toutes manières, strictement au même que les deux possibilités envisagées jusqu'à présent, avec une restriction supplémentaire (quid si ton programme doit être compilé avec un compilo plus ancien :question:)
Dans trois ans, quand la norme aura été finalisée et que les compilateurs actuels la suivront par défaut, je ne dis pas...

Mais, à l'heure d'écrire ces lignes, je ne suis pas absolument certain que le fait d'utiliser C++0x en production soit réellement une bonne idée :P
Certes, mais il a quelques choses qu'il ne faut pas négliger:

Pas besoin de boost pour l'utiliser, il fait partie du standard.
Permet de mettre en place un message d'erreur compréhensible.

C'était juste une note; qui plus est, static_assert c'est uniquement du compile-time et donc sans danger pour tout code qui passe cette étape, donc sans danger pour les soft en production.