masquer le bit le plus significatif

J’ai écrit cette fonction pour supprimer le bit le plus significatif dans chaque octet. Mais cette fonction ne semble pas fonctionner comme je le voulais.

La taille du fichier de sortie est toujours ‘0’, je ne comprends pas pourquoi rien n’a été écrit dans le fichier de sortie. Existe-t-il un moyen plus simple et meilleur de supprimer le bit le plus significatif dans chaque octet?

En ce qui concerne les opérateurs de poste, la section 6.5.7 de la norme C stipule:

Si la valeur de l’opérande de droite est négative ou est supérieure ou égale à la largeur de l’opérande de gauche promu, le comportement n’est pas défini.

Donc, premièrement, supprimez nBuffer << 8; . Même s'il était bien défini, il ne s'agirait pas d'un opérateur d'affectation.

Comme les gens l'ont mentionné, vous feriez mieux d'utiliser CHAR_BIT que 8. Je suis presque certain qu'au lieu de 0x7f vous voulez dire UCHAR_MAX >> 1 et au lieu de 7, vous CHAR_BIT - 1 dire CHAR_BIT - 1 .

Concentrons-nous simplement sur nBuffer et bit_count, ici. Je commenterai tout ce qui n'utilise ni l'un ni l'autre.

  bit_count += 7; if (bit_count == 7*8) { *out_buf++ = nBuffer; /*if((write(out_fd, bit_buf, sizeof(char))) == -1) oops("Cannot write on the file", "");*/ nBuffer << 8; bit_count -= 8; } nBuffer = 0; bit_count = 0; 

A la fin de ce code, quelle est la valeur de nBuffer? Qu'en est-il de bit_count? Quel impact cela aurait-il sur votre deuxième boucle? while (bit_count > 0)

Passons maintenant au code commenté:

  if((write(out_fd, bit_buf, sizeof(char))) == -1) oops("Cannot write on the file", ""); 

Où atsortingbuez-vous une valeur à bit_buf? Utiliser une variable non initialisée est un comportement indéfini.

Au lieu de passer par tous les bits pour trouver le plus haut, cela ne passe que par les 1 bits. high() renvoie le bit haut de l’argument, ou zéro si l’argument est zéro.

 inline int high(int n) { int k; do { k = n ^ (n - 1); n &= ~k; } while (n); return (k + 1) >> 1; } inline int drop_high(int n) { return n ^ high(n); } 
 unsigned char remove_most_significant_bit(unsigned char b) { int bit; for(bit = 0; bit < 8; bit++) { unsigned char mask = (0x80 >> bit); if( mask & b) return b & ~mask; } return b; } void remove_most_significant_bit_from_buffer(unsigned char* b, int length) { int i; for(i=0; i 

Je ne passerai pas en revue toute votre réponse pour fournir votre code retravaillé, mais il est facile de supprimer l’élément le plus important. Cela vient du fait que le bit le plus significatif peut facilement être trouvé en utilisant la base de journal 2 convertie en entier.

 #include  #include  int RemoveMSB(int a) { return a ^ (1 << (int)log2(a)); } int main(int argc, char const *argv[]) { int a = 4387; printf("MSB of %d is %d\n", a, (int)log2(a)); a = RemoveMSB(a); printf("MSB of %d is %d\n", a, (int)log2(a)); return 0; } 

Sortie:

 MSB of 4387 is 12 MSB of 291 is 8 

En tant que tel, 4387 en binary est 1000100100011 avec le bit le plus significatif à 12.

De même, 291 en binary est 0000100100011 avec le bit le plus significatif à 8.