c++ स्मृति में किसी संख्या को संग्रहीत करने के तरीके को कैसे मुद्रित करें(cout का उपयोग करके)?




binary iostream (7)

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

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

char a, b;

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

b = a >> 3;

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

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

ए = 00111010 (यह एक char है, तो 1 बाइट)

बी = 00001000 (यह एक char है, तो 1 बाइट)

सी = 11111110 11000101 (यह एक छोटा है, तो 2 बाइट्स)

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


क्या आप यही खोज रहे हैं?

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

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

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

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


std::bitset पर ऑन-द-फ्लाई रूपांतरण का उपयोग करें। कोई अस्थायी चर नहीं, कोई लूप नहीं, कोई फ़ंक्शन नहीं, कोई मैक्रोज़ नहीं।

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

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

#include<iostream>

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

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

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

#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
}

संभवतः एक std::bitset को मान का प्रतिनिधित्व करने का सबसे आसान तरीका है, फिर उस को स्ट्रीम करने के लिए स्ट्रीम करें।

#include <bitset>
...

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

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




outputstream