PureBasic

Bonjour a tous,
Je souhaiterais simplement savoir a quoi sert l'operateur " & " ( qui doit surement porter un Nom ). et quel est son fonctionnement.
Je vous en remerci d'avance

Ca sert à faire des calculs bit à bit. Il faut se représenter les nombres en binaire. Par exemple 138 donnera %10001010 et 25 sera %00011001. On les aligne:
%10001010
%00011001
Et dans le résultat, il yaura un 1 là où il y a 1 ds chacune des opérandes, 0 sinon:
___%10001010
_&_%00011001
=__%00001000

Ca sert à vérifier un bit en particulier ds une valeur qui sert de drapeau, ou à transformer un octet signé en non signé:
var.l=peekb(*addresse) & $ff
te donnera la valeur de l'octet en le considérant comme non-signé (0 à 255, au lieu de -128 à 127).
Voilà, voilà... Je sais pas si je suis très clair

Salut

C'est un opérateur logique qui permet de faire des opérations bit à bit.

Va faire un tour sur ce site. C'est très bien expliqué.
http://www.lille.iufm.fr/labo/pagesProj ... e2/op1.htm

Chris

Ah oui...
Ca a l'air un peu plus complet que mon baffouillage

Ca a l'air un peu plus complet que mon baffouillage

C'est pas du baffouillage, mais c'est vrai que c'est pas le genre de truc qui peut s'expliquer facilement en trois phrases

Je viens de retrouver un autre site que j'avais dans mes favoris :
http://perso.wanadoo.fr/carlov/cours/an ... naire.html

Chris

Merci Pour vos Liens " & " l'explication
Je suis en train de lire cela, ça s'avere tres interessant

AND est un ET logique (binaire). Il vous faut être familiarisé avec les nombres binaires pour utiliser cet opérateur. Le résultat de cet opérateur est le résultat d'un ET logique entre les valeurs des expressions LHS et RHS, bit à bit. La valeur de chaque bit résultant est fixée comme indiqué dans la table ci-dessous. De plus, si le résultat de l'opérateur n'est pas utilisé et qu'il y a une variable LHS, alors le résultat sera directement stocké dans cette variable. Cet opérateur ne peut être utilisé avec une variable de type chaine.

LHS | RHS |Résultat
------------------
0 | 0 | 0
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1
Exemple:
; La représentation binaire des valeurs est utilisée pour une présentation plus claire et lisible
a.w = %1000 & %0101 ; Le résultat sera 0
b.w = %1100 & %1010 ; Le résutlat sera %1000
bits = a & b ; Effectue un ET bit à bit entre a et b et utilise le résultat avec l'opérateur =
a & b ; Effectue un ET bit à bit entre a et b et place le résultat directement dans la variable "a"

Voici ce que dit la doc , que veux-tu savoir de plus ?
Bon ok , ça c'est pour le fonctionnement
alors à quoi ça peut servir ?

ça peut servir à faire des masques, par exemple :

dans le mode 16 bits les couleurs sont codées dans un word (16 bits )
bits 1 à 5 pour le bleu
Bits 6 à 11 pour le vert
Bits 12 à 16 pour le rouge

Une fois que tu as lu le word , comment isoler la couleur bleue?
avec un masque %0000 0000 0001 1111 ( on met les 5 bits qui correspondent au bleu à 1 et les autres à 0)
et ensuite tu appliques un ET logique entre le word qui représente la couleur et ton masque , le résultat te donnera la couleur bleue
admettons que le word soit
%1101 1001 1011 0011 < c'est la couleur d'un pixel en 16 bits
%0000 0000 0001 1111 < c'est le masque pour isoler le bleu
%0000 0000 0001 0011 < Et ça c'est le résultat après un &
la couleur bleue = %0000 0000 0001 0011 = 19

autre exemple

la différence entre une majuscule et une minuscule , c'est le sixième bit
exemple
le "a" s'écrit %1100001
le "A" s'écit %1000001
Tu constates qu'il n'y a que le 6eme bit qui change pour passer d'une minuscule à une majuscule

