क्या मैं सी या सी ++ में एक बाइनरी शाब्दिक उपयोग कर सकता हूं?

Question

मुझे एक बाइनरी नंबर के साथ काम करने की आवश्यकता है।

मैंने लिखने की कोशिश की:

const x = 00010000;

लेकिन यह काम नहीं किया।

मुझे पता है कि मैं एक हेक्साडेसिमल संख्या का उपयोग कर सकता हूं जिसका मान उतना ही है 00010000, लेकिन मैं जानना चाहता हूं कि क्या बाइनरी संख्याओं के लिए C ++ में एक प्रकार है और यदि नहीं है, तो क्या मेरी समस्या का कोई और समाधान है?

Comments

आप जानते हैं कि 00010000अष्टदल है, है ना? (और आपकी घोषणा एक प्रकार की याद आ रही है।)

— कीथ थॉम्पसन

यहाँ C ++ शाब्दिक का उपयोग करके आधुनिक तरीका।

— लोल

C ++ 14 ने इसके लिए एक फीचर जोड़ा। नीचे दिए गए अधिक विवरण के लिए मेरा नया उत्तर देखें। बेशक, इसे एक कंपाइलर की आवश्यकता होती है जो इसे लागू करता है।

— lpapp

@FormlessCloud: ये C और C ++ मानकों में दिए गए वाक्यविन्यास नियम हैं ( 0bकेवल C ++ 14 में दिखाई देते हैं)। वे असंदिग्ध होने के लिए डिज़ाइन किए गए हैं।

— कीथ थॉम्पसन

बाइनरी लीटर के

— एमजे रेबर्न

Answer 1

आप C ++ 0x की प्रतीक्षा करतेBOOST_BINARY समय उपयोग कर सकते हैं । :) BOOST_BINARYयकीनन टेम्प्लेट कार्यान्वयन इंसोफ़र पर एक फायदा है क्योंकि इसे सी कार्यक्रमों में भी इस्तेमाल किया जा सकता है (यह 100% प्रीप्रोसेसर-चालित है।)

अनुलग्‍नक (यानी बाइनरी फॉर्म में एक नंबर का प्रिंट आउट) करने के लिए, आप गैर-पोर्टेबल itoaफ़ंक्शन का उपयोग कर सकते हैं , या अपना खुद का कार्यान्वयन कर सकते हैं ।

दुर्भाग्य से आप एसटीएल धाराओं के साथ बेस 2 फॉर्मेटिंग नहीं कर सकते हैं (क्योंकि setbaseकेवल आधार 8, 10 और 16 को सम्मानित करेगा), लेकिन आप या तो एक संस्करण का उपयोग कर सकते हैं , या (अधिक संक्षिप्त, अभी तक थोड़ा कम कुशल) ।std::stringitoastd::bitset

#include <boost/utility/binary.hpp>
#include <stdio.h>
#include <stdlib.h>
#include <bitset>
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  unsigned short b = BOOST_BINARY( 10010 );
  char buf[sizeof(b)*8+1];
  printf("hex: %04x, dec: %u, oct: %06o, bin: %16s\n", b, b, b, itoa(b, buf, 2));
  cout << setfill('0') <<
    "hex: " << hex << setw(4) << b << ", " <<
    "dec: " << dec << b << ", " <<
    "oct: " << oct << setw(6) << b << ", " <<
    "bin: " << bitset< 16 >(b) << endl;
  return 0;
}

पैदा करता है:

hex: 0012, dec: 18, oct: 000022, bin:            10010
hex: 0012, dec: 18, oct: 000022, bin: 0000000000010010

एक दिलचस्प चर्चा के लिए मैनर फ़ार्म के हर्ब सटर के द स्ट्रिंग फॉर्मेटर्स भी पढ़ें ।

Comments

जिस पृष्ठ पर आप लिंक कहते हैं, आप केवल 8, 10 या 16 सेटबेस के साथ उपयोग कर सकते हैं। हालाँकि:int main() { cout << bitset<8>(42); }

@ bitsetटिप के लिए धन्यवाद , मैंने पहले ही थोड़ा सुधार कर लिया था, setbaseहालांकि मैंने आपकी टिप्पणी देखी थी।

— vladr

