क्या द्विआधारी प्रारूप में प्रिंट करने के लिए एक प्रिंटफ कनवर्टर है?

434

मैं प्रिंट के साथ हेक्स या ऑक्टल नंबर के रूप में प्रिंट कर सकता हूं। क्या द्विआधारी, या मनमाना आधार के रूप में मुद्रित करने के लिए एक प्रारूप टैग है?

मैं जीसीसी चला रहा हूं।

printf("%d %x %o\n", 10, 10, 10); //prints "10 A 12\n"
print("%b\n", 10); // prints "%b\n"
c  printf 
— ब्रायन
स्रोत
आप ऐसा नहीं कर सकते, जहां तक ​​मुझे पता है, प्रिंटफ का उपयोग कर रहा हूं। आप स्पष्ट रूप से, इसे पूरा करने के लिए एक सहायक विधि लिख सकते हैं, लेकिन यह उस दिशा की तरह ध्वनि नहीं करता है जिस दिशा में आप जाना चाहते हैं।
— इयान पी
इसके लिए पूर्वनिर्धारित कोई प्रारूप नहीं है। आपको इसे स्वयं एक स्ट्रिंग में बदलने की आवश्यकता है और फिर स्ट्रिंग प्रिंट करें।
— rslite
एक त्वरित Google खोज ने कुछ जानकारी के साथ इस पृष्ठ का निर्माण किया जो उपयोगी हो सकता है: फ़ोरम.macrumors.com/archive/index.php/t-165959.html
— इयान पी
12
एएनएसआई स्टैंडर्ड सी लाइब्रेरी के हिस्से के रूप में नहीं - यदि आप पोर्टेबल कोड लिख रहे हैं, तो सबसे सुरक्षित तरीका अपना स्वयं का रोल करना है।
— टोमोग्लिक जूल
एक बयान मानक और सामान्य (किसी भी लंबाई के किसी भी अभिन्न प्रकार के लिए) सी ++ पर बाइनरी स्ट्रिंग के रूपांतरण का समाधान: stackoverflow.com/a/31660310/1814353
— luart

जवाबों:

266

हैकी लेकिन मेरे लिए काम करता है:

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

आपको दुर्भाग्य से सभी अतिरिक्त उद्धरणों की आवश्यकता है। इस दृष्टिकोण में मैक्रोज़ के दक्षता जोखिम हैं (एक फ़ंक्शन को तर्क के रूप में पास न करें BYTE_TO_BINARY) लेकिन स्मृति मुद्दों और स्ट्रैकट के कई आक्रमणों से यहां कुछ अन्य प्रस्तावों में बचा जाता है।

— विलियम व्हाईट
स्रोत
13
और इसका फायदा यह भी है कि कई बार इनवोकेबल होने के लिए बफ़र्स printfवाले staticनहीं हो सकते।
— पैट्रिक श्ल्टर
4
मैंने इसे बदलने के %dलिए स्वतंत्रता ले ली है %c, क्योंकि यह और भी तेज़ होना चाहिए ( %d%c
3
16, 32, 64 बिट इंट समर्थन के साथ इस मैक्रो का विस्तारित संस्करण पोस्ट किया गया: stackoverflow.com/a/25108449/432509
— ideasman42
2
ध्यान दें कि यह दृष्टिकोण मैत्रीपूर्ण नहीं है। intसिस्टम पर 32-बिट्स मानते हुए , 32-बिट मान को प्रिंट करने के लिए 32 * 4-बाइट मान के लिए स्थान की आवश्यकता होगी; कुल 128 बाइट्स। जो, स्टैक आकार के आधार पर, एक मुद्दा हो सकता है या नहीं भी हो सकता है।
— user694733
1
बाइट में बाइट के चारों ओर कोष्ठक जोड़ने के लिए महत्वपूर्ण है या आप एक ऑपरेशन भेजते समय समस्याओं में भाग सकते हैं BYTE_TO_BARY (a | b) -> a | b & 0x01! = (a | b) & 0x01
— Ivan Hoffmann
203

किसी भी डेटाटाइप के लिए बाइनरी प्रिंट करें

//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;
}
— criptych मोनिका के साथ खड़ा है
स्रोत
8
बनाम गलत मैच size_t i; for (i=size; i-- > 0; )से बचने का सुझाव । size_tint
— chux -
1
क्या कोई इस कोड के पीछे के तर्क पर विस्तार से बता सकता है?
— jII
2
प्रत्येक बाइट को ptr(बाहरी लूप) में लें; तब प्रत्येक बिट के लिए वर्तमान बाइट (आंतरिक लूप), वर्तमान बिट द्वारा बाइट को मुखौटा करें ( 1 << j)। दाईं ओर बाइट जिसमें 0 ( 0000 0000b) या 1 ( 0000 0001b) शामिल है। प्रारूप के साथ परिणामी बाइट प्रिंटफ प्रिंट करें %u। HTH।
— नील्सबॉट
1
@ ZX9 ध्यान दें कि सुझाए गए कोड का इस्तेमाल किया> लूप को कब समाप्त करना है यह निर्धारित करने के लिए आपकी टिप्पणी के साथsize_t का नहीं >=।
— chux -
3
@ ZX9 अभी भी तुम्हारा एक उपयोगी मूल टिप्पणी के रूप में कोडर के लिए >और >=अहस्ताक्षरित प्रकार के किनारे के उपयोग पर विचार करने से सावधान रहने की जरूरत है । 0एक अहस्ताक्षरित किनारे का मामला है और आमतौर पर कम आम के साथ हस्ताक्षरित गणित के विपरीत होता है INT_MAX/INT_MIN।
— चक्स -
151

