बाइनरी फॉर्म में एक नंबर (कैसेट का उपयोग करके) प्रिंट कैसे करें?

Question

मैं ऑपरेटिंग सिस्टम के बारे में एक कॉलेज के पाठ्यक्रम का अनुसरण कर रहा हूं और हम बाइनरी से हेक्साडेसिमल, दशमलव से हेक्साडेसिमल, आदि में बदलना सीख रहे हैं और आज हमने सिर्फ यह सीखा कि दो के पूरक का उपयोग करके मेमोरी में कैसे हस्ताक्षरित / अहस्ताक्षरित नंबर संग्रहीत किए जाते हैं (~ संख्या + 1)।

हमारे पास कागज पर करने के लिए कुछ अभ्यास हैं और मैं शिक्षक को अपना काम सौंपने से पहले अपने उत्तर सत्यापित करने में सक्षम होना चाहूंगा। मैंने पहले कुछ अभ्यासों के लिए C ++ प्रोग्राम लिखा था, लेकिन अब मैं इस बात पर अड़ा हुआ हूं कि मैं निम्नलिखित समस्या के साथ अपने उत्तर को कैसे सत्यापित कर सकता हूं:

char a, b;

short c;
a = -58;
c = -315;

b = a >> 3;

और हम द्विआधारी प्रतिनिधित्व दिखाने की जरूरत है स्मृति में की a, bऔर c।

मैंने इसे कागज पर किया है और यह मुझे निम्नलिखित परिणाम देता है (दो के पूरक के बाद संख्याओं की स्मृति में सभी द्विआधारी निरूपण):

a = 00111010 (यह एक चर है, इसलिए 1 बाइट)

b = 00001000 (यह एक चर है, इसलिए 1 बाइट)

c = 11111110 11000101 (यह छोटा है, इसलिए 2 बाइट्स)

क्या मेरे उत्तर को सत्यापित करने का कोई तरीका है? क्या सी ++ में किसी संख्या की याद में बाइनरी प्रतिनिधित्व दिखाने के लिए एक मानक तरीका है, या क्या मुझे प्रत्येक चरण को खुद को कोड करना होगा (दो के पूरक की गणना करें और फिर बाइनरी में कनवर्ट करें)? मुझे पता है कि बाद में इतना समय नहीं लगेगा, लेकिन मैं उत्सुक हूं कि क्या ऐसा करने का कोई मानक तरीका है।

Comments

क्या आप हेक्साडेसिमल प्रतिनिधित्व को समझते हैं? यदि आप करते हैं, तो आप हेक्स प्रतिनिधित्व ( std::hexमैनिपुलेटर का उपयोग करके ) प्रिंट कर सकते हैं - मैं इसे आराम करने के लिए आपके लिए एक अभ्यास के रूप में छोड़ दूँगा ...

— निम

आप "मेमोरी" में बहुत जोर देते हैं, लेकिन मुझे आशा है कि वे आपको एंडियन मुद्दों से निपटने में मदद नहीं कर रहे हैं।

— मार्क रंसोम

क्या आप जानते हैं कि अंतःकरण क्या है, इसके बारे में कोई विचार है? यदि आप करते हैं, तो क्या आप इस अभ्यास के लिए इसकी परवाह करते हैं? इन प्रश्नों का उत्तर आपके प्रश्न के उत्तर को प्रभावित कर सकता है।

— आर। मार्टिनो फर्नांडीस

आपकी आईडीई के आधार पर, यदि आप अपने हाथ से लिखे गए समाधान की शुद्धता को सत्यापित करना चाहते हैं और वास्तव में कुछ उपयोगी प्रदर्शित करने के लिए प्रोग्राम नहीं लिख रहे हैं, तो आप मेमोरी की सटीक सामग्री को देखने के लिए विज़ुअल स्टूडियो के मेमोरी व्यूअर जैसी किसी चीज़ का उपयोग कर सकते हैं।

