বাইনারি ফর্ম্যাটে মুদ্রণের জন্য কি একটি প্রিন্টফ রূপান্তরকারী আছে?

434

আমি প্রিন্টফের সাথে একটি হেক্স বা অষ্টাল নম্বর হিসাবে মুদ্রণ করতে পারি। বাইনারি, বা স্বেচ্ছাচারী বেস হিসাবে মুদ্রণের জন্য কোনও ফর্ম্যাট ট্যাগ নেই?

আমি জিসিসি চালাচ্ছি।

printf("%d %x %o\n", 10, 10, 10); //prints "10 A 12\n"
print("%b\n", 10); // prints "%b\n"
c  printf 
— ব্রায়ান
সূত্র
প্রিন্টফ ব্যবহার করে আপনি যতদূর জানতে পারছেন এটি করতে পারবেন না। আপনি এগুলি সম্পাদন করার জন্য অবশ্যই একটি সহায়ক পদ্ধতি লিখতে পারেন, তবে আপনি যে দিকে যেতে চান সেদিকে এটি শোনাচ্ছে না।
— ইয়ান পি
এর জন্য পূর্বনির্ধারিত কোনও বিন্যাস নেই। এটিকে আপনার নিজের একটি স্ট্রিংয়ে রূপান্তর করতে হবে এবং তারপরে স্ট্রিংটি মুদ্রণ করতে হবে।
— rslite
একটি দ্রুত গুগল অনুসন্ধান এই পৃষ্ঠায় এমন কিছু তথ্য তৈরি করেছে যা দরকারী হতে পারে: forums.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পারবেন না।
— প্যাট্রিক Schlüter
4
আমি এটিকে পরিবর্তন করার %dজন্য স্বাধীনতা নিয়েছি %c, কারণ এটি আরও দ্রুত হওয়া উচিত ( %dডিজিট-> চর রূপান্তর করতে হবে, যখন %cযুক্তিটি সহজভাবে প্রকাশ করবে
3
সঙ্গে 16, 32, 64 বিট int- এ সমর্থন এই ম্যাক্রো একটি প্রসারিত সংস্করণ পোস্ট: stackoverflow.com/a/25108449/432509
— ideasman42
2
মনে রাখবেন যে এই পদ্ধতিটি বন্ধুত্বপূর্ণ নয়। ধরে intনেওয়া সিস্টেমে 32-বিট, একক 32-বিট মান মুদ্রণের জন্য 32 * 4-বাইট মানগুলির জন্য স্থান প্রয়োজন হবে; মোট 128 বাইট স্ট্যাক আকারের উপর নির্ভর করে কোনটি কোনও সমস্যা হতে পারে বা নাও হতে পারে।
— ব্যবহারকারী 694733
1
ম্যাক্রোতে বাইটের চারপাশে বন্ধনী যুক্ত করা গুরুত্বপূর্ণ বা কোনও অপারেশন প্রেরণ করার সময় আপনি সমস্যার মধ্যে পড়ে যেতে পারেন BYTE_TO_BINARY (a | b) -> a | b & 0x01! = (a | b) & 0x01
— ইভান হফম্যান
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;
}
— ক্রিপটাইচ মনিকার সাথে দাঁড়িয়ে আছে
সূত্র
8
সুপারিশ size_t i; for (i=size; i-- > 0; )এড়াতে size_tবনাম intভুল ম্যাচ।
— chux - মনিকা পুনরায় ইনস্টল করুন
1
কেউ এই কোড পিছনে যুক্তি বিস্তারিত দয়া করে বলতে পারেন?
— jII
2
ptr(বাইরের লুপ) প্রতিটি বাইট নিন ; তারপরে প্রতিটি বিটের জন্য বর্তমান বাইট (অভ্যন্তরীণ লুপ), বর্তমান বিট ( 1 << j) দ্বারা বাইটটি মাস্ক করুন । 0 ( 0000 0000b) বা 1 ( 0000 0001b) সমেত একটি বাইটের ফলে ডানদিকে ডান স্থানান্তর করুন । বিন্যাস সহ ফলাফল বাইট প্রিন্ট মুদ্রণ করুন %u। আছে HTH।
— নিলসবট
1
@ জেডএক্স 9 বিজ্ঞপ্তি দিন যে লুপটি কখন বন্ধ করতে হবে তা নির্ধারণ করতে প্রস্তাবিত কোডটি আপনার মন্তব্যের >সাথে size_tনয় এবং ব্যবহৃত হয়েছে >=।
— chux - মনিকা পুনরায় স্থাপন করুন
3
@ জেডএক্স 9 এখনও কোডার হিসাবে আপনার একটি দরকারী মূল মন্তব্যটি সাইন ইন না করে >এবং >=প্রকারের ক্ষেত্রে প্রান্তের ক্ষেত্রে বিবেচনা করে যত্নবান হওয়া দরকার । 0স্বাক্ষরবিহীন প্রান্তের কেস এবং সাধারণত দেখা যায়, স্বল্প পরিমাণে স্বাক্ষরিত গণিতের বিপরীতে INT_MAX/INT_MIN।
— chux - মনিকা পুনরায় স্থাপন করুন
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
@ এভিলটিচ: আপনি নিজের একটি প্যারামিটার হিসাবে একটি টের্নারি অপারেটর ব্যবহার করছেন strcat()! আমি সম্মত হই যে strcatকার্যভারের জন্য একটি অগ্রণী পয়েন্টার পোস্ট-ইনক্রিমেন্ট করার চেয়ে সম্ভবত বোঝা সহজ, তবে এমনকি প্রাথমিকদের কীভাবে স্ট্যান্ডার্ড লাইব্রেরিটি সঠিকভাবে ব্যবহার করতে হয় তাও জানতে হবে। অ্যাসাইনমেন্টের জন্য একটি ইনডেক্সেড অ্যারে ব্যবহার করা ভাল প্রদর্শিত হতে পারে (এবং আসলে কাজ করবে, যেহেতু bআপনি যখন ফাংশনটি প্রতিবার কল করবেন তখন অল-জিরোতে রিসেট হয়নি)।
— tomlogic
3
এলোমেলো: বাইনারি বাফার চর স্থির, এবং অ্যাসাইনমেন্টের সমস্ত জিরোতে সাফ হয়ে যায়। এটি কেবল এটি প্রথমবার চালানোর সময় সাফ করবে এবং এর পরে এটি পরিষ্কার হবে না, পরিবর্তে শেষ মানটি ব্যবহার করবে।
— মার্কওয়াটসন
8
এছাড়াও, এই দস্তাবেজটি উচিত যে পূর্ববর্তী ফলাফলের ফাংশন আবার কল পর অবৈধ হয়ে যাবে, তাই কলারের এর মতো এটিকে ব্যবহারের চেষ্টা করা উচিত নয়: printf("%s + %s = %s", byte_to_binary(3), byte_to_binary(4), byte_to_binary(3+4))।
— পাওলো ইবারম্যান
84