यहां तकनीकों को प्रदर्शित करने के लिए एक त्वरित हैक है जो आप चाहते हैं। 

#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;
}
— EvilTeach
स्रोत
2
यह निश्चित रूप से कम "अजीब" है, जो कस्टम लेखन के बजाय प्रिंटफ के लिए एक अधिभार है। एक डेवलपर के लिए कोड के लिए नया समझना आसान है, साथ ही साथ।
— उग्र कॉडर
43
कुछ बदलाव: strcatलूप के प्रत्येक पास पर स्ट्रिंग में एक सिंगल चार जोड़ने का एक अक्षम तरीका है। इसके बजाय, एक जोड़ें char *p = b;और आंतरिक लूप को बदलें *p++ = (x & z) ? '1' : '0'। z256 (2 ^ 8) के बजाय 128 (2 ^ 7) से शुरू होना चाहिए। इसी तरह (थ्रेड सेफ्टी के लिए) उपयोग करने के लिए बफर को पॉइंटर लेने के लिए अपडेट करने पर विचार करें inet_ntoa()।
— टोमोग्लिक जूल
3
@EvTTeach: आप अपने आप को एक पैरामीटर के रूप में एक टर्नरी ऑपरेटर का उपयोग कर रहे हैं strcat()! मैं मानता हूं कि strcatअसाइनमेंट के लिए डीरिफाइंड पॉइंटर को पोस्ट-इन्क्रीमेंट करने की तुलना में समझना आसान है, लेकिन शुरुआती लोगों को यह भी जानना होगा कि स्टैण्डर्ड लाइब्रेरी का सही इस्तेमाल कैसे किया जाए। शायद असाइनमेंट के लिए अनुक्रमित सरणी का उपयोग करना एक अच्छा प्रदर्शन रहा होगा (और वास्तव में काम करेगा, क्योंकि bजब भी आप फ़ंक्शन को कॉल करते हैं, तो हर बार सभी-शून्य पर रीसेट नहीं होता है)।
— टॉमलॉजिक
3
रैंडम: बाइनरी बफर चार स्थिर है, और असाइनमेंट में सभी शून्य को मंजूरी दे दी है। यह केवल पहली बार चलने के बाद ही इसे साफ करेगा, और इसके बाद यह स्पष्ट नहीं होगा, बल्कि अंतिम मूल्य का उपयोग करेगा।
— markwatson
8
इसके अलावा, इस दस्तावेज़ होना चाहिए कि पिछले परिणाम समारोह फिर से कॉल के बाद अमान्य हो जाएँगे, तो कॉल इस तरह इसका इस्तेमाल करने की कोशिश नहीं करनी चाहिए: printf("%s + %s = %s", byte_to_binary(3), byte_to_binary(4), byte_to_binary(3+4))।
— पाओलो एबरमैन
84

सामान्य रूप से ग्लिबक में एक बाइनरी रूपांतरण विनिर्देशक नहीं है।

ग्लिफ़क में फ़ंक्शन के प्रिंटफ़ () परिवार में कस्टम रूपांतरण प्रकार जोड़ना संभव है। देखें register_printf_function जानकारी के लिए। आप अपने स्वयं के उपयोग के लिए एक कस्टम% b रूपांतरण जोड़ सकते हैं, अगर यह उपलब्ध होने के लिए एप्लिकेशन कोड को सरल करता है।

यहाँ एक उदाहरण है कि कैसे glibc में एक कस्टम प्रिंटफ़ प्रारूप लागू किया जाए।

— DGentry
स्रोत
मैंने हमेशा अपने v [snf] प्रिंटफ () को सीमित मामलों के लिए लिखा है, जहाँ मुझे अलग-अलग मूलांक चाहिए थे: इसलिए ख़ुशी है कि मैंने इस पर ध्यान दिया।
— जेमी
3
warning: 'register_printf_function' is deprecated [-Wdeprecated-declarations]हालांकि ऐसा करने के लिए एक नया कार्य है register_printf_specifier():। नए उपयोग का एक उदाहरण यहां पाया जा सकता है: codereview.stackexchange.com/q/219994/200418
— Cacahuete Frito
47

आप गति 1 को बेहतर बनाने के लिए एक छोटी तालिका का उपयोग कर सकते हैं । इसी तरह की तकनीक एम्बेडेड दुनिया में उपयोगी हैं, उदाहरण के लिए, एक बाइट को उल्टा करने के लिए:

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

1 मैं ज्यादातर उन एम्बेडेड अनुप्रयोगों की बात कर रहा हूँ जहाँ ऑप्टिमाइज़र इतने आक्रामक नहीं होते हैं और गति अंतर दिखाई देता है।

— शाहबाज
स्रोत
27

कम से कम महत्वपूर्ण बिट प्रिंट करें और इसे दाईं ओर शिफ्ट करें। ऐसा करना तब तक जब तक कि शून्य शून्य न हो जाए, बिना अग्रणी शून्य के द्विआधारी प्रतिनिधित्व करता है, लेकिन उलटा क्रम। पुनरावृत्ति का उपयोग करते हुए, ऑर्डर को काफी आसानी से ठीक किया जा सकता है।