— केली नरो

यहां तक ​​कि Google ऐसा करता है, उदाहरण के लिए "बाइनरी में -58" - लेकिन यह कोड में खुद को कैसे करना है, यह जानने के लिए +1।

— कोनराड रुडोल्फ

Answer 1

सबसे आसान तरीका शायद std::bitsetमूल्य का प्रतिनिधित्व करना है, फिर उसे स्ट्रीम करें cout।

#include <bitset>
...

char a = -58;    
std::bitset<8> x(a);
std::cout << x << '\n';

short c = -315;
std::bitset<16> y(c);
std::cout << y << '\n';

Comments

बेनाम: आह, मैं के बारे में भूल std::bitsetजाओ! +1मुझ से।

— sbi

मेरी अज्ञानता को क्षमा करें, लेकिन क्या यह केवल एक संख्या (जैसे 8 00001000 होगा) के द्विआधारी प्रतिनिधित्व को दर्शाएगा या इसकी मेमोरी प्रतिनिधित्व (जैसे कि -8 साइन बिट की देखभाल करके और "दो के पूरक" का उपयोग करके कैसे संग्रहीत किया जाएगा)?

— जेसी एमोंड

@ जेसे: bitsetनिर्माता के तर्क को एक अहस्ताक्षरित मान के रूप में व्याख्यायित किया जाता है, जो दो पूरक के समान है। सख्ती से बोलना, सी ++ दो पूरक अंकगणित की गारंटी नहीं देता है, और -58 >> 3आपके उदाहरण में ऑपरेशन अपरिभाषित है।

— पोटाटोज़वाटर

क्या मैं बिटसेट मान (यानी, इस उदाहरण में x या y) को एक char * को टाइप कर सकता हूं?

— nirvanaswap

धन्यवाद जेरी, मुझे कुछ मिनटों बाद पता चला। FYI करें, कास्टिंग काम नहीं करता है, बिटसेट वेरिएंट कुछ वास्तव में आर्कान-दिखने वाले बिटसेट 3ul (?) वर्ग का एक ऑब्जेक्ट है। अमूर्त काम करने के लिए सबसे अच्छा है!

— nirvanaswap

Answer 2

करने के लिए मक्खी रूपांतरण का उपयोग करें std::bitset। कोई अस्थायी चर, कोई छोर, कोई कार्य, कोई मैक्रोज़ नहीं।

Live On Coliru

#include <iostream>
#include <bitset>

int main() {
    int a = -58, b = a>>3, c = -315;

    std::cout << "a = " << std::bitset<8>(a)  << std::endl;
    std::cout << "b = " << std::bitset<8>(b)  << std::endl;
    std::cout << "c = " << std::bitset<16>(c) << std::endl;
}

प्रिंटों:

a = 11000110
b = 11111000
c = 1111111011000101

Comments

ध्यान दें कि हार्ड-कोडिंग आकार आवश्यक नहीं है। जैसे प्रिंट का xउपयोग करें std::cout << std::bitset<8*sizeof(x)>(x):।

— Apollys

Answer 3

यदि आप किसी ऑब्जेक्ट का बिट प्रतिनिधित्व प्रदर्शित करना चाहते हैं, न कि केवल एक पूर्णांक, पहले एक चार सरणी के रूप में फिर से व्याख्या करना याद रखें, तो आप उस सरणी की सामग्री को हेक्स के रूप में मुद्रित कर सकते हैं, या बाइनरी के रूप में भी (बिटसेट के माध्यम से):

#include <iostream>
#include <bitset>
#include <climits>

template<typename T>
void show_binrep(const T& a)
{
    const char* beg = reinterpret_cast<const char*>(&a);
    const char* end = beg + sizeof(a);
    while(beg != end)
        std::cout << std::bitset<CHAR_BIT>(*beg++) << ' ';
    std::cout << '\n';
}
int main()
{
    char a, b;
    short c;
    a = -58;
    c = -315;
    b = a >> 3;
    show_binrep(a);
    show_binrep(b);
    show_binrep(c);
    float f = 3.14;
    show_binrep(f);
}

