Discussion :

[deubelte]

Bonjour
je n'arrive pas à comprendre le code suivant:

Code :

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

1
2
3
4
5
6
 
template <unsigned long N>
struct binary{
static unsigned const value
 =binary<N/10>::value<<1 |N%10
};

Pas au niveau de la syntaxe, mais au niveau de l'exécution de l'instruction.
Que fait:
binary<N/10>::value<<1 |N%10

Dans quel ordre cela se lit?
Si par exemple N=139,
N%10=9

On décale de 1 bit binary<N/10>::value

On fait ensuite l'addition binaire de N%10 et de binary<N/10>::value<<1.
J'imagine que cela renvoie le nombre en décimale d'un binaire?

merci

[méphistopheles]

Bonjour.

si on applique les priorités des opérateurs, l'expression est en clair:

Code :

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

(binary<(N/10)>::value<<1 )|(N%10)

en gros, on a binary<(N/10)>*2 + (N%10)

étant donnée que la suite des N/10 va converger vers 0, on vas parler en fonction de binary(0) que nous noterons U0 (il doit exister uns spécialisation de ta classe pour cette valeur)
on a donc
binary(x=[1...9])=U0*2+x
binary(x=[10...19])=U0*4+(x-10) +2
binary(x=[20...29])=U0*8+(x-20) +4
...
binary(x!=0)=binary((x/10)*10) +x%10

comme à mon avise binary(0)=0
ça nous fait :
0,1,2,3,4,...,9,2,3,4,............

puis à partir de binary 100,
binary(100)=binary(10)*2=4
binary(101)=binary(10)*2+1=5
..
binary(110)=binary(11)*2=6
etc...
on a donc un convertisseur depuis des nombres notés en binaire mais sur une base digitale vers leurs valeur réelle. pour ma part, je trouve que c'est un peu tordu, mais bon,c'est plutot bien trouvé

bonne chance pour la suite

[deubelte]

Je ne comprend pas pourquoi tu as mis un 8 devant U0

binary(x=[20...29])=U0*8+(x-20) +4

j'aurais mis 4.

[Luc Hermitte]

Ce n'est pas une addition.
C'est un OU binaire (/bit à bit). => 12->2, 13->3, etc.

(Je ne cache pas que l'intérêt m'échappe encore -- avec un décalage de 4, on aurait eu des plages différentes (et donc une vraie addition arithmétique obfusquée) entre le modulo et le dividende, et donc un encodage en BCD, mais là ce n'est pas le cas, on ne décale que de 1 ce qui implique un recouvrement et ... n'importe quoi au final.)

[méphistopheles]

Ce n'est pas une addition.
C'est un OU binaire (/bit à bit). => 12->2, 13->3, etc.

(Je ne cache pas que l'intérêt m'échappe encore -- avec un décalage de 4, on aurait eu des plages différentes (et donc une vraie addition arithmétique obfusquée) entre le modulo et le dividende, et donc un encodage en BCD, mais là ce n'est pas le cas, on ne décale que de 1 ce qui implique un recouvrement et ... n'importe quoi au final.)

J'avoue que j'ai un peu simplifié avec cette histoire d'addition, mais en supposant U0=0 le résultat est le même:
binary(x=[0...9])=x
binary(10)=2 //(00|10==10)
binary(11)=3
binary(12)=2 //(10|10==10) //mais on s'en fiche un peu
binary(13)=3 //mais on s'en fiche un peu
binary(14)=6 //mais on s'en fiche un peu
...
binary(100)=binary(10)<<1=4
binary(101)=5
binary(102)=6//mais on s'en fiche un peu
binary(103)=7//mais on s'en fiche un peu
...
binary (110)=binary(11)<<1=6
binary (111)=7
binary (112)=6//mais on s'en fiche un peu
binary (113)=7//mais on s'en fiche un peu
...
binary(1000)=binary(100)<<1=8

donc ça marche.

la fonction inverse serait:

Code :

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

1
2
3
4
5
6
7
8
9
10
template <unsigned long N>
struct decbin{
static unsigned const value
 =10*decbin<N<<1>::value + N%2 
};
template <>
struct decbin<0>{
static unsigned const value
 =0;
};

ou encore pour rester dans le même style obscurantiste

Code :

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

1
2
3
4
5
6
7
8
9
10
template <unsigned long N>
struct decbin{
static unsigned const value
 =10*decbin<N<<1>::value | (N&1)
};
template <>
struct decbin<0>{
static unsigned const value
 =0;
};

voilà. par contre, si la spécialisation de binary en 0 n'ets pas 0, je ne vois pas ce que ça peut être

bonne chance

[deubelte]

Voila mon calcul:


Si N<=9, N%10=N, donc binary(x)=2U0+x

Si 10<=N<=19 alors N%10=N-10, et N/10 est compris entre 1 et 2, (convertir en int, cela vaut 1) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(1)+x-10=2*(2U0+1)+x-10=4U0+2+(x-10)


Si 20<=N<=29 alos N%20=N-20 et N/10 est compris entre 2 et 3 (convertir en int, cela vaut 2) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(2)+(x-20)=2*(2U0+2)+x-20=4U0+4+(x-20)

Si 30<=N<=39 alos N%10=N-30 et N/10 est compris entre 3 et 4 (converti en int, cela vaut 3) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(3)+N-30=2*(2U0+3)+(x-30)=4U0+6+(x-30)