Question

I need this function for some personal work and although doing this in general is trivial, I haven’t really played around with bit-shifting before. I have the following code, which tries to convert an integer into a vector of unsigned integers, where each is 1 or 0 (representing the bit). I can assume that the integers are always greater than or equal to 0. Here is my code:

vector<unsigned int> toBinary(int x)
{
    stack<unsigned int> s;
    vector<unsigned int> ret_val;

    for (unsigned i = 0; i < sizeof(x); ++i)
    {
        int z = ((x >> i) & 1) ? 1 : 0;
        s.push(z);
    }

    unsigned num_bits = s.size();
    for (unsigned i = 0; i < num_bits; ++i)
    {
        ret_val.push_back(s.top());
        s.pop();
    }

    return ret_val;
}

This works okay for integers up to 16, then it fails. I use the stack to reverse the order of the bits so the most significant bit is on the left in the final returned value. Why is this broken, and how can I clean it up? Thank you

Answer 1

x is an int – presumably 32 bits, i.e. 4 bytes, in size. sizeof x = 4, 4 bits allow for numbers 0..15

What you want is 8*sizeof x, because of the 8 bits in a byte – although there is a better way (see below).

Cleaning up-wise:

1. Avoid using namespace std, if you must use it then narrow it down to single use (e.g. using std::vector). This means decorating things with std::, but it’s worth it for readability.

2. Use unsigned int rather than int, be explicit about what you’re using.

3. Returning a vector of bool seems to make more sense.

4. The number of bits in a unsigned int is given by std::numeric_limits<unsigned int>::digits (#include <limits>).

5. You can avoid the use of a stack easily enough by using std::reverse on the vector (#include <algorithm>).

Putting it all together, your function could look something like:

std::vector<bool> toBinary(unsigned int x)
{
    std::vector<bool> ret_val;

    for ( unsigned int z = x; z > 0; z /= 2 ) {

        bool r = ( ( z & 1 ) == 1 );
        ret_val.push_back(r);
    }

    int bits = std::numeric_limits<unsigned int>::digits;
    ret_val.resize(bits);

    std::reverse( ret_val.begin(), ret_val.end() );

    return ret_val;
}