সাধারণত গ্লিবসি-তে কোনও বাইনারি রূপান্তর নির্দিষ্টকরণকারী নেই।

গ্লিবিসি-তে ফাংশনগুলির প্রিন্টফ () পরিবারে কাস্টম রূপান্তর প্রকার যুক্ত করা সম্ভব। বিস্তারিত জানতে নিবন্ধক_প্রিন্টফ_ফানশন দেখুন । আপনার নিজের ব্যবহারের জন্য আপনি কাস্টম% বি রূপান্তর যুক্ত করতে পারেন, যদি এটি অ্যাপ্লিকেশন কোডটি সহজলভ্য করে এটি উপলব্ধ করে।

এখানে গ্লিবসিতে কীভাবে কাস্টম প্রিন্টফ ফর্ম্যাটগুলি প্রয়োগ করতে হয় তার একটি উদাহরণ ।

— DGentry
সূত্র
আমি সর্বদা আমার নিজস্ব ভি [স্নেফ] প্রিন্টফ () সীমাবদ্ধ ক্ষেত্রে যেখানে আলাদা আলাদা রেডিক্স চেয়েছি তার জন্য লিখেছি: এতে আমি খুব খুশি হয়েছি।
— জেমি
3
warning: 'register_printf_function' is deprecated [-Wdeprecated-declarations]একই, যদিও করতে একটি নতুন ফাংশন: register_printf_specifier()। নতুন ব্যবহার একটি উদাহরণ এখানে পাওয়া যেতে পারে: codereview.stackexchange.com/q/219994/200418
— Cacahuete বাণিজ্যের একজন অনুমোদিত প্রতিনিধি
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');
— Koray Tugay
@ KorayTugay এটি নির্দেশ করার জন্য ধন্যবাদ। আমি ফাংশন কলটি সংশোধন করে একটি ডেমো যুক্ত করেছি।
— দানিজার
6
আপনার স্বাক্ষরবিহীন ইনট নম্বরটিও ব্যবহার করা উচিত, কারণ প্রদত্ত নম্বরটি নেতিবাচক হলে ফাংশনটি কখনও শেষ না হওয়া পুনরাবৃত্তির কলটিতে প্রবেশ করে।
— পাফি
আরও দক্ষ পদ্ধতি, যেহেতু ASCII তে, '0' + 1 = '1':putc('0'+(number&1), stdout);
— রজার ডিউক
22