यहाँ c + 11: akrzemi1.wordpress.com/2012/10/23/user-defined-literals-part-ii में यूज़र-डिफ़ाइंड लिटरल्स पर एक ट्यूटोरियल है । जाहिर है c ++ 1y (उर्फ c ++ 14) मानक में द्विआधारी शाब्दिक शामिल होगा।

— चेशायरकोव

Answer 2

यदि आप GCC का उपयोग कर रहे हैं तो आप इसके लिए GCC एक्सटेंशन (जो C ++ 14 मानक में शामिल है ) का उपयोग कर सकते हैं :

int x = 0b00010000;

Comments

कई अन्य संकलक के पास आधार में संख्याओं को व्यक्त करने के इस या अन्य समान तरीके हैं

— nategoose

यह मानकीकृत होना अच्छा होगा, लेकिन क्लैंग उसी संकेतन का समर्थन करता है।

— पोलीमोन

यह Clang, GCC और TCC में काम करता है। यह पीसीसी में काम नहीं करता है। मेरे पास परीक्षण करने के लिए कोई अन्य संकलक नहीं है।

— मिखस

मैंने कई एम्बेडेड-सिस्टम कंपाइलरों को देखा है जो इसका समर्थन करते हैं। मुझे कोई विशेष कारण नहीं पता है कि यह एक मानक भाषा सुविधा नहीं होनी चाहिए।

— सुपरकैट

@polemon open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf (C ++ 14।)

— जोनाथन बाल्डविन

Answer 3

आप बाइनरी लीटर का उपयोग कर सकते हैं। वे सी ++ 14 में मानकीकृत हैं। उदाहरण के लिए,

int x = 0b11000;

जीसीसी में समर्थन