#include <stdio.h>

void print_binary(int number)
{
    if (number) {
        print_binary(number >> 1);
        putc((number & 1) ? '1' : '0', stdout);
    }
}

मेरे लिए, यह समस्या का सबसे साफ समाधान है। यदि आपको 0bउपसर्ग पसंद है और एक नई पंक्ति चरित्र अनुगामी है, तो मैं सुझाव देता हूं कि फंक्शन रैप करें।

ऑनलाइन डेमो

— danijar
स्रोत
त्रुटि: कॉल करने के लिए बहुत कम तर्क, अपेक्षित 2, 1 पीटीसी ((संख्या और 1); '1': '0');
— कोरे तुगे
@KorayTugay यह इंगित करने के लिए धन्यवाद। मैंने फ़ंक्शन कॉल को ठीक किया और एक डेमो जोड़ा।
— danijar
6
आपको अहस्ताक्षरित int संख्या का उपयोग करना चाहिए, क्योंकि जब दी गई संख्या ऋणात्मक होती है, तो फ़ंक्शन कभी न खत्म होने वाले पुनरावर्ती कॉल में प्रवेश करता है।
— फफूंद
अधिक कुशल दृष्टिकोण, चूंकि ASCII में, '0' + 1 = '1':putc('0'+(number&1), stdout);
— रोजर ड्यूक
22

@William व्हाइट के जवाब के आधार पर, इस मैक्रो प्रदान करता है int8, 16, 32और 64संस्करणों, पुन: उपयोग INT8से बचने पुनरावृत्ति करने के लिए मैक्रो।