नोट सबसे आम प्रणाली, थोड़ा-endian हैं कि इतने के उत्पादन में show_binrep(c)है नहीं , 1111111 011000101 आप उम्मीद है क्योंकि वह नहीं है कि यह कैसे स्मृति में संग्रहीत है। यदि आप बाइनरी में मूल्य प्रतिनिधित्व की तलाश कर रहे हैं , तो एक सरल cout << bitset<16>(c)काम करता है।

Answer 4

क्या सी + + की याद में बाइनरी प्रतिनिधित्व दिखाने के लिए सी ++ में एक मानक तरीका है [...]?

नहीं std::bin, कोई पसंद नहीं है std::hexया नहीं std::dec, लेकिन खुद को एक नंबर बाइनरी आउटपुट करना मुश्किल नहीं है:

आप सभी अन्य, बाएं-शिफ्ट को मास्क करके बाएं-सबसे थोड़ा आउटपुट करते हैं, और आपके पास जितने भी बिट्स हैं उनके लिए दोहराएं।

(एक प्रकार में बिट्स की संख्या है sizeof(T) * CHAR_BIT।)

Answer 5

जो पहले से ही पोस्ट किया गया है उसके समान, बस बिट प्राप्त करने के लिए बिट-शिफ्ट और मास्क का उपयोग करना; किसी भी प्रकार के लिए प्रयोग करने योग्य, एक टेम्पलेट होने के नाते ( केवल यकीन नहीं है कि 1 बाइट में बिट्स की संख्या प्राप्त करने का एक मानक तरीका है, मैंने यहां 8 का उपयोग किया है )।

#include<iostream>
#include <climits>

template<typename T>
void printBin(const T& t){
    size_t nBytes=sizeof(T);
    char* rawPtr((char*)(&t));
    for(size_t byte=0; byte<nBytes; byte++){
        for(size_t bit=0; bit<CHAR_BIT; bit++){
            std::cout<<(((rawPtr[byte])>>bit)&1);
        }
    }
    std::cout<<std::endl;
};

int main(void){
    for(int i=0; i<50; i++){
        std::cout<<i<<": ";
        printBin(i);
    }
}

Comments

बाइट प्रति बिट की संख्या प्राप्त करने का मानक तरीका मैक्रो है CHAR_BIT।

— आर। मार्टिनो फर्नांडिस 14

ऐसा प्रतीत होता है कि sbi ने @ R.MartinhoFernandes की टिप्पणी के अनुसार पोस्ट का संपादन किया। हालाँकि, उन्होंने अंतिम वाक्य को नहीं बदला। मैं संपादित करूंगा।

— gsamaras

Answer 6

पुन: प्रयोज्य समारोह:

template<typename T>
static std::string toBinaryString(const T& x)
{
    std::stringstream ss;
    ss << std::bitset<sizeof(T) * 8>(x);
    return ss.str();
}

उपयोग:

int main(){
  uint16_t x=8;
  std::cout << toBinaryString(x);
}

यह सभी प्रकार के पूर्णांकों के साथ काम करता है।

Answer 7

#include <iostream> 
#include <cmath>       // in order to use pow() function
using namespace std; 

string show_binary(unsigned int u, int num_of_bits);

int main() 
{ 

  cout << show_binary(128, 8) << endl;   // should print 10000000
  cout << show_binary(128, 5) << endl;   // should print 00000
  cout << show_binary(128, 10) << endl;  // should print 0010000000

  return 0; 
}

string show_binary(unsigned int u, int num_of_bits) 
{ 
  string a = "";

  int t = pow(2, num_of_bits);   // t is the max number that can be represented

  for(t; t>0; t = t/2)           // t iterates through powers of 2
      if(u >= t){                // check if u can be represented by current value of t
          u -= t;
          a += "1";               // if so, add a 1
      }
      else {
          a += "0";               // if not, add a 0
      }

  return a ;                     // returns string
}