GCC में GCC 4.3 में समर्थन शुरू हुआ (देखें https://gcc.gnu.org/gcc-4.3/changes.html ) C भाषा परिवार के एक्सटेंशन के रूप में (देखें https://gcc.gnu.org/oniltocs/gcc/ C-Extensions.html # C-Extensions ), लेकिन GCC 4.9 के बाद से अब इसे C ++ 14 फ़ीचर या एक्सटेंशन के रूप में मान्यता दी गई है ( GCC बाइनरी लिटरल्स और C ++ 14 वाले के बीच अंतर देखें ? )

विजुअल स्टूडियो में सपोर्ट

विजुअल स्टूडियो 2015 प्रिव्यू में विजुअल स्टूडियो का समर्थन शुरू हुआ (देखें https://www.visualstudio.com/news/vs2015-preview-vs#C++ )।

Comments

आप 'प्रत्येक भाग को अलग करने के लिए' का उपयोग कर सकते हैं: "0b0000'0100'0100'0001

— कैमिनो

@camino अच्छा आप पहले ढीला कर सकते हैं "

— निकोस

यह स्वीकृत उत्तर होना चाहिए। अन्य जवाबों में से अधिकांश पुराने हो चुके हैं।

— एलेक्स

Answer 4

template<unsigned long N>
struct bin {
    enum { value = (N%10)+2*bin<N/10>::value };
} ;

template<>
struct bin<0> {
    enum { value = 0 };
} ;

// ...
    std::cout << bin<1000>::value << '\n';

शाब्दिक के बाएं अंक को अभी भी 1 होना है, लेकिन फिर भी।

Comments

बेहतर संस्करण: bitbucket.org/kniht/scraps/src/tip/cpp/binary.hpp ( binary<10>::value == binary<010>::valueऔर कुछ त्रुटि की जाँच)

इससे पहले कि मैं अपने खुद के लगभग समान जवाब पोस्ट करने से पहले किसी तरह यह याद किया। लेकिन खान में अग्रणी अंक 0 होना है, न कि 1.

— मार्क रैनसम

इस टेम्प्लेट आइडिया का एक बेहतर संस्करण: code.google.com/p/cpp-binary-constants

— वैलेंटाइन गैलीआ

@ValentinGalea - Google संस्करण इससे बेहतर क्यों है?

— एजे

यह शानदार है। बहुत बुरा यह बिट्स की उच्च संख्या के लिए काम नहीं करता है।

— क्वांटम भौतिक विज्ञानी

Answer 5

कुछ संकलक (आमतौर पर माइक्रोकंट्रोलर के लिए ) में एक विशेष सुविधा होती है जिसे "0b ..." उपसर्ग द्वारा शाब्दिक द्विआधारी संख्या को पहचानने के भीतर कार्यान्वित किया जाता है , हालांकि संख्या से पहले (ज्यादातर C / C ++ मानकों में) ऐसी सुविधा नहीं है और यदि है यह मामला है, यहाँ यह मेरा वैकल्पिक समाधान है:

#define B_0000    0
#define B_0001    1
#define B_0010    2
#define B_0011    3
#define B_0100    4
#define B_0101    5
#define B_0110    6
#define B_0111    7
#define B_1000    8
#define B_1001    9
#define B_1010    a
#define B_1011    b
#define B_1100    c
#define B_1101    d
#define B_1110    e
#define B_1111    f

#define _B2H(bits)    B_##bits
#define B2H(bits)    _B2H(bits)
#define _HEX(n)        0x##n
#define HEX(n)        _HEX(n)
#define _CCAT(a,b)    a##b
#define CCAT(a,b)   _CCAT(a,b)

#define BYTE(a,b)        HEX( CCAT(B2H(a),B2H(b)) )
#define WORD(a,b,c,d)    HEX( CCAT(CCAT(B2H(a),B2H(b)),CCAT(B2H(c),B2H(d))) )
#define DWORD(a,b,c,d,e,f,g,h)    HEX( CCAT(CCAT(CCAT(B2H(a),B2H(b)),CCAT(B2H(c),B2H(d))),CCAT(CCAT(B2H(e),B2H(f)),CCAT(B2H(g),B2H(h)))) )

// Using example
char b = BYTE(0100,0001); // Equivalent to b = 65; or b = 'A'; or b = 0x41;
unsigned int w = WORD(1101,1111,0100,0011); // Equivalent to w = 57155; or w = 0xdf43;
unsigned long int dw = DWORD(1101,1111,0100,0011,1111,1101,0010,1000); //Equivalent to dw = 3745774888; or dw = 0xdf43fd28;

नुकसान (यह इतना बड़ा नहीं है):

• द्विआधारी संख्या को 4 से 4 से समूहीकृत करना होगा;
• बाइनरी शाब्दिक में केवल अहस्ताक्षरित पूर्णांक संख्याएं होनी चाहिए;

लाभ :

• कुल प्रीप्रोसेसर संचालित, निष्पादन योग्य कार्यक्रम के लिए spending processor timeव्यर्थ परिचालनों ( like "?.. :..", "<<", "+") में नहीं (इसे अंतिम अनुप्रयोग में सौ गुना किया जा सकता है);
• यह "mainly in C"संकलक और सी ++ के रूप में अच्छी तरह से काम करता है ( template+enum solution works only in C++ compilers);
• इसमें केवल "शाब्दिक निरंतर" मूल्यों को व्यक्त करने के लिए "लालसा" की सीमा है। यदि किसी व्यक्ति ने संकल्प को जारी रखते हुए निरंतर मूल्यों को व्यक्त किया होता तो प्रारंभिक लंपटता (आमतौर पर 8 बिट्स: 0-255) होती।"enum solution" (usually 255 = reach enum definition limit) अलग-अलग, "शाब्दिक स्थिर" सीमाओं के , तो संकलक अधिक संख्या में अनुमति देता है;
• कुछ अन्य समाधान लंबे या several header files(ज्यादातर मामलों में आसानी से पठनीय और समझने योग्य नहीं है, और परियोजना को अनावश्यक रूप से भ्रमित और विस्तारित कर देते हैं, जैसे कि प्रयोग करके "BOOST_BINARY()") सहित निरंतर परिभाषाओं की अतिरंजित संख्या (मेरी राय में बहुत से परिभाषित) की मांग करते हैं ;
• समाधान की सादगी: आसानी से पठनीय, समझने योग्य और अन्य मामलों के लिए समायोज्य (8 से 8 के समूह के लिए भी बढ़ाया जा सकता है);

Comments

क्यों B_0100इस्तेमाल किया जाता है (बजाय 0100)? जैसे की char b = BYTE(0100,0001);।

— पीटर मोर्टेंसन

@PeterMortensen B_ _B2Hप्रीप्रोसेसर फ़ंक्शन द्वारा जोड़ा जाता है।

— mxmlnkn

Answer 6

यह धागा मदद कर सकता है।

/* Helper macros */
#define HEX__(n) 0x##n##LU
#define B8__(x) ((x&0x0000000FLU)?1:0) \
+((x&0x000000F0LU)?2:0) \
+((x&0x00000F00LU)?4:0) \
+((x&0x0000F000LU)?8:0) \
+((x&0x000F0000LU)?16:0) \
+((x&0x00F00000LU)?32:0) \
+((x&0x0F000000LU)?64:0) \
+((x&0xF0000000LU)?128:0)

/* User macros */
#define B8(d) ((unsigned char)B8__(HEX__(d)))
#define B16(dmsb,dlsb) (((unsigned short)B8(dmsb)<<8) \
+ B8(dlsb))
#define B32(dmsb,db2,db3,dlsb) (((unsigned long)B8(dmsb)<<24) \
+ ((unsigned long)B8(db2)<<16) \
+ ((unsigned long)B8(db3)<<8) \
+ B8(dlsb))