@William Whyte এর উত্তর উপর ভিত্তি করে, এই একটি ম্যাক্রো যে প্রদান করে 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
Optionচ্ছিকভাবে PRINTF_BYTE_TO_BINARY_INT#ব্যবহারের জন্য সংজ্ঞায়িতদের একটি শ্রেণীবদ্ধ সংস্করণ যুক্ত করবে ।
— ধারণাগুলি 42
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);প্রত্যাশার মতো কাজ করবে না। কলারকে বাফারটি পাস করতে বাধ্য করা স্টোরেজের প্রয়োজনীয়তাটিকে স্পষ্ট করে তোলে; কলকারী অবশ্যই স্ট্যাটিক বাফারটি ব্যবহার করতে পারেন যদি এটি সত্যই পছন্দ করে তবে একই বাফারের পুনরায় ব্যবহার স্পষ্ট হয়ে যায়। আরও মনে রাখবেন যে, আধুনিক পিআইসি এবিআইতে, স্ট্যাটিক বাফারগুলিতে সাধারণত স্ট্যাকের বাফারদের চেয়ে অ্যাক্সেসের জন্য বেশি কোডের প্রয়োজন হয়।
— আর .. গিথহাব বন্ধ করুন সহায়তা আইসিসি
8
এটি এখনও একটি খারাপ নকশা। এই ক্ষেত্রে এটিগুলির জন্য একটি অতিরিক্ত অনুলিপি পদক্ষেপ প্রয়োজন, এবং কলার প্রয়োজন নেই এমন ক্ষেত্রে এমনকি কলার বাফার সরবরাহ করার চেয়ে কম ব্যয়বহুল । স্ট্যাটিক স্টোরেজ ব্যবহার করা একটি খারাপ প্রতিমা।
— আর .. গিথহাব থামিয়ে দিন IEL
3
অপ্রয়োজনীয় অতিরিক্ত নামের প্রিপ্রসেসর বা পরিবর্তনশীল প্রতীক টেবিলের নাম স্থান দূষিত করে রাখা উচিত যা প্রতিটি আহ্বানকারীকে বরাদ্দ করতে হবে এমন স্টোরেজ সঠিকভাবে আকারের জন্য ব্যবহার করতে হবে এবং প্রতিটি কলারকে এই মানটি জানতে বাধ্য করতে এবং প্রয়োজনীয় পরিমাণ বরাদ্দ করতে বাধ্য হয় স্টোরেজ, খারাপ ডিজাইন যখন সহজ ফাংশন-স্থানীয় স্টোরেজ সমাধান বেশিরভাগ উদ্দেশ্য এবং উদ্দেশ্যগুলির জন্য যথেষ্ট হবে এবং যখন একটি সাধারণ স্টার্ডআপ () কল ব্যবহারের বাকি 99% অংশ কভার করে।
— গ্রেগ এ উডস
5
এখানে আমরা একমত হতে হবে। আমি দেখতে পাচ্ছি না যে কীভাবে একটি অযৌক্তিক প্রিপ্রোসেসর প্রতীক যুক্ত করার ফলে ব্যবহারের কেসগুলি গুরুতরভাবে সীমাবদ্ধ করার, ইন্টারফেসটিকে ত্রুটি-প্রবণ করে তোলা, অস্থায়ী মানের জন্য প্রোগ্রামের সময়কালের জন্য স্থায়ী সঞ্চয়স্থান সংরক্ষণ করা এবং বেশিরভাগ ক্ষেত্রে আরও খারাপ কোড উত্পন্ন করার ক্ষতিকারকতার কাছে আসে comes আধুনিক প্ল্যাটফর্ম
— আর .. গিথহাব বন্ধ করুন ICE
5
আমি কারণ ছাড়াই মাইক্রো-অপ্টিমাইজ করার পক্ষে নেই (অর্থাত্ পরিমাপ)। তবে আমি মনে করি পারফরম্যান্স, এটি মাইক্রো-লাভ স্কেলে হলেও, এটি মৌলিকভাবে উচ্চতর ডিজাইনের পাশাপাশি বোনাস হিসাবে আসে তখন তা উল্লেখযোগ্য।
— আর .. গিথহাব থামিয়ে দিন IEL
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 টি অক্ষর দীর্ঘ হওয়া উচিত যাতে শেষ অক্ষরটি নাল টার্মিনেটর হিসাবে থাকতে পারে।
— টমলোগিক
এছাড়াও বি প্রতিবারই আরম্ভ করা দরকার।
— এভিলটেক
2
যদি আপনি কিছু পরিবর্তন করেন না: ১. একটি চূড়ান্ত শূন্যের জন্য স্থান যুক্ত করুন: static char b[9] = {0}২ লুপের বাইরে ঘোষণার স্থানটি সরান: int z,y;৩. চূড়ান্ত শূন্য যুক্ত করুন : 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));
}

