İkili biçimde bir sayı nasıl yazdırılır (cout kullanılarak)?

İşletim sistemleri hakkında bir kolej dersini takip ediyorum ve ikilikten onaltılıya, ondalıktan onaltılıya vb. + 1).

Kağıt üzerinde yapacağımız birkaç alıştırma var ve çalışmalarımı öğretmene göndermeden önce cevaplarımı doğrulamak istiyorum. İlk birkaç alıştırma için bir C ++ programı yazdım ama şimdi cevabımı aşağıdaki sorunla nasıl doğrulayabileceğim konusunda sıkışıp kaldım:

char a, b;

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

b = a >> 3;

ve biz ikili gösterimini göstermek gerekir bellekte arasında a, bve c.

Ben kağıt üzerinde yaptım ve bana aşağıdaki sonuçları verir (ikisinin tamamlayıcı sonra sayıların hafızasında tüm ikili sunumlar):

a = 00111010 (bir karakter, yani 1 bayt)

b = 00001000 (bir karakter, yani 1 bayt)

c = 11111110 11000101 (kısa, yani 2 bayt)

Cevabımı doğrulamanın bir yolu var mı? C ++ 'da bir sayının belleğinde ikili temsili göstermek için standart bir yol var mı, ya da her adımı kendim kodlamak zorunda (ikisinin tamamlayıcı hesaplamak ve sonra ikili dönüştürmek)? İkincisinin çok uzun sürmeyeceğini biliyorum ama bunu yapmanın standart bir yolu olup olmadığını merak ediyorum.

En kolay yol muhtemelen std::bitsetdeğeri temsil eden bir değer oluşturmaktır ve sonra bunu akışa aktarmaktır 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';

Anında anında dönüşümü kullanın std::bitset. Geçici değişken yok, döngü yok, işlev yok, makro yok.

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

Baskılar:

a = 11000110
b = 11111000
c = 1111111011000101

Yalnızca bir tam sayı değil, herhangi bir nesnenin bit temsilini görüntülemek istiyorsanız, önce bir char dizisi olarak yeniden yorumlamayı unutmayın, o zaman dizinin içeriğini onaltılık, hatta ikili (bitset aracılığıyla) yazdırabilirsiniz:

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

Çıktısı böylece Not en yaygın sistemler, küçük endian olduğunu show_binrep(c)olduğunu değil beklediğiniz 1111111 011000101 o bellekte depolanır nasıl değil çünkü. İkili değer temsili arıyorsanız , o zaman basit bir cout << bitset<16>(c)iş.

C ++ bir sayının belleğinde ikili gösterimi göstermek için standart bir yolu var mı [...]?

Hayır. std::bin, Gibi std::hexveya yoktur , std::decancak kendiniz bir sayı ikilisi çıkarmak zor değildir:

En soldaki biti, diğerlerini maskeleyerek, sola kaydırıp, sahip olduğunuz tüm bitler için tekrarlayın.

(Bir türdeki bit sayısı sizeof(T) * CHAR_BIT.)

Daha önce yayınlananlara benzer şekilde, sadece bit almak için bit-shift ve maske kullanın; bir şablon olarak her tür için kullanılabilir ( sadece 1 baytta bit sayısını almanın standart bir yolu olup olmadığından emin değilim, burada 8 kullandım ).

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

Yeniden kullanılabilir fonksiyonu:

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

Kullanımı:

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

Bu her türlü tamsayı ile çalışır.

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

Eski C ++ sürümünü kullanarak bu snippet'i kullanabilirsiniz:

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

Std :: bitset cevapları ve kolaylık şablonlarını kullanma:

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

Bu şekilde kullanmak:

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;

Çıktı üretir:

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

İşte bir sayının ikili temsilini almanın gerçek yolu:

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

Bu aradığınız şey mi?

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