#include <stdio.h>

int main(void)
{
    // 261, evaluated at compile-time
    unsigned const number = B16(00000001,00000101);

    printf("%d \n", number);
    return 0;
}

यह काम करता हैं! (सभी क्रेडिट टॉम टॉरफ़्स जाते हैं।)

Comments

मुझे वास्तव में समझ नहीं आया (प्रोग्रामिंग में और विशेष रूप से C ++ में ima शुरुआत) लेकिन यह दिलचस्प लगता है इसलिए मैं इसे कुछ और C ++ अध्ययनों के बाद समझने की कोशिश करूंगा, धन्यवाद

— hamza

B8 मैक्रो "बाइनरी" शाब्दिक को हेक्स शाब्दिक रूप से परिवर्तित करके और हर 4 बिट को निकालने का काम करता है।

— dan04

मुझे आश्चर्य है कि 0x ## n ## LU का मतलब क्या है? इस तरह के सिंटैक्स का सामना कभी नहीं किया।

— फेडेरिको ए। रामपोनी

@ धमाका: यह वास्तव में जटिल है। लेकिन आपको जो समझने की जरूरत है वह सिर्फ #include <stdio> के बाद से है।

— फेडरिको ए। रामपोनी

@ फ़ेडरिको: ##प्रीप्रोसेसर ऑपरेटर टोकन को एक साथ चिपकाता है। तो, इस मामले में, यदि आप कॉल करते हैं HEX__(10), तो इसका विस्तार होता है 0x10LU।

— जेम्स मैकनेलिस

Answer 7

जैसा कि पहले ही उत्तर दिया गया है, सी मानकों में सीधे बाइनरी नंबर लिखने का कोई तरीका नहीं है। हालाँकि, संकलक एक्सटेंशन हैं, और जाहिर तौर पर C ++ 14 में 0bबाइनरी के लिए उपसर्ग शामिल है । (ध्यान दें कि यह उत्तर मूल रूप से 2010 में पोस्ट किया गया था।)

एक लोकप्रिय समाधान हेल्पर मैक्रो के साथ एक हेडर फ़ाइल को शामिल करना है । एक आसान विकल्प यह भी है कि एक फाइल बनाई जाए जिसमें सभी 8-बिट पैटर्न के लिए मैक्रो परिभाषाएँ शामिल हों, जैसे:

#define B00000000 0
#define B00000001 1
#define B00000010 2
…

यह केवल 256 #defineएस में परिणाम देता है , और यदि 8-बिट बाइनरी स्थिरांक से बड़े की आवश्यकता होती है, तो इन परिभाषाओं को पाली और ओआरएस के साथ जोड़ा जा सकता है, संभवतः हेल्पर मैक्रोज़ (जैसे, BIN16(B00000001,B00001010)) के साथ। (प्रत्येक 16-बिट के लिए अलग-अलग मैक्रोज़ होने पर, अकेले 32-बिट होने दें, मूल्य प्रशंसनीय नहीं है।)