কোনও আকারের ধরণের এবং স্বাক্ষরিত এবং স্বাক্ষরযুক্ত স্বাক্ষরের জন্য কাজ করে। শিফটটি সাইন এক্সটেনশান করতে পারে বলে সাইন ইনটগুলি পরিচালনা করতে '& 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

পূর্বে পোস্ট করা উত্তরগুলির মধ্যে কোনওটিই আমি যা খুঁজছিলাম ঠিক তেমন নয়, তাই আমি একটি লিখেছিলাম। % বি এর সাথে ব্যবহার করা অত্যন্ত সহজ 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 টিরও বেশি বিট দিয়ে উপচে পড়বে?
— জানুস ট্রয়লসেন
শুভ কল, হ্যাঁ এটি হবে ... আমাকে বলা হয়েছিল যে আমাকে মালক ব্যবহার করা দরকার, কখনও ডন করে না?
— টেকপ্লেক্সএন্জিনিয়ার
হ্যা অবশ্যই. সুপার ইজি:char* buffer = (char*) malloc(sizeof(char) * 50);
— জানুস ট্রোলসন
@ জানুস ট্রেলসন, বা আরও পরিষ্কার, আরও ছোট, রক্ষণাবেক্ষণযোগ্য:char *buffer = malloc(sizeof(*buffer) * 50);
— শাহবাজ
"% বি" এই ক্ষেত্রে "% বি" এর চেয়ে আলাদা হবে কেন? পূর্ববর্তী উত্তরগুলি বলেছিল "সি স্ট্যান্ডার্ড লাইব্রেরিতে বাইনারি আউটপুট করার জন্য কোনও বিন্যাসকরণ কার্য নেই" " এবং " কিছু রানটাইম"% বি "সমর্থন করে যদিও এটি মানক নয়" " ।
— পিটার মর্টেনসেন 21
8

