Discussion :

[Aniss00]

Salut,

J'ai trouver plusieurs lignes qui resemble a la ligne suivante dans un code c :

Code :

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

var =temp | label | (var1 << 28) | ( var2 << 8);

j'aimerai savoir ce que cela signifie et a quoi sert les |

Note: la var doit etre a 32bits

Merci

[gerald3d]

Bonjour.

Le signe | est l'opérateur "ou" logique binaire. (edit1. Merci à Bktero pour la précision linguistique)

Les signes << (ou >>) servent à décaler les bits vers la gauche (ou vers la droite). Par exemple var2<<8 demande de décaler les bits de var2 vers la gauche 8 fois. La faq est très explicative à ce sujet .

[Invité]

Bonsoir,

Le | et le << font tout deux partie de ce que l'on appellent en C les opérateurs bit à bit. Ils permettent d'effectuer des opérations directement sur les bites d'une variable.
Les deux présent ci-dessus sont respectivement le "OU logique" et le "décalage à gauche"
En plus de ceux-ci, il existe encore le &, le >> , le ^ et le ~, respectivement "ET logique", "décalage à droite", "OU exclusif" et "NOT".

Le &, le |, le ^ et le ~ sont directement issue de l'algèbre booléenne.
Pour plus de renseignement, je t'invite à lire par exemple ici, où tu trouveras les bases sur les ET et OU logique.


En prenant un exemple comparable à ce que tu nous montres, mais avec une variable sur 8bits pour la facilité :

Code :

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
unsigned char val1 = 38 // En binaire : 00100110
unsigned char val2 = 15 // En binaire : 00001111
unsigned char resultat;

resultat = val1 | val2 | (val1 << 2) | (val2 << 4);

/*
   *       00100110
   * OU    00001111
   *       00101110 ( résultat val1 | val2 ) EDIT: Faute de frappe.
   * OU    10011000 (décalage à gauche, on "pousse" à gauche les bits de la variable 2 fois, en remplissant la queue par des 0)
   *       10111110 (résultat (val1 | val2) | (val1 << 2)
   * OU    11110000 (décalage à gauche, on "pousse" à gauche les bits de la variable, en remplissant la queue par des 0)
   *       11111110 ( résultat ((val1 | val2) | (val1 << 2)) | (val2 << 4)
   */

Dans l'exemple montré, le résultat de l'opération val1 | val2 | (val1 << 2) | (val2 << 4) donne donc 11111110b, soit 254 en valeur décimale.
Une dernière chose, les opérateurs bit à bit ne peuvent se faire uniquement que sur des valeurs entières. Exit donc les float et double.

[foetus]

Code :

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

1
2
3
4
5
6
unsigned char val1 = 38 // En binaire : 00100110
unsigned char val2 = 15 // En binaire : 00001111
 
   *       00100110
   * OU    00001111
   *       00100110 ( résultat val1 | val2 )

Révises un peu tes tables logiques

Table OU

Code :

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

1
2
3
4
B\ A 0  1
0    0  1
 
1    1  1

Table ET

Code :

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

1
2
3
4
B\ A 0  1
0    0  0
 
1    0  1

Parce que (mode violent )

Code :

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
21
22
#define BYTETOBINARYPATTERN "%d%d%d%d%d%d%d%d"
#define BYTETOBINARY(byte)  \
  (byte & 0x80 ? 1 : 0), \
  (byte & 0x40 ? 1 : 0), \
  (byte & 0x20 ? 1 : 0), \
  (byte & 0x10 ? 1 : 0), \
  (byte & 0x08 ? 1 : 0), \
  (byte & 0x04 ? 1 : 0), \
  (byte & 0x02 ? 1 : 0), \
  (byte & 0x01 ? 1 : 0) 
 
 
int main(int argc, char* argv[])
{
    unsigned char a = 38; // 00100110
    unsigned char b = 15; // 00001111
    unsigned char c = (a | b);
 
    printf("a: "BYTETOBINARYPATTERN" (%d)\nb: "BYTETOBINARYPATTERN" (%d)\na | b: "BYTETOBINARYPATTERN" (%d)\n", BYTETOBINARY(a), a, BYTETOBINARY(b), b, BYTETOBINARY(c), c);
 
    return 0;
}

a: 00100110 (38)
b: 00001111 (15)
a | b: 00101111 (47)

[Invité]

Oh mince... J'aurais du me relire avant de valider ce que j'ai mis...

" Mais c'est pas ma fôte m'sieur, j'suis jeune ! "

[Bktero]

| est le OU bit à bit (ou OU binaire) quand || est le OU logique.

Voir http://en.wikipedia.org/wiki/Operato...ical_operators et http://en.wikipedia.org/wiki/Operato...wise_operators.