Besoin de comprendre un code

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

Code:

---

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

Bonjour.

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

Code:

---

(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 :)

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.

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

Citation:

---

Envoyé par 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.)

---

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:

---

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:

---

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

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)

Citation:

---

Envoyé par deubelte

Voila mon calcul:


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

---

en fait non car "|" n'est pas équivalent à '+'. C'est vrai si U0 =0 (ce que j'ai supposé dans mon exemple afin d'avoir binary(0)=binary(N=0) (ce qui semble logique) )

Citation:

---

Envoyé par deubelte

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<=49 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)

---

Si on oublie le fait que '|' n'est pas égal à '+', c'est bien plus juste que ce que j'avais mis dans mon post #2. Les bonnes valeurs (si je ne me suis pas trompé :aie:) sont dans mon post #5 mais ce sur quoi je voulais insister est que les valeurs qui n'ont autre chose que des 0 ou des 1 n'ont pas d'intérêt dans le cadre de cette fonction qui est une espèce de pseudo-conversion binaire décimal (enfin de la représentation binaire dans un affichage décimal à une représentation numérique pour être plus exact).

en gros, si je donne 10101001, la fonction doit me sortir 169. par contre elle n'est pas censée avoir un quelconque résultat valable pour des nombres intégrant tout autre numéro que 1 ou 0.

Citation:

---

C'est vrai si U0 =0 (ce que j'ai supposé dans mon exemple afin d'avoir binary(0)=binary(N=0) (ce qui semble logique) )

---

C'est le cas, en tout cas dans l'exemple que j'ai donné


C'est exemple est issu du livre C++ Template MetaProgramming. De Abrahams.

Citation:

---

Envoyé par deubelte

C'est le cas, en tout cas dans l'exemple que j'ai donné


C'est exemple est issu du livre C++ Template MetaProgramming. De Abrahams.

---

ce qui m'étonne, c'est que je ne suis pas sûr que ce soit optimal: même si le template est évalué a l'avance, je ne suis pas sûr que le résultat des expressions soit précalculé.... et même si le nombre de calculs doit être en quelque chose comme O(4.log(N)) soit 4 par "décimale" ("duale" ?) le mode de représentation me parait vraiment curieux et pas performant comparé à un mode "string"(un décalage de bit par valeur plus passage à la valeur suivante, soit la moitié en temps)...

Citation:

---

Envoyé par méphistopheles

ce qui m'étonne, c'est que je ne suis pas sûr que ce soit optimal: même si le template est évalué a l'avance, je ne suis pas sûr que le résultat des expressions soit précalculé....

---

euh si :{ c'est genre le principe de la meta-prog, au final t'as valeur est entierement évaluée par le compilateur qui ensuite fait de la propagation de constante

Citation:

---

Envoyé par Joel F

euh si :{ c'est genre le principe de la meta-prog, au final t'as valeur est entierement évaluée par le compilateur qui ensuite fait de la propagation de constante

---

Ok, j'avais un doute , je range ma mauvaise langue.

Merci pour l'info ;)

Note que le bout de code est juste là pour avoir un truc abordable (ie simple) afin de montrer la TMP au lecteur facilement, il mentionne bien que le but principal n'est pas de faire du calcul. (même si oui Joel je sais que ça peut être intéressant de le faire :p)