/* --- 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

पठनीयता के लिए आप उदाहरण के लिए एक विभाजक जोड़ना चाहते हैं:

My Flag 00010110,11100001,00101011,01111101,01111000,10010000,11110000,00101000
— ideasman42
स्रोत
यह उत्कृष्ट है। क्या कम से कम बिट्स महत्वपूर्ण बिट्स के साथ शुरू होने वाले मुद्रण के लिए कोई विशेष कारण है?
— गगनसो
2
आप अल्पविराम जोड़ने की सलाह कैसे देंगे?
— nmz787
PRINTF_BYTE_TO_BINARY_INT#वैकल्पिक रूप से उपयोग करने के लिए परिभाषित करने का एक समूहित संस्करण जोड़ देगा ।
— विचार 224217
16

यहाँ फ़ंक्शन का एक संस्करण है जो तर्क / आकार / तर्क के प्रकार पर सीमा मुद्दों या सीमाओं से ग्रस्त नहीं है:

#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 के बीच किसी भी आधार के लिए काम करेगा, यदि आप वांछित आधार से सिर्फ 2 को प्रतिस्थापित करते हैं। उपयोग है:

char tmp[FMT_BUF_SIZE];
printf("%s\n", binary_fmt(x, tmp));

xकोई अभिन्न अभिव्यक्ति कहां है।

— आर .. गिटहब स्टॉप हेल्पिंग आईसीई
स्रोत
7
हां, आप ऐसा कर सकते हैं। लेकिन यह वास्तव में खराब डिजाइन है। यहां तक ​​कि अगर आपके पास थ्रेड्स या रीटर्रानसी नहीं है, तो कॉल करने वाले को char *a = binary_fmt(x), *b = binary_fmt(y);यह जानना होगा कि स्टैटिक बफर का पुन: उपयोग किया जा रहा है, और जैसी चीजें अपेक्षित रूप से काम नहीं करेंगी। एक बफर पास करने के लिए कॉल करने के लिए मजबूर करने से भंडारण की आवश्यकता का पता चलता है; यदि वास्तव में वांछित है, तो कॉलर एक स्थिर बफर का उपयोग करने के लिए स्वतंत्र है, और फिर उसी बफर का पुन: उपयोग स्पष्ट हो जाता है। यह भी ध्यान दें कि, आधुनिक PIC ABI पर, स्थिर बफ़र्स आमतौर पर स्टैक पर बफ़र्स की तुलना में अधिक कोड तक पहुँच पाते हैं।
— आर .. गिटहब स्टॉप हेल्पिंग ICE
8
यह अभी भी एक बुरा डिजाइन है। इसके लिए उन मामलों में एक अतिरिक्त नकल कदम की आवश्यकता होती है, और यह उन मामलों में भी कम खर्चीला नहीं है , जहां पर उन मामलों में भी बफर प्रदान नहीं किया जाता है, जहां नकल की आवश्यकता नहीं होती है। स्थिर भंडारण का उपयोग करना केवल एक बुरी मुहावरा है।
— आर .. गिटहब स्टॉप हेल्पिंग ICE
3
गैर-अतिरिक्त नाम के साथ प्रीप्रोसेसर या चर प्रतीक तालिका के नामस्थान को प्रदूषित करने के लिए, जिसका उपयोग हर कॉलर द्वारा आवंटित किए जाने वाले भंडारण को ठीक से करने के लिए किया जाना चाहिए , और इस मूल्य को जानने के लिए और हर कॉल करने वाले को मजबूर करने के लिए आवश्यक राशि आवंटित करना भंडारण, खराब डिजाइन है जब सरल कार्य-स्थानीय भंडारण समाधान सबसे अधिक उद्देश्य और उद्देश्यों के लिए पर्याप्त होगा, और जब एक साधारण स्ट्रैडअप () कॉल शेष उपयोगों का 99% कवर करता है।
— ग्रेग ए। वुड्स
5
यहाँ हम असहमत होने जा रहे हैं। मैं यह नहीं देख सकता कि एक विनीत पूर्वप्रक्रमक चिन्ह को जोड़ने से कहीं भी उपयोग के मामलों को गंभीर रूप से सीमित करने की हानिकारकता के पास आता है, इंटरफ़ेस त्रुटि-प्रवण बना देता है, अस्थायी मान के लिए कार्यक्रम की अवधि के लिए स्थायी भंडारण को जमा करता है, और अधिकांश पर बदतर कोड उत्पन्न करता है। आधुनिक मंच।
— आर .. गिटहब स्टॉप हेल्पिंग ICE
5
मैं बिना कारण (यानी माप) के सूक्ष्म-अनुकूलन की वकालत नहीं करता। लेकिन मुझे लगता है कि प्रदर्शन, भले ही यह सूक्ष्म लाभ के पैमाने पर हो, यह ध्यान देने योग्य है जब यह मूल रूप से बेहतर डिजाइन के साथ एक बोनस के रूप में आता है।
— आर .. गिटहब स्टॉप हेल्पिंग ICE
13 
const char* byte_to_binary( int x )
{
    static char b[sizeof(int)*8+1] = {0};
    int y;
    long long z;
    for (z=1LL<<sizeof(int)*8-1,y=0; z>0; z>>=1,y++)
    {
        b[y] = ( ((x & z) == z) ? '1' : '0');
    }

    b[y] = 0;

    return b;
}
— DanSkeel
स्रोत
6
यदि आप उपयोग करते हैं '1'और '0'इसके बजाय 49और 48अपनी त्रैमासिक में साफ करें। इसके अलावा, b9 अक्षर लंबे होने चाहिए , ताकि अंतिम चरित्र एक शून्य टर्मिनेट रह सके।
— टॉमोलॉजिकल
साथ ही बी को हर बार इनिशियलाइज़ करना होगा।
— EvilTeach
2
यदि आप कुछ नहीं बदलते हैं: 1. अंतिम शून्य के लिए स्थान जोड़ें: static char b[9] = {0}2. घोषणा को लूप से बाहर ले जाएं: int z,y;3. अंतिम शून्य जोड़ें b[y] = 0:। इस तरह से किसी भी सुदृढीकरण की आवश्यकता नहीं है।
— Kobor42
1
अच्छा समाधान। मैं हालांकि कुछ सामान बदल जाएगा। यानी स्ट्रिंग में पीछे जा रहा है ताकि किसी भी आकार के इनपुट को ठीक से संभाला जा सके।
— Kobor42
उन सभी 8को प्रतिस्थापित किया जाना चाहिए CHAR_BIT।
— alk
12

त्वरित और आसान समाधान:

void printbits(my_integer_type x)
{
    for(int i=sizeof(x)<<3; i; i--)
        putchar('0'+((x>>(i-1))&1));
}

किसी भी आकार के प्रकार के लिए और हस्ताक्षरित और अहस्ताक्षरित ints के लिए काम करता है। '' और 1 'पर हस्ताक्षर किए गए किलों को संभालने की जरूरत है क्योंकि शिफ्ट साइन एक्सटेंशन कर सकती है।

ऐसा करने के बहुत सारे तरीके हैं। यहाँ एक हस्ताक्षरित या अहस्ताक्षरित 32 बिट प्रकार (हस्ताक्षर किए बिना एक नकारात्मक डालने पर, केवल वास्तविक बिट्स को प्रिंट करना) और कोई गाड़ी वापसी से 32 बिट या एन बिट्स को प्रिंट करने के लिए एक सुपर सरल है। ध्यान दें कि मैं बिट शिफ्ट से पहले घटाया गया हूं:

#define printbits_n(x,n) for (int i=n;i;i--,putchar('0'|(x>>i)&1))
#define printbits_32(x) printbits_n(x,32)

बिट्स के साथ एक स्ट्रिंग को वापस स्टोर या प्रिंट करने के बारे में क्या? आप या तो मेमोरी को आवंटित कर सकते हैं और इसे वापस कर सकते हैं और उपयोगकर्ता को इसे मुक्त करना होगा, या फिर आप एक स्टेटिक स्ट्रिंग लौटाएंगे, लेकिन अगर यह फिर से, या किसी अन्य थ्रेड द्वारा कॉल किया जाता है, तो यह बंद हो जाएगा। दिखाए गए दोनों तरीके:

char *int_to_bitstring_alloc(int x, int count)
{
    count = count<1 ? sizeof(x)*8 : count;
    char *pstr = malloc(count+1);
    for(int i = 0; i<count; i++)
        pstr[i] = '0' | ((x>>(count-1-i))&1);
    pstr[count]=0;
    return pstr;
}

#define BITSIZEOF(x)    (sizeof(x)*8)

char *int_to_bitstring_static(int x, int count)
{
    static char bitbuf[BITSIZEOF(x)+1];
    count = (count<1 || count>BITSIZEOF(x)) ? BITSIZEOF(x) : count;
    for(int i = 0; i<count; i++)
        bitbuf[i] = '0' | ((x>>(count-1-i))&1);
    bitbuf[count]=0;
    return bitbuf;
}

के साथ बुलाना:

// memory allocated string returned which needs to be freed
char *pstr = int_to_bitstring_alloc(0x97e50ae6, 17);
printf("bits = 0b%s\n", pstr);
free(pstr);

// no free needed but you need to copy the string to save it somewhere else
char *pstr2 = int_to_bitstring_static(0x97e50ae6, 17);
printf("bits = 0b%s\n", pstr2);
— Robotbugs
स्रोत
10

पहले से पोस्ट किए गए उत्तरों में से कोई भी ऐसा नहीं है जो मैं देख रहा था, इसलिए मैंने एक लिखा। यह% 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);
    }
— TechplexEngineer
स्रोत
1
50 से अधिक बिट्स के साथ यह अतिप्रवाह होगा?
— Janus Troelsen
अच्छा कॉल, हाँ, यह होगा ... मुझे बताया गया था कि मुझे मॉलॉक का उपयोग करने की आवश्यकता है, कभी भी डॉन?
— TechplexEngineer
हां बिल्कुल। सुपर आसान:char* buffer = (char*) malloc(sizeof(char) * 50);
— Janus Troelsen
@ जानुस ट्रॉल्सन, या बहुत क्लीनर, छोटा, बनाए रखने योग्य:char *buffer = malloc(sizeof(*buffer) * 50);
— शाहबाज
इस संदर्भ में "% B" "% b" से भिन्न क्यों होगा? पिछले उत्तर में कहा गया था कि "बाइनरी को आउटपुट करने के लिए सी मानक लाइब्रेरी में कोई स्वरूपण फ़ंक्शन नहीं है।" और " कुछ रनटाइम्स"% b "का समर्थन करते हैं, हालांकि यह एक मानक नहीं है।" ।
— पीटर मोर्टेंसन
8

कुछ रनटाइम्स "% b" का समर्थन करते हैं, हालांकि यह एक मानक नहीं है।

एक दिलचस्प चर्चा के लिए यहां भी देखें:

http://bytes.com/forum/thread591027.html

HTH

— rlerallut
स्रोत
1
यह वास्तव में सी रनटाइम लाइब्रेरी की एक संपत्ति है, संकलक नहीं।
— cjm
7

इस कोड को आपकी आवश्यकताओं को 64 बिट तक संभालना चाहिए। मैंने 2 फ़ंक्शन pBin & pBinFill बनाए हैं। दोनों एक ही काम करते हैं, लेकिन pBinFill फिल्चर के साथ प्रमुख स्थानों में भर जाता है। परीक्षण फ़ंक्शन कुछ परीक्षण डेटा उत्पन्न करता है, फिर फ़ंक्शन का उपयोग करके इसे प्रिंट करता है।



char* pBinFill(long int x,char *so, char fillChar); // version with fill
char* pBin(long int x, char *so);                   // version without fill
#define kDisplayWidth 64

char* pBin(long int x,char *so)
{
 char s[kDisplayWidth+1];
 int  i=kDisplayWidth;
 s[i--]=0x00;   // terminate string
 do
 { // fill in array from right to left
  s[i--]=(x & 1) ? '1':'0';  // determine bit
  x>>=1;  // shift right 1 bit
 } while( x > 0);
 i++;   // point to last valid character
 sprintf(so,"%s",s+i); // stick it in the temp string string
 return so;
}

char* pBinFill(long int x,char *so, char fillChar)
{ // fill in array from right to left
 char s[kDisplayWidth+1];
 int  i=kDisplayWidth;
 s[i--]=0x00;   // terminate string
 do
 { // fill in array from right to left
  s[i--]=(x & 1) ? '1':'0';
  x>>=1;  // shift right 1 bit
 } while( x > 0);
 while(i>=0) s[i--]=fillChar;    // fill with fillChar 
 sprintf(so,"%s",s);
 return so;
}

void test()
{
 char so[kDisplayWidth+1]; // working buffer for pBin
 long int val=1;
 do
 {
   printf("%ld =\t\t%#lx =\t\t0b%s\n",val,val,pBinFill(val,so,'0'));
   val*=11; // generate test data
 } while (val < 100000000);
}

Output:
00000001 =  0x000001 =  0b00000000000000000000000000000001
00000011 =  0x00000b =  0b00000000000000000000000000001011
00000121 =  0x000079 =  0b00000000000000000000000001111001
00001331 =  0x000533 =  0b00000000000000000000010100110011
00014641 =  0x003931 =  0b00000000000000000011100100110001
00161051 =  0x02751b =  0b00000000000000100111010100011011
01771561 =  0x1b0829 =  0b00000000000110110000100000101001
19487171 = 0x12959c3 =  0b00000001001010010101100111000011
— mrwes
स्रोत
1
"#define चौड़ाई 64" log4cxx से stream.h के साथ संघर्ष करता है। कृपया, पारंपरिक रूप से बेतरतीब परिभाषित नामों का उपयोग करें :)
— कगली-सान
5
@mhambra: आपको widthइसके बजाय जेनेरिक नाम का उपयोग करने के लिए log4cxx को बताना चाहिए !
— u0b34a0f6ae
7

क्या द्विआधारी प्रारूप में प्रिंट करने के लिए एक प्रिंटफ कनवर्टर है?

printf()परिवार केवल आधार 8, 10, और 16 में मुद्रित करने के लिए सीधे मानक विनिर्देशक का उपयोग कर में सक्षम है। मैं सुझाव देता हूं कि एक ऐसा फ़ंक्शन बनाएं जो संख्या को कोड की विशेष आवश्यकताओं के अनुसार स्ट्रिंग में परिवर्तित करता है।

किसी भी आधार में मुद्रित करने के लिए [2-36]

अब तक के अन्य सभी उत्तरों में कम से कम एक सीमा है।

  1. रिटर्न बफर के लिए स्थिर मेमोरी का उपयोग करें। यह फ़ंक्शन को तर्क के रूप में उपयोग किए जाने की संख्या को सीमित करता है printf()।

  2. स्मृति को आवंटित बिंदुओं को कॉलिंग कोड की आवश्यकता आवंटित करें।

  3. स्पष्ट रूप से एक उपयुक्त बफर प्रदान करने के लिए कॉलिंग कोड की आवश्यकता होती है।

  4. printf()सीधे बुलाओ । यह करने के लिए के लिए एक नया समारोह बाध्य fprintf(), sprintf(), vsprintf(), आदि

  5. कम पूर्णांक श्रेणी का उपयोग करें।

निम्नलिखित में से कोई भी सीमा नहीं है । इसमें C99 या बाद के और उपयोग की आवश्यकता होती है "%s"। यह बफर स्पेस प्रदान करने के लिए एक यौगिक शाब्दिक का उपयोग करता है । इसमें कई कॉल के साथ कोई परेशानी नहीं है 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
— chux - मोनिका को बहाल करना
स्रोत
यह बहुत उपयोगी है। क्या आप जानते हैं कि इसका उपयोग C ++ में कैसे किया जाता है? जब मैं संकलित करता हूं, तो यह एक त्रुटि उत्पन्न करता है "गंभीरता कोड विवरण प्रोजेक्ट फ़ाइल लाइन दमन राज्य त्रुटि C4576 एक प्रारंभिक सूची के बाद एक कोष्ठक प्रकार एक गैर-मानक स्पष्ट प्रकार रूपांतरण सिंटैक्स हैलो सी है: \ my_projects का हैलो / हेल्लो \ mainlopp 39। "
— बस एक शिक्षार्थी
1
@Justalearner यह C ++ उत्पन्न करता है क्योंकि यदि C सुविधा यौगिक शाब्दिक का उपयोग करता है जो C ++ का हिस्सा नहीं है। शायद अपना सी ++ कार्यान्वयन पोस्ट करें जो कि ऐसा करने की कोशिश करता है - भले ही अधूरा हो, मुझे यकीन है कि आपको मदद मिलेगी - जब तक आप पहले अपना प्रयास दिखाते हैं।
— chux -
6

हो सकता है कि थोड़ा सा OT, लेकिन अगर आपको केवल कुछ बाइनरी ऑपरेशन को समझने या वापस करने के लिए डीबग करने के लिए इसकी आवश्यकता है, तो आप wcalc (एक साधारण कंसोल कैलकुलेटर) पर एक नज़र डाल सकते हैं। -B विकल्पों के साथ आपको बाइनरी आउटपुट मिलता है।

जैसे

$ wcalc -b "(256 | 3) और 0xff"
 = 0 बी 11
— quinmars
स्रोत
1
इस मोर्चे पर कुछ अन्य विकल्प भी हैं ... ruby -e 'printf("%b\n", 0xabc)', dcइसके 2oबाद 0x123pऔर इसके बाद ।
— lindes
6

बाइनरी को आउटपुट करने के लिए सी मानक लाइब्रेरी में कोई प्रारूपण फ़ंक्शन नहीं है। सभी प्रारूप संचालन प्रिंटफ परिवार समर्थन मानव पठनीय पाठ की ओर हैं।

— फ्लोरियन बोश
स्रोत
5

निम्नलिखित पुनरावर्ती कार्य उपयोगी हो सकता है:

void bin(int n)
{
    /* Step 1 */
    if (n > 1)
        bin(n/2);
    /* Step 2 */
    printf("%d", n % 2);
}
— कपिल
स्रोत
7
सावधान रहें, यह नकारात्मक पूर्णांक के साथ काम नहीं करता है।
— एंडरसन फ्रीटास
4

