Visualizzare la rappresentazione binaria di un numero in C? [duplicare]
-
22-08-2019 - |
Domanda
Eventuali duplicati:
Esiste un convertitore printf per stampare in formato binario?
studente C e mi chiedevo:
Dato un numero, è possibile fare qualcosa di simile a quanto segue?
char a = 5;
printf("binary representation of a = %b",a);
> 101
O avrei dovuto scrivere il mio metodo per fare la trasformazione a binario?
Soluzione
Si (scrivere il proprio), qualcosa come la seguente funzione completa.
#include <stdio.h> /* only needed for the printf() in main(). */
#include <string.h>
/* Create a string of binary digits based on the input value.
Input:
val: value to convert.
buff: buffer to write to must be >= sz+1 chars.
sz: size of buffer.
Returns address of string or NULL if not enough space provided.
*/
static char *binrep (unsigned int val, char *buff, int sz) {
char *pbuff = buff;
/* Must be able to store one character at least. */
if (sz < 1) return NULL;
/* Special case for zero to ensure some output. */
if (val == 0) {
*pbuff++ = '0';
*pbuff = '\0';
return buff;
}
/* Work from the end of the buffer back. */
pbuff += sz;
*pbuff-- = '\0';
/* For each bit (going backwards) store character. */
while (val != 0) {
if (sz-- == 0) return NULL;
*pbuff-- = ((val & 1) == 1) ? '1' : '0';
/* Get next bit. */
val >>= 1;
}
return pbuff+1;
}
Aggiungi il principale al fine di esso per vederlo in funzionamento:
#define SZ 32
int main(int argc, char *argv[]) {
int i;
int n;
char buff[SZ+1];
/* Process all arguments, outputting their binary. */
for (i = 1; i < argc; i++) {
n = atoi (argv[i]);
printf("[%3d] %9d -> %s (from '%s')\n", i, n,
binrep(n,buff,SZ), argv[i]);
}
return 0;
}
Esegui con "progname 0 7 12 52 123"
di ottenere:
[ 1] 0 -> 0 (from '0')
[ 2] 7 -> 111 (from '7')
[ 3] 12 -> 1100 (from '12')
[ 4] 52 -> 110100 (from '52')
[ 5] 123 -> 1111011 (from '123')
Altri suggerimenti
Non v'è alcun modo diretto (vale a dire utilizzando printf
o un'altra funzione di libreria standard) per stamparlo. Si dovrà scrivere la propria funzione.
/* This code has an obvious bug and another non-obvious one :) */
void printbits(unsigned char v) {
for (; v; v >>= 1) putchar('0' + (v & 1));
}
Se stai usando terminale, è possibile utilizzare i codici di controllo per stampare byte in ordine naturale:
void printbits(unsigned char v) {
printf("%*s", (int)ceil(log2(v)) + 1, "");
for (; v; v >>= 1) printf("\x1b[2D%c",'0' + (v & 1));
}
dirkgently , ma fissare i suoi due bug, e sempre la stampa di un numero fisso di cifre:
void printbits(unsigned char v) {
int i; // for C89 compatability
for(i = 7; i >= 0; i--) putchar('0' + ((v >> i) & 1));
}
#include<iostream>
#include<conio.h>
#include<stdlib.h>
using namespace std;
void displayBinary(int n)
{
char bistr[1000];
itoa(n,bistr,2); //2 means binary u can convert n upto base 36
printf("%s",bistr);
}
int main()
{
int n;
cin>>n;
displayBinary(n);
getch();
return 0;
}
Utilizzare una tabella di ricerca, come:
char *table[16] = {"0000", "0001", .... "1111"};
quindi stampare ogni bocconcino come questo
printf("%s%s", table[a / 0x10], table[a % 0x10]);
Sicuramente è possibile utilizzare un solo tavolo, ma sarà leggermente più veloce e troppo grande.
Questo codice dovrebbe gestire le vostre esigenze fino a 64 bit.
char* pBinFill(long int x,char *so, char fillChar); // version with fill
char* pBin(long int x, char *so); // version without fill
#define width 64
char* pBin(long int x,char *so)
{
char s[width+1];
int i=width;
s[i--]=0x00; // terminate string
do
{ // fill in array from right to left
s[i--]=(x & 1) ? '1':'0'; // determine bit
x>>=1; // shift right 1 bit
} while( x > 0);
i++; // point to last valid character
sprintf(so,"%s",s+i); // stick it in the temp string string
return so;
}
char* pBinFill(long int x,char *so, char fillChar)
{ // fill in array from right to left
char s[width+1];
int i=width;
s[i--]=0x00; // terminate string
do
{
s[i--]=(x & 1) ? '1':'0';
x>>=1; // shift right 1 bit
} while( x > 0);
while(i>=0) s[i--]=fillChar; // fill with fillChar
sprintf(so,"%s",s);
return so;
}
void test()
{
char so[width+1]; // working buffer for pBin
long int val=1;
do
{
printf("%ld =\t\t%#lx =\t\t0b%s\n",val,val,pBinFill(val,so,0));
val*=11; // generate test data
} while (val < 100000000);
}
Output:
00000001 = 0x000001 = 0b00000000000000000000000000000001
00000011 = 0x00000b = 0b00000000000000000000000000001011
00000121 = 0x000079 = 0b00000000000000000000000001111001
00001331 = 0x000533 = 0b00000000000000000000010100110011
00014641 = 0x003931 = 0b00000000000000000011100100110001
00161051 = 0x02751b = 0b00000000000000100111010100011011
01771561 = 0x1b0829 = 0b00000000000110110000100000101001
19487171 = 0x12959c3 = 0b00000001001010010101100111000011
Si deve scrivere il proprio trasformazione. Solo decimali, numeri esadecimali e ottale sono supportati con identificatori di formato.
Non v'è alcun identificatore di formato d'acquisto per questo nel linguaggio C. Anche se ho scritto questo frammento di codice python veloce per aiutare a capire il processo passo dopo passo a rotolare il proprio.
#!/usr/bin/python
dec = input("Enter a decimal number to convert: ")
base = 2
solution = ""
while dec >= base:
solution = str(dec%base) + solution
dec = dec/base
if dec > 0:
solution = str(dec) + solution
print solution
ha spiegato:
dec = input ( "Immettere un numero decimale da convertire:") - richiedere all'utente per l'input numerico (ci sono diversi modi per fare questo in C tramite scanf per esempio)
base = 2 - specificare la nostra base è 2 (binario)
soluzione = "" - creare una stringa vuota in cui dovremo concatenare la nostra soluzione
mentre dec> = base: - mentre il nostro numero è più grande rispetto alla base è entrato
soluzione = str (% di base dec) + soluzione - ottenere il modulo del numero alla base, e aggiungerlo al l'inizio della nostra stringa (bisogna aggiungere i numeri da destra a sinistra divisione utilizzando e metodo rimanente). la funzione str () converte il risultato dell'operazione di una stringa. Non è possibile concatenare interi con stringhe in pitone, senza una conversione di tipo.
dec = DEC / basamento - dividere il numero decimale dalla base preparativi di prendere il successivo modulo
se dec> 0: soluzione = str (dec) + soluzione - se qualcosa è rimasto, inserirlo all'inizio (questo sarà 1, se non altro)
soluzione di stampa - stampare il numero finale