Làm thế nào để in (sử dụng cout) một số ở dạng nhị phân?

Tôi đang theo một khóa học đại học về các hệ điều hành và chúng tôi đang học cách chuyển đổi từ nhị phân sang thập lục phân, thập phân sang thập lục phân, v.v. + 1).

Chúng tôi có một vài bài tập để làm trên giấy và tôi muốn có thể xác minh câu trả lời của mình trước khi gửi bài tập của mình cho giáo viên. Tôi đã viết một chương trình C ++ cho một vài bài tập đầu tiên nhưng bây giờ tôi bị mắc kẹt về cách tôi có thể xác minh câu trả lời của mình với vấn đề sau:

char a, b;

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

b = a >> 3;

và chúng ta cần để hiển thị các biểu diễn nhị phân trong bộ nhớ của a, bvà c.

Tôi đã thực hiện nó trên giấy và nó cho tôi các kết quả sau (tất cả các biểu diễn nhị phân trong bộ nhớ của các số sau phần bù của hai số):

a = 00111010 (đó là một char, vì vậy 1 byte)

b = 00001000 (đó là một char, vì vậy 1 byte)

c = 11111110 11000101 (ngắn, nên 2 byte)

Có cách nào để xác minh câu trả lời của tôi không? Có một cách tiêu chuẩn trong C ++ để hiển thị biểu diễn nhị phân trong bộ nhớ của một số hay tôi phải tự viết mã cho từng bước (tính toán phần bù của hai và sau đó chuyển đổi thành nhị phân)? Tôi biết cái sau sẽ không mất nhiều thời gian nhưng tôi tò mò liệu có cách nào chuẩn để làm như vậy không.

Cách dễ nhất có lẽ là tạo một std::bitsetđại diện cho giá trị, sau đó truyền phát nó đến 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';

Sử dụng chuyển đổi nhanh chóng để std::bitset. Không có biến tạm thời, không có vòng lặp, không có chức năng, không có macro.

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

Bản in:

a = 11000110
b = 11111000
c = 1111111011000101

Nếu bạn muốn hiển thị biểu diễn bit của bất kỳ đối tượng nào, không chỉ là số nguyên, hãy nhớ diễn giải lại dưới dạng mảng char trước, sau đó bạn có thể in nội dung của mảng đó, dưới dạng hex hoặc thậm chí dưới dạng nhị phân (thông qua bitet):

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

Lưu ý rằng hầu hết các hệ thống phổ biến là ít về cuối nhỏ, vì vậy sản lượng show_binrep(c)là không những 1111111 011000101 bạn mong đợi, bởi vì đó không phải là cách nó được lưu trữ trong bộ nhớ. Nếu bạn đang tìm kiếm đại diện giá trị trong nhị phân, thì một cout << bitset<16>(c)công việc đơn giản .

Có cách nào chuẩn trong C ++ để hiển thị biểu diễn nhị phân trong bộ nhớ của một số [...] không?

Không. Không std::bin, giống như std::hexhoặc std::dec, nhưng không khó để tự xuất một số nhị phân:

Bạn xuất ra bit trái nhiều nhất bằng cách che dấu tất cả các bit khác, dịch chuyển trái và lặp lại điều đó cho tất cả các bit bạn có.

(Số lượng bit trong một loại là sizeof(T) * CHAR_BIT.)

Tương tự như những gì đã được đăng, chỉ cần sử dụng bit-shift và mặt nạ để lấy bit; có thể sử dụng cho bất kỳ loại nào, là một mẫu ( chỉ không chắc chắn nếu có một cách tiêu chuẩn để lấy số bit trong 1 byte, tôi đã sử dụng 8 ở đây ).

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

Chức năng tái sử dụng:

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

Sử dụng:

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

Điều này hoạt động với tất cả các loại số nguyên.

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

Sử dụng phiên bản C ++ cũ, bạn có thể sử dụng đoạn mã này:

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

Sử dụng câu trả lời std :: bitset và các mẫu tiện lợi:

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

Sử dụng nó như thế này:

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;

Tạo đầu ra:

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

Đây là cách thực sự để có được biểu diễn nhị phân của một số:

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

Đây có phải là những gì bạn đang tìm kiếm?

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