निश्चित रूप से नकारात्मक पक्ष यह है कि इस सिंटैक्स को सभी प्रमुख शून्य लिखने की आवश्यकता होती है, लेकिन यह बिट्स झंडे और हार्डवेयर रजिस्टरों की सामग्री का उपयोग करने के लिए इसे भी स्पष्ट कर सकता है। इस संपत्ति के बिना एक सिंटैक्स में होने वाले फ़ंक्शन-जैसे मैक्रो के लिए, bithacks.hऊपर लिंक देखें ।

Comments

तो, अगर आपके पास सभी मैक्रोज़ हैं, तो CPP को पढ़ने के लिए कितनी बड़ी फ़ाइल की आवश्यकता होगी long long int?

— विल्हेमटेल

@ विल्हेमटेल: और उस की क्या प्रासंगिकता है जब मैंने "सभी 8-बिट पैटर्न" (= 256 लाइनें) निर्दिष्ट किया था , और उन लोगों से बड़ी मात्रा में संयोजन का सुझाव दिया था? यहां तक ​​कि स्वीकृत उत्तर की BOOST_BINरी हेडर में सभी 8-बिट पैटर्न को परिभाषित करती है ...

— आर्क 12

Answer 8

C ++ ओवर-इंजीनियरिंग मानसिकता पहले से ही यहां अन्य उत्तरों के लिए अच्छी तरह से जिम्मेदार है। यहाँ एक C के साथ इसे करने का मेरा प्रयास है, इसे सरल-सरल बनाये रखने की मानसिकता रखें:

unsigned char x = 0xF; // binary: 00001111

Answer 9

C में शुद्ध बाइनरी संख्याओं के लिए मूल अंकन नहीं है । आपका सबसे अच्छा शर्त यहाँ या तो होगा अष्टाधारी (जैसे 07777की) हेक्साडेसिमल (जैसे 0xfff)।

Answer 10

आप इस प्रश्न में पाए गए फ़ंक्शन का उपयोग C ++ में 22 बिट्स तक कर सकते हैं। यहाँ लिंक से कोड, उपयुक्त रूप से संपादित किया गया है:

template< unsigned long long N >
struct binary
{
  enum { value = (N % 8) + 2 * binary< N / 8 > :: value } ;
};

template<>
struct binary< 0 >
{
  enum { value = 0 } ;
};

तो आप कुछ ऐसा कर सकते हैं binary<0101011011>::value।

Answer 11

आपके साथ काम करने वाली सबसे छोटी इकाई एक बाइट (जो charप्रकार की है) है। आप बिट्स के साथ काम कर सकते हैं, हालांकि बिटवाइज़ ऑपरेटरों का उपयोग करके।

पूर्णांक शाब्दिक के लिए, आप केवल दशमलव (आधार 10), अष्टक (आधार 8) या हेक्साडेसिमल (बेस 16) संख्याओं के साथ काम कर सकते हैं। C और C ++ में कोई बाइनरी (बेस 2) शाब्दिक नहीं हैं।

अष्टक संख्याएँ उपसर्गों से युक्त होती हैं 0और षोडश संख्याएँ उपसर्गों के साथ 0x। दशमलव संख्या में कोई उपसर्ग नहीं है।

C ++ 0x में आप वह कर पाएंगे जो आप उपयोगकर्ता द्वारा परिभाषित शाब्दिक रूप से करना चाहते हैं ।

Comments

क्या मैं कम से कम एक प्रिंट या एक कटआउट फ़ंक्शन में हेक्साडेसिमल के बाइनरी मूल्य दिखा सकता हूं?

— हमजा

हाँ, आप <shameless_plug> stackoverflow.com/questions/2611764#2611883 </shameless_plug>

— vladr

कुछ सी कंपाइलर बाइनरी लीटर के लिए 0b100101 का समर्थन करते हैं, लेकिन यह दुर्भाग्यपूर्ण विस्तार है, दुर्भाग्य से।

— जोए एडम्स

ध्यान दें कि, जबकि यह मानक में परिभाषित नहीं है, कुछ संकलक (विशेष रूप से माइक्रोकंट्रोलर और एम्बेडेड सिस्टम के लिए) 0b00101010एक सुविधा के रूप में द्विआधारी के लिए सिंटैक्स जोड़ते हैं । SDCC एक है, और मुझे यकीन है कि कुछ और भी हैं। (संपादित करें: हाह, मुझे इसे हराया, @ जोये!)

— मैट बी।

Answer 12

