web-dev-qa-db-ja.com

Cを使用してintをバイナリ表現で出力します

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

次のような出力が得られます。

0000000000000000000000000000000000xtpYy（および未知の文字の束。

関数の欠陥ですか、それとも文字配列のアドレスなどを印刷していますか？申し訳ありませんが、どこに問題があるのか​​わかりません。

NBコードは here から

編集：それは宿題ではありませんFYI、私は他の誰かの画像操作ルーチンをなじみのない言語でデバッグしようとしています。しかし、それが基本的な概念であるために宿題としてタグ付けされている場合は、フェアプレーです。

cbinaryinteger
23
gav

割り当てられたバッファを渡す場所で、さらに最適化された別のオプションがあります。正しいサイズであることを確認してください。

// 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);
}
30
Adam Markowitz

いくつかの提案：

  • 文字列をヌルで終了
  • マジックナンバーを使用しないでください
  • malloc()の戻り値を確認してください
  • malloc()の戻り値をキャストしないでください
  • バイナリ表現に興味があるので、算術演算の代わりにバイナリ演算を使用します
  • 2回ループする必要はありません

コードは次のとおりです。

#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;
}
8
Christoph

文字列はnullで終了していません。文字列の最後に_'\0'_文字を追加してください。または、callocの代わりにmallocを使用して割り当てることができます。これにより、返されるメモリがゼロになります。

ところで、このコードには他にも問題があります。

  • 使用されているように、呼び出したときにメモリを割り当て、割り当てられた文字列をfree()ingする責任を呼び出し側に残します。 printf呼び出しで呼び出すだけでメモリがリークします。
  • 番号を2回パスしますが、これは不要です。 1つのループですべてを実行できます。

使用できる代替実装を次に示します。

_#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));
_

2番目のパラメーターは、結果文字列を格納するバッファーへのポインターです。バッファーがない場合は、NULLと_int2bin_を渡すと、staticバッファーに書き込み、それを返します。元の実装に対するこの利点は、呼び出し元が返される文字列のfree()ingを心配する必要がないことです。

欠点は、静的バッファが1つしかないため、後続の呼び出しで以前の呼び出しの結果が上書きされることです。後で使用するために、複数の呼び出しからの結果を保存できませんでした。また、スレッドセーフではありません。つまり、この方法で異なるスレッドから関数を呼び出すと、お互いの文字列を壊してしまう可能性があります。その可能性がある場合は、NULLを渡す代わりに、独自のバッファーを渡す必要があります。

_char str[33];
int2bin(0xDEADBEEF, str);
puts(str);
_
7
John Kugelman

これは、4ビットごとに区切られたバイナリコードとしてintergerを表示するために作成したものです：

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++;
}

それは少し大きいかもしれませんが、私は常に誰もが何が起こっているかを理解できるように（私は願っています）書きます。これが役に立てば幸いです。

1
Kirito

これは簡単なアルゴリズムです。

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;
        }
    }
1
Luqman_Ahmad
#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");
    }

}
1
amol
#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;
}
0
aldo núñez

私がこれを行う最も簡単な方法（8ビット表現の場合）：

#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;
}
0
KoSv

いくつかのこと：

int f = 32;
int i = 1;
do{
  str[--f] = i^a?'1':'0';
}while(i<<1);
  • プラットフォームに大きく依存しますが、上記のこのアイデアがあなたを開始するかもしれません。
  • Memset（str、0、33）を使用してchar配列全体を0に設定してみませんか？
  • Free（）することを忘れないでください!!!関数呼び出し後のchar *配列！
0
merkuro

これが私の解決策です。すべての0と左端のビットに1で始まるマスクを作成し、仮定 32ビット整数の各ビットに対して論理的に右にシフトします。現在マスクされている整数の値をブール値に変換することにより、ビットが順次印刷されます。

void printBits(int val){
    for(unsigned int mask = 0x80000000; mask; mask >>= 1){
         printf("%d", !!(mask & val));
    }
}
0
Rosemary Fortanely

2つのこと：

  1. NULキャラクターはどこに置きますか？ _'\0'_が設定されている場所が表示されません。
  2. Intは署名され、0xFF000000は負の値として解釈されます。したがって、while (a > 0)はすぐにfalseになります。

余談：内部のmalloc関数は見苦しいです。 int2binにバッファを提供するのはどうですか？

0
Markus Schnell
#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;
}
0
Anil Kumar

コーディングされた2つの単純なバージョン ここ （軽度の再フォーマットで再現）。

#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;
}
0
nik

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
0
Sequoya

//これは私たちの先生が私たちにこれをするように頼んだときにしたことです

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);
}
0
Ioannis Vogiatzis

それほどエレガントではありませんが、目標を達成し、理解するのは非常に簡単です：

#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
Michelangelo Machado