How to convert an int to a binary string representation in C++

Question

I have an int that I want to store as a binary string representation. How can this be done?

Solution 1

Try this:

#include <bitset>
#include <iostream>
int main()
{
    std::bitset<32>      x(23456);
    std::cout << x << "\n";


    // If you don't want a variable just create a temporary.
    std::cout << std::bitset<32>(23456) << "\n";
}

Solution 2

I have an int that I want to first convert to a binary number.

What exactly does that mean? There is no type "binary number". Well, an int is already represented in binary form internally unless you're using a very strange computer, but that's an implementation detail -- conceptually, it is just an integral number.

Each time you print a number to the screen, it must be converted to a string of characters. It just so happens that most I/O systems chose a decimal representation for this process so that humans have an easier time. But there is nothing inherently decimal about int.

Anyway, to generate a base b representation of an integral number x, simply follow this algorithm:

1. initialize s with the empty string

2. m = x % b

3. x = x / b

4. Convert m into a digit, d.

5. Append d on s.

6. If x is not zero, goto step 2.

7. Reverse s

Step 4 is easy if b <= 10 and your computer uses a character encoding where the digits 0-9 are contiguous, because then it's simply d = '0' + m. Otherwise, you need a lookup table.

Steps 5 and 7 can be simplified to append d on the left of s if you know ahead of time how much space you will need and start from the right end in the string.

In the case of b == 2 (e.g. binary representation), step 2 can be simplified to m = x & 1, and step 3 can be simplified to x = x >> 1.

Solution with reverse:

#include <string>
#include <algorithm>

std::string binary(unsigned x)
{
    std::string s;
    do
    {
        s.push_back('0' + (x & 1));
    } while (x >>= 1);
    std::reverse(s.begin(), s.end());
    return s;
}

Solution without reverse:

#include <string>

std::string binary(unsigned x)
{
    // Warning: this breaks for numbers with more than 64 bits
    char buffer[64];
    char* p = buffer + 64;
    do
    {
        *--p = '0' + (x & 1);
    } while (x >>= 1);
    return std::string(p, buffer + 64);
}

Solution 3

http://snippets.dzone.com/posts/show/4716 or http://www.phanderson.com/printer/bin_disp.html are two good examples.

The basic principle of a simple approach:

• Loop until the # is 0
• & (bitwise and) the # with 1. Print the result (1 or 0) to the end of string buffer.
• Shift the # by 1 bit using >>=.
• Repeat loop
• Print reversed string buffer

To avoid reversing the string or needing to limit yourself to #s fitting the buffer string length, you can:

• Compute ceiling(log2(N)) - say L
• Compute mask = 2^L
• Loop until mask == 0:
  • & (bitwise and) the mask with the #. Print the result (1 or 0).
  • number &= (mask-1)
  • mask >>= 1 (divide by 2)

Solution 4

AND the number with 100000..., then 010000..., 0010000..., etc. Each time, if the result is 0, put a '0' in a char array, otherwise put a '1'.

int numberOfBits = sizeof(int) * 8;
char binary[numberOfBits + 1];
int decimal = 29;

for(int i = 0; i < numberOfBits; ++i) {
    if ((decimal & (0x80000000 >> i)) == 0) {
        binary[i] = '0';
    } else {
        binary[i] = '1';
    }
}
binary[numberOfBits] = '\0';
string binaryString(binary);

Solution 5

I assume this is related to your other question on extensible hashing.

First define some mnemonics for your bits:

const int FIRST_BIT = 0x1;
const int SECOND_BIT = 0x2;
const int THIRD_BIT = 0x4;

Then you have your number you want to convert to a bit string:

int x = someValue;

You can check if a bit is set by using the logical & operator.

if(x & FIRST_BIT)
{
    // The first bit is set.
}

And you can keep an std::string and you add 1 to that string if a bit is set, and you add 0 if the bit is not set. Depending on what order you want the string in you can start with the last bit and move to the first or just first to last.

You can refactor this into a loop and using it for arbitrarily sized numbers by calculating the mnemonic bits above using current_bit_value<<=1 after each iteration.

View more solutions

Comments

[neuromancer]

I don't want to just print a binary number, I want to store it in a string.

[WhirlWind]

No, the answer isn't perfect, but why don't you think about it and then you'll know forever?

[Stephen]

You don't need to "print" it. Imagine he said "put the result on the end of the string buffer".

[Adam]

+1 for researching the user's other posts (and for the answer itself)

[AK_]

@FredOverflow Could you explain more what does x>>=1 mean/does?

[fredoverflow]

@AK_ It means "shift all the bits inside x one to the right". For unsigned integers, it has the exact same semantics as x /= 2.

[AK_]

@fredOverflow It is still not clear - I know that x>>1 means shift to the right by one but here you wrote while(x>>=1) does it mean shift by 1 and check if it is a 1 then continue looping? what if x=10000011b? won't that loop break at the 3rd shift to the right? - thanks again!

[fredoverflow]

@AK_ No, the "condition" becomes false when the value of x is 0; that is, when all bits are 0.

[Bar]

This is guaranteed to work, the accepted answers had issues with leading zeros in my case.