কিছু রানটাইম "% বি" সমর্থন করে যদিও এটি মানক নয়।

একটি আকর্ষণীয় আলোচনার জন্য এখানে দেখুন:

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

আছে HTH

— rlerallut
সূত্র
1
এটি আসলে সি রানটাইম লাইব্রেরির একটি সম্পত্তি, সংকলক নয়।
— সিজেএম
7

এই কোডটি আপনার প্রয়োজনগুলি 64 বিট পর্যন্ত পরিচালনা করতে হবে। আমি 2 ফাংশন পিবিন এবং পিনফিল তৈরি করেছি। দু'জনই একই কাজ করে তবে পিবিনফিল ফিলচারের সাহায্যে শীর্ষস্থানগুলিতে পূরণ করে। পরীক্ষা ফাংশনটি কিছু পরীক্ষার ডেটা তৈরি করে, তারপরে এটি ফাংশনটি ব্যবহার করে প্রিন্ট করে।



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
"# নির্ধারিত প্রস্থ 64" লগ 4cxx থেকে স্ট্রিমের সাথে বিরোধ করে। দয়া করে, প্রচলিতভাবে এলোমেলোভাবে সংজ্ঞায়িত নামগুলি ব্যবহার করুন :)
— কাগলি-সান
5
@ মাহাম্ব্রা: আপনার যেমন জেনেরিক নাম ব্যবহার করার জন্য log4cxx বন্ধ করে দেওয়া উচিত width!
— u0b34a0f6ae
7

বাইনারি ফর্ম্যাটে মুদ্রণের জন্য কি একটি প্রিন্টফ রূপান্তরকারী আছে?

printf()পরিবার শুধুমাত্র বেস 8, 10, এবং 16 এর মধ্যে প্রিন্ট করতে সরাসরি মান নির্দিষ্টকরী ব্যবহার সক্ষম হয়। আমি এমন একটি ফাংশন তৈরির পরামর্শ দিচ্ছি যা কোডের নির্দিষ্ট প্রয়োজনীয়তার জন্য সংখ্যাটিকে স্ট্রিংয়ে রূপান্তর করে।

যে কোনও বেসে মুদ্রণ করতে [2-3-]

এখনও অবধি অন্যান্য সমস্ত উত্তরগুলির মধ্যে এই সীমাবদ্ধতার মধ্যে কমপক্ষে একটি রয়েছে।

  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 - মনিকা পুনরায় স্থাপন করুন
সূত্র
এটি খুব দরকারী। আপনি কি এটি সি ++ এ ব্যবহার করবেন জানেন? আমি যখন সংকলন করি তখন এটি ত্রুটি উত্পন্ন করে "গুরুতর কোড বিবরণ প্রকল্প ফাইল লাইন দমন স্থিতি ত্রুটি C4576 একটি প্রথম বন্ধকের তালিকা অনুসারে একটি প্রথম বন্ধনী টাইপ হ'ল মানহীন স্বতন্ত্র ধরণের রূপান্তর বাক্য সিনট্যাক্স হ্যালো সি: \ আমার_প্রজেক্টস \ হ্যালো \ হ্যালো \ মেন সিপিপি 39 "
— কেবলমাত্র একজন শিক্ষানবিশ
1
@ জুতালেয়ার্নার এটি একটি সি ++ জেনারেট করে কারণ যদি এটি সি বৈশিষ্ট্যযুক্ত যৌগিক আক্ষরিক ব্যবহার করে যা সি ++ এর অংশ নয়। সম্ভবত আপনার সি ++ বাস্তবায়ন পোস্ট করুন যা একই কাজ করার চেষ্টা করে - অসম্পূর্ণ হলেও, আমি নিশ্চিত আপনি সহায়তা পাবেন - যতক্ষণ আপনি প্রথমে আপনার প্রচেষ্টাটি দেখান।
— chux - মনিকা পুনরায় স্থাপন করুন
6

