আমি কি সি বা সি ++ তে বাইনারি আক্ষরিক ব্যবহার করতে পারি?

190

আমার বাইনারি নম্বর নিয়ে কাজ করা দরকার।

আমি লেখার চেষ্টা করেছি:

const x = 00010000;

তবে এটি কার্যকর হয়নি।

আমি জানি যে আমি একটি হেক্সাডেসিমাল নম্বর ব্যবহার করতে পারি যার সমান মান রয়েছে 00010000তবে আমি জানতে চাই বাইনারি সংখ্যার জন্য সি ++ তে কোনও প্রকার রয়েছে কিনা এবং যদি তা না পাওয়া যায় তবে আমার সমস্যার আর কোনও সমাধান আছে কি?

c++  c  binary 
— হামজা
সূত্র
51
তুমি জানো ওটা 00010000আটল, তাই না? (এবং আপনার ঘোষণায় কোনও প্রকার অনুপস্থিত))
— কিথ থম্পসন
C ++ আক্ষরিক ব্যবহার করে এখানে আধুনিক পদ্ধতি।
— Lol4t0
2
সি ++ 14 এটির জন্য একটি বৈশিষ্ট্য যুক্ত করেছে। নীচে আরও তথ্যের জন্য আমার নতুন উত্তর দেখুন। অবশ্যই এটির জন্য একটি সংকলক প্রয়োজন যা এটি প্রয়োগ করে।
— lpapp
1
@ ফর্মলেসক্লাউড: এগুলি সি এবং সি ++ স্ট্যান্ডার্ডগুলিতে দেওয়া বাক্য বিন্যাসগুলি ( 0bকেবলমাত্র সি ++ 14 এ প্রদর্শিত হবে)। এগুলি দ্ব্যর্থহীন হওয়ার জন্য ডিজাইন করা হয়েছে।
— কিথ থম্পসন
2
— এমজে রায়বার্ন

উত্তর:

70

আপনি সি ++ 0 এক্স অপেক্ষা করার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

আকর্ষণীয় আলোচনার জন্য হার্ব সাটারের স্ট্রিং ফরম্যাটারস অফ মনোর ফার্মও পড়ুন ।

— vladr
সূত্র
2
আপনি যে পৃষ্ঠায় লিঙ্ক করেছেন ঠিক সেই পৃষ্ঠা হিসাবে, আপনি কেবল সেটবেস দিয়ে 8, 10 বা 16 ব্যবহার করতে পারেন। তবে:int main() { cout << bitset<8>(42); }
টিপটির জন্য রাজার ধন্যবাদ bitset, setbaseআপনার মন্তব্যটি দেখার আগে আমি ইতিমধ্যে কিছুটা সংশোধন করেছি।
— ভ্লাদর
সি ++ 11 এ ব্যবহারকারী-সংজ্ঞায়িত আক্ষরিক সম্পর্কে একটি টিউটোরিয়াল এখানে রয়েছে: akrzemi1.wordpress.com/2012/10/23/user-defined-literals-part-ii । স্পষ্টত সি ++ 1 ই (ওরফে সি ++ 14) বাইনারি লিটারেলগুলিকে স্ট্যান্ডার্ডের অন্তর্ভুক্ত করবে।
— CHESirekow
274

আপনি যদি জিসিসি ব্যবহার করে থাকেন তবে আপনি এর জন্য একটি জিসিসি এক্সটেনশন (যা সি ++ 14 স্ট্যান্ডার্ডের অন্তর্ভুক্ত ) ব্যবহার করতে পারেন:

int x = 0b00010000;
— qrdl
সূত্র
2
বেশ কিছু অন্যান্য কম্পাইলার বেস 2. সংখ্যার প্রকাশ এটি বা অন্যান্য উপায় একই রকম
— nategoose
4
এই মানক করা ভাল হবে, কিন্তু ঝনঝন একই স্বরলিপি সমর্থন করে।
— পোলেমন
14
এটি ক্ল্যাং, জিসিসি এবং টিসিসিতে কাজ করে। এটি পিসিসিতে কাজ করে না। পরীক্ষার জন্য আমার কাছে অন্য কোনও সংকলক নেই।
— মিছাস
6
আমি বেশ কয়েকটি এম্বেডড-সিস্টেম সংকলক দেখেছি যা এটি সমর্থন করে। আমি কোনও বিশেষ কারণ জানি না এটি স্ট্যান্ডার্ড ভাষার বৈশিষ্ট্য না হওয়া উচিত।
— সুপারক্যাট
5
— জোনাথন বাল্ডউইন
98

