Réponse acceptée !
#include <stdio.h>


unsigned const char SALU = 128; /*(10000000 en binaire)*/
unsigned const char COMMENT = 64; /*(01000000 en binaire)*/
unsigned const char SA = 32; /*(00100000 en binaire)*/
unsigned const char VA = 16; /*(00010000)*/
unsigned const char BIEN= 8; /*(00001000)*/
unsigned const char MAL = 4; /*(00000100)*/
unsigned const char BOF = 2; /*(00000010)*/
unsigned const char OUER = 1; /*(00000001)*/

void je_retrouve (unsigned char c);

int main ()
{
je_retrouve (SALU | COMMENT | SA | VA | BIEN); /*10000000 | 01000000 | 00100000 | 00010000 | 00001000  = 11111000, on transmet donc à la fonction la variable 11111000*/
printf (" ?\n");
je_retrouve (SA | VA | MAL);/*00100000 |00010000 |00000100 = 001010100, on tranmet à la fonction le nombre 001010100*/
getch ();
return 0;
}

void je_retrouve (unsigned char c) /* Ici on effectue un et binaire pour voir si la bits que l'on veur est à 0 ou à 1*/
{
if (c & SALU)printf ("salu ");
if (c & COMMENT)printf ("comment ");
if (c & SA)printf ("sa ");
if (c & VA)printf ("va ");
if (c & BIEN)printf ("bien ");
if (c & MAL)printf ("mal ");
if (c & BOF)printf ("bof ");
if (c & OUER)printf ("ouer ");

}

Réponse acceptée !
salut,
l'idée quand tu fais un truc du genre, c'est que les flags a positionner ne possedent en binaire qu'un seul 1 : cela revient a choisir des entiers qui sont des puissances de 2 (1,2,4,8,16,32, ...en binaire 32 s'ecrit 100000, etc.)
exemple:
#define FLAG0 1
#define FLAG1 2
#define FLAG2 4
#define FLAG3 8
#define FLAG4 16

DWORD res = (FLAG1 | FLAG3);
if (res & FLAG0)
   printf("flag0 positionne\n");
if (res & FLAG1)
   printf("flag1 positionne\n");
if (res & FLAG2)
   printf("flag2 positionne\n");
if (res & FLAG3)
   printf("flag3 positionne\n");
if (res & FLAG4)
   printf("flag4 positionne\n");

si tu fais (res & 5) tu obtiendras "flag0 positionne" mais ca n'est pas "forcement" pertinent car 5 n'est pas une puissance de 2.
Avec un entier tu peux positionner jusqu'a 32 flags (un entier est codé sur 32 bits ...)
Tu pouvais aussi faire ca:
#define FLAG0 (1 << 0)
#define FLAG1 (1 << 1)
#define FLAG2 (1 << 2)
#define FLAG3 (1 << 3)
#define FLAG4 (1 << 4)

voila; bonne méditation

Réponse acceptée !
Tout entier différent de 0 signifie vrai, et 0 signifie faux