मैंने आकार और C ++ - ness के लिए शीर्ष समाधान को अनुकूलित किया, और इस समाधान के लिए मिला:

inline std::string format_binary(unsigned int x)
{
    static char b[33];
    b[32] = '\0';

    for (int z = 0; z < 32; z++) {
        b[31-z] = ((x>>z) & 0x1) ? '1' : '0';
    }

    return b;
}
— paniq
स्रोत
3
यदि आप डायनेमिक मेमोरी (थ्रू std::string) का उपयोग करना चाहते हैं , तो आप staticऐरे से छुटकारा पा सकते हैं । सबसे सरल तरीका यह होगा कि आप staticक्वालीफायर को छोड़ दें और bफ़ंक्शन को स्थानीय बनाएं ।
— शाहबाज
((x>>z) & 0x01) + '0'काफी है।
— जेसन सी
4

कम कोड और संसाधनों का उपयोग करके किसी भी प्रकार से बिट्स प्रिंट करें

इस दृष्टिकोण में विशेषताएं हैं:

  • चर और शाब्दिक के साथ काम करता है।
  • आवश्यक नहीं होने पर सभी बिट्स को पुन: व्यवस्थित नहीं करता है।
  • केवल एक बाइट पूरा होने पर प्रिंटफ़ को कॉल करें (सभी बिट्स के लिए अनावश्यक रूप से नहीं)।
  • किसी भी प्रकार के लिए काम करता है।
  • छोटे और बड़े धीरज के साथ काम करता है (जाँच के लिए GCC #defines का उपयोग करता है)।
  • टाइपोफ़ () का उपयोग करता है जो सी मानक नहीं है लेकिन बड़े पैमाने पर परिभाषित किया गया है।
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define for_endian(size) for (int i = 0; i < size; ++i)
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define for_endian(size) for (int i = size - 1; i >= 0; --i)
#else
#error "Endianness not detected"
#endif

#define printb(value)                                   \
({                                                      \
        typeof(value) _v = value;                       \
        __printb((typeof(_v) *) &_v, sizeof(_v));       \
})

void __printb(void *value, size_t size)
{
        uint8_t byte;
        size_t blen = sizeof(byte) * 8;
        uint8_t bits[blen + 1];

        bits[blen] = '\0';
        for_endian(size) {
                byte = ((uint8_t *) value)[i];
                memset(bits, '0', blen);
                for (int j = 0; byte && j < blen; ++j) {
                        if (byte & 0x80)
                                bits[j] = '1';
                        byte <<= 1;
                }
                printf("%s ", bits);
        }
        printf("\n");
}

int main(void)
{
        uint8_t c1 = 0xff, c2 = 0x44;
        uint8_t c3 = c1 + c2;

        printb(c1);
        printb((char) 0xff);
        printb((short) 0xff);
        printb(0xff);
        printb(c2);
        printb(0x44);
        printb(0x4411ff01);
        printb((uint16_t) c3);
        printf("\n");

        return 0;
}

उत्पादन

$ ./printb 
11111111 
11111111 
00000000 11111111 
00000000 00000000 00000000 11111111 
01000100 
00000000 00000000 00000000 01000100 
01000100 00010001 11111111 00000001 
00000000 01000011

मैंने सभी बाइट्स (बिट स्ट्रिंग्स) के साथ एक टेबल को भरने और इनपुट / इंडेक्स बाइट के आधार पर उन्हें प्रिंट करने के लिए एक और दृष्टिकोण ( बिटप्रिंट.एच ) का उपयोग किया है । यह देखने लायक है।

— गीसलन जी बेम
स्रोत
4 
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');
    }

}
— малин чекуров
स्रोत
या '0' के चरित्र मान में 0 या 1 जोड़ें;) कोई टर्नरी की जरूरत नहीं है।
— उल्लू
3

