c를 사용하여 이진 표현에서 int를 인쇄합니다
https://stackoverflow.com/questions/1024389
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
int의 이진 표현을 인쇄 할 수있는 함수를 찾고 있습니다. 내가 지금까지 가지고있는 것은;
char *int2bin(int a)
{
char *str,*tmp;
int cnt = 31;
str = (char *) malloc(33); /*32 + 1 , because its a 32 bit bin number*/
tmp = str;
while ( cnt > -1 ){
str[cnt]= '0';
cnt --;
}
cnt = 31;
while (a > 0){
if (a%2==1){
str[cnt] = '1';
}
cnt--;
a = a/2 ;
}
return tmp;
}
하지만 내가 전화 할 때
printf("a %s",int2bin(aMask)) // aMask = 0xFF000000
나는 같은 출력을 얻는다;
00000000000000000000000000000000000000xpyy (및 알 수없는 문자.
함수의 결함입니까, 아니면 캐릭터 배열의 주소를 인쇄하고 있습니까? 죄송합니다. 내가 어디에서 잘못 될지 알 수 없습니다.
NB 코드는 왔습니다 여기
편집 : 그것은 숙제가 아니며, 다른 사람의 이미지 조작 루틴을 익숙하지 않은 언어로 디버깅하려고합니다. 그러나 그것이 기본 개념이기 때문에 숙제로 태그가 붙어 있다면 공정한 플레이.
해결책
할당 된 버퍼를 통과하는 곳에서 더 최적화 된 또 다른 옵션이 있습니다. 올바른 크기인지 확인하십시오.
// buffer must have length >= sizeof(int) + 1
// Write to the buffer backwards so that the binary representation
// is in the correct order i.e. the LSB is on the far right
// instead of the far left of the printed string
char *int2bin(int a, char *buffer, int buf_size) {
buffer += (buf_size - 1);
for (int i = 31; i >= 0; i--) {
*buffer-- = (a & 1) + '0';
a >>= 1;
}
return buffer;
}
#define BUF_SIZE 33
int main() {
char buffer[BUF_SIZE];
buffer[BUF_SIZE - 1] = '\0';
int2bin(0xFF000000, buffer, BUF_SIZE - 1);
printf("a = %s", buffer);
}
다른 팁
몇 가지 제안 :
- 끈으로 문자열을 종료하십시오
- 마법 번호를 사용하지 마십시오
- 반환 값을 확인하십시오
malloc() - 반환 값을 캐스트하지 마십시오
malloc() - 이진 표현에 관심이 있으므로 산술 대신 이진 작업을 사용하십시오.
- 두 번 반복 할 필요가 없습니다
코드는 다음과 같습니다.
#include <stdlib.h>
#include <limits.h>
char * int2bin(int i)
{
size_t bits = sizeof(int) * CHAR_BIT;
char * str = malloc(bits + 1);
if(!str) return NULL;
str[bits] = 0;
// type punning because signed shift is implementation-defined
unsigned u = *(unsigned *)&i;
for(; bits--; u >>= 1)
str[bits] = u & 1 ? '1' : '0';
return str;
}
문자열은 무효가 끝나지 않습니다. 추가하십시오 '\0' 문자열 끝에있는 캐릭터; 또는 할당 할 수 있습니다 calloc 대신에 malloc, 이것은 당신에게 반환되는 메모리를 제로화 할 것입니다.
그건 그렇고,이 코드에는 다른 문제가 있습니다.
- 사용 된대로 메모리를 호출 할 때 메모리를 할당하여 발신자가 책임을 져야합니다.
free()할당 된 문자열을 ing. 당신이 그냥 호출하면 메모리가 누출됩니다.printf전화. - 그것은 숫자를 두 번 통과시켜 불필요합니다. 한 번의 루프로 모든 것을 할 수 있습니다.
다음은 사용할 수있는 대체 구현이 있습니다.
#include <stdlib.h>
#include <limits.h>
char *int2bin(unsigned n, char *buf)
{
#define BITS (sizeof(n) * CHAR_BIT)
static char static_buf[BITS + 1];
int i;
if (buf == NULL)
buf = static_buf;
for (i = BITS - 1; i >= 0; --i) {
buf[i] = (n & 1) ? '1' : '0';
n >>= 1;
}
buf[BITS] = '\0';
return buf;
#undef BITS
}
용법:
printf("%s\n", int2bin(0xFF00000000, NULL));
두 번째 매개 변수는 결과 문자열을 저장하려는 버퍼에 대한 포인터입니다. 버퍼가 없으면 전달할 수 있습니다. NULL 그리고 int2bin a static 버퍼링하고 그것을 당신에게 반환하십시오. 원래 구현에 비해 이것의 장점은 발신자가 걱정할 필요가 없다는 것입니다. free()반환되는 문자열.
단점은 하나의 정적 버퍼 만 있으므로 후속 통화가 이전 호출의 결과를 덮어 쓰는 것입니다. 나중에 사용하기 위해 여러 번의 전화에서 결과를 저장할 수 없습니다. 또한, 그것은 threadSafe가 아닙니다. 즉, 다른 스레드 에서이 기능을 이런 방식으로 호출하면 서로의 문자열을 깎을 수 있습니다. 가능성이 있다면 통과하는 대신 자신의 버퍼를 전달해야합니다. NULL, 그렇게 :
char str[33];
int2bin(0xDEADBEEF, str);
puts(str);
다음은 간단한 알고리즘입니다.
void decimalToBinary (int num) {
//Initialize mask
unsigned int mask = 0x80000000;
size_t bits = sizeof(num) * CHAR_BIT;
for (int count = 0 ;count < bits; count++) {
//print
(mask & num ) ? cout <<"1" : cout <<"0";
//shift one to the right
mask = mask >> 1;
}
}
이것은 내가 interger를 4 비트마다 분리 된 Binairy 코드로 표시하기 위해 만든 것입니다.
int getal = 32; /** To determain the value of a bit 2^i , intergers are 32bits long**/
int binairy[getal]; /** A interger array to put the bits in **/
int i; /** Used in the for loop **/
for(i = 0; i < 32; i++)
{
binairy[i] = (integer >> (getal - i) - 1) & 1;
}
int a , counter = 0;
for(a = 0;a<32;a++)
{
if (counter == 4)
{
counter = 0;
printf(" ");
}
printf("%i", binairy[a]);
teller++;
}
조금 클 수 있지만 모든 사람이 무슨 일이 일어나고 있는지 이해할 수있는 방식으로 항상 글을 씁니다. 이것이 도움이 되었기를 바랍니다.
#include<stdio.h>
//#include<conio.h> // use this if you are running your code in visual c++, linux don't
// have this library. i have used it for getch() to hold the screen for input char.
void showbits(int);
int main()
{
int no;
printf("\nEnter number to convert in binary\n");
scanf("%d",&no);
showbits(no);
// getch(); // used to hold screen...
// keep code as it is if using gcc. if using windows uncomment #include & getch()
return 0;
}
void showbits(int n)
{
int i,k,andmask;
for(i=15;i>=0;i--)
{
andmask = 1 << i;
k = n & andmask;
k == 0 ? printf("0") : printf("1");
}
}
두가지:
- NUL 캐릭터는 어디에 넣습니까? 나는 어디에있는 곳을 볼 수 없다
'\0'설정되었습니다. - int가 서명되고 0xff000000은 음수 값으로 해석됩니다. 그래서
while (a > 0)즉시 거짓이됩니다.
따로 : 내부의 malloc 기능은 추악합니다. int2bin에 버퍼를 제공하는 것은 어떻습니까?
몇 가지 :
int f = 32;
int i = 1;
do{
str[--f] = i^a?'1':'0';
}while(i<<1);
- 플랫폼 의존적이지만 위의 아이디어가 시작됩니다.
- Memset (Str, 0, 33)을 사용하여 전체 숯 배열을 0으로 설정하지 않겠습니까?
- 자유를 잊지 마세요 () !!! 기능 호출 후 char* 배열!
코딩 된 두 가지 간단한 버전 여기 (가벼운 개혁으로 재현).
#include <stdio.h>
/* Print n as a binary number */
void printbitssimple(int n)
{
unsigned int i;
i = 1<<(sizeof(n) * 8 - 1);
while (i > 0)
{
if (n & i)
printf("1");
else
printf("0");
i >>= 1;
}
}
/* Print n as a binary number */
void printbits(int n)
{
unsigned int i, step;
if (0 == n) /* For simplicity's sake, I treat 0 as a special case*/
{
printf("0000");
return;
}
i = 1<<(sizeof(n) * 8 - 1);
step = -1; /* Only print the relevant digits */
step >>= 4; /* In groups of 4 */
while (step >= n)
{
i >>= 4;
step >>= 4;
}
/* At this point, i is the smallest power of two larger or equal to n */
while (i > 0)
{
if (n & i)
printf("1");
else
printf("0");
i >>= 1;
}
}
int main(int argc, char *argv[])
{
int i;
for (i = 0; i < 32; ++i)
{
printf("%d = ", i);
//printbitssimple(i);
printbits(i);
printf("\n");
}
return 0;
}
// 이것은 선생님이 우리에게 이것을 요청했을 때 내가 한 일입니다.
int main (int argc, char *argv[]) {
int number, i, size, mask; // our input,the counter,sizeofint,out mask
size = sizeof(int);
mask = 1<<(size*8-1);
printf("Enter integer: ");
scanf("%d", &number);
printf("Integer is :\t%d 0x%X\n", number, number);
printf("Bin format :\t");
for(i=0 ; i<size*8 ;++i ) {
if ((i % 4 == 0) && (i != 0)) {
printf(" ");
}
printf("%u",number&mask ? 1 : 0);
number = number<<1;
}
printf("\n");
return (0);
}
이 작업을 수행하는 가장 간단한 방법 (8BIT 표현의 경우) :
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
char *intToBinary(int z, int bit_length){
int div;
int counter = 0;
int counter_length = (int)pow(2, bit_length);
char *bin_str = calloc(bit_length, sizeof(char));
for (int i=counter_length; i > 1; i=i/2, counter++) {
div = z % i;
div = div / (i / 2);
sprintf(&bin_str[counter], "%i", div);
}
return bin_str;
}
int main(int argc, const char * argv[]) {
for (int i = 0; i < 256; i++) {
printf("%s\n", intToBinary(i, 8)); //8bit but you could do 16 bit as well
}
return 0;
}
다음은 char *가 필요하지 않은 다른 솔루션입니다.
#include <stdio.h>
#include <stdlib.h>
void print_int(int i)
{
int j = -1;
while (++j < 32)
putchar(i & (1 << j) ? '1' : '0');
putchar('\n');
}
int main(void)
{
int i = -1;
while (i < 6)
print_int(i++);
return (0);
}
또는 더 많은 가독성을 위해 여기 :
#define GRN "\x1B[32;1m"
#define NRM "\x1B[0m"
void print_int(int i)
{
int j = -1;
while (++j < 32)
{
if (i & (1 << j))
printf(GRN "1");
else
printf(NRM "0");
}
putchar('\n');
}
그리고 다음은 출력이 있습니다.
11111111111111111111111111111111
00000000000000000000000000000000
10000000000000000000000000000000
01000000000000000000000000000000
11000000000000000000000000000000
00100000000000000000000000000000
10100000000000000000000000000000
#include <stdio.h>
#define BITS_SIZE 8
void
int2Bin ( int a )
{
int i = BITS_SIZE - 1;
/*
* Tests each bit and prints; starts with
* the MSB
*/
for ( i; i >= 0; i-- )
{
( a & 1 << i ) ? printf ( "1" ) : printf ( "0" );
}
return;
}
int
main ()
{
int d = 5;
printf ( "Decinal: %d\n", d );
printf ( "Binary: " );
int2Bin ( d );
printf ( "\n" );
return 0;
}
그렇게 우아하지는 않지만 목표를 달성하고 이해하기 쉽습니다.
#include<stdio.h>
int binario(int x, int bits)
{
int matriz[bits];
int resto=0,i=0;
float rest =0.0 ;
for(int i=0;i<8;i++)
{
resto = x/2;
rest = x%2;
x = resto;
if (rest>0)
{
matriz[i]=1;
}
else matriz[i]=0;
}
for(int j=bits-1;j>=0;j--)
{
printf("%d",matriz[j]);
}
printf("\n");
}
int main()
{
int num,bits;
bits = 8;
for (int i = 0; i < 256; i++)
{
num = binario(i,bits);
}
return 0;
}
여기 내 해결책이 있습니다. 그것은 가장 왼쪽에서 모든 0과 1에서 시작하는 마스크를 생성하고, 추정 32 비트 정수. 비트는 현재 마스크 된 정수의 값을 부울 값으로 변환하여 순차적으로 인쇄됩니다.
void printBits(int val){
for(unsigned int mask = 0x80000000; mask; mask >>= 1){
printf("%d", !!(mask & val));
}
}
#include <stdio.h>
int main(void) {
int a,i,k=1;
int arr[32]; \\ taken an array of size 32
for(i=0;i <32;i++)
{
arr[i] = 0; \\initialised array elements to zero
}
printf("enter a number\n");
scanf("%d",&a); \\get input from the user
for(i = 0;i < 32 ;i++)
{
if(a&k) \\bit wise and operation
{
arr[i]=1;
}
else
{
arr[i]=0;
}
k = k<<1; \\left shift by one place evry time
}
for(i = 31 ;i >= 0;i--)
{
printf("%d",arr[i]); \\print the array in reverse
}
return 0;
}
void print_binary(int n) {
if (n == 0 || n ==1)
cout << n;
else {
print_binary(n >> 1);
cout << (n & 0x1);
}
}
제휴하지 않습니다 StackOverflow
