PureBasic

Apres quelques dizaines de minutes de recherche je passe en mode "help me please" :

J'aimerai coder une Procédure, dont l'un des arguments optionel est une combinaison de différente valeur ( constante, variable ) , exactement comme dans une Procedure PB standard comme par exemple un "buttonGadget"

Code : Tout sélectionner

Resultat = ButtonGadget(#Gadget, x, y, Largeur, Hauteur, Texte$ [, Options])

L'argument "Options" est , je cite l'aide PB :

Le paramètre facultatif 'Options' peut être une combinaison des constantes suivantes:"

J'ai bien quelques idées pour comment gérer ça avec une chaine de caracteres séprarer par des virgules par exemple. Mais je voudrais faire ça "Bien".
Ce qui m'interesse c'est comment gerer la récupération des arguments qui peuvent être au format :

Code : Tout sélectionner

#CONSTANT_A | #CONSTANT_B | variable1 | etc...

Doit-on passer par du decalage de Bit grace aux instructions >> ou << , un truc dans ce genre ?
Comme par exemple on s'arrange pour que chaque Constante représente un Bit dans un Octet et le faire de cumuler les bit a 1 ou 0 ou active ou pas les options.
J'ai peut de me compliquer la vie pour rien en faite.

bref quel serait la "bonne pratique" ?

Doit-on passer par du decalage de Bit grace aux instructions >> ou << , un truc dans ce genre ?
Comme par exemple on s'arrange pour que chaque Constante représente un Bit dans un Octet et le faire de cumuler les bit a 1 ou 0 ou active ou pas les options.

Oui c'est ça.

voici un exemple

Code : Tout sélectionner

#Option1 = 1 << 0
#Option2 = 1 << 1
#Option3 = 1 << 2
#Option4 = 1 << 3

Option = #Option2 | #Option3

Procedure Toto(Option=#Option1)
  If Option & #Option1
    Debug "Option 1"
  EndIf
  
  If Option & #Option2 
    Debug "Option 2"
  EndIf
  
  If Option & #Option3
    Debug "Option 3"
  EndIf
  
  If Option & #Option4
    Debug "Option 4"
  EndIf
EndProcedure

Toto()
Debug "********"
Toto(#Option2 | #Option4)

Un autre exemple :

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Nom du projet : Exemple de combinaison de constantes
; Nom du Fichier : Constantes Binaire.pb
; Version du fichier : 0.0.0
; Programmation : OK
; Programmé par : Guimauve
; Date : 28-09-2008
; Mise à jour : 28-09-2008
; Codé avec PureBasic V4.30
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

#Cte_Alpha = %00001
#Cte_Beta  = %00010
#Cte_Gamma = %00100
#Cte_Iota  = %01000
#Cte_Kappa = %10000

Debug #Cte_Alpha
Debug #Cte_Beta
Debug #Cte_Gamma
Debug #Cte_Iota
Debug #Cte_Kappa
Debug ""
Debug #Cte_Alpha 
Debug #Cte_Alpha | #Cte_Beta 
Debug #Cte_Alpha | #Cte_Beta | #Cte_Gamma
Debug #Cte_Alpha | #Cte_Beta | #Cte_Gamma | #Cte_Iota
Debug #Cte_Alpha | #Cte_Beta | #Cte_Gamma | #Cte_Iota | #Cte_Kappa

Debug #Cte_Alpha | #Cte_Kappa
Debug #Cte_Beta | #Cte_Gamma | #Cte_Kappa
Debug #Cte_Iota | #Cte_Kappa

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< FIN DU FICHIER <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<

A+
Guimauve

Nickel,c'est exactement ça.
Merci beaucoup.

Merci à vous deux pour l'explication, sujet super intéressant
Je l'avais déjà posé sur le forum anglais, mais j'avais compris qu'a moitié (L'anglais aide pas)

En fait c'est l'exemple "visuel" de GUIMAUVE qui m'a éclairé, je comprend ce qu'est un décalage de bit...enfin si j'ai compris
Et grâce a celui de comtois additionné, je comprend maintenant a quoi servent les << que j'avais jamais rien compris

J'ai essayé de faire l'inverse, c'est à dire retrouver toutes les constantes a partir de la "somme"
A mon avis c'est pas comme ça qu'on fait, mais ça marche, si y'a plus simple...n'hésitez pas

Code : Tout sélectionner

#Cte_Alpha = %00001
#Cte_Beta  = %00010
#Cte_Gamma = %00100
#Cte_Iota  = %01000
#Cte_Kappa = %10000


Debug #Cte_Alpha | #Cte_Beta
Debug #Cte_Alpha | #Cte_Beta | #Cte_Gamma
Debug #Cte_Alpha | #Cte_Beta | #Cte_Gamma | #Cte_Iota
Debug #Cte_Alpha | #Cte_Beta | #Cte_Gamma | #Cte_Iota | #Cte_Kappa

Debug #Cte_Alpha | #Cte_Kappa
Debug #Cte_Beta | #Cte_Gamma | #Cte_Kappa
Debug #Cte_Iota | #Cte_Kappa

Debug ""

a = #Cte_Alpha | #Cte_Beta
b = #Cte_Alpha | #Cte_Beta | #Cte_Gamma
c = #Cte_Alpha | #Cte_Beta | #Cte_Gamma | #Cte_Iota
d = #Cte_Alpha | #Cte_Beta | #Cte_Gamma | #Cte_Iota | #Cte_Kappa

e = #Cte_Alpha | #Cte_Kappa
f = #Cte_Beta | #Cte_Gamma | #Cte_Kappa
g = #Cte_Iota | #Cte_Kappa

Procedure TrouveConstante(Variable)
  
 If Variable - (1 << 4) => 0
  Variable - (1 << 4)
  Debug "#Cte_Kappa"
 EndIf
 
 If Variable - (1 << 3) => 0
  Variable - (1 << 3)
  Debug "#Cte_Iota"
 EndIf 
 
 If Variable - (1 << 2) => 0
  Variable - (1 << 2)
  Debug "#Cte_Gamma"
 EndIf 
 
 If Variable - (1 << 1) => 0
  Variable - (1 << 1)
  Debug "#Cte_Beta"
 EndIf 
 
 If Variable - (1 << 0) => 0
  Variable - (1 << 0)
  Debug "#Cte_Alpha"
 EndIf

 Debug ""

EndProcedure

Debug "a"
TrouveConstante(a)

Debug "b"
TrouveConstante(b)

Debug "c"
TrouveConstante(c)

Debug "d"
TrouveConstante(d)

Debug "e"
TrouveConstante(e)

Debug "f"
TrouveConstante(f)

Debug "g"
TrouveConstante(g)

Kwai chang caine a écrit :je comprend maintenant a quoi servent les << que j'avais jamais rien compris

Par moment un petit exemple parle de lui-même.

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Nom du projet : Décalage de bits
; Nom du fichier : Byte shifting.pb
; Version du fichier : 1.0.0
; Programmation : OK
; Programmé par : Guimauve
; Date : 08-11-2011
; Mise à jour : 08-11-2011
; Code PureBasic : 4.60
; Plateforme : Windows, Linux, MacOS X
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

VarA = 1
VarB = 1024

For Index = 0 To 10
  
  Debug "VarA = " + Str(VarA) + " : VarB = " + Str(VarB)
  VarA = VarA << 1
  VarB = VarB >> 1
  
Next

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< FIN DU FICHIER <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<

Le débogueur a écrit :VarA = 1 : VarB = 1024
VarA = 2 : VarB = 512
VarA = 4 : VarB = 256
VarA = 8 : VarB = 128
VarA = 16 : VarB = 64
VarA = 32 : VarB = 32
VarA = 64 : VarB = 16
VarA = 128 : VarB = 8
VarA = 256 : VarB = 4
VarA = 512 : VarB = 2
VarA = 1024 : VarB = 1

A+
Guimauve

Mon exemple pour retrouver les constantes ne t'a apparemment pas choqué

Bon bah tant mieux, parce que je me demandais si c’était vraiment comme ça qu'on retrouvait les constantes ??

Merci beaucoup GUIMAUVE, grâce à toi j'ai compris qu'on pousse d'un bit a gauche avec <<1 et de 2 avec <<2 ........etc ...

C'est cool

J'ai pas encore essayé de comprendre quand c'est un chiffre moins simple que le 1 au départ

Code : Tout sélectionner

Debug "Décalage d'un BIT a gauche avec <<1"
VarA = 1

For Index = 0 To 10
 
 Debug "VarA = " + Trim(Str(VarA)) + Space(10-Len(Trim(Str(VarA)))) + " : " + RSet(Bin(VarA), 11 ,"0")
 VarA = VarA << 1
  
Next
 
Debug ""
Debug "Décalage de 2 BITS a gauche avec <<2"
Debug ""

VarA = 1

For Index = 0 To 10
 
 Debug "VarA = " + Trim(Str(VarA)) + Space(10-Len(Trim(Str(VarA)))) + " : " + RSet(Bin(VarA), 21 ,"0")
 VarA = VarA << 2
  
Next

Ca donne ça :

Décalage d'un BIT a gauche avec <<1
VarA = 1 : 00000000001
VarA = 2 : 00000000010
VarA = 4 : 00000000100
VarA = 8 : 00000001000
VarA = 16 : 00000010000
VarA = 32 : 00000100000
VarA = 64 : 00001000000
VarA = 128 : 00010000000
VarA = 256 : 00100000000
VarA = 512 : 01000000000
VarA = 1024 : 10000000000

Décalage de 2 BITS a gauche avec <<2

VarA = 1 : 000000000000000000001
VarA = 4 : 000000000000000000100
VarA = 16 : 000000000000000010000
VarA = 64 : 000000000000001000000
VarA = 256 : 000000000000100000000
VarA = 1024 : 000000000010000000000
VarA = 4096 : 000000001000000000000
VarA = 16384 : 000000100000000000000
VarA = 65536 : 000010000000000000000
VarA = 262144 : 001000000000000000000
VarA = 1048576 : 100000000000000000000

Fred, dans le fichier d'aide de PureBasic, a écrit :Opérateur << (Décalage à gauche)

Décale vers la gauche les bits du nombre LHS de RHS places. Décaler les bits vers la gauche revient à faire une multiplication par un multiple de 2. Il est conseillé de bien comprendre les opérations binaires avant d'utiliser cet opérateur.

Opérateur >> (Décalage à droite)

Décale vers la droite les bits du nombre LHS de RHS places. Décaler les bits vers la droite revient à faire une division par un multiple de 2. Il est conseillé de bien comprendre les opérations binaires avant d'utiliser cet opérateur.

Comment pourrais-je mieux expliquer ?

A+
Guimauve

Comment pourrais-je mieux expliquer ?

En expliquant ce que veut dire LHS et RHS

Naaan je rigole.....j'suis allé voir sur la doc

LHS = Left Hand Side ou partie gauche, RHS = Right Hand Side ou partie droite

C'est cool les décalages, j'ai même compris pour les autres chiffres, grâce à toi

Ca décale tous le pavé à gauche en rajoutant X zéro à droite

Code : Tout sélectionner

Debug "Décalage d'un bit à gauche << 1 égal à multiplier par 1(bit) * 2 c'est à dire 2"
Debug 33
Debug Bin(33) 
Debug Bin(33 << 1)
Debug 33 << 1

Debug ""

Debug 5
Debug Bin(5) 
Debug Bin(5 << 1)
Debug 5 << 1

Debug ""
Debug "Décalage de 2 bits à gauche << 2 égal à multiplier par 2(bit) * 2 c'est à dire 4"

Debug 33
Debug Bin(33) 
Debug Bin(33 << 2)
Debug 33 << 2

Debug ""

Debug 5
Debug Bin(5) 
Debug Bin(5 << 2)
Debug 5 << 2

Donne :

Décalage d'un bit à gauche << 1 égal à multiplier par 1(bit) * 2 c'est à dire 2
33
100001
1000010
66

5
101
1010
10

Décalage de 2 bits à gauche << 2 égal à multiplier par 2(bit) * 2 c'est à dire 4
33
100001
10000100
132

5
101
10100
20

Donc ça marche apparemment pour tous les chiffres, même si ils sont pas multiples de 2

J'suis content j'ai compris comment ça marchait, j'suis pas sur que je vais m'en rappeler, parce ce que je sais pas à quoi ça sert, donc je risque pas de m'en servir

Surement à de la prog de haut niveau

...........KCC s'abstenir

Encore merci GUIMAUVE

J'ai aussi bien du mal à comprendre l’intérêt concret de ces commandes de décalage par rapport à une incrémentation de i dans un repeat / until par exemple.

ça sert à plein de choses , voir les exemples sur les options.

Autre exemple, avec les couleurs.
Chaque couleur est codée sur un octet, un long contient 4 octets :

Le décalage permet de placer chaque couleur sur l'octet souhaité

Code : Tout sélectionner

R = 123
G = 45
B = 156

Couleur = b << 16 | G << 8 | R 

Debug RGB(R, G, B)
Debug Couleur

Je me doutais bien que ça servait...autrement FRED il l'aurait pas fait

C'est cool l'exemple que t'as donné...ARS va surement comprendre plus vite que moi....moi j'ai juste trouvé ça magique

Je l'ai mis dans ma hotte

Merci COMTOIS

Plus haut je parle de couleur, c'est un raccourci ! il s'agit des composantes rouge, verte et bleue d'une couleur.

ça marche pareil en changeant l'ordre d'écriture , le décalage ne change pas lui.
Couleur = R | G << 8 | B << 16
Couleur = B << 16 | G << 8 | R

Pour une couleur 24 bits (soit 3 octets)
La composante rouge occupe le premier octet (donc pas de décalage)
La composante verte occupe le second octet (décalage de 8 bits, soit un octet)
La composante bleue occupe le troisième octet (décalage de 16 bits, soit 2 octets)

Code : Tout sélectionner

R = 123
G = 45
B = 156

Couleur = R | G << 8 | B << 16 

Debug RGB(R, G, B)
Debug Couleur

ça peut aussi servir dans les jeux, tu veux limiter la taille mémoire occuper par tes personnages et quand même stocker un max d'infos dans une variable. Tu peux décider d'affecter à chaque bit de ta variable un état ou une action. (ou faire un codage binaire sur un octet, affecter des bits d'états sur un autre octet, etc, et ensuite tu déchiffres le tout en faisant de la manipulation de bits, des décalages, des masques (avec un &)
Par exemple
Contenu des objets :

Bit 0 = Gourde
Bit 1 = Corde
Bit 2 = Autre chose
Bit 3 = Etc

Une seule variable ContenuDeMonSacADos permet de stocker plein d'infos, ça peut être pratique pour limiter la taille des datas à envoyer sur le net dans un jeu en réseau.

Code : Tout sélectionner

#Gourde = 1 << 0
#Corde  = 1 << 1
#Autre  = 1 << 2
#Etc    = 1 << 3

Procedure Test(Test, texte$)
  If Test 
    Debug "Chouette j'ai ça --> " + texte$
  Else
    Debug "Dommage, je n'ai pas ça --> " + texte$
  EndIf
EndProcedure

;Exemple d'utilisation avec un long (4 octets)
ContenuDeMonSacADos.l = 0
; A chaque fois que tu prends un objet
ContenuDeMonSacADos | #Corde
ContenuDeMonSacADos | #Autre

; Pour tester si tu as une corde
Test(ContenuDeMonSacADos & #Corde, "Corde")

;Pour déposer une corde
ContenuDeMonSacADos & ~(#Corde)
Test(ContenuDeMonSacADos & #Corde, "Corde")

; Pour tester si tu as une gourde
Test(ContenuDeMonSacADos & #Gourde, "Gourde")

;Tu peux aussi décider que le second octet sera un compteur de vie
Vie = 3
ContenuDeMonSacADos | Vie << 8 ; Décalage de 8 bits pour stocker vie dans le deuxième octet

;Pour décrémenter d'une vie
;On récupère uniquement le 2ème octet avec un masque,
;puis on décale  dans le sens inverse, et on décrémente la vie
Vie = ((ContenuDeMonSacADos & $0F00) >> 8) - 1 ; 
Debug Vie

Et ben dis donc.....je comprend pourquoi j'ai jamais fait de jeu

C'est un truc de dingue, comment c'est pointu

Les gens y peuvent pas imaginer que pour qu'ils se marrent pendant des heures au point d'en avoir les dents seches, y'a des génies comme toi qui bossent des centaines d'heures à décaler les BIT à droite et a gauche comme sur les photos de mariages ou personne n'est jamais à sa place

Bon, après cette explication au combien passionnante et géniale, que j'ai lu au moins 10 fois et que je vais ajouter encore une fois dans ma hotte.
Je vais aller jouer au billes.....la aussi y'a une histoire de décalage.

Tu dois pousser une boule avec une autre, pour ce faire du décale ton doigt rapidement derrière l'autre

Code : Tout sélectionner

Pouce << index

Et si ça marche....tu as gagné une vie...la tienne quand tes parents il te voient pas revenir sans plus aucune de tes billes qu'ils t'ont acheté la veille

Non sincèrement, merci de cette explication, ça rejoint donc bien ce que je disais, c'est pour de la prog de haut niveau, je m'en doutais

Je vais te laisser cette partie, et je m'occupe de la mienne, je retourne a mes billes

Encore merci beaucoup COMTOIS

Tu peux faire des jeux, ce n'est pas indispensable de faire tout ça

PureBasic

Procedure : Arguments multiple sur une variable

Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable

Re: Procedure : Arguments multiple sur une variable