मुझे paniq द्वारा कोड पसंद आया, स्थैतिक बफर एक अच्छा विचार है। हालाँकि यह विफल रहता है यदि आप एक सिंगल प्रिंटफ () में कई बाइनरी फॉर्मेट चाहते हैं क्योंकि यह हमेशा एक ही पॉइंटर देता है और एरे को ओवरराइट कर देता है।

यहां एक सी स्टाइल ड्रॉप-इन है जो एक विभाजन बफर पर सूचक को घुमाता है।

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;
}
— eMPee584
स्रोत
1
एक बार countपहुँच MAXCNT - 1, के अगले वेतन वृद्धि countयह होगा MAXCNTशून्य के बजाय, जो सरणी की सीमाओं से बाहर एक पहुँच का कारण होगा। आपको करना चाहिए था count = (count + 1) % MAXCNT।
— शाहबाज
1
वैसे, यह बाद में एक डेवलपर के लिए एक आश्चर्य के रूप में आएगा जो MAXCNT + 1एकल में इस फ़ंक्शन के लिए कॉल का उपयोग करता है printf। सामान्य तौर पर, यदि आप 1 से अधिक चीज़ों के लिए विकल्प देना चाहते हैं, तो इसे अनंत बनाएं। 4 जैसी संख्याएँ केवल समस्या पैदा कर सकती हैं।
— शाहबाज
3

