Discussion :

[SKone]

Bonjour,

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

Code C++ :

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

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 C++ :

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
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 C++ :

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
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 C++ :

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

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

[ternel]

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

[Invité]

hello,

d'apres stack

tu peux definir ton const en dehors de ta classe

Code :

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

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;

[SKone]

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 C++ :

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

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

[ternel]

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.

[SKone]

leternel > Tu aurais un exemple fonctionnelle ?

Merci