Comment imprimer (en utilisant Cout) un nombre sous forme binaire?

Question

je suis un cours collégial sur les systèmes d'exploitation et nous apprenons comment convertir binaire en hexadécimal, décimal en hexadécimal, etc., et aujourd'hui, nous venons d'apprendre comment les chiffres signés / non signés sont stockés dans la mémoire à l'aide du complément à deux (~ nombre + 1).

Nous avons quelques exercices à faire sur le papier et je voudrais être en mesure de vérifier mes réponses avant de soumettre mon travail à l'enseignant. J'ai écrit un programme C ++ pour les premiers exercices, mais maintenant je suis coincé comment je pouvais vérifier ma réponse au problème suivant:

char a, b;

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

b = a >> 3;

et nous devons montrer la représentation binaire dans la mémoire de a, b et c.

Je l'ai fait sur papier et il me donne les résultats suivants (toutes les représentations binaires en mémoire des numéros après le complément à deux):

a = 00111010 (il est un produit de carbonisation, donc 1 octet)

b = 00001000 (il est un produit de carbonisation, donc 1 octet)

c = 11111110 11000101 (il est court, de sorte que 2 octets)

Y at-il un moyen de vérifier ma réponse? Est-il un moyen standard en C ++ pour montrer la représentation binaire en mémoire d'un numéro, ou dois-je le code chaque étape moi-même (calculer le complément à deux, puis convertir en binaire)? Je sais que ce dernier ne prendrait pas si longtemps, mais je suis curieux de savoir s'il y a un moyen standard de le faire.

Answer 1

Le plus simple est sans doute de créer un std::bitset représentant la valeur, écouter que pour 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';

Answer 2

Utilisation en conversion à la volée à std::bitset. Pas de variables temporaires, pas de boucle, aucune fonction, aucune macro.

en direct sur 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;
}

Prints:

a = 11000110
b = 11111000
c = 1111111011000101

Answer 3

Si vous souhaitez afficher la représentation binaire de tout objet, non seulement un entier, souvenez-vous de réinterpréter comme un tableau de caractères d'abord, vous pouvez imprimer le contenu de ce tableau, comme hex, ou même sous forme binaire (via bitset) :

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

Notez que la plupart des systèmes communs sont peu endian, de sorte que la sortie de show_binrep(c) est pas 1111111 011000101 vous attendez, parce que ce n'est pas la façon dont il est stocké dans la mémoire. Si vous cherchez valeur représentation en binaire, puis une usine simple cout << bitset<16>(c).

Answer 4

Y at-il un moyen standard en C ++ pour montrer la représentation binaire en mémoire d'un numéro [...]?

Non

. Il n'y a pas std::bin, comme std::hex ou std::dec, mais il est difficile de ne pas vous produire un binaire de nombre:

sortie la plus à gauche peu en masquant tous les autres, à gauche quart de travail, et répéter que, pour tous les bits que vous avez.

(Le nombre de bits dans un type est sizeof(T) * CHAR_BIT.)

Answer 5

Similaire à ce qui est déjà affiché, juste à l'aide de changement de bit et un masque pour obtenir le bit; utilisable pour tout type, étant un modèle ( ne ne sais pas s'il y a un moyen standard pour obtenir le nombre de bits dans 1 octet, je 8 ici ).

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

Answer 6

Fonction réutilisable:

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

Utilisation:

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

Cela fonctionne avec tous les types d'entiers.

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
}

Answer 8

En utilisant ancienne version C ++, vous pouvez utiliser cet extrait:

template<typename T>
string toBinary(const T& t)
{
  string s = "";
  int n = sizeof(T)*8;
  for(int i=n; 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 = ã => 111000110
b = ° => 111111000
c = -315 => 11111111011000101

Answer 9

Voici la vraie façon d'obtenir une représentation binaire d'un nombre:

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

Answer 10

Est-ce que vous cherchez?

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