décalge à droite de bits

Bonjour, j'ai une petite question concernant le décalage à droite de bits.

Lorque que l'on décal à droite à droite cela revient à divisé par combien?

Par pow(2, nombre_de_bits) ( x>>2 correspond à x/4).

donc si j'ai bien compris on divise par 2 si on décale d'un bit?

Car j'ai utilisé une fonction permettant de faire ce genre de décalage. Je décale de 8 bits et j'obtiens x/4.

Il y a un problème mais je ne vois pas trop où. Voici la fonction:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
/*!
  \fn int ShiftRightFixedValue(int inp , int nbits, int n)
 
  \brief \~french Cette fonction permet de décaler les bits d'un entier
                  signé de n positions vers la droite (équivalent à inp>>n).
                                  si un entier est au format \f$X(a,b)\f$ on a
                                  \f[ X(a,b)>> = X(a-n,b+n)\f]
 
 \param inp   : \~french Valeur entière signé à décaler vers la droite
 \param nbits : \~french Nombre de bits total décrivant l'entier avec le signe
 \param n     : \~french Nombre de bits du décalage
 
 \return \~french Valeur après décalage
*/
 
int ShiftRightFixedValue(int inp ,int nbits, int n)
{
  static int sign;
  int mask_sign;
  int abs_inp;
  int max;
  int i,j;
 
  max = (1<<(nbits-1))-1;
  if (n>=nbits) {
    printf("Error in ShiftRightFixedValue() : the shift value exceeds the number of digits in the value\n");
	exit(EXIT_FAILURE);
  }	 
  mask_sign=max+1;
  if (((mask_sign & inp)>>(nbits-1))==0) 
      sign = 1; 
  else 
      sign = -1;
 
  abs_inp=(int)(fabs((double)inp));
 
  abs_inp>>=n;
  j=abs_inp*sign;
 
  return (j);
}

DAns mon exemple au départ je suis codé sur 24bits dont 1 bit de signe.
Je veux revenirr sur 16bits avec 1 bit de signe.

Donc

inp : x
nbits : 24
n : 8

Pourquoi sign est-il static ?
Le décalage lors du second if est inutile.
J'ai de gros doutes sur abs_inp.