আপনি বাইনারি আক্ষরিক ব্যবহার করতে পারেন। সেগুলিকে সি ++ 14 এ প্রমিত করা হয়েছে। উদাহরণ স্বরূপ,

int x = 0b11000;

জিসিসিতে সহায়তা

জিসিসিতে সমর্থন জিসিসির ৪.৩-এ শুরু হয়েছিল ( https://gcc.gnu.org/gcc-4.3/changes.html দেখুন ) সি ভাষা পরিবারে এক্সটেনশন হিসাবে ( https://gcc.gnu.org/onlinesocs/gcc/ দেখুন সি-এক্সটেনশানস html # সি-এক্সটেনশানস ), তবে জিসিসি ৪.৯ থেকে এটি এখন সি ++ ১৪ বৈশিষ্ট্য বা একটি এক্সটেনশন হিসাবে স্বীকৃত ( জিসিসির বাইনারি আক্ষরিক এবং সি ++ 14 এর মধ্যে পার্থক্য দেখুন ? )

ভিজ্যুয়াল স্টুডিওতে সমর্থন

ভিজ্যুয়াল স্টুডিওতে সমর্থন ভিজ্যুয়াল স্টুডিও 2015 পূর্বরূপে শুরু হয়েছিল (দেখুন https://www.visualstudio.com/news/vs2015-preview-vs#C++ )।

— মোহাম্মদ এল-নাকিব
সূত্র
5
আপনি প্রতিটি অংশ পৃথক করতে 'ব্যবহার করতে পারেন: "0b0000'0100'0100'0001
— ক্যামিনো
1
@ ক্যামিনো চমৎকার আপনি প্রথমটি আলগা করতে পারেন "
— নিকোস
এটি গ্রহণযোগ্য উত্তর হওয়া উচিত। অন্যান্য উত্তরগুলির বেশিরভাগই পুরানো oo
— অ্যালেক্স
73 
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 হতে হবে তবে তা সত্ত্বেও।

— wilhelmtell
সূত্র
4
আরও ভাল সংস্করণ: bitbucket.org/kniht/scraps/src/tip/cpp/binary.hpp ( binary<10>::value == binary<010>::valueএবং কিছু ত্রুটি পরীক্ষা করা)
আমি আমার নিজের প্রায় অনুরূপ উত্তর পোস্ট করার আগে কোনওরকম এটিকে মিস করেছি। তবে খনিতে শীর্ষস্থানীয়
— মার্ক রান্সম
4
এই টেমপ্লেট আইডিয়াটির আরও ভাল সংস্করণ: কোড. google.com/p/cpp-binary-constants
— ভ্যালেন্টিন গেলা
@ ভ্যালেন্টিনগেলা - এর চেয়ে গুগল সংস্করণটি আরও ভাল কেন?
— আজেদ
এটি চিত্তাকর্ষক চিত্তাকর্ষক। খুব খারাপ এটি উচ্চ সংখ্যক বিটের জন্য কাজ করে না।
— কোয়ান্টাম পদার্থবিদ 13
31

কয়েকটি সংকলক (সাধারণত মাইক্রোকন্ট্রোলারদের জন্য এটির) সংখ্যার পূর্ববর্তী "0 বি ..." উপসর্গ দ্বারা আক্ষরিক বাইনারি সংখ্যাগুলি সনাক্তকরণের মধ্যে একটি বিশেষ বৈশিষ্ট্য প্রয়োগ করা হয় , যদিও বেশিরভাগ সংকলক (সি / সি ++ মান) এর বৈশিষ্ট্য নেই এবং যদি এটি থাকে কেস, এখানে এটি আমার বিকল্প সমাধান:

#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 টিও গ্রুপিংয়ের জন্য বাড়ানো যেতে পারে);
— রেনাতো শ্যান্ডেলিয়ার
সূত্র
কেন উদাহরণস্বরূপ B_0100ব্যবহার করা হয় না (পরিবর্তে 0100)? যেমন মতই char b = BYTE(0100,0001);।
— পিটার মর্টেনসেন
@ পিটারমোরটেনসন বি_ _B2Hপ্রিপ্রসেসর ফাংশন দ্বারা যুক্ত হয় ।
— mxMLnkn
20

এই থ্রেড সাহায্য করতে পারে।

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

এটি কাজ করে! (সমস্ত ক্রেডিট টম টরফসে যায়))

— ফেডেরিকো এ রামপনি
সূত্র
আমি সত্যিই বুঝতে পারি নি (প্রোগ্রামিংয়ে ইমাম শিক্ষানবিশ এবং বিশেষত সি ++ তে) তবে এটি আকর্ষণীয় বলে মনে হচ্ছে তাই আমি আরও কিছু সি ++ অধ্যয়নের পরে এটি বোঝার চেষ্টা করব, ধন্যবাদ
— হামজা
3
বি 8 ম্যাক্রো "বাইনারি" আক্ষরিককে হেক্স আক্ষরিক রূপান্তর করে এবং প্রতি 4 র্থ বিট বের করে কাজ করে।
— dan04
আমি ভাবছি 0x ## n ## LU এর অর্থ কী? এ জাতীয় সিনট্যাক্সের মুখোমুখি হয়নি।
— ফেডেরিকো এ রামপোনি
@ হামজা: এটি আসলে জটিল। তবে আপনার যা বোঝার দরকার তা কেবল # অন্তর্ভুক্ত <স্টাডিও> থেকে।
— ফেডেরিকো এ। রামপনি
8
@ ফেডেরিকো: ##প্রিপ্রেসেসর অপারেটর টোকেনগুলি এক সাথে আটকান । সুতরাং, এই ক্ষেত্রে, আপনি কল করলে HEX__(10)এটি প্রসারিত হয় 0x10LU।
— জেমস ম্যাকনেলিস
18

ইতিমধ্যে উত্তর হিসাবে, সি মানদণ্ডে সরাসরি বাইনারি সংখ্যা লেখার কোনও উপায় নেই। সংকলক এক্সটেনশনগুলি রয়েছে, তবে স্পষ্টতই C ++ 14 0bবাইনারিটির উপসর্গ অন্তর্ভুক্ত করে । (দ্রষ্টব্য যে এই উত্তরটি মূলত ২০১০ সালে পোস্ট করা হয়েছিল))

