Drucken eines int in Binärdarstellung mit C

Question

Ich bin auf der Suche nach einer Funktion, mir zu erlauben, die binäre Darstellung eines int zu drucken. Was ich habe, so weit ist;

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;

}

Aber wenn ich rufe

printf("a %s",int2bin(aMask)) // aMask = 0xFF000000

Ich erhalte eine Ausgabe wie;

  

0000000000000000000000000000000000xtpYy (und ein paar unbekannten Zeichen.

Ist es ein Fehler in der Funktion oder bin Druck mir die Adresse des Zeichenfeldes oder so etwas? Sorry, ich kann einfach nicht sehen, wohin ich gehe falsch.

Hinweis: Der Code ist von hier

EDIT: Es ist nicht Hausaufgaben FYI, ich versuche jemand andere Bildbearbeitungsroutinen in einer fremden Sprache zu debuggen. Wenn aber es hat sich als Hausaufgaben markiert, weil es ein elementares Konzept dann Fairplay.

Answer 1

Hier ist eine andere Option, die mehr optimiert, wo Sie in Ihrem zugewiesenen Puffer übergeben. Stellen Sie sicher, dass es die richtige Größe.

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

Answer 2

Einige Vorschläge:

• Null beenden Zeichenfolge
• verwenden Sie keine magischen Zahlen
• Überprüfen Sie den Rückgabewert von malloc()
• nicht werfen den Rückgabewert von malloc()
• verwenden binäre Operationen anstelle von arithmetisch diejenigen, wie Sie in der binären Darstellung interessiert sind
• gibt es keine Notwendigkeit für Looping zweimal

Hier ist der Code:

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

Answer 3

Ihre Zeichenkette ist nicht null-terminiert. Vergewissern Sie sich ein '\0' Zeichen am Ende der Zeichenfolge hinzuzufügen; oder könnten Sie ordnen es mit calloc statt malloc, die den Speicher wird Null, die Ihnen zurückgegeben wird.

Übrigens gibt es andere Probleme mit diesem Code:

• Wie verwendet, weist es den Speicher, wenn Sie es nennen, den Anrufer verantwortlich für das Verlassen des zugewiesenen String free()ing. Sie werden ein Speicherleck auf, wenn Sie nur in einem printf Anruf nennen.
• Es macht zwei Durchgänge über die Zahl, die nicht notwendig ist. Sie können alles in einer Schleife tun.

Hier ist eine alternative Implementierung Sie nutzen könnten.

#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
}

Verbrauch:

printf("%s\n", int2bin(0xFF00000000, NULL));

Der zweite Parameter ist ein Zeiger auf einen Puffer, in dem Sie die Ergebniszeichenfolge gespeichert werden soll. Wenn Sie verpassen keinen Puffer haben NULL und int2bin werden zu einem static Puffer schreiben und zurück, dass zu Ihnen. Dies hat den Vorteil gegenüber der ursprünglichen Implementierung ist, dass der Anrufer nicht über free()ing die Zeichenfolge kümmern muss, die zurückgegeben wird.

Ein Nachteil ist, dass es nur ein statischer Puffer so nachfolgende Aufrufe werden die Ergebnisse aus früheren Anrufen überschreiben. Sie können nicht die Ergebnisse aus mehreren Anrufen für eine spätere Verwendung speichern. Auch ist es nicht thread, was bedeutet, wenn Sie die Funktion auf diese Weise aus verschiedenen Threads rufen sie einander die Saiten hauen könnte. Wenn das eine Möglichkeit ist müssen Sie in Ihrem eigenen Puffer passieren, anstatt NULL zugeben, etwa so:

char str[33];
int2bin(0xDEADBEEF, str);
puts(str);

Answer 4

Hier ist ein einfacher Algorithmus.

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

Answer 5

Das ist was ich machte einen interger als binairy Code anzuzeigen es je 4 Bit getrennt ist:

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

könnte es ein wenig zu groß sein, aber ich schreibe es immer so (ich hoffe), dass jeder kann verstehen, was los ist. hoffen, dass dies dazu beigetragen.

Answer 6

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

}

Answer 7

Zwei Dinge:

1. Wo setzen Sie die NUL-Zeichen? Ich kann nicht einen Ort sehen, wo '\0' eingestellt ist.
2. Int unterzeichnet und 0xFF000000 würde als negativer Wert interpretiert werden. So while (a > 0) wird sofort falsch sein.

Neben: Die malloc Funktion innen ist hässlich. Was über einen Puffer bereitstellt, um int2bin?

Answer 8

Ein paar Dinge:

int f = 32;
int i = 1;
do{
  str[--f] = i^a?'1':'0';
}while(i<<1);

• Es ist sehr plattformabhängig, aber vielleicht diese Idee oben bekommt man begonnen.
• Warum nicht memset verwenden (str, 0, 33) einzustellen der ganze char-Array auf 0?
• Vergessen Sie nicht, zu befreien () !!! die char * Array nach dem Funktionsaufruf!

Answer 9

Zwei einfache Versionen codiert hier (reproduziert mit leichter Neuformatierung).

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

Answer 10

// Das ist das, was ich tat, als unser Lehrer uns gebeten, dies zu tun

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

Answer 11

Der einfachste Weg für mich, dies zu tun (für eine 8-Bit-Darstellung):

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

Answer 12

Hier ist eine andere Lösung, die kein Zeichen benötigt *.

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

Oder hier für mehr Lesbarkeit:

#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');
}

Und hier ist die Ausgabe:

11111111111111111111111111111111
00000000000000000000000000000000
10000000000000000000000000000000
01000000000000000000000000000000
11000000000000000000000000000000
00100000000000000000000000000000
10100000000000000000000000000000

Answer 13

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

Answer 14

Nicht so elegant, aber erreicht Ihr Ziel und es ist sehr leicht zu verstehen:

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

Answer 15

Hier ist meine Lösung. Es schafft eine Maske, mit allen 0en und einem 1 in der äußersten linken Bit beginnen und verschiebt es logisch richtig für jedes Bit in dem angenommen 32-Bit-Integer. Die Bits werden sequentiell gedruckt, indem der Wert des aktuell maskiert ganze Zahl in einen booleschen Wert umgewandelt wird.

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

Answer 16

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

Answer 17

void print_binary(int n) {
    if (n == 0 || n ==1) 
        cout << n;
    else {
        print_binary(n >> 1);
        cout << (n & 0x1);
    }
}