pour obtenir la majuscule d'un Char tu as juste à changer son 6eme bit

Code : Tout sélectionner

a$="a"
b$= Chr(Asc(a$) & %11011111) ; c'est un autre masque .
Debug a$
Debug b$

Edit :
Forcément le temps que je prépare une réponse, tout à déjà été dit en plus complet

bon tant pis , je n'efface pas le post

et pendant que j'y suis , je vais parler du OU binaire en reprenant l'exemple des majuscules et minuscules

donc quand tu veux forcer un char en minuscule , tu as juste le 6eme bit à mettre à 1 , pour cela tu utilises le OU binaire |

Code : Tout sélectionner

a$ = "a"
b$ = Chr(Asc(a$) & %11011111)
c$ = Chr(Asc(b$) | %00100000)
Debug a$
Debug b$ 
Debug c$

bon ok , c'est pas très utile , mais bon ... vu l'heure tardive je n'ai pas d'autres exemples à l'esprit

C'est l'algèbre de Bool, Mathématicien anglais.

Fais une recherche avec Google sur algèbre de Bool.

Oui, l'algèbre de Boole est essentielle en informatique.
Et c'est amusant de noter que ce brave Boole (ne lui mangez pas son e, svp

) est mort dans les années 1860, c'est-à-dire longtemps avant les premiers processeurs.

mort dans les années 1860, c'est-à-dire longtemps avant les premiers processeurs.

Ouuups, j'ai dit une connerie!

En fait les lointains ancêtres de nos PC avaient déjà été inventés...
Ils étaient peut-être rudimentaires, mais les principes de base étaient là.
Ah, cette foutue manie de s'imaginer que tout a été inventé au 20e siècle ! Quel chauvinisme !

Toutes mes excuses pour cette désinformation.

Oui Boole avec un e.

Merci Beaucoup

C'est Vraiment tres gentil, j'ai eu une reponse vraiment rapide !
J'avais aussi poser la question sur le forum de 3gdc ( je savais qui allait me repondre ), Chiwawa.
Il m'a aussi expliqué son fonctionnement, c'est un peu fouilli et j'ai reussi a comprendre grâce a vous.

Donc j'avais fait un petit recapitulatif de ce que j'avais apris Hier, il me reste encore des tonnes de choses a apprendre :
----------------------------------------------------------------------------------
Donc je recapitule pour moi même ( je me suis un peu documenté ):

Code : Tout sélectionner

 0 & 1 = 0
 0 & 0 = 0
 1 & 1 = 1

Donc Pour les Pairs, " la comparaison " des Bits doit donnée 0.
Donc Le Binaire se compte ainsi

Code : Tout sélectionner

0001
0010
0011
0100
Etc...

Pour Passer d'un Binaire en Entier =>
Exemple de " 0100 "
On part du rang le plus a droite
0*1 + 0*2 + 1*4 + 0*8 = 4.

L'addition des Bits ( 4 + 1 ).

0100
0001
------
0101

1*1+0*2+1*4+0*8 = 5

Même Operation avec les retenus ( 4 + 4 ) =8.

0100
0100
------
1000

0*1+0*2+0*4+1*8 = 8

Ok, donc ça fonctionne.

En clair, ça fonctionne comme des interrupteurs " Ouvert/Fermé " mis a la suite ( montée en serie ), si l'un deux est ouvert ( = 0 ), alors la lumiere mis au bout ne fonctionneras pas.

Pile ____ _ ______ _ ____ Lumiere Brillante ( 1 & 1 ) = 1

Pile _____ / ______ _ _____ Lumiere etteinte. ( 0 & 1 ) = 0

Pile _____/ _______ / _____ Lumiere etteinte. ( 0 & 0 ) = 0

Et donc pour le " OR " ( | ) , c'est un circuit monté en derivation.
Je crois que j'ai resumé les Bases.
----------------------------------------------------------------------------------

Merci encore

PureBasic

L'operateur " & ".

L'operateur " & ".