একটি জনপ্রিয় কাজের ভিত্তিতে হেল্পার ম্যাক্রোগুলির সাথে একটি শিরোনাম ফাইল অন্তর্ভুক্ত করা । একটি সহজ বিকল্প হ'ল এমন একটি ফাইল উত্পন্ন করাও যাতে সমস্ত 8-বিট নিদর্শনগুলির জন্য ম্যাক্রো সংজ্ঞা অন্তর্ভুক্ত থাকে:

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

এর ফলাফলটি কেবল 256 #defineসেকেন্ডে আসে এবং যদি 8-বিটের চেয়ে বেশি বাইনারি ধ্রুবক প্রয়োজন হয় তবে এই সংজ্ঞাগুলি শিফট এবং ওআরগুলির সাথে সংযুক্ত করা যেতে পারে, সম্ভবত হেল্পার ম্যাক্রোগুলির সাথে (যেমন,BIN16(B00000001,B00001010) )। (প্রতিটি 16-বিটের জন্য স্বতন্ত্র ম্যাক্রোগুলি রাখা, 32-বিটকে ছেড়ে দিন, মান প্রশংসনীয় নয়))

অবশ্যই খারাপ দিকটি হ'ল এই বাক্য গঠনটির জন্য সমস্ত নেতৃস্থানীয় শূন্যগুলি লেখার প্রয়োজন রয়েছে, তবে এটি বিট ফ্ল্যাগ এবং হার্ডওয়্যার রেজিস্টারগুলির সামগ্রীগুলির মতো ব্যবহারের জন্য আরও পরিষ্কার করে দিতে পারে। কোনও ফাংশনের মতো ম্যাক্রোর জন্য এই সম্পত্তিটি ছাড়া সিনট্যাক্সের ফলাফল হয়, bithacks.hউপরে লিঙ্কযুক্ত দেখুন ।