कोई मानक और पोर्टेबल तरीका नहीं है।

कुछ कार्यान्वयन इटोआ () प्रदान करते हैं , लेकिन यह अधिकांश में नहीं होने जा रहा है, और इसमें कुछ हद तक क्रमी इंटरफ़ेस है। लेकिन कोड लिंक के पीछे है और आपको अपने स्वयं के फॉर्मेटर को बहुत आसानी से लागू करने देना चाहिए।

— wnoise
स्रोत
3

मानक पुस्तकालय के उपयोग से बाइनरी स्ट्रिंग प्रतिनिधित्व में किसी भी अभिन्न प्रकार का सामान्य रूपांतरण

#include <bitset>
MyIntegralType  num = 10;
print("%s\n",
    std::bitset<sizeof(num) * 8>(num).to_string().insert(0, "0b").c_str()
); // prints "0b1010\n"

या केवल: std::cout << std::bitset<sizeof(num) * 8>(num);

— luart
स्रोत
1
यह C ++ के लिए एक मुहावरेदार समाधान है, लेकिन वह
— danijar
3

मेरा समाधान:

long unsigned int i;
for(i = 0u; i < sizeof(integer) * CHAR_BIT; i++) {
    if(integer & LONG_MIN)
        printf("1");
    else
        printf("0");
    integer <<= 1;
}
printf("\n");
— SarahGaidi
स्रोत
3