Comments

नहीं होना चाहिए int t = pow(2, num_of_bits - 1);?

— BmyGuest

Answer 8

पुराने C ++ संस्करण का उपयोग करके, आप इस स्निपेट का उपयोग कर सकते हैं:

template<typename T>
string toBinary(const T& t)
{
  string s = "";
  int n = sizeof(T)*8;
  for(int i=n-1; i>=0; i--)
  {
    s += (t & (1 << i))?"1":"0";
  }
  return s;
}

int main()
{
  char a, b;

  short c;
  a = -58;
  c = -315;

  b = a >> 3;

  cout << "a = " << a << " => " << toBinary(a) << endl;
  cout << "b = " << b << " => " << toBinary(b) << endl;
  cout << "c = " << c << " => " << toBinary(c) << endl;
}

a = => 11000110
b = => 11111000
c = -315 => 1111111011000101

Comments

बिट्स की गलत संख्या को प्रिंट करना। १११ ००० ११० ९ बिट्स है,

— डेविड लेजर

मैंने सीमा की गलती की, कृपया अब जांच करें

— रतह

Answer 9

Std का उपयोग करना :: बिटसेट उत्तर और सुविधा टेम्पलेट:

#include <iostream>
#include <bitset>
#include <climits>

template<typename T>
struct BinaryForm {
    BinaryForm(const T& v) : _bs(v) {}
    const std::bitset<sizeof(T)*CHAR_BIT> _bs;
};

template<typename T>
inline std::ostream& operator<<(std::ostream& os, const BinaryForm<T> bf) {
    return os << bf._bs;
}

इसे इस तरह से उपयोग करना:

auto c = 'A';
std::cout << "c: " << c << " binary: " << BinaryForm{c} << std::endl;
unsigned x = 1234;
std::cout << "x: " << x << " binary: " << BinaryForm{x} << std::endl;
int64_t z { -1024 };
std::cout << "z: " <<  << " binary: " << BinaryForm{z} << std::endl;

उत्पादन उत्पन्न करता है:

c: A binary: 01000001
x: 1234 binary: 00000000000000000000010011010010
z: -1024 binary: 1111111111111111111111111111111111111111111111111111110000000000

Answer 10

यहां किसी संख्या का द्विआधारी प्रतिनिधित्व प्राप्त करने का सही तरीका है:

unsigned int i = *(unsigned int*) &x;

Comments

नहीं ; यह सिर्फ x को i में कॉपी करता है। जब तक आपका यह मजाक के रूप में मतलब नहीं था?

— एंथोनीडी 973 21

Answer 11

यह वही है जो आप खोज रहे हैं?

std::cout << std::hex << val << std::endl;

Comments

मॉडरेटर नोट मैंने इस उत्तर के तहत विरोधी या अन्यथा गैर रचनात्मक टिप्पणियों को शुद्ध करने की कोशिश की , और मैं बहुत टूटी हुई बातचीत के साथ समाप्त हुआ। सभी टिप्पणियों को शुद्ध किया गया था। कृपया टिप्पणियों को व्यावसायिक, रचनात्मक और अधिकांश विषय पर रखें। यदि ओपी इसे हटाना चाहता था, तो ओपी ने इसे अब तक हटा दिया होगा। यदि आप इस जवाब से असहमत हैं, तो वोट करें। यदि आप इस उत्तर को सुधार सकते हैं, तो संपादित करें। </argument>। वास्तव में, हम वयस्क हैं, हाँ? मैं लगभग यकीन है कि हर किसी को 13. खत्म हो गया था बनाने के लिए यह सब यहाँ टिप्पणी की जिस पर उम्र की जाँच की

— टिम पोस्ट