# Thread: Easy way for decimal-binary conversion?

1. ## Easy way for decimal-binary conversion?

For a little challenge exercise i was doing i had to come up with a program that would take a decimal number as input and output it in binary form (ie 36 = 100100). I was successful in doing this, but only with a long, complicated program that mathematically converted them. I figure since everything in a computer's memory is in binary anyway, there should be a much easier way to just tell it to print the raw binary value of the integer variable. Is there such a way?

BTW, here is the long, complicated (but working none-the-less) method that i came up with:

Code:
```#include <iostream>
#include <cstring>
using namespace std;

float pwr(int b, int e);

int main()
{
float value, remainder;
int largest_digit, power;
bool done = 0;
char in_binary[255];
cout << "Enter the number: \n";
cin >> value;
cin.ignore();
for (int x = 0; done == 0; x++)
{
if ((value / pwr(2, x)) < 2)
{
largest_digit = x;
done = 1;
}
}
done = 0;
remainder = value;
power = largest_digit;
for (int x = 0; power >= 0; x++)
{
if ((remainder / pwr(2, power)) >= 1)
{
in_binary[x] = '1';
remainder = (remainder - pwr(2, power));
}
else
{
in_binary[x] = '0';
}
power = (power - 1);
}
in_binary[(largest_digit + 1)] = '\0';
cout << "\n" << in_binary << "\n";
system("pause");

}

float pwr(int b, int e)
{
if (e != 0)
{
int n;
n = b;
for (int x = 0; x < (e - 1); x++)
{
n = (n * b);
}
return float(n);
}
else
{
return 1;
}
}```
OK so I just put that in cuz its the first program i've ever written longer than 10 or so lines and i was pretty proud of myself

2. The STL <bitset> will do what you want for positive integers:
Code:
```#include <iostream>
#include <bitset>

using namespace std;

int main()
{
unsigned long decNumber = 10;
bitset<16> biNumber(decNumber);

int len = static_cast<int>(biNumber.size());

for(int i = len - 1; i >= 0; i--)
{
cout<<biNumber[i];
if(i % 4 == 0) cout<<" ";
}
cout<<endl;

return 0;
}```
Note a bitset is ordered from right to left:

index 15--->0000 0000 0000 1010<----index 0

As for the static_cast, the size() function returns a size_t type, which is an unsigned short(positive integers below a certain size). Since you have to count down the loop to 0, using a size_t type for the loop control 'i' won't work, e.g.:
Code:
```size_t len = biNumber.size();
for(size_t i = len; i >= 0; i--)```
The last time through the loop i gets decremented to -1 which causes the loop to end, but before the loop can end the program will crash. 'i' is a size_t type(=unsigned short), so it has to be a positive integer. Therefore, decrementing i to -1 is not allowed and it will cause the program to crash. That's why i has to be an int, so it can be negative, and casting the return value from size() was necessary.

3. When bored:
Code:
```#include <iostream>
#include <string>
#include <cmath>
#include <limits>

int main()
{
using namespace std;
const unsigned numbits = static_cast<int>(
ceil(
log(double(numeric_limits<unsigned>::max()))
/
log(double(2))
)
);

unsigned div = static_cast<unsigned>(pow(double(2), double(numbits-1)));

string bin;

unsigned num = 45329;
// 1011000100010001

while ( div != 0 )
{
if ( div <= num )
{
bin.push_back('1');
num -= div;
}
else
{
if ( bin.size() != 0 )
bin.push_back('0');
}
div /= 2;
}
cout<<"Predefined value: 1011000100010001"<<endl;
cout<<"Experiment value: "<<bin<<endl;
}```

4. Not bad, though I don't know why you're using floats sometimes.

Your intuition is correct. Two operators in C are known as the bit shifting operators. They are '<<' and '>>'. (They are used in a different way when dealing with input and output streams.) Essentially, they multiply integers by powers of two. (x << y) multiplies x by two to the y'th power. (x >> y) divides x by two to the y'th power (rounding down).

For example, 32 >> 3 == 4. Also, 4 << 3 == 32. You can compute 2 to the nth power with the expression (1 << n). These operations are very efficient.

You can get the least-significant bit of a number by calculating the remainder when dividing by 2. For example, the least significant bit of 7 is 1, because 7 is odd. (Its binary representation is 111.) Whereas 6 is 110, so its least significant bit is zero.

So x % 2 returns the least-significant bit of x. And x >> 1 divides x by two (moving all the bits of the binary representation over by one position). Here's a program:

Code:
```#include <iostream>
using std::cout; using std::endl; using std::cin;

int main() {
unsigned int inp;
char binary_str[33];
// A length of 33 is chosen with the (unfounded) assumption that unsigned
// integers are only 32 bits long, maximum.  This is usually the case, but
// instead, I would use #include <string> and use the std::string datatype, to
// avoid overflowing the array bounds.  (If I were to compile this code for a
// machine that uses sixty-four bit integers, the array could overflow.)

cout << "Enter your number: ";
cin >> inp;

int w = 0;
while (inp != 0) {

if (inp % 2 == 0) {
binary_str[w] = '0';
} else {
binary_str[w] = '1';
}

// The above if-then-else statement could be simplified by writing:
//     binary_str[w] = '0' + inp % 2;
// but let's not get ahead of ourselves.

w = w + 1;

inp = inp >> 1; // Shift the bits over by a position.
}

binary_str[w] = '\0';

cout << "\n" << binary_str << endl;

return 0;
}```
Unfortunately, this string is written out backwards! (You can fix this, right?)

5. My 2 cents :-)

I originally didn't use stringstream and just outputted the answer directly, however this way, you will be able to use the answer elsewhere.

Code:
```#include <iostream>
#include <sstream>
using namespace std;

int main()
{

stringstream ss;
unsigned value, bit = 2147483648, index = 32;

cout << "Enter the number: \n";
cin >> value;

while (index--)
ss << ((value & bit)&&true),bit >>= 1;

cout << "\n" << ss.str() << "\n";
system("pause");
}```
Functionized
Code:
```#include <sstream>
using namespace std;
std::string dec2bin(unsigned value)
{
stringstream ss;
unsigned bit = 2147483648, index =32;
while (index--)	ss << ((value & bit) && true), bit >>= 1;
return ss.str();
}```