반응형
이진 형식으로 인쇄 할 printf 변환기가 있습니까?
16 진수 또는 8 진수로 printf를 사용하여 인쇄 할 수 있습니다. 바이너리 또는 임의의 기준으로 인쇄 할 형식 태그가 있습니까?
gcc를 실행 중입니다.
printf("%d %x %o\n", 10, 10, 10); //prints "10 A 12\n"
print("%b\n", 10); // prints "%b\n"
해 키지 만 나를 위해 작동합니다.
#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte) \
(byte & 0x80 ? '1' : '0'), \
(byte & 0x40 ? '1' : '0'), \
(byte & 0x20 ? '1' : '0'), \
(byte & 0x10 ? '1' : '0'), \
(byte & 0x08 ? '1' : '0'), \
(byte & 0x04 ? '1' : '0'), \
(byte & 0x02 ? '1' : '0'), \
(byte & 0x01 ? '1' : '0')
printf("Leading text "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(byte));
멀티 바이트 유형의 경우
printf("m: "BYTE_TO_BINARY_PATTERN" "BYTE_TO_BINARY_PATTERN"\n",
BYTE_TO_BINARY(m>>8), BYTE_TO_BINARY(m));
불행히도 모든 여분의 따옴표가 필요합니다. 이 접근법은 매크로의 효율성 위험이 BYTE_TO_BINARY있지만 ( 함수를의 인수로 전달하지 마십시오 ) 여기 다른 제안에서 메모리 문제와 strcat의 여러 호출을 피하십시오.
모든 데이터 유형에 대한 이진 인쇄
//assumes little endian
void printBits(size_t const size, void const * const ptr)
{
unsigned char *b = (unsigned char*) ptr;
unsigned char byte;
int i, j;
for (i=size-1;i>=0;i--)
{
for (j=7;j>=0;j--)
{
byte = (b[i] >> j) & 1;
printf("%u", byte);
}
}
puts("");
}
테스트
int main(int argv, char* argc[])
{
int i = 23;
uint ui = UINT_MAX;
float f = 23.45f;
printBits(sizeof(i), &i);
printBits(sizeof(ui), &ui);
printBits(sizeof(f), &f);
return 0;
}
다음은 원하는 것을 수행하는 기술을 보여주는 빠른 해킹입니다.
#include <stdio.h> /* printf */
#include <string.h> /* strcat */
#include <stdlib.h> /* strtol */
const char *byte_to_binary(int x)
{
static char b[9];
b[0] = '\0';
int z;
for (z = 128; z > 0; z >>= 1)
{
strcat(b, ((x & z) == z) ? "1" : "0");
}
return b;
}
int main(void)
{
{
/* binary string to int */
char *tmp;
char *b = "0101";
printf("%d\n", strtol(b, &tmp, 2));
}
{
/* byte to binary string */
printf("%s\n", byte_to_binary(5));
}
return 0;
}
glibc에는 바이너리 변환 지정자가 없습니다.
glibc의 printf () 함수 계열에 사용자 정의 변환 유형을 추가 할 수 있습니다. 자세한 내용은 register_printf_function 을 참조하십시오. 응용 프로그램 코드를 단순화하여 사용할 수 있도록 사용자 지정 % b 변환을 직접 사용할 수 있습니다.
다음은 glibc에서 사용자 정의 printf 형식을 구현하는 방법 의 예 입니다.
작은 테이블을 사용하여 속도를 향상시킬 수 있습니다 1 . 예를 들어 바이트를 반전시키는 것과 같은 내장 기술에서 비슷한 기술이 유용합니다.
const char *bit_rep[16] = {
[ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
[ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
[ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
[12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};
void print_byte(uint8_t byte)
{
printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
}
1 주로 옵티마이 저가 그리 공격적이지 않고 속도 차이가 보이는 임베디드 응용 프로그램을 말합니다.
최하위 비트를 인쇄하여 오른쪽으로 옮기십시오. 정수가 0이 될 때까지이 작업을 수행하면 이진수 표현이 선행 0없이 역순으로 인쇄됩니다. 재귀를 사용하면 순서를 쉽게 수정할 수 있습니다.
#include <stdio.h>
void print_binary(int number)
{
if (number) {
print_binary(number >> 1);
putc((number & 1) ? '1' : '0', stdout);
}
}
나에게 이것은 문제에 대한 가장 깨끗한 해결책 중 하나입니다. 당신이 좋아하는 경우 0b접두사와 후행 줄 바꿈 문자를, 나는 기능을 포장하는 것이 좋습니다.
@William 와이트의 답변에 따라,이 제공하는 매크로이다 int8, 16, 32및 64재사용 버전 INT8피하기 반복에 매크로를.
/* --- PRINTF_BYTE_TO_BINARY macro's --- */
#define PRINTF_BINARY_PATTERN_INT8 "%c%c%c%c%c%c%c%c"
#define PRINTF_BYTE_TO_BINARY_INT8(i) \
(((i) & 0x80ll) ? '1' : '0'), \
(((i) & 0x40ll) ? '1' : '0'), \
(((i) & 0x20ll) ? '1' : '0'), \
(((i) & 0x10ll) ? '1' : '0'), \
(((i) & 0x08ll) ? '1' : '0'), \
(((i) & 0x04ll) ? '1' : '0'), \
(((i) & 0x02ll) ? '1' : '0'), \
(((i) & 0x01ll) ? '1' : '0')
#define PRINTF_BINARY_PATTERN_INT16 \
PRINTF_BINARY_PATTERN_INT8 PRINTF_BINARY_PATTERN_INT8
#define PRINTF_BYTE_TO_BINARY_INT16(i) \
PRINTF_BYTE_TO_BINARY_INT8((i) >> 8), PRINTF_BYTE_TO_BINARY_INT8(i)
#define PRINTF_BINARY_PATTERN_INT32 \
PRINTF_BINARY_PATTERN_INT16 PRINTF_BINARY_PATTERN_INT16
#define PRINTF_BYTE_TO_BINARY_INT32(i) \
PRINTF_BYTE_TO_BINARY_INT16((i) >> 16), PRINTF_BYTE_TO_BINARY_INT16(i)
#define PRINTF_BINARY_PATTERN_INT64 \
PRINTF_BINARY_PATTERN_INT32 PRINTF_BINARY_PATTERN_INT32
#define PRINTF_BYTE_TO_BINARY_INT64(i) \
PRINTF_BYTE_TO_BINARY_INT32((i) >> 32), PRINTF_BYTE_TO_BINARY_INT32(i)
/* --- end macros --- */
#include <stdio.h>
int main() {
long long int flag = 1648646756487983144ll;
printf("My Flag "
PRINTF_BINARY_PATTERN_INT64 "\n",
PRINTF_BYTE_TO_BINARY_INT64(flag));
return 0;
}
이 결과는 다음과 같습니다.
My Flag 0001011011100001001010110111110101111000100100001111000000101000
가독성을 위해 다음과 같은 구분 기호를 추가 할 수 있습니다.
My Flag 00010110,11100001,00101011,01111101,01111000,10010000,11110000,00101000
다음은 재진입 문제 나 인수의 크기 / 유형에 대한 제한이없는 함수 버전입니다.
#define FMT_BUF_SIZE (CHAR_BIT*sizeof(uintmax_t)+1)
char *binary_fmt(uintmax_t x, char buf[static FMT_BUF_SIZE])
{
char *s = buf + FMT_BUF_SIZE;
*--s = 0;
if (!x) *--s = '0';
for(; x; x/=2) *--s = '0' + x%2;
return s;
}
이 코드는 2를 원하는베이스로 바꾸면 2에서 10 사이의 모든베이스에 대해서도 잘 작동합니다. 사용법은 :
char tmp[FMT_BUF_SIZE];
printf("%s\n", binary_fmt(x, tmp));
x완전한 표현은 어디에 있습니까 ?
const char* byte_to_binary( int x )
{
static char b[sizeof(int)*8+1] = {0};
int y;
long long z;
for (z=1LL<<sizeof(int)*8-1,y=0; z>0; z>>=1,y++)
{
b[y] = ( ((x & z) == z) ? '1' : '0');
}
b[y] = 0;
return b;
}
이전에 게시 된 답변 중 어느 것도 내가 찾던 것이 아니므로 하나를 썼습니다. 와 함께 % B를 사용하는 것은 매우 간단합니다 printf!
/*
* File: main.c
* Author: Techplex.Engineer
*
* Created on February 14, 2012, 9:16 PM
*/
#include <stdio.h>
#include <stdlib.h>
#include <printf.h>
#include <math.h>
#include <string.h>
static int printf_arginfo_M(const struct printf_info *info, size_t n, int *argtypes) {
/* "%M" always takes one argument, a pointer to uint8_t[6]. */
if (n > 0) {
argtypes[0] = PA_POINTER;
}
return 1;
} /* printf_arginfo_M */
static int printf_output_M(FILE *stream, const struct printf_info *info, const void *const *args) {
int value = 0;
int len;
value = *(int **) (args[0]);
//Beginning of my code ------------------------------------------------------------
char buffer [50] = ""; //Is this bad?
char buffer2 [50] = ""; //Is this bad?
int bits = info->width;
if (bits <= 0)
bits = 8; // Default to 8 bits
int mask = pow(2, bits - 1);
while (mask > 0) {
sprintf(buffer, "%s", (((value & mask) > 0) ? "1" : "0"));
strcat(buffer2, buffer);
mask >>= 1;
}
strcat(buffer2, "\n");
// End of my code --------------------------------------------------------------
len = fprintf(stream, "%s", buffer2);
return len;
} /* printf_output_M */
int main(int argc, char** argv) {
register_printf_specifier('B', printf_output_M, printf_arginfo_M);
printf("%4B\n", 65);
return (EXIT_SUCCESS);
}
표준이 아니지만 일부 런타임은 "% b"을 (를) 지원합니다.
흥미로운 토론을 보려면 여기를 참조하십시오.
http://bytes.com/forum/thread591027.html
HTH
이 코드는 최대 64 비트의 요구를 처리해야합니다. pBin & pBinFill이라는 2 개의 함수를 만들었습니다. 둘 다 동일한 작업을 수행하지만 pBinFill은 선행 공백을 fillChar로 채 웁니다. 테스트 기능은 일부 테스트 데이터를 생성 한 다음이 기능을 사용하여 인쇄합니다.
char* pBinFill(long int x,char *so, char fillChar); // version with fill
char* pBin(long int x, char *so); // version without fill
#define kDisplayWidth 64
char* pBin(long int x,char *so)
{
char s[kDisplayWidth+1];
int i=kDisplayWidth;
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[kDisplayWidth+1];
int i=kDisplayWidth;
s[i--]=0x00; // terminate string
do
{ // fill in array from right to left
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[kDisplayWidth+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
이진 형식으로 인쇄 할 printf 변환기가 있습니까?
그만큼 printf() 제품군은 표준 지정자를 사용하여 8, 10 및 16 기반으로 만 인쇄 할 수 있습니다. 코드의 특정 요구에 따라 숫자를 문자열로 변환하는 함수를 만드는 것이 좋습니다.
베이스에 인쇄하려면 [2-36]
지금까지 다른 모든 답변에는 이러한 제한 중 하나 이상이 있습니다.
리턴 버퍼에 정적 메모리를 사용하십시오. 이것은 함수가에 대한 인수로 사용될 수있는 횟수를 제한합니다
printf().포인터를 비우려면 호출 코드가 필요한 메모리를 할당하십시오.
적절한 버퍼를 명시 적으로 제공하려면 호출 코드가 필요합니다.
printf()직접 전화하십시오 . 이것은을위한 새로운 기능 의무화fprintf(),sprintf(),vsprintf(), 등감소 된 정수 범위를 사용하십시오.
다음은 위의 제한이 없습니다 . C99 이상이 필요합니다 "%s". 이것은 사용하는 화합물 리터럴 버퍼 공간을 제공 할 수있다. 의 여러 통화에 문제가 없습니다 printf().
#include <assert.h>
#include <limits.h>
#define TO_BASE_N (sizeof(unsigned)*CHAR_BIT + 1)
// v. compound literal .v
#define TO_BASE(x, b) my_to_base((char [TO_BASE_N]){""}, (x), (b))
// Tailor the details of the conversion function as needed
// This one does not display unneeded leading zeros
// Use return value, not `buf`
char *my_to_base(char *buf, unsigned i, int base) {
assert(base >= 2 && base <= 36);
char *s = &buf[TO_BASE_N - 1];
*s = '\0';
do {
s--;
*s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i % base];
i /= base;
} while (i);
// Could employ memmove here to move the used buffer to the beginning
return s;
}
#include <stdio.h>
int main(void) {
int ip1 = 0x01020304;
int ip2 = 0x05060708;
printf("%s %s\n", TO_BASE(ip1, 16), TO_BASE(ip2, 16));
printf("%s %s\n", TO_BASE(ip1, 2), TO_BASE(ip2, 2));
puts(TO_BASE(ip1, 8));
puts(TO_BASE(ip1, 36));
return 0;
}
산출
1020304 5060708
1000000100000001100000100 101000001100000011100001000
100401404
A2F44
약간 OT 일 수도 있지만 수행중인 바이너리 작업을 이해하거나 추적하기 위해 디버깅에만 필요하다면 wcalc (간단한 콘솔 계산기)를 살펴볼 수 있습니다. -b 옵션을 사용하면 이진 출력이 나타납니다.
예 :
$ wcalc -b "(256 | 3) & 0xff" = 0b11
C 표준 라이브러리에는 바이너리를 출력하는 서식 기능이 없습니다. printf 제품군이 지원하는 모든 형식 작업은 사람이 읽을 수있는 텍스트를 대상으로합니다.
다음과 같은 재귀 함수가 유용 할 수 있습니다.
void bin(int n)
{
/* Step 1 */
if (n > 1)
bin(n/2);
/* Step 2 */
printf("%d", n % 2);
}
크기와 C ++에 대한 최고의 솔루션을 최적화 하고이 솔루션에 도달했습니다.
inline std::string format_binary(unsigned int x)
{
static char b[33];
b[32] = '\0';
for (int z = 0; z < 32; z++) {
b[31-z] = ((x>>z) & 0x1) ? '1' : '0';
}
return b;
}
void
print_binary(unsigned int n)
{
unsigned int mask = 0;
/* this grotesque hack creates a bit pattern 1000... */
/* regardless of the size of an unsigned int */
mask = ~mask ^ (~mask >> 1);
for(; mask != 0; mask >>= 1) {
putchar((n & mask) ? '1' : '0');
}
}
paniq의 코드가 마음에 들었습니다. 정적 버퍼는 좋은 생각입니다. 그러나 단일 printf ()에서 여러 이진 형식을 원할 경우 항상 동일한 포인터를 반환하고 배열을 덮어 쓰므로 실패합니다.
다음은 스플릿 버퍼에서 포인터를 회전시키는 C 스타일 드롭 인입니다.
char *
format_binary(unsigned int x)
{
#define MAXLEN 8 // width of output format
#define MAXCNT 4 // count per printf statement
static char fmtbuf[(MAXLEN+1)*MAXCNT];
static int count = 0;
char *b;
count = count % MAXCNT + 1;
b = &fmtbuf[(MAXLEN+1)*count];
b[MAXLEN] = '\0';
for (int z = 0; z < MAXLEN; z++) { b[MAXLEN-1-z] = ((x>>z) & 0x1) ? '1' : '0'; }
return b;
}
표준적이고 휴대용 방식이 없습니다.
일부 구현은 itoa ()를 제공 하지만 대부분은 아니고 다소 거친 인터페이스를 가지고 있습니다. 그러나 코드는 링크 뒤에 있으며 자체 포맷터를 매우 쉽게 구현할 수 있어야합니다.
적은 코드와 리소스를 사용하여 모든 유형의 비트 인쇄
이 접근 방식은 다음과 같은 특성을 갖습니다.
- 변수 및 리터럴과 함께 작동합니다.
- 필요하지 않은 경우 모든 비트를 반복하지 않습니다.
- 바이트를 완료 할 때만 printf를 호출하십시오 (모든 비트에 대해 불필요하지는 않음).
- 모든 유형에 적용됩니다.
- 작고 큰 엔디안으로 작동합니다 (확인을 위해 GCC #defines 사용).
- C 표준은 아니지만 크게 정의 된 typeof ()를 사용합니다.
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define for_endian(size) for (int i = 0; i < size; ++i)
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define for_endian(size) for (int i = size - 1; i >= 0; --i)
#else
#error "Endianness not detected"
#endif
#define printb(value) \
({ \
typeof(value) _v = value; \
__printb((typeof(_v) *) &_v, sizeof(_v)); \
})
void __printb(void *value, size_t size)
{
uint8_t byte;
size_t blen = sizeof(byte) * 8;
uint8_t bits[blen + 1];
bits[blen] = '\0';
for_endian(size) {
byte = ((uint8_t *) value)[i];
memset(bits, '0', blen);
for (int j = 0; byte && j < blen; ++j) {
if (byte & 0x80)
bits[j] = '1';
byte <<= 1;
}
printf("%s ", bits);
}
printf("\n");
}
int main(void)
{
uint8_t c1 = 0xff, c2 = 0x44;
uint8_t c3 = c1 + c2;
printb(c1);
printb((char) 0xff);
printb((short) 0xff);
printb(0xff);
printb(c2);
printb(0x44);
printb(0x4411ff01);
printb((uint16_t) c3);
printf("\n");
return 0;
}
산출
$ ./printb
11111111
11111111
00000000 11111111
00000000 00000000 00000000 11111111
01000100
00000000 00000000 00000000 01000100
01000100 00010001 11111111 00000001
00000000 01000011
내가 사용한 또 다른 접근 방식 ( bitprint.h을 (비트 문자열로) 모든 바이트있는 테이블을 작성하고 입력 / 인덱스 바이트에 기반을 인쇄). 살펴볼 가치가 있습니다.
내 해결책 :
long unsigned int i;
for(i = 0u; i < sizeof(integer) * CHAR_BIT; i++) {
if(integer & LONG_MIN)
printf("1");
else
printf("0");
integer <<= 1;
}
printf("\n");
그의 대답에 @ ideasman42의 제안을 바탕으로,이 제공하는 매크로이다 int8, 16, 32및 64재사용 버전 INT8피하기 반복에 매크로를.
/* --- PRINTF_BYTE_TO_BINARY macro's --- */
#define PRINTF_BINARY_SEPARATOR
#define PRINTF_BINARY_PATTERN_INT8 "%c%c%c%c%c%c%c%c"
#define PRINTF_BYTE_TO_BINARY_INT8(i) \
(((i) & 0x80ll) ? '1' : '0'), \
(((i) & 0x40ll) ? '1' : '0'), \
(((i) & 0x20ll) ? '1' : '0'), \
(((i) & 0x10ll) ? '1' : '0'), \
(((i) & 0x08ll) ? '1' : '0'), \
(((i) & 0x04ll) ? '1' : '0'), \
(((i) & 0x02ll) ? '1' : '0'), \
(((i) & 0x01ll) ? '1' : '0')
#define PRINTF_BINARY_PATTERN_INT16 \
PRINTF_BINARY_PATTERN_INT8 PRINTF_BINARY_SEPARATOR PRINTF_BINARY_PATTERN_INT8
#define PRINTF_BYTE_TO_BINARY_INT16(i) \
PRINTF_BYTE_TO_BINARY_INT8((i) >> 8), PRINTF_BYTE_TO_BINARY_INT8(i)
#define PRINTF_BINARY_PATTERN_INT32 \
PRINTF_BINARY_PATTERN_INT16 PRINTF_BINARY_SEPARATOR PRINTF_BINARY_PATTERN_INT16
#define PRINTF_BYTE_TO_BINARY_INT32(i) \
PRINTF_BYTE_TO_BINARY_INT16((i) >> 16), PRINTF_BYTE_TO_BINARY_INT16(i)
#define PRINTF_BINARY_PATTERN_INT64 \
PRINTF_BINARY_PATTERN_INT32 PRINTF_BINARY_SEPARATOR PRINTF_BINARY_PATTERN_INT32
#define PRINTF_BYTE_TO_BINARY_INT64(i) \
PRINTF_BYTE_TO_BINARY_INT32((i) >> 32), PRINTF_BYTE_TO_BINARY_INT32(i)
/* --- end macros --- */
#include <stdio.h>
int main() {
long long int flag = 1648646756487983144ll;
printf("My Flag "
PRINTF_BINARY_PATTERN_INT64 "\n",
PRINTF_BYTE_TO_BINARY_INT64(flag));
return 0;
}
이 결과는 다음과 같습니다.
My Flag 0001011011100001001010110111110101111000100100001111000000101000
가독성을 위해 변경할 수 있습니다 #define PRINTF_BINARY_SEPARATOR에 #define PRINTF_BINARY_SEPARATOR ","나#define PRINTF_BINARY_SEPARATOR " "
출력됩니다 :
My Flag 00010110,11100001,00101011,01111101,01111000,10010000,11110000,00101000
또는
My Flag 00010110 11100001 00101011 01111101 01111000 10010000 11110000 00101000
void print_ulong_bin(const unsigned long * const var, int bits) {
int i;
#if defined(__LP64__) || defined(_LP64)
if( (bits > 64) || (bits <= 0) )
#else
if( (bits > 32) || (bits <= 0) )
#endif
return;
for(i = 0; i < bits; i++) {
printf("%lu", (*var >> (bits - 1 - i)) & 0x01);
}
}
작동해야합니다-테스트되지 않았습니다.
/* Convert an int to it's binary representation */
char *int2bin(int num, int pad)
{
char *str = malloc(sizeof(char) * (pad+1));
if (str) {
str[pad]='\0';
while (--pad>=0) {
str[pad] = num & 1 ? '1' : '0';
num >>= 1;
}
} else {
return "";
}
return str;
}
/* example usage */
printf("The number 5 in binary is %s", int2bin(5, 4));
/* "The number 5 in binary is 0101" */
다음은 메모리 레이아웃을 보여줍니다.
#include <limits>
#include <iostream>
#include <string>
using namespace std;
template<class T> string binary_text(T dec, string byte_separator = " ") {
char* pch = (char*)&dec;
string res;
for (int i = 0; i < sizeof(T); i++) {
for (int j = 1; j < 8; j++) {
res.append(pch[i] & 1 ? "1" : "0");
pch[i] /= 2;
}
res.append(byte_separator);
}
return res;
}
int main() {
cout << binary_text(5) << endl;
cout << binary_text(.1) << endl;
return 0;
}
다음은 템플릿을 사용하여 32 비트 및 64 비트 정수를 인쇄 할 수 있는 paniq 솔루션 의 작은 변형입니다 .
template<class T>
inline std::string format_binary(T x)
{
char b[sizeof(T)*8+1] = {0};
for (size_t z = 0; z < sizeof(T)*8; z++)
b[sizeof(T)*8-1-z] = ((x>>z) & 0x1) ? '1' : '0';
return std::string(b);
}
다음과 같이 사용할 수 있습니다.
unsigned int value32 = 0x1e127ad;
printf( " 0x%x: %s\n", value32, format_binary(value32).c_str() );
unsigned long long value64 = 0x2e0b04ce0;
printf( "0x%llx: %s\n", value64, format_binary(value64).c_str() );
결과는 다음과 같습니다.
0x1e127ad: 00000001111000010010011110101101
0x2e0b04ce0: 0000000000000000000000000000001011100000101100000100110011100000
방금 솔루션을 게시하고 싶습니다. 0과 1 바이트 중 하나를 얻는 데 사용되지만이 함수를 몇 번 호출하면 더 큰 데이터 블록에 사용할 수 있습니다. 128 비트 이상의 구조체에 사용합니다. size_t를 입력 매개 변수로 사용하고 인쇄하려는 데이터에 대한 포인터로 사용하도록 수정하여 크기와 무관 할 수도 있습니다. 그러나 그것은 나를 위해 잘 작동합니다.
void print_binary(unsigned char c)
{
unsigned char i1 = (1 << (sizeof(c)*8-1));
for(; i1; i1 >>= 1)
printf("%d",(c&i1)!=0);
}
void get_binary(unsigned char c, unsigned char bin[])
{
unsigned char i1 = (1 << (sizeof(c)*8-1)), i2=0;
for(; i1; i1>>=1, i2++)
bin[i2] = ((c&i1)!=0);
}
서명되지 않은 int에 대해 어떻게했는지
void printb(unsigned int v) {
unsigned int i, s = 1<<((sizeof(v)<<3)-1); // s = only most significant bit at 1
for (i = s; i; i>>=1) printf("%d", v & i || 0 );
}
비트 조작 문제를 해결하면서 C를위한 작은 유틸리티 함수입니다. 이것은 마스크를 사용하여 각 세트 비트를 확인하는 문자열을 넘어갑니다 (1 <
void
printStringAsBinary(char * input)
{
char * temp = input;
int i = 7, j =0;;
int inputLen = strlen(input);
/* Go over the string, check first bit..bit by bit and print 1 or 0
**/
for (j = 0; j < inputLen; j++) {
printf("\n");
while (i>=0) {
if (*temp & (1 << i)) {
printf("1");
} else {
printf("0");
}
i--;
}
temp = temp+1;
i = 7;
printf("\n");
}
}
참고 URL : https://stackoverflow.com/questions/111928/is-there-a-printf-converter-to-print-in-binary-format
반응형
'development' 카테고리의 다른 글
| Synchronized Block 대신 Synchronized Method를 사용하는 것이 유리합니까? (0) | 2020.02.22 |
|---|---|
| typescript 오류 TS2304 : 이름 'require'를 찾을 수 없습니다 (0) | 2020.02.22 |
| matplotlib에서 x 또는 y 축의 "틱 주파수"를 변경 하시겠습니까? (0) | 2020.02.22 |
| C #에서 Dictionary에 저장된 값을 업데이트하는 방법은 무엇입니까? (0) | 2020.02.22 |
| 입력 유형 = "텍스트"에서 입력시 변경 사항을 추적하는 가장 좋은 방법은 무엇입니까? (0) | 2020.02.22 |