[C] Costruire una maschera per estrarre bit meno significativi

[asteroid]

salve

voglio estrarre i k bit meno significativi della mia variabile intera A
x esemp: k=4
A= 5 in binario = 0000 0101

tramite l'utilizzo di una maschera in C.

mask= 0000 1111

Sò che ci sono 3 modi per costruire una maschera:

1. tramite potenze di 2 quindi utilizzando pow della libreria math.h ----> nn mi serve

2. tramite costate decimale, ottale o esadecimale ---> questa si

3. tramite operatori bitwise -----> anche


vi sarei grado anche se mi dareste un acenno, su come costruire una maschera con questi modi

[asteroid]

ho provato ad implementare il codice in C, ma non riesco a visualizzare i bit meno significativi e la maschera che mi sono creata con gli operatori bitwise

#include <stdio.h>
#include <stdlib.h>
#define n_len 16
void bit_short(short n, unsigned char bit[n_len]);
void estrai_bit(unsigned char bit[n_len], short A, short k);
int main()
{
  short A,k;
  unsigned char bit[n_len];
  printf("numero:"); scanf("%d",&A);
  bit_short(A,bit);
  printf("in binario:");
  for(k=0; k<n_len; k++)
  (k%4==0) ? printf(" %1u",bit[k]): printf("%1u",bit[k]);
  printf("\n");
  printf("quanti bit meno significativi vuoi estrarre?  :");
  scanf("%d",&k);
  printf("i bit meno significativi: \n");
   estrai_bit(bit,A,k);
   
  system("PAUSE");	
  return 0;
}
void bit_short(short n, unsigned char bit[n_len])
{
     short j;
     j=n_len-1;
     do        {
               bit[j--]=n&1;
               n=n>>1;
               } while(n !=0 && j>=0);
     if(j>=0)
               {
     do        {
               bit[j--]=0;
               } while(j>=0);
               }
}
void estrai_bit(unsigned char bit[n_len],short A, short k)
{ short mask=0;
 short i;
  for(i=1; i>k; i++){
  mask=mask<<1|1;
    bit[i]=A&mask;
    printf("%u\n",bit[i]);
    printf("%d\n",mask);
}
}

[MItaly]

2. Se è una costante te la calcoli da te, basta convertire il numero binario che rappresenta la tua maschera in esadecimale o in decimale e usarlo assieme all'operatore &.
3. Ci sono più modi. Uno molto semplice è:

unsigned int maschera = ~((~0u)<<numero_bit);