आप इनलाइन असेंबली का उपयोग इस तरह भी कर सकते हैं:

int i;

__asm {
    mov eax, 00000000000000000000000000000000b
    mov i,   eax
}

std::cout << i;

ठीक है, यह कुछ हद तक ओवरकिल हो सकता है, लेकिन यह काम करता है।

Comments

आपका समाधान बहु-मंच नहीं है। कई आर्किटेक्चर में आप सी में असेंबली कोड को शामिल नहीं कर सकते हैं। विशेष रूप से Microsoft विज़ुअल स्टूडियो कंपाइलर में (जब x86 32 बिट्स के लिए संकलित किया जाता है)। लेकिन आपको यह भी कैसे पता चलेगा कि आपके प्रोसेसर में 'ईएक्स' रजिस्टर है? मोबाइल फोन, एआर 64 प्रोसेसर आदि में एआरएम प्रोसेसर के बारे में सोचें, उनके पास 'ईएक्स' नहीं है। MIPS प्रोसेसर में कमांड भी नहीं है 'mov'

— DanielHsH

Answer 13

कुछ अन्य उत्तरों के आधार पर, लेकिन यह एक अवैध बाइनरी शाब्दिक कार्यक्रमों को अस्वीकार करेगा। अग्रणी शून्य वैकल्पिक हैं।

template<bool> struct BinaryLiteralDigit;

template<> struct BinaryLiteralDigit<true> {
    static bool const value = true;
};

template<unsigned long long int OCT, unsigned long long int HEX>
struct BinaryLiteral {
    enum {
        value = (BinaryLiteralDigit<(OCT%8 < 2)>::value && BinaryLiteralDigit<(HEX >= 0)>::value
            ? (OCT%8) + (BinaryLiteral<OCT/8, 0>::value << 1)
            : -1)
    };
};

template<>
struct BinaryLiteral<0, 0> {
    enum {
        value = 0
    };
};

#define BINARY_LITERAL(n) BinaryLiteral<0##n##LU, 0x##n##LU>::value

उदाहरण:

#define B BINARY_LITERAL

#define COMPILE_ERRORS 0

int main (int argc, char ** argv) {
    int _0s[] = { 0, B(0), B(00), B(000) };
    int _1s[] = { 1, B(1), B(01), B(001) };
    int _2s[] = { 2, B(10), B(010), B(0010) };
    int _3s[] = { 3, B(11), B(011), B(0011) };
    int _4s[] = { 4, B(100), B(0100), B(00100) };

    int neg8s[] = { -8, -B(1000) };

#if COMPILE_ERRORS
    int errors[] = { B(-1), B(2), B(9), B(1234567) };
#endif

    return 0;
}

Answer 14

एक बाइनरी नंबर का "प्रकार" किसी भी दशमलव, हेक्स या ऑक्टल संख्या के समान होता है: int(या यहां तक ​​कि चार, लघु, लंबे लंबे)।

जब आप एक स्थिर असाइन करते हैं, तो आप इसे 11011011 (उत्सुकता और दुर्भाग्य से) के साथ असाइन नहीं कर सकते हैं, लेकिन आप हेक्स का उपयोग कर सकते हैं। मानसिक रूप से अनुवाद करने के लिए हेक्स थोड़ा आसान है। निबल्स (4 बिट्स) में चंक करें और [0-9a-f] में एक चरित्र में अनुवाद करें।

Answer 15

आप एक बिटसेट का उपयोग कर सकते हैं

bitset<8> b(string("00010000"));
int i = (int)(bs.to_ulong());
cout<<i;

Answer 16

मैंने @ रेनटो-झूमर द्वारा दिए गए अच्छे उत्तर को आगे बढ़ाकर निम्नलिखित का समर्थन सुनिश्चित किया:

• _NIBBLE_(…) - 4 बिट्स, तर्क के रूप में 1 कुतरना
• _BYTE_(…) - तर्क के रूप में 8 बिट्स, 2 निबल
• _SLAB_(…) - 12 बिट्स, 3 निबल्स तर्क के रूप में
• _WORD_(…) - 16 बिट्स, 4 निबल्स तर्क के रूप में
• _QUINTIBBLE_(…) - 20 बिट, तर्क के रूप में 5 निबल
• _DSLAB_(…) - 24 बिट, तर्क के रूप में 6 निबल
• _SEPTIBBLE_(…) - 28 बिट्स, 7 निबल्स तर्क के रूप में
• _DWORD_(…) - 32 बिट्स, 8 निबल्स तर्क के रूप में

