How to print (using cout) a number in binary form?

Use on-the-fly conversion to std::bitset. No temporary variables, no loops, no functions, no macros.

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

Prints:

a = 11000110 b = 11111000 c = 1111111011000101 

In C++20 you can use std::format to do this:

unsigned char a = -58; std::cout << std::format("{:b}", a); 

Output:

11000110 

If std::format is not available on your system you can use the {fmt} library, it is based on. {fmt} and C++23 also provide the print function that makes this even easier and more efficient (godbolt):

unsigned char a = -58; fmt::print("{:b}", a); 

Disclaimer: I'm the author of {fmt} and C++20 std::format.

If you want to display the bit representation of any object, not just an integer, remember to reinterpret as a char array first, then you can print the contents of that array, as hex, or even as binary (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); } 

Note that most common systems are little-endian, so the output of show_binrep(c) is not the 1111111 011000101 you expect, because that's not how it's stored in memory. If you're looking for value representation in binary, then a simple cout << bitset<16>(c) works.

Is there a standard way in C++ to show the binary representation in memory of a number [...]?

No. There's no std::bin, like std::hex or std::dec, but it's not hard to output a number binary yourself:

You output the left-most bit by masking all the others, left-shift, and repeat that for all the bits you have.

(The number of bits in a type is sizeof(T) * CHAR_BIT.)

Reusable function:

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

Usage:

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

This works with all kind of integers.

Similar to what is already posted, just using bit-shift and mask to get the bit; usable for any type, being a template (only not sure if there is a standard way to get number of bits in 1 byte, I used 8 here).

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

Using the std::bitset answers and convenience templates:

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

Using it like this:

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: " << z << " binary: " << BinaryForm{z} << std::endl; 

Generates output:

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

I have had this problem when playing competitive coding games online. Here is a solution that is quick to implement and is fairly intuitive. It also avoids outputting leading zeros or relying on <bitset>

std::string s; do { s = std::to_string(r & 1) + s; } while ( r>>=1 ); std::cout << s; 

You should note however that this solution will increase your runtime, so if you are competing for optimization or not competing at all you should use one of the other solutions on this page.

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

Using old C++ version, you can use this snippet :

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 

These days with C++23 you don't even explicitly need iostream.

#include <print> int main() { std::println("{:b}", 4563685); return 0; } Output: 10001011010001011100101 

This will infer a suitable type for the argument. You can provide an explicit template parameter to println if you want but for built-in integral types you shouldn't need to.