কিছুটা ওটি হতে পারে তবে আপনি যে বাইনারি ক্রিয়াকলাপগুলি করছেন তা বোঝার জন্য বা ডিটগিংয়ের জন্য আপনার যদি এটির প্রয়োজন হয় তবে আপনি ডাব্লুএসিএলসি (একটি সাধারণ কনসোল ক্যালকুলেটর) দেখে নিতে পারেন। -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

আমি আকার এবং সি ++ - নেসের জন্য শীর্ষ সমাধানটি অনুকূলিত করে এই সমাধানটি পেয়েছি:

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

কম কোড এবং সংস্থান ব্যবহার করে যে কোনও প্রকার থেকে বিটগুলি প্রিন্ট করুন

এই পদ্ধতির বৈশিষ্ট্য হিসাবে রয়েছে:

  • ভেরিয়েবল এবং আক্ষরিক সাথে কাজ করে।
  • যখন প্রয়োজন হয় না তখন সমস্ত বিটগুলি পুনরাবৃত্তি করে না।
  • বাইট সম্পূর্ণ করার সময়ই প্রিন্টফে কল করুন (সমস্ত বিটের জন্য অযৌক্তিকভাবে নয়)।
  • যে কোনও প্রকারের জন্য কাজ করে।
  • সামান্য এবং বড় এডিয়েননেস নিয়ে কাজ করে (পরীক্ষার জন্য জিসিসি # নির্দিষ্টকরণগুলি ব্যবহার করে)।
  • (টাইপফ) ব্যবহার করুন যা সি স্ট্যান্ডার্ড নয় তবে মূলত সংজ্ঞায়িত।
#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

সমস্ত বাইট (বিট স্ট্রিং হিসাবে) সহ একটি টেবিল পূরণ করতে এবং ইনপুট / সূচক বাইটের ভিত্তিতে এগুলি মুদ্রণের জন্য আমি আরেকটি পদ্ধতির ( বিটপ্রিন্ট। H ) ব্যবহার করেছি । এটি একবার দেখুন মূল্যবান।

— গিস্লান জি। বেম
সূত্র
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

আমি পানিকের সাহায্যে কোডটি পছন্দ করেছি, স্ট্যাটিক বাফারটি ভাল ধারণা। তবে এটি ব্যর্থ হয় যদি আপনি একক মুদ্রণ () মুভিতে একাধিক বাইনারি ফর্ম্যাট চান তবে এটি সর্বদা একই পয়েন্টারটি ফেরত দেয় এবং অ্যারেটিকে ওভাররাইট করে।

এখানে একটি সি স্টাইলের ড্রপ-ইন রয়েছে যা বিভক্ত বাফারে পয়েন্টারকে ঘোরায়।

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
এটি সি ++ এর জন্য একটি অদ্ভুত সমাধান তবে তিনি সি
— র
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
পূর্ববর্তী উত্তর বলেছিল "কিছু বাস্তবায়ন ইতোয়া সরবরাহ করে (), তবে এটি বেশিরভাগ ক্ষেত্রে হবে না" ?
— পিটার মর্টেনসেন 21
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);
        }
}

কাজ করা উচিত - অপরিশোধিত।

— Olli
সূত্র
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

পানিকের সমাধানের একটি সামান্য প্রকরণ এখানে 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
— সিংহরাশি
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.