— Arkku
সূত্র
2
সুতরাং, সিপিপি যদি আপনার কোনও ম্যাক্রোর জন্য সমস্ত ম্যাক্রো থাকে তবে কত বড় ফাইল পড়তে হবে long long int?
— উইলহেমটেল
3
@ উইলহেলমটেল: এবং এর সাথে কী প্রাসঙ্গিকতা আছে যখন আমি "সমস্ত 8-বিট নিদর্শন" (= 256 লাইন) নির্দিষ্ট করেছি এবং সেগুলি থেকে বৃহত্তর পরিমাণের সংমিশ্রণের পরামর্শ দিয়েছি ? এমনকি গৃহীত উত্তরের
— BOOST_BINARY
16

সি ++ ওভার ইঞ্জিনিয়ারিং মানসিকতা ইতিমধ্যে এখানে অন্যান্য উত্তরের জন্য জবাবদিহি করা হয়েছে। এটি সি, এটি-সহজ-এফএফএসের মানসিকতার সাথে এটি করার চেষ্টা আমার এখানে রয়েছে:

unsigned char x = 0xF; // binary: 00001111
— ক্রেইগ
সূত্র
12

খাঁটি বাইনারি সংখ্যার জন্য সি এর নেটিভ স্বাক্ষর নেই। আপনার সেরা বাজি এখানে পারেন হবে অকট্যাল (যেমন 07777এর) হেক্সাডেসিমেল (যেমন 0xfff)।

— নিকোলাই ফেটিসোসোভ
সূত্র
11

আপনি এই প্রশ্নে পাওয়া ফাংশনটি 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।

— মার্ক মুক্তি
সূত্র
7

আপনি যে ক্ষুদ্রতম ইউনিটটির সাথে কাজ করতে পারেন তা হলেন একটি বাইট (যা টাইপযুক্ত char)। আপনি বিটওয়াইড অপারেটর ব্যবহার করে বিট দিয়ে কাজ করতে পারেন।

পূর্ণসংখ্যার আক্ষরিক হিসাবে, আপনি কেবল দশমিক (বেস 10), অক্টাল (বেস 8) বা হেক্সাডেসিমাল (বেস 16) সংখ্যার সাথে কাজ করতে পারেন। সি বা সি ++ তে কোনও বাইনারি (বেস 2) লিটারেল নেই।

অক্টাল সংখ্যাগুলি উপসর্গযুক্ত 0এবং হেক্সাডেসিমাল সংখ্যাগুলি উপসর্গযুক্ত হয় 0x। দশমিক সংখ্যার কোনও উপসর্গ নেই।

সি ++ 0 এক্স-এ আপনি ব্যবহারকারীর সংজ্ঞায়িত আক্ষরিক মাধ্যমে আপনি যা করতে চান তা করতে সক্ষম হবেন ।

— ব্রায়ান আর বন্ডি
সূত্র
আমি কি কমপক্ষে কোনও মুদ্রণ বা একটি কাউট ফাংশনে একটি হেক্সাডেসিমালের বাইনারি মান প্রদর্শন করতে পারি?
— হামজা
হ্যাঁ আপনি করতে পারেন <shameless_plug> stackoverflow.com/questions/2611764#2611883 </shameless_plug>
— vladr
5
কিছু সি সংকলক বাইনারি আক্ষরিক জন্য 0b100101 সমর্থন করে তবে দুর্ভাগ্যক্রমে এটি একটি মানহীন এক্সটেনশন।
— জোয়ে অ্যাডামস
3
নোট করুন, যদিও এটি স্ট্যান্ডার্ডে সংজ্ঞায়িত করা হয়নি, কিছু সংকলক (মাইক্রোকন্ট্রোলার এবং এমবেডেড সিস্টেমগুলির জন্য উল্লেখযোগ্যভাবে) 0b00101010সুবিধার হিসাবে ফর্মটিতে বাইনারিগুলির জন্য সিনট্যাক্স যুক্ত করে । এসডিসি একটি, এবং আমি নিশ্চিত যে আরও কিছু আছে এমনও আছে। (সম্পাদনা: হাহ, আমাকে এটি মারুন, @ জোয়াই!)
— ম্যাট বি।
5

