Problème avec l'inversion de la commande

Question

J'essaie d'imprimer un nombre binaire en c mais le dilemme que j'ai est que c'est l'impression dans l'ordre inverse. J'ai défini une fonction pour me dire combien de bits il y a, de cette façon que je peux travailler à partir du dernier bit arrière

pour obtenir le nième bit je peux utiliser

(value >> totalNumberOfBits) & 1; 

dans une boucle alors que je peux courir jusqu'à ce que le totalNumberOfBits == 0;

en tant que tel

while(totalNumberOfBits!= 0){ 
    putchar(n >> totalNumberOfBits)&1; 
    totalNumberOfBits--; 
} 

tous les pointeurs seraient les bienvenus - je pense que je peux être massivley au large, j'ai une approche qui les imprime nombre bien backw SDRA mais iam essayant de trouver un moyen d'éviter cette

grâce

Answer 1

while (totalNumberOfBits != 0) { 
    putchar(n >> totalNumberOfBits) & 1; 
    totalNumberOfBits--; 
} 

D'accord, vous êtes le code était assez proche (et était en fait déjà l'impression sur les bits dans l'ordre correct), mais il y avait 3 petites erreurs. Tout d'abord, lors de la compilation Visual Studio me donne l'avertissement suivant:

warning C4552: '&' : operator has no effect; expected operator with side-effect 

Il se plaint de la & 1 partie de votre code, que vous semblez avoir accidentellement placé en dehors des parenthèses de votre appel de fonction putchar. La deuxième erreur est que, alors que vous imprimez correctement les bits, vous imprimez les caractères \ 0 et \ 1. \ 0 ne s'affichera pas dans la console, et \ 1 ressemblera très probablement à un smiley, alors réglons-le également.

while (totalNumberOfBits != 0) { 
    putchar(((n >> totalNumberOfBits) & 1) ? '1' : '0'); 
    totalNumberOfBits--; 
} 

Ceci est très proche maintenant, il reste juste une petite erreur. En raison de la vérification de votre boucle while effectue, et l'endroit où vous décrémentez totalNumberOfBits, vous ne vérifiez jamais le bit pour 2^0, alors que vous vérifiez 2^8 même si votre n est seulement 8 bits (et donc hors de portée). Nous passons donc le décrément, et les remplacer par !=:

while (--totalNumberOfBits >= 0) { 
    putchar(((n >> totalNumberOfBits) & 1) ? '1' : '0'); 
} 

Answer 2

Au lieu de décalage à droite, essayez gauche déplacer et se terminent à la taille des mots. Ou utilisez la taille WORD moins le nombre de bits et supprimez ces 0 premiers en premier.

N'oubliez pas de changer le & pour obtenir le bit le plus élevé.

Answer 3

Votre putchar(n >> totalNumberOfBits)&1 est une erreur (remarque où le bon parent est). Votre code actuel génère des valeurs apparemment aléatoires (basées sur les bits 'actuels' et les plus significatifs de votre numéro), et si vous déplacez simplement le bon parent là où vous vouliez le placer, vous écrirez '\0' et '\1' (qui sont null et un autre code de contrôle). Au lieu de cela, vous voulez écrire '0' et '1' (chiffres zéro et un).

C'est une de ces choses mieux représenté par un exemple:

void f() { 
    // hardcode total_bits values for this example 
    // in reality you'd call your function 
    int num = 42; // 101010 in binary 
    for (int total_bits = 6; total_bits;) { 
    putchar("01"[(num >> --total_bits) & 1]); 
    } 

    num = 5; // 101 in binary 
    // loop written verbosely, but does exactly the same: 
    for (int total_bits = 3; total_bits;) { 
    --total_bits; // decrement after condition is checked, before used 
    int bit = (num >> total_bits) & 1; // bit is always 0 or 1 
    char c = "01"[bit]; // c is always '0' or '1' 
    putchar(c); 
    } 
} 

Notez où le décrément est (peut être déplacé si vous voulez, mais pas à la 3ème partie de la boucle — qui changerait l'ordre de calcul), et cette boucle ne gère pas le cas où num est zéro.

Answer 4

static void 
print_binary(int value, int numBits) 
{ 
    /* postfix decrement, so the loop will run numBits times */ 
    while (0 < numBits--) { 

     /* 
     * Since numBits was decremented it now is an index to the next bit from 
     * the left. So, we shift a one to the left that number of bits, do a 
     * bitwise-AND with the value and test whether it is not equal to 0. If 
     * so, print a 1. Otherwise, print a 0! 
     */ 
     putchar((value & (1 << numBits)) ? '1' : '0'); 
    } 
} 

Answer 5

Serait-ce faire, en utilisant la fonction itoa pour convertir le nombre et le stocker dans une mémoire tampon et utiliser la fonction de chaîne reverse personnalisée qui retourne un pointeur vers un char et convertir le pointeur vers un char à un nouveau int en utilisant la fonction atoi. C'est un moyen facile de le faire.

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

#define STRMAX 50 

char *reverse(const char *); 

int main(int argc, char **argv){ 
    static char inpBuf[25]; 
    char *ptr = NULL; 
    int num = 1234; 

    /* Convert num to a string */ 
    itoa(num, inpBuf, 10); 

    /* Reverse the string */ 
    ptr = reverse(inpBuf); 

    /* Convert the reversed string back to num */ 
    num = atoi(ptr); 
    /* num is reversed! i.e. 4321 */ 

    /* Free the pointer */ 
    if (ptr) free(ptr); 
} 

char *reverse(const char* sInput) { 
    char* sOutput; 
    int iCnt = 0, iCntRev; 
    sOutput = (char *)malloc((STRMAX * sizeof(char)) + 1); 
    if (sOutput){ 
     for (iCntRev = strlen(sInput); iCntRev >= 0; iCntRev--) { 
      *sOutput++ = sInput[iCntRev]; 
      iCnt++; 
     } 
     *sOutput++ = '\0'; 
    } 
    return (sOutput - iCnt); 
} 

Hope this helps, Meilleures salutations, Tom.

Answer 6

void printbin (entrée int) { int i; int masque = 0x80000000; // en supposant que 32 nombre entier de bits for (i = 0; i < 32; i ++) { if (masque d'entrée &) putchar ('1') autre putchar ('0'); masque >> = 1; }}