मैं वास्तव में "क्विंटिबबल" और "सेप्टिबल" शब्दों के बारे में इतना निश्चित नहीं हूं। अगर किसी को कोई विकल्प पता है तो कृपया मुझे बताएं।

यहाँ मैक्रो फिर से लिखा गया है:

#define __CAT__(A, B) A##B
#define _CAT_(A, B) __CAT__(A, B)

#define __HEX_0000 0
#define __HEX_0001 1
#define __HEX_0010 2
#define __HEX_0011 3
#define __HEX_0100 4
#define __HEX_0101 5
#define __HEX_0110 6
#define __HEX_0111 7
#define __HEX_1000 8
#define __HEX_1001 9
#define __HEX_1010 a
#define __HEX_1011 b
#define __HEX_1100 c
#define __HEX_1101 d
#define __HEX_1110 e
#define __HEX_1111 f

#define _NIBBLE_(N1) _CAT_(0x, _CAT_(__HEX_, N1))
#define _BYTE_(N1, N2) _CAT_(_NIBBLE_(N1), _CAT_(__HEX_, N2))
#define _SLAB_(N1, N2, N3) _CAT_(_BYTE_(N1, N2), _CAT_(__HEX_, N3))
#define _WORD_(N1, N2, N3, N4) _CAT_(_SLAB_(N1, N2, N3), _CAT_(__HEX_, N4))
#define _QUINTIBBLE_(N1, N2, N3, N4, N5) _CAT_(_WORD_(N1, N2, N3, N4), _CAT_(__HEX_, N5))
#define _DSLAB_(N1, N2, N3, N4, N5, N6) _CAT_(_QUINTIBBLE_(N1, N2, N3, N4, N5), _CAT_(__HEX_, N6))
#define _SEPTIBBLE_(N1, N2, N3, N4, N5, N6, N7) _CAT_(_DSLAB_(N1, N2, N3, N4, N5, N6), _CAT_(__HEX_, N7))
#define _DWORD_(N1, N2, N3, N4, N5, N6, N7, N8) _CAT_(_SEPTIBBLE_(N1, N2, N3, N4, N5, N6, N7), _CAT_(__HEX_, N8))

और यहाँ रेनाटो का उपयोग उदाहरण है:

char b = _BYTE_(0100, 0001); /* equivalent to b = 65; or b = 'A'; or b = 0x41; */
unsigned int w = _WORD_(1101, 1111, 0100, 0011); /* equivalent to w = 57155; or w = 0xdf43; */
unsigned long int dw = _DWORD_(1101, 1111, 0100, 0011, 1111, 1101, 0010, 1000); /* Equivalent to dw = 3745774888; or dw = 0xdf43fd28; */

Answer 17

बस C ++ में मानक पुस्तकालय का उपयोग करें:

#include <bitset>

आपको एक प्रकार का चर चाहिए std::bitset:

std::bitset<8ul> x;
x = std::bitset<8>(10);
for (int i = x.size() - 1; i >= 0; i--) {
      std::cout << x[i];
}

इस उदाहरण में, मैंने बाइनरी फॉर्म को स्टोर 10किया x।

8ulआपके बिट्स के आकार को परिभाषित करता है, तो 7ulइसका मतलब है सात बिट्स और इतने पर।

Answer 18

C ++ नाम का एक मानक टेम्पलेट प्रदान करता है std::bitset। पसंद आने पर इसे आजमाएं।

Answer 19

आप एक सरणी का उपयोग करके देख सकते हैं bool:

bool i[8] = {0,0,1,1,0,1,0,1}

Comments

बहुत सारे पतन, कोई स्पष्टीकरण नहीं। यहाँ आपकी व्याख्या है: stackoverflow.com/questions/2064550/c-why-bool-is-8-bits-long इसके अलावा, एक सरणी में प्रत्येक तत्व एक अलग मेमोरी पते पर है। लेकिन हम एक पते पर पैक 1 और 0 का एक क्रम चाहते हैं।

— जेएमआई मैडिसन