उसके जवाब में @ ideasman42 के सुझाव के आधार पर, इस मैक्रो प्रदान करता है int8, 16, 32और 64संस्करणों, पुन: उपयोग INT8से बचने पुनरावृत्ति करने के लिए मैक्रो।

/* --- PRINTF_BYTE_TO_BINARY macro's --- */
#define PRINTF_BINARY_SEPARATOR
#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_SEPARATOR              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_SEPARATOR              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_SEPARATOR              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

पठनीयता के लिए आप बदल सकते हैं: #define PRINTF_BINARY_SEPARATORकरने के लिए #define PRINTF_BINARY_SEPARATOR ","या#define PRINTF_BINARY_SEPARATOR " "

यह आउटपुट होगा:

My Flag 00010110,11100001,00101011,01111101,01111000,10010000,11110000,00101000

या

My Flag 00010110 11100001 00101011 01111101 01111000 10010000 11110000 00101000
— Et7f3XIV
स्रोत
इस कोड को कॉपी करने के लिए धन्यवाद, पहले इस प्रोजेक्ट में कॉपी करने के लिए, जिस पर मैं काम कर रहा हूं, यह महसूस करना थकाऊ काम की तरह है :)
— DevZer0
3

उपयोग:

char buffer [33];
itoa(value, buffer, 2);
printf("\nbinary: %s\n", buffer);

अधिक रेफरी के लिए, देखें कि प्रिंटफ के माध्यम से बाइनरी नंबर कैसे प्रिंट करें ।

— kapilddit
स्रोत
1
पिछले उत्तर में कहा गया था कि "कुछ कार्यान्वयन इटोआ () प्रदान करते हैं, लेकिन यह सबसे अधिक नहीं होगा" ?
— पीटर मोर्टेंसन
2 
void print_ulong_bin(const unsigned long * const var, int bits) {
        int i;

        #if defined(__LP64__) || defined(_LP64)
                if( (bits > 64) || (bits <= 0) )
        #else
                if( (bits > 32) || (bits <= 0) )
        #endif
                return;

        for(i = 0; i < bits; i++) { 
                printf("%lu", (*var >> (bits - 1 - i)) & 0x01);
        }
}

काम करना चाहिए - अप्रयुक्त।

— ओली
स्रोत
2 
/* Convert an int to it's binary representation */

char *int2bin(int num, int pad)
{
 char *str = malloc(sizeof(char) * (pad+1));
  if (str) {
   str[pad]='\0';
   while (--pad>=0) {
    str[pad] = num & 1 ? '1' : '0';
    num >>= 1;
   }
  } else {
   return "";
  }
 return str;
}

/* example usage */

printf("The number 5 in binary is %s", int2bin(5, 4));
/* "The number 5 in binary is 0101" */
— बेन कोरडरो
स्रोत
4
एक मॉलोकेशन की लागत का भुगतान प्रदर्शन को नुकसान पहुंचाएगा। कॉलगर्ल को बफर के विनाश के लिए ज़िम्मेदारी से गुजरना निर्दयी है।
— एविल टीच
2

अगला आपको मेमोरी लेआउट दिखाएगा:

#include <limits>
#include <iostream>
#include <string>

using namespace std;

template<class T> string binary_text(T dec, string byte_separator = " ") {
    char* pch = (char*)&dec;
    string res;
    for (int i = 0; i < sizeof(T); i++) {
        for (int j = 1; j < 8; j++) {
            res.append(pch[i] & 1 ? "1" : "0");
            pch[i] /= 2;
        }
        res.append(byte_separator);
    }
    return res;
}

int main() {
    cout << binary_text(5) << endl;
    cout << binary_text(.1) << endl;

    return 0;
}
— Yola
स्रोत
"अगला आपको मेमोरी लेआउट दिखाएगा" से आपका क्या मतलब है ?
— पीटर मोर्टेंसन
2

यहाँ paniq के समाधान की एक छोटी विविधता है जो 32 और 64 बिट पूर्णांक की छपाई की अनुमति देने के लिए टेम्पलेट्स का उपयोग करता है:

template<class T>
inline std::string format_binary(T x)
{
    char b[sizeof(T)*8+1] = {0};

    for (size_t z = 0; z < sizeof(T)*8; z++)
        b[sizeof(T)*8-1-z] = ((x>>z) & 0x1) ? '1' : '0';

    return std::string(b);
}

और इस्तेमाल किया जा सकता है:

unsigned int value32 = 0x1e127ad;
printf( "  0x%x: %s\n", value32, format_binary(value32).c_str() );

unsigned long long value64 = 0x2e0b04ce0;
printf( "0x%llx: %s\n", value64, format_binary(value64).c_str() );

यहाँ परिणाम है:

  0x1e127ad: 00000001111000010010011110101101
0x2e0b04ce0: 0000000000000000000000000000001011100000101100000100110011100000
— सिंह
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.