MetaProg, TypeTrait et Integral Constant

Bonjour,

Je cherche à calculer des puissances de 2 à la compilation de la manière suivante :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template < uint64_t uPower > struct Power2 { static uint64_t const Value = 2*Power2< uPower - 1 >::Value; };   template <> struct Power2< 0 > { static uint64_t const Value = 1; };

---

Le problème de cette méthode c'est que cela fonctionne si et seulement si uPower est une uint64_t.

Donc j'implémente ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

template < typename T, T uPower > struct Power2 { static T const Value = static_cast< T >( 2 )*Power2< uPower - static_cast< T >( 1 ) >::Value; };   // Par contre je dois spécialisé pour tout mes types. template <> struct Power2< uint64_t, 0 > { static uint64_t const Value = 1; };   template <> struct Power2< uint32_t, 0 > { static uint32_t const Value = 1; };   // ...

---

Aucun problème par contre dans mon code j'ai u128 et u256 (qui sont des classes pour représenter des unsigned int 128 et 256 bits).

Et je ne peux pas spécialisé puisqu'on ne peut pas avoir de constante "non-integral".

J'avais essayé le truc :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

template < typename T > struct Power2 { static T::value_type const Value = static_cast< T::value_type >( 2 )*Power2< std::integral_constant< T::value_type, T::value - static_cast< T::value_type >( 1 ) > >::Value; };   template <> struct Power2< std::integral_constant< uint32_t, 0 > > { static uint32_t const Value = 1; };   template <> struct Power2< std::integral_constant< uint64_t, 0 > > { static uint64_t const Value = 1; };   // ...

---

Mais la spécialisation comme prévu pour mes types ne fonctionnes pas pour les mêmes raisons. Const non integral impossible.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

static u128 const u128Zero( 0 ); static u256 const u256Zero( 0 );   template <> struct Power2< std::integral_constant< u128, u128Zero > > { static u128 const Value = u128Zero; };   template <> struct Power2< std::integral_constant< u256, u256Zero > > { static u256 const Value = u256Zero; };

---

Connaissez-vous une solution pour résoudre ce problème ?

Merci

j'imagine qu'il te faudrait un constructeur public implicite prenant un intégral en argument.

hello,

d'apres stack

tu peux definir ton const en dehors de ta classe

Code:

---

1 2 3 4 5 6 7

template <> struct Power2< std::integral_constant< u256, u256Zero > > { static u256 const Value; }; template<> const u256 Power2<std::integral_constant< u256, u256Zero >>::_value = u256Zero;

---

leternel> Cela ne change rien puisque le C++ interdit les constants non "integral"
galerien69> On pourrait mais le problème n'est pas la définition d'une constante non integral mais la spécialisation d'un template avec un non integral :

Code:

---

1 2 3 4 5 6 7

template <> struct Power2< std::integral_constant< u256, u256Zero > > { static u256 const Value; }; template<> const u256 Power2<std::integral_constant< u256, u256Zero >>::_value = u256Zero;

---

Ne fonctionne pas puisque std::integral_constant ne peut pas être spécialisé avec des "non integral". C'est dans le nom "integral_constant" :)

La spécialisation avec un non integral est impossible mais comment peut-on contourner ce problème ?

Merci

il pourrait suffire de spécialiser std::integral_constant pour ton type pseudo-intégral, en vérifiant que cela respecte bien la sémantique définie.

leternel > Tu aurais un exemple fonctionnelle ?

Merci

Bonjour,

A priori je ne vois pas de solution en partant de ce que tu as déjà fait.

Tu as vraiment besoin de pouvoir faire les manipulations à la compilation et à l’exécution ? Si ce n'est pas le cas, tu pourrais essayer de faire manipuler des pairs de std::integral à ton meta-programme pour représenter un entier (a*m+b comme tu as du faire pour créer ton type avec une pair de uint_64).

Citation:

---

Envoyé par SKone

leternel > Tu aurais un exemple fonctionnelle ?

Merci

---

Non, parce que je n'en ai pas sous la main.
Mais les politiques et traits sont souvent "extensibles" en les spécialisant pour un type précis.

J'ai bien dis "spécialiser" pas "instancier"

leternel> Le problème ce n'est pas tant le type, mais la valeur qui va avec <class T, T t>. Si le type n'est pas un type entier, tu ne peux pas l'utiliser comme second paramètre template (et faire tout les calculs qui vont avec). Et l'ensemble des types entiers est fixé, si ton type n'en fait pas parti, il n'en fait pas parti.

J'en prends note, merci.

Citation:

---

Envoyé par Flob90

Bonjour,

A priori je ne vois pas de solution en partant de ce que tu as déjà fait.

Tu as vraiment besoin de pouvoir faire les manipulations à la compilation et à l’exécution ? Si ce n'est pas le cas, tu pourrais essayer de faire manipuler des pairs de std::integral à ton meta-programme pour représenter un entier (a*m+b comme tu as du faire pour créer ton type avec une pair de uint_64).

---

