Traitement binaire - entier (c)

Commenter

Contenu du snippet

Ils s'agit des fonctions de conversion entier/binaire et quelques fonctions de traitements le tout en chaine de caractère.

Source / Exemple : 


#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define BITS       20
#define BON        1
#define MAUVAIS    0
#define OVER       2
#define BASE       16
#define EOS        '\0'

int entier2binaire(char*, int );
int binaire2entier(char*);
void reverse(char* );
int powrec(int , int );
void not(char*);
char* and(char* , char*);
char* add(char*, char*);
char lsl(int, char*);
char lsr(int, char*);
char rol(int, char*);
char rol_single(char*);
char ror(int , char*);

int main( int argc, char *argv[])
{
int flag, flag2, n, m, choix, i, MAX, ret;
char tab[BITS], *mes, car;
char tab2[BITS], *tab3, *tab4;
MAX = powrec(BASE, BITS);   /* l'entier maximal représenté sur BITS bits dans la base BASE */

printf("\n***************************************************************\n");
printf("\tManipulation des chaines binaires\n");
printf("***************************************************************\n\n");
 printf("\t0 ==> Quitter \n");
 printf("\t1 ==> Convertir un entier en binaire\n");
 printf("\t2 ==> Complement logique\n");
 printf("\t3 ==> ET logique\n");
 printf("\t4 ==> Addition deux registres\n");
 printf("\t5 ==> Decallage logique de bits vers la gauche\n");
 printf("\t6 ==> Decallage logique de bits vers la droite\n");
 printf("\t7 ==> Rotation de bits vers la gauche\n");
 printf("\t8 ==> Rotation de bits vers la droite\n");
 printf("\t9 ==> Convertir un binaire en entier \n\n");

 op:
 printf("Entrez l'operation a faire : ");
 ret = scanf("%d", &choix);

 if(ret)
 {
        switch(choix)
        {
        case 0:
             printf("\n Aurevoir...\n");
             goto end;
             break;

        case 1:
            printf("Entrez l'entier : ");
             scanf("%d", &n);
             flag = entier2binaire(tab, n);
             switch(flag)
             {
             case 0:
             printf("%d est un nombre negatif\n");
             goto op;
             break;
             case 1:
             printf("%d => 'B' %s \n", n, tab);
             goto op;
             break;
             default:
             printf("Debordement de la memoire : %d n'est pas codable sur %d bits \n", n, BITS);
             goto op;
             break;
             }
             break;

         case 2:
              printf("Entrez l'entier a complementer : ");
              scanf("%d",&n);
              entier2binaire(tab, n);
              printf(" %d => 'B' %s \n", n, tab);
              not(tab);
              printf("/%d => 'B' %s\n", n, tab);
              goto op;
              break;

          case 3:
               printf("Entrez le premier entier : ");
               scanf("%d", &n);
               printf("Entrez le second entier : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               entier2binaire(tab2, m);
               tab3 = and(tab, tab2);
               printf(" p  = 'B' %s \n",  tab);
               printf(" q  = 'B' %s \n",  tab2);
               printf("p^q = 'B' %s \n",  tab3);
               goto op;
               break;

          case 4:
               printf("Entrez le premier entier : ");
               scanf("%d", &n);
               printf("Entrez le second entier : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               entier2binaire(tab2, m);
               tab4 = add(tab, tab2);
               printf(" p  = 'B' %s \n",  tab);
               printf(" q  = 'B' %s \n",  tab2);
               printf("p+q = 'B' %s \n",  tab4);
               goto op;
               break;

          case 5:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de decallage vers la gauche : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("  p = 'B' %s \n", tab);
               car = lsl(m, tab);
               printf("l~p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 6:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de decallage vers la droite : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("  p = 'B' %s \n", tab);
               car = lsr(m, tab);
               printf("r~p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 7:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de rotation vers la gauche : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("    p = 'B' %s \n", tab);
               car = rol(m, tab);
               printf("LOL p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 8:
               printf("Entrez l'entier : ");
               scanf("%d", &n);
               printf("Entrez le nombre de bits de rotation vers la droite : ");
               scanf("%d", &m);
               entier2binaire(tab, n);
               printf("    p = 'B' %s \n", tab);
               car = ror(m, tab);
               printf("LOR p = 'B' %s => %c\n", tab, car);
               goto op;
               break;

          case 9:
               printf("Entrez le binaire : ");
               scanf("%s", tab3);
               n = binaire2entier(tab3);
               switch(n)
               {
               case 0:
               printf("%s n'est pas un binaire \n", tab3);
               goto op;
               break;
               default:
               printf("'B' %s = %d \n", tab3, n);
               goto op;
               break;
               }

          default:
                  printf("Mauvaise entree! \n");
                  goto op;
                  break;

        }
 }
 else
 {
                  printf("Mauvaise entree! \n");
                  goto end;
}

   end:
      system("PAUSE");
      return 0;
}

/* La fonction qui converti un entier positif en binaire sur 20 bits*/
int entier2binaire(char *ch, int n)
{
int retour;
int i = 0;

if( n < 0)
{
retour = MAUVAIS;
}
else{
while(i < BITS)
{


  • (ch + i) = ((n%BASE) + '0');

n /=2;
i++;
}
 if(n != 0)
retour = OVER;
else{


  • (ch + BITS)= EOS;

reverse(ch);
retour = BON;
}
}

return retour;
}

/*La procedure qui renverse une chaine */
void reverse(char *ch)
{
int i, n;
char ch2[BITS];
n = BITS;
i = 0;
strcpy(ch2, ch);
while((*(ch + n - 1) = *(ch2 + i)) != EOS)
{
n--;
i++;
}
}

/* que fait cette fonction? */
int powrec(int base, int n)
{
int i, result = 0;
for(i=0; i<n; i++)
result += pow(base, i);

return result;
}

/* complement logique */
void not(char *tab)
{
int i = 0;
while(*(tab + i) != EOS)
{


  • (tab + i) = (*(tab + i) == '0')? '1' : '0';

i++;
}
}

/* et logique */
char* and(char *ch1, char* ch2)
{
int i ;
char *ch;
ch = (char*)malloc((strlen(ch1)+1)*sizeof(char));
i = 0;

while(*(ch1 + i) != EOS)
{


  • (ch + i) = ((*(ch1 + i) == '0') || (*(ch2 + i) == '0'))?  '0' : '1';

i++;
}


  • (ch + i) =EOS;

return ch;
}

/* addition entre registre */
char* add(char *ch1, char *ch2)
{
char *ch;
int eval, i, r, n;
i = 0;
r = 0;
n = strlen(ch1) - 1;

ch = (char*)malloc((n + 1)*sizeof(char ));
while(n >=0 )
{
 eval = *(ch1 + n) + *(ch2 + n) -'0' - '0' + r;

if(eval == 0)
{


  • (ch + n) = '0';

r = 0;
}
if(eval == 1)
{


  • (ch + n) = '1';

r = 0;
}
if(eval == 2)
{


  • (ch + n) = '0';

r = 1;
}
if(eval == 3)
{


  • (ch + n) = '1';

r = 1;
}
n--;
}


     
  • (ch + BITS) = EOS;

 if(r)
printf("retenu = %d \n", r);
return ch;
}

/* decallage logique de val bits a gauche */
char lsl(int val, char *ch)
{
char *ch1, car;
int i, n;
i = 0;
n = strlen(ch);

car = *(ch + val -1);
while( i < (n - val))
{


  • (ch + i) = *(ch + i + val);

i++;
}

while(*(ch + i) != EOS)
{


  • (ch + i) = '0';

i++;
}
return car;
}

/* decallage logique de val bits a droite */
char lsr(int val, char *ch)
{
char *ch1, car;
int i, n;

reverse(ch);
car = lsl(val, ch);
reverse(ch);
return car;
}

/* rotation d'un bit à gauche, pourquoi? */
char rol_single(char *ch)
{
int i;
char car;
i=0;
car = *ch;
while(*(ch + i + 1) != EOS)
{


  • (ch + i) = *(ch + i +1);

i++;
}


  • (ch + i) = car;


return car;
}

/* rotation de val bit a gauche */
char rol(int val, char *ch)
{
char car;
int i = 0;
car = *(ch + val-1);
while(i < val)
{
rol_single(ch);
i++;
}

return car;
}

/* rotation de val bits a droite */
char ror(int val, char *ch)
{
char car;
reverse(ch);
car = rol(val, ch);
reverse(ch);
 return car;
 }

 int binaire2entier(char *ch)
 {
 int i, result, n;
 i = 0;
 result = 0;

 n = strlen(ch) -1;

 while(*(ch + i) != EOS)
 {
 if(*(ch + n) != '0' && *(ch + n) != '1')
 {
 result = MAUVAIS;
 break;
 }
 else{
 result += (*(ch + n) -'0')*pow(BASE, i);
 i++;
 n--;
 }
 }

 return result;
 }

Conclusion :


Rien de nouveau pour les anciens

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (professeurr)