내가 할 수 있는 인쇄하십시오 printf 비호환성의 hex 또는 옥탈칩을 번호입니다. 태그 등 기본 형식 또는 임의 바이너리인 인쇄하려면 있나요?
제가 운영하는 mgcc.
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));
추가 의견 죄송합니다. 모두 필요합니다. 이러한 접근 방식의 위험요소요 효율성을 매크로를 (don& # 39 를 인수로 BYTE_TO_BINARY ',' t 전달 함수) 의 메모리 문제를 피할 수 있지만 일부 기타 제안 및 다중 호출 스트라카트 삽입하십시오.
//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 의 printf 제품군뿐입니다 유형. &Lt 참조 (http://www.gnu.org/software/libc/manual/html_node/Customizing-Printf.html), a href = " " >;; register_printf_function< /A>; 자세한 내용은. 사용자 정의 %b İç 사용할 경우 변환 단축시킵니다 추가할 수 있다, 응용 프로그램 코드를 단순화됩니다 할꺼이나 사용할 수 있습니다.
여기서 a href = " ";;; (http://codingrelic.geekhold.com/2008/12/printf-acular.html) 는 < > example< /a>; 사용자 정의 구현 방법 형식으로 printf glibc.
작은 표를 sup> 1< /sup> speed< 향상시키십시오 사용할 수 있습니다;;;;). 예를 들어, 한 바이트입니다 뒤바꾸려면 포함된 세계 유사한 기술을 유용하게 사용할 수 있습니다.
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]);
}
< sup> 1< /sup>;;; # 39 m, 가지고 있는 i& 주로 임베디드 애플리케이션 및 속도 차이가 꽤 공격적이군 않습니다를 옵티 마이저 가시적입니다.
최하위 비트 및 shift+ctrl 아웃해야 인쇄인쇄 오른쪽에. 그러나 주요 제로 (zero) 가 될 때까지 이렇게 정수 없이 이진 표현을 반전됩니다 주문. 주문을 반복, 사용하여 매우 쉽게 해결할 수 있습니다.
#include <stdio.h>
void print_binary(int number)
{
if (number) {
print_binary(number >> 1);
putc((number & 1) ? '1' : '0', stdout);
}
}
이 문제에 대한 해결책을 다는일은, 깨끗한 중 하나입니다. '새' 와 같은 경우, 나는 줄 문자 함수를 랩할 제안하세요 0b 접두어입니다 뒤를 이었다.
/* --- 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
가독성을 위해 분리자를 eg 에 추가할 수 있습니다.
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 개에서 10 개 사이의 모든 베이스 잘 작동되는 코드를 것처럼 그냥 # 39 에 의해 2& 재장착합니다 경우 필요한 기본. 사용 방법은 다음과 같습니다.
char tmp[FMT_BUF_SIZE];
printf("%s\n", binary_fmt(x, tmp));
여기서 'x' 는 임의의 적분 표현식입니다.
그래서 그 대답이 없음 내가 찾던 바로 그 이전에 게시하기를 작성했습니까 하나. 이는 단순한 사용할 수 있는 '슈퍼 %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);
}
>. 이진 형식으로 printf 변환기 인쇄하려면 있나요?
Printf () 는 '가족' 이 수만 인쇄하려면 기준 8, 10, 그리고 16 사용하여 표준 지정자를 직접. 내가 만드는 제안하세요 변환하는 기능을 필요에 따라, s # 39 명으로 문자열으로 code&.
지금까지 적어도 하나의 다른 모든 답을 이러한 제한이 있다.
정적 메모리 사용 복귀 것을 의미한다. 이 횟수를 제한값 함수 printf () '' 인수로 사용할 수 있습니다.
호출하는 코드를 만들기 위해 필요한 메모리를 할당할 포인터를 가진다.
호출하는 코드를 필요한 적절한 명시적으로 제공하는 것을 의미한다.
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
이 코드는 사용자의 요구를 할 수 있을지 최대 64 비트. 내가 만든 2 총괄하였습니다 멜빈 &. 멜빈필. 하지만 모두 같은 일을 할 수 있는 공간을 멜빈필 업계를 선도하는 칠합니다 필처. 테스트 테스트 데이터를 관심용 함수를 사용하여 아웃해야 생성하는지 일부 기능을 보여준다.
< pre> < code>;;;
멜빈필 (long int * 계속해보게, x, 챨 챨 필처), 챨 // 버전과 칠
멜빈 (long int * x, 챨 그러하매), 챨 버전 채우기 없이 //
멜빈 (long int * x, 챨 그러하매) 챨 { 챨 s [카디스프레이비데스 + 1]; int i = 카디스프레이비데스. s [i -] = 0x10 종료시킵니다 문자열이어야; / / 책임질래 오른쪽에서 왼쪽으로 칠 어레이당 {/ / s [i -] = (x &. 1)? # 39, & # 39 1& # 39 0& :& # 39;;;; 약어입니다 사항결정 // x&, gt, gt, 오른쪽 1 비트 = 1; / / shift+ctrl &. } 낼수있지않나 (x &, gt 0); i++; / / 가리키십시오 마지막 유효함 문자 스프링스프 (,, 그래서 " %s" s+i); 스틱 it 의 임시 구체화하십시오 문자열이어야 // 그래서 반품하십시오. } < /code> < /pre>;;;
< pre> < code>;;;
출력: 00000001 0b00000000000000000000000000000001 0x000001 = = 00000011 0b00000000000000000000000000001011 0x00000b = = 00000121 0b00000000000000000000000001111001 0x000079 = = 00001331 0b00000000000000000000010100110011 0x000533 = = 00014641 0b00000000000000000011100100110001 0x003931 = = 00161051 0b00000000000000100111010100011011 0x02751b = = 01771561 0b00000000000110110000100000101001 0x1b0829 = = 19487171 0b00000001001010010101100111000011 0x12959c3 = = < /code> < /pre>;;;
C 표준 라이브러리에서 출력할 수 있는 것과 같은 바이너리 포맷 기능이 없다. 모든 사람이 읽을 수 있는 텍스트 포맷 작업과 printf 제품군은 향해 있다.
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');
}
}
아니 표준판과 이동형이든지 것입니다.
몇몇 구현들은 제공하십시오 [이토라 ()] (http://en.wikibooks.org/wiki/C_Programming/C_Reference/stdlib.h/itoa), s not going to be 대부분의, 정보기술 (it), 하지만 it& # 39 는 다소 지저분한 인터페이스입니다. 하지만 이 코드는 쉽게 구현할 수 있어 https://partner. İç 포맷터 예쁜 합니다.
내가 좋아했잖아 파니크 의해 코드 정적 버퍼가, 좋습니다. 하지만 실패한 스케쳐내 이진 형식으로 printf () 같은 여러 단일 되돌려줍니다 때문에 항상 포인터입니다 및 덮어씁니다 어레이입니다.
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;
}