Bonjour, actuellement je fais du C et j'ai du mal sur certaines choses, je vais vous poser le probleme et j'aimerai simplement comprendre l'utilité de ces fonctions.
 
Exercice 1 :
A l'aide du masquage (& ), et de décalages (>> ) afficher en binaire la valeur d'un caractere quelconque rentré par l'opérateur.  
 
 exemple:
 
 A : 0100 0001
 ('A' à pour code ASCII 0x41)
 
j'ai trouvé la solution mais je ne la comprend pas  
 
#include <conio.h>
#include <stdio.h>
#include <vcl.h>
#pragma hdrstop
 
//---------------------------------------------------------------------------
 
#pragma argsused
int main(int argc, char* argv[])
 
{
    char carac;
 
    printf("%d",(carac >> 7) & 1);
    printf("%d",(carac >> 6) & 1);
    printf("%d",(carac >> 5) & 1);
    printf("%d",(carac >> 4) & 1);
    printf("%d",(carac >> 3) & 1);
    printf("%d",(carac >> 2)& 1);
    printf("%d",(carac >> 1)& 1);
    printf("%d",(carac >>0 )& 1);
 
    getch();
    return 0;
}
 
je souhaiterai une reponse claire étant donné que je suis novice le langage C ne m'est pas du tout familié. merci a vous

C'est pas du C standard déjà (header : conio.h, vcl.h non standards et pragma quelque peu spéciaux)...
 
Ton code ne peut pas marcher car carac n'est pas initialisé (encore moins avec un caractère utilisateur)...
 
Avant de parler de C, il faut que tu saches "faire" l'algorithme dans un pseudo langage (de ton invention si nécessaire)...
 
Visiblement, c'est carrément la notion de binaire (algèbre de boole, opérateur binaires, masquage binaire, etc... ), d'encodage (codage ASCII des caractères) que tu ne maitrises pas car sinon une simple recherche google permet de savoir comment faire des choses (afficher, lire un caractère, etc...) ou à partir d'un code savoir ce que fait chaque fonction (printf, getch).
 
Je vois "Exercice 1", c'est dans le cadre d'un cours ?

Bonjour et desolé vous repondre seulement ce matin,

donc oui c est dans le cadre d 'un cours, mon programme fonctionne bien et je suis le seul de mon groupe a avoir trouvé la solution, mais a la base le probleme ete posé différement je n'ai plus le sujet mais j'ai la solution:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <conio.h>
#include <stdio.h>

//---------------------------------------------------------------------------

#pragma argsused
int main(int argc, char* argv[])
   
{
    char carac;

    printf("\nrentrez un caractere: " );
    scanf("%c", &carac);

   if((carac & 0x80) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x40) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x20) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x10) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x08) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x04) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x02) !=0) printf("1" );
    else printf("0" );

   if((carac & 0x01) !=0) printf("1" );
    else printf("0" );

    getch();
    return 0;
}
//---------------------------------------------------------------------------
 
ce code me permet de faire exactement la meme chose que le premier programme que je vous ai posté(d 'en sortir un nombre binaire qui me donne le resultat en hexa en entrant un caractere) mais avec beaucoup moins de ligne, donc ma question est comment cela se fait il etant donné qu'on ne test pas comme dans cette solution ? merci

pour comprendre ce genre de chose il faut faire des dessins sur un brouillon.
 
Mais pour schématiser, on a :
- d'un coté un calcul et l'affichage du résultat (0 ou 1) pour le premier code
- de l'autre un test (contrôle d'un bit) pour affichage d'un 0 ou d'un 1 en fonction du résultat
 
Dans le détail :  
 
Pour le premier code
Cette approche est moins "évidente" car en fait on fait :
- le calcul d'une valeur 0 ou d'une valeur 1 si le bit en position X vaut 1 ou non
- on affiche le résultat du calcul directement (le printf("%d" sert à ça)
 
Le calcul lui-même se fait par :
- je décale le bit souhaité en position 1 (la position la plus à droite)
- je masque les autres bits résiduels (éventuels) avec le "& 1"
 
Pour le deuxième code
on teste directement le bit à la position "x" via un masque spécialisé (qui "cible" directement le bon bit 0x80 = 10000000). Si le test est "vrai" on affiche 1 sinon 0 (les deux printfs)
 
Sur le C en général
En fait en C les choses sont assez subtiles car le test peut être fait sur tout type de variable (on peut faire un if sur tout et n'importe quoi). Tous les langages ne l'autorisent pas, mais le C se voulant un langage proche de la machine, c'est parfaitement légal (et même largement utilisé)...
 
Ainsi  

peut être simplifié en  

 
Au début de la boucle,
i = 8, i-- vaut 7 et le corps de boucle fait: putchar('0' + ((c >> 7) & 1));
Donc c >> 7 fait décaler de 7 bits vers la droite les bits du caractère c, et on masque cette valeur avec 1, soit 0...01 en binaire, c'est a dire qu'on ne garde que le dernier bit de ce avec quoi on masque.
Donc on ne garde le dernier bit de c décalé de 7 bits vers la droite, c'est a dire le 8e bit de c. Donc ((c >> 7) & 1)) vaut 1 si le 8e bit de c est 1 et vaut 0 si le 8e bit de c est 0.
Pour l'imprimer, on fait donc putchar('0' + 1) soit putchar('1') si le 8e bit de c est 1, et putchar('0' + 0) soit putchar('0') si le 8e bit de c est 0.
Au tour suivant, i = 7, c'est sur le 7e bit de c que tout ça va s'appliquer, etc.
 
On peut faire la même chose avec masquage et décalage du masque de manière explicite comme suit:
 

d est le masque, 10000000 au départ, c&d est l'opération de masquage de c par le masque, et a chaque tour de boucle, le masque se décale d'un bit a droite (d >>= 1), donc on a 10000000, puis 01000000, 00100000,..., 00000010, 00000001.
 
A+,

Merci pour vos reponses, je prendrai le temps de vous lire ce soir!  

tout est deja plus clair ! merci a vous