C ++二进制到十进制和反向转换器

Question

I've almost solved this exercise: Binary to Decimal and Back Converter - "Develop a converter to convert a decimal number to binary or a binary number to its decimal equivalent." So, the binary to decimal converter works perfectly, but the other one doesn't. convertToBinary() function returns crap and I don't know why. Here is the code:

#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;

char* convertToBinary(int dec);
int convertToDec(const char* bin);

int main()
{
    std::cout << convertToBinary(100) << std::endl; // wtf!
    return 0;
}

char* convertToBinary(int dec)
{
    char binary[15] = "";
    int result;
    for(int i = 0; dec >= 1; dec /= 2, ++i)
    {
      result = !((dec % 2) == 0);
      binary[i] = result + 48;
    }
    for(int i = strlen(binary); strlen(binary) % 4 != 0; ++i) // add some zeros to make it look cool
      binary[i] = '0';
    for(int i = 0, j = strlen(binary)-1; i < j; ++i, --j) // reverse the array
    {
      char temp = binary[i];
      binary[i] = binary[j];
      binary[j] = temp;
    }
    std::cout << binary << std::endl; // looking good!
    return binary;
}

int convertToDec(const char* bin)
{
    int dec = 0;
    int size = strlen(bin);
    for(int i = 0; *bin; ++i, ++bin)
    {
      int ch = *bin - 48;
      dec += ch * pow(2, size - i - 1);
    }
    return dec;
}

Answer 1

Using c language

char *convertToBinary(int value)
{
    char   *binary;
    size_t  length;
    size_t  i;   

    length = 8 * sizeof(value);
    binary = malloc(1 + length);
    if (binary == NULL)
        return NULL;
    for (i = 0 ; i < length ; ++i)
        binary[length - i - 1] = (value & (1 << i)) ? '1' : '0';
    binary[length] = '\0';

    return binary;
}

int binaryToDecimal(const char *binary)
{
    int    value;
    size_t length;
    size_t i;

    value  = 0;
    length = strlen(binary);

    for (i = 0 ; i < length ; i++)
        value |= (binary[i] == '1') ? (1 << (length - i - 1)) : 0;
    return value;
}

Using c++ language

std::string convertToBinary(int value)
{
    std::string binary;
    size_t      length;

    length = 8 * sizeof(value);

    binary.resize(length);
    for (size_t i = 0 ; i < length ; ++i)
        binary[length - i - 1] = (value & (1 << i)) ? '1' : '0';
    return binary;
}

int binaryToDecimal(const std::string &binary)
{
    int    value;
    size_t length;

    value  = 0;
    length = binary.length();

    for (size_t i = 0 ; i < length ; i++)
        value |= (binary[i] == '1') ? (1 << (length - i - 1)) : 0;
    return value;
}

to convert from binary to decimal, you can use strtol of course.

Your mistake is returning a local variable, a local variable is automatically deallocated when the function returns, and hence the garbage you got.

Answer 2

When you do something like this:

char *toString(...)
{
    char res[MAX_RES];

    // fill res
    return res;
}

you create the array res as a local array on the stack. This array goes out of scope when you return from the function; a pointer to this array is no longer valid and most likely will point to garbage.

If you want to use C-style char buffers, there are two ways to get around this:

Allocate the result on the heap.

char *toString(...)
{
    char *res = malloc(MAX_RES);

    // fill res
    return res;
}

Data allocated on the heap with malloc will be valid until explicitly released with free . The advantage of this approach is that you can make the string as long as you wish. Thedrawback is that the allocation might fail. It is also worth noting that the caller now owns the string and is responsible for free ing it:

char *x = toString(...);

// do stuff with x
free(x);

**Pass the buffer and maximum length **

int toString(char *res, size_t max, ...)
{
    // fill res
}

That is the approach many library functions use, notably snprintf . The caller has to provide their own buffer and information on the maximum allowable length in order to avoid buffer overflows. This approach must keep track of the buffer size and truncate the result if necessary, possibly maintaining the string null-terminated. Such functions could be void , but it is customary to return the actual string length or -1 as error indicator.

It is called like this:

char x[200];

toString(x, sizeof(x), ...);
// do stuff with x