আপনি এর মতো ইনলাইন সমাবেশটিও ব্যবহার করতে পারেন:

int i;

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

std::cout << i;

ঠিক আছে, এটি কিছুটা ওভারকিল হতে পারে, তবে এটি কার্যকর হয়।

— renger
সূত্র
3
আপনার সমাধানটি মাল্টি-প্ল্যাটফর্ম নয়। অনেক আর্কিটেকচারে আপনি সি এর মধ্যে সমাবেশ কোড অন্তর্ভুক্ত করতে পারবেন না বিশেষত মাইক্রোসফ্ট ভিজ্যুয়াল স্টুডিও সংকলকটিতে আপনি করতে পারেন (x86 32 বাইটের জন্য সংকলিত হলে)। আপনার প্রসেসরের 'ই্যাক্স' রেজিস্টার আছে কিনা তা আপনি কীভাবে জানবেন? মোবাইল ফোন, এক্স 6464 প্রসেসর ইত্যাদিতে এআরএম প্রসেসরের কথা চিন্তা করুন তাদের 'ই্যাক্স' নেই। এমআইপিএস প্রসেসরের এমনকি '
— মুভ
4

কিছু অন্যান্য উত্তরের ভিত্তিতে, তবে এইটি অবৈধ বাইনারি আক্ষরিক সহ প্রোগ্রামগুলি প্রত্যাখ্যান করবে। শীর্ষস্থানীয় শূন্যগুলি alচ্ছিক।

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;
}
— টমাস এডিং
সূত্র
3

বাইনারি সংখ্যার "প্রকার" কোনও দশমিক, হেক্স বা অষ্টাল সংখ্যার সমান: int(বা এমনকি চর, সংক্ষিপ্ত, দীর্ঘ দীর্ঘ)।

আপনি যখন একটি ধ্রুবক নিযুক্ত করেন, আপনি এটি 11011011 (কৌতূহল এবং দুর্ভাগ্যক্রমে) দিয়ে বরাদ্দ করতে পারবেন না, তবে আপনি হেক্স ব্যবহার করতে পারেন। মানসিকভাবে অনুবাদ করা হেক্স একটু সহজ easier নিবলিতে বিভক্ত (4 বিট) এবং [0-9a-f] এর একটি অক্ষরে অনুবাদ করুন।

— স্টিফেন
সূত্র
2

আপনি একটি বিটসেট ব্যবহার করতে পারেন

bitset<8> b(string("00010000"));
int i = (int)(bs.to_ulong());
cout<<i;
— Deqing
সূত্র
2

@ রেনাটো-শ্যান্ডেলিয়ারের দেওয়া উত্তরের উত্তরটি নিশ্চিত করে আমি উত্তরটি প্রসারিত করেছি:

  • _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; */
— madmurphy
সূত্র
0

কেবলমাত্র সি ++ এ স্ট্যান্ডার্ড লাইব্রেরিটি ব্যবহার করুন:

#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অর্থ সাতটি বিট এবং।

— হাদি রাশেখ
সূত্র
-1

সি ++ নামক একটি মানক টেম্পলেট সরবরাহ করে std::bitset। ভালো লাগলে চেষ্টা করে দেখুন

— Summer_More_More_Tea
সূত্র
-9

আপনি একটি অ্যারের ব্যবহার করে চেষ্টা করতে পারেন bool:

bool i[8] = {0,0,1,1,0,1,0,1}
— জর্জে wagenknecht
সূত্র
1
প্রচুর ডাউনভোটস, কোনও ব্যাখ্যা নেই। আপনার ব্যাখ্যাটি এখানে: স্ট্যাকওভারফ্লো / প্রশ্ন / 2064550 / c-why-bool- is-8- bit-long এছাড়াও, অ্যারেতে প্রতিটি উপাদান একটি পৃথক মেমরি ঠিকানায় থাকে। তবে আমরা এক ঠিকানায় প্যাক করা 1 এবং 0 এর একটি ক্রম চাই।
— জেএমআই মেডিসন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.