Ca semble une bonne idée, ça réduit les puissance de 2 sur les u128 à 1 multiplication et à 3 multiplications sur les u256. (pas de constexpr par contre :?)

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 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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141

#include <iostream>   template <uint32_t uPower, int var=0> struct Power2 { };   template <uint32_t uPower> struct Power2<uPower, 0> { static const uint64_t t256_a = 2*Power2<uPower-1, 1>::t256_a; static const uint64_t t256_b = Power2<uPower-1, 1>::t256_b; static const uint64_t t256_c = Power2<uPower-1, 1>::t256_c; static const uint64_t t256_d = Power2<uPower-1, 1>::t256_d;   static const uint64_t t128_a = 2*Power2<uPower-1, 1>::t128_a; static const uint64_t t128_b = Power2<uPower-1, 1>::t128_b;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <uint32_t uPower> struct Power2<uPower, 1> { static const uint64_t t256_a = Power2<uPower-1, 2>::t256_a; static const uint64_t t256_b = 2*Power2<uPower-1, 2>::t256_b; static const uint64_t t256_c = Power2<uPower-1, 2>::t256_c; static const uint64_t t256_d = Power2<uPower-1, 2>::t256_d;   static const uint64_t t128_a = Power2<uPower-1, 2>::t128_a; static const uint64_t t128_b = 2*Power2<uPower-1, 2>::t128_b;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <uint32_t uPower> struct Power2<uPower, 2> { static const uint64_t t256_a = Power2<uPower-1, 3>::t256_a; static const uint64_t t256_b = Power2<uPower-1, 3>::t256_b; static const uint64_t t256_c = 2*Power2<uPower-1, 3>::t256_c; static const uint64_t t256_d = Power2<uPower-1, 3>::t256_d;   static const uint64_t t128_a = 2*Power2<uPower-1, 3>::t128_a; static const uint64_t t128_b = Power2<uPower-1, 3>::t128_b;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <uint32_t uPower> struct Power2<uPower, 3> { static const uint64_t t256_a = Power2<uPower-1, 0>::t256_a; static const uint64_t t256_b = Power2<uPower-1, 0>::t256_b; static const uint64_t t256_c = Power2<uPower-1, 0>::t256_c; static const uint64_t t256_d = 2*Power2<uPower-1, 0>::t256_d;   static const uint64_t t128_a = Power2<uPower-1, 0>::t128_a; static const uint64_t t128_b = 2*Power2<uPower-1, 0>::t128_b;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <> struct Power2< 0, 0 > { static const uint64_t t256_a = 1; static const uint64_t t256_b = 1; static const uint64_t t256_c = 1; static const uint64_t t256_d = 1;   static const uint64_t t128_a = 1; static const uint64_t t128_b = 1;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <> struct Power2< 0, 1 > { static const uint64_t t256_a = 1; static const uint64_t t256_b = 1; static const uint64_t t256_c = 1; static const uint64_t t256_d = 1;   static const uint64_t t128_a = 1; static const uint64_t t128_b = 1;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <> struct Power2< 0, 2 > { static const uint64_t t256_a = 1; static const uint64_t t256_b = 1; static const uint64_t t256_c = 1; static const uint64_t t256_d = 1;   static const uint64_t t128_a = 1; static const uint64_t t128_b = 1;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   template <> struct Power2< 0, 3 > { static const uint64_t t256_a = 1; static const uint64_t t256_b = 1; static const uint64_t t256_c = 1; static const uint64_t t256_d = 1;   static const uint64_t t128_a = 1; static const uint64_t t128_b = 1;   static const uint32_t t32 = (uint32_t)(t256_a*t256_b*t256_c*t256_d); static const uint64_t t64 = t256_a*t256_b*t256_c*t256_d; };   int main(int argc, char **argv) { uint64_t p256_a = Power2<200>::t256_a; uint64_t p256_b = Power2<200>::t256_b; uint64_t p256_c = Power2<200>::t256_c; uint64_t p256_d = Power2<200>::t256_d;   uint64_t p128_a = Power2<100>::t128_a; uint64_t p128_b = Power2<100>::t128_b;   uint64_t p50 = Power2<50>::t64;   uint32_t p30 = Power2<30>::t32;   std::cout << "2^200 = " << p256_a << "*" << p256_b << "*" << p256_c << "*" << p256_d << "\n"; std::cout << "2^100 = " << p128_a << "*" << p128_b << "\n"; std::cout << "2^50 = " << p50 << "\n"; std::cout << "2^30 = " << p30 << "\n";   return 0; }

---

Cela permet de calculer la puissance de 2 d'un uint32 seulement, mais bon de toute façon à partir de 2^255 ça va overflow.

Pour ceux que ça intéresse, le pow contexpr C++11 :

Code:

---

1 2 3 4 5 6 7 8

template <class T, class S> inline constexpr T pow(T n, S p) { return p ? n*pow(n, p - 1) : 1; }   pow(567uLL, 30);

---

Ce code détecte les overflows à la compilation.