• ~0u ottiene un intero senza segno che ha tutti i bit a 1 (parte come tutto zero, quindi ci viene applicato l'operatore not bitwise che lo fa diventare tutto uni);
• al numero così ottenuto viene applicato uno shift verso sinistra di numero_bit; quando si effettua uno shift a sinistra da destra entrano degli zeri, così ora il numero avrà numero_bit zeri a destra, alla cui sinistra ci saranno tutti gli uni;
• al numero in questione viene nuovamente applicato il not binario, che converte gli uni in zeri e viceversa; si ottiene così la maschera desiderata.

Esempio (con numero_bit=4):

0u              0000000000000000
~0u             1111111111111111
~0u<<4          1111111111110000
~((~0u)<<4)     0000000000001111

[asteroid]

Originariamente inviato da MItaly
2. Se è una costante te la calcoli da te, basta convertire il numero binario che rappresenta la tua maschera in esadecimale o in decimale e usarlo assieme all'operatore &.
3. Ci sono più modi. Uno molto semplice è:

unsigned int maschera = ~((~0u)<<numero_bit);

• ~0u ottiene un intero senza segno che ha tutti i bit a 1 (parte come tutto zero, quindi ci viene applicato l'operatore not bitwise che lo fa diventare tutto uni);
• al numero così ottenuto viene applicato uno shift verso sinistra di numero_bit; quando si effettua uno shift a sinistra da destra entrano degli zeri, così ora il numero avrà numero_bit zeri a destra, alla cui sinistra ci saranno tutti gli uni;
• al numero in questione viene nuovamente applicato il not binario, che converte gli uni in zeri e viceversa; si ottiene così la maschera desiderata.

Esempio (con numero_bit=4):

0u              0000000000000000
~0u             1111111111111111
~0u<<4          1111111111110000
~((~0u)<<4)     0000000000001111

mi trovo perfettamente;
thx
------------------------------------------------------------------------------------------


quindi volendo applicare per estrarre bit meno significativi al mio codice

void estrai_bit_meno_sign( short A, short k)
{
    unsigned short mask=~((~0u)<<k);

   A=A&mask;      */ applico & per i bit meno significativi /*
}

poi nel main

printf("quanti bit meno significativi vuoi estrarre?  :");
  scanf("%d",&k);

  printf("i bit meno significativi: ");
   estrai_bit(A,k);
   for(i=0; i<k; i++){
   bit_short(A,bit);
   printf(" %1u",bit[i]);
}

quando vado ad eseguirlo mi restituisce sempre i bit 0

[MItaly]

Da quanto vedo hai modificato estrai_bit_meno_sign ma stai ancora chiamando estrai_bit. Inoltre in estrai_bit_meno_sign vai a modificare il parametro, ma questo è passato per valore (e non per puntatore), quindi le modifiche che fai nella funzione non si ripercuotono all'esterno. Passa A per puntatore, oppure cambia la funzione in modo che restituisca il valore modificato come valore di ritorno.

[asteroid]

si... fa esattamente la stessa cosa

#include <stdio.h>
#include <stdlib.h>
#define n_len 16
void bit_short(short n, unsigned char bit[n_len]);
void estrai_bit_meno_sign( short *A, short k);
int main()
{
  short A,k,i;
  unsigned char bit[n_len];
  printf("numero:"); scanf("%d",&A);
  bit_short(A,bit);
  printf("in binario:");
  for(k=0; k<n_len; k++)
  (k%4==0) ? printf(" %1u",bit[k]): printf("%1u",bit[k]);
  printf("\n");
  printf("quanti bit meno significativi vuoi estrarre?  :");
  scanf("%d",&k);
  printf("i bit meno significativi: ");
   estrai_bit_meno_sign(&A,k);
   for(i=k; i>0; i--)
   {
   bit_short(A,bit);
   printf(" %1u",bit[i]);
}
printf("\n");
  system("PAUSE");	
  return 0;
}
void bit_short(short n, unsigned char bit[n_len])
{
     short j;
     j=n_len-1;
     do        {
               bit[j--]=n&1;
               n=n>>1;
               } while(n !=0 && j>=0);
     if(j>=0)
               {
     do        {
               bit[j--]=0;
               } while(j>=0);
               }
}
void estrai_bit_meno_sign(short *A, short k)
{unsigned short mask=~((~0u)<<k);
   *A=*A&mask;
}

[MItaly]

Ma cos'è che dovrebbe fare quella bit_short?

[asteroid]

la funzione bit_short la utilizzo per generare i bit dello short A che gli passo... infatti nella prima chiamata della funzione bit_short... riesco a visualizzare i bit dello short... poi quando voglio vedere i bit meno significativi, quindi nella seconda chiamata, mi genera i bit 0000...

int main()
{
  short A,k,i;
  unsigned char bit[n_len];
  printf("numero:"); scanf("%d",&A);
  bit_short(&A,bit);                                  <--------------- funziona qui
  printf("in binario:");
  for(k=0; k<n_len; k++)
  (k%4==0) ? printf(" %1u",bit[k]): printf("%1u",bit[k]);

printf("i bit meno significativi: ");
   estrai_bit_meno_sign(&A,k);
   for(i=k; i>0; i--)
   {
   bit_short(&A,bit);                                <-----------------  qui no
   printf("%1u",bit[i]);

[asteroid]

mi genera dei bit sballati tipo se gli metto in input il numero 5 in binario è : 0000 0101
estrai i 4 bit meno significativi...
e il risultato dell' output:
1010

void estrai_bit_meno_sign(short *n, short k,unsigned char bit[n_len])
{unsigned short mask=~((~0u)<<k);
short i;
   i=n_len-1;
     do        {
               bit[--i]=*n&1;
               *n=*n^mask;
               } while(*n !=0 && i>=0);
     if(i>=0)
     {
     do{
            bit[--i]=0;
       }while(i>=0);
       }
       for(i=0; i<k; i++){
   printf("%u",bit[i]);
}
}