Drucken Sie ein int in binärer Darstellung mit C

Hier ist eine weitere option, die mehr optimiert, wo Sie passieren, in Ihrem zugewiesenen Puffer übergeben wird. Stellen Sie sicher, dass es die richtige Größe hat.

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

InformationsquelleAutor der Antwort Adam Markowitz

Dein string nicht null-terminiert ist. Stellen Sie sicher, fügen Sie eine '\0' - Zeichen am Ende der Zeichenfolge; oder man kann reservieren, es mit calloc statt mallocdie null, der Speicher, der zu Ihnen zurückgegeben.

Durch die Art und Weise, es gibt andere Probleme mit diesem code:

• Wie hier verwendet, weist es den Speicher, wenn Sie es nennen, verlassen der Anrufer verantwortlich für free()ing der zugewiesenen string. Sie werden Speicherverlust, wenn Sie nur nennen Sie es in einem printf nennen.
• Es zwei Durchgänge über die Zahl, die unnötig ist. Sie können alles tun, was in einer Schleife.

Hier ist eine alternative Implementierung, die Sie verwenden konnten.

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

Verwendung:

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

Der zweite parameter ist ein Zeiger auf einen Puffer, die Sie möchten, speichern Sie die Ergebnis-string. Wenn Sie nicht über einen Puffer übergeben werden können NULL und int2bin schreiben Sie eine static Puffer und zurück, um Sie. Der Vorteil dieser gegenüber der ursprünglichen Implementierung ist, dass der Anrufer keine sorgen über free()ing der Zeichenfolge, die zurückgegeben wird.

Ein Nachteil ist, dass es nur eine statische Puffer auf, so dass nachfolgende Aufrufe überschrieben werden, die die Ergebnisse von früheren anrufen. Sie konnte nicht speichern Sie die Ergebnisse mehrerer Aufrufe für die spätere Verwendung. Auch, es ist nicht threadsicher, das heißt, wenn Sie rufen Sie die Funktion auf diese Weise aus verschiedenen threads konnte Sie Klamotten des jeweils anderen strings. Wenn das ist eine Möglichkeit, Sie müssen pass, die in Ihre eigenen Puffer, anstatt die NULL:

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

InformationsquelleAutor der Antwort John Kugelman

dies ist, was ich aus der Anzeige einer interger als binairy code getrennt je 4 bits:

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 bisschen groß, aber ich Schreibe immer einen Weg (hoffe ich), dass jeder verstehen kann, was Los ist. hoffe, das half.

InformationsquelleAutor der Antwort Kirito

Zwei Dinge:

1. Wo legst du das NUL-Zeichen? Ich kann nicht sehen, ein Ort, wo '\0' eingestellt ist.
2. Int ist signed, und 0xFF000000 würde interpretiert werden als ein negativer Wert. So while (a > 0) wird sofort falsch.

Beiseite: Die malloc-Funktion ist innen hässlich. Was über die Bereitstellung einen Puffer, um int2bin?

InformationsquelleAutor der Antwort Markus Schnell

Zwei einfache Versionen kodiert hier (reproduziert mit milden 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;
}

InformationsquelleAutor der Antwort nik

//Dies ist, was ich getan habe, als unser Lehrer fragte uns, 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);
} 

InformationsquelleAutor der Antwort Ioannis Vogiatzis

Hier ist eine andere Lösung, die nicht erfordert ein 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);
}

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

InformationsquelleAutor der Antwort Sequoya

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

InformationsquelleAutor der Antwort Michelangelo Machado

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

InformationsquelleAutor der Antwort sean