C - Pointer points to random values

Question

I'm pretty confused by pointers in general and I have no idea why this is happening. Normally a pointer to an array would just print out the values of an array but I have no idea why this is happening. Could someone explain why or suggest what is happening?

char *showBits(int dec, char *buf) {
    char array[33];
    buf=array;
    unsigned int mask=1u<<31;
    int count=0;
    while (mask>0) {
        if ((dec & mask) == 0) {
            array[count]='0';
        }
        else {
            array[count]='1';
        }
        count++;
        mask=mask>>1;
    }
    return buf;
    }

Expecting it to return a binary representation of dec, but printing it produces random garbage.

*Normally a pointer to an array would just print out the values of an array*. No, pointers don't print anything. — lurker, Aug 20 '17 at 11:15
'return buf;' returns pointer to local array with automatic storage - UB. — Martin James, Aug 20 '17 at 11:15
Duplicate of [Function returning address of local variable](https://stackoverflow.com/questions/22288871/function-returning-address-of-local-variable-error-in-c). — Weather Vane, Aug 20 '17 at 11:16
'char *showBits(int dec, char *buf)' passing in 'buf' is pointless since you overwrite it with 'buf=array;' — Martin James, Aug 20 '17 at 11:16
@lurker Doesn't it normally print out the value stored at the address? — danielwestfall, Aug 20 '17 at 11:19
@danielwestfall it does not matter what it passes in:) You splat the parameter with your pointer to 'array'. — Martin James, Aug 20 '17 at 11:20
@danielwestfall were you attempting to COPY array to the one whose address is passed in as 'buf'? — Martin James, Aug 20 '17 at 11:23
@danielwestfall sorry.. Overwrite. Assign to. Change the value of. The point is that the passed-in value of parameter 'buf' is lost when you do 'buf=array;' — Martin James, Aug 20 '17 at 11:24
@MartinJames Yes. Is there a better way to store a decimal number as a binary string rather than an array? — danielwestfall, Aug 20 '17 at 11:26
Possible duplicate (can't cv): https://stackoverflow.com/questions/423186/since-i-cant-return-a-local-variable-whats-the-best-way-to-return-a-string-fr — Antti Haapala -- Слава Україні, Aug 20 '17 at 11:26
Another time, please ask only one question per Question. While it's not unreasonable to have more than one question, if they are *tightly* related, Questions should usually stick to a single question, not tack an additional thing on at the end. — Makyen, Aug 20 '17 at 11:26
@Mayken Ok, that seems completely reasonable. Just curious while I have your attention. — danielwestfall, Aug 20 '17 at 11:28
There seems to be one more problem: You're not null-terminating the string either. — Antti Haapala -- Слава Україні, Aug 20 '17 at 11:28
@AnttiHaapala Do I have to manually add the null terminator at the end of the string? — danielwestfall, Aug 20 '17 at 11:30
Maybe helpful: [How to debug small programs](http://ericlippert.com/2014/03/05/how-to-debug-small-programs/). — honk, Aug 20 '17 at 11:31
@danielwestfall this is C. In C you have 2 choices. You null terminate your strings or you shoot your foot. — Antti Haapala -- Слава Україні, Aug 20 '17 at 11:31
Duplicate - returns pointer to the automatic char array. After return it does not exists anymore — 0___________, Aug 20 '17 at 11:43

alk · Answer 1 · 2017-08-20T13:45:37.313

You have

char *showBits(int dec, char *buf);

and the function is expected "to return a binary representation of dec".

Assuming int is 32 bits, do

#define INT_BITS (32) // to avoid all those magic numbers: 32, 32-1, 32+1

Assuming further that the function is called like this:

int main(void)
{
  int i = 42;  
  char buf[INT_BITS + 1]; // + 1 to be able to store the C-string's '0'-terminator.

  printf("%d = 0b%s\n", i, showBits(i, buf));
}

You could change your code as follows:

char *showBits(int dec, char *buf) {
  // char array[INT_BITS + 1]; // drop this, not needed as buf provides all we need
  // buf=array; // drop this; see above

  unsigned int mask = (1u << (INT_BITS - 1));
  size_t count = 0; // size_t is typically used to type indexes

  while (mask > 0) {
    if ((dec & mask) == 0) {
      buf[count] = '0'; // operate on the buffer provided by the caller. 
    } else {
      buf[count] = '1'; // operate on the buffer provided by the caller. 
    }

    count++;

    mask >>= 1; // same as: mask = mask >> 1;
  }

  buf[INT_BITS] = '\0'; // '0'-terminate the char-array to make it a C-string.

  return buf;
}

Alternatively the function can be used like this:

int main(void)
{
  ...

  showBits(i, buf);
  printf("%d = 0b%s\n", i, buf);
}

The result printed should look like this in both cases:

42 = 0b00000000000000000000000000101010

score 1 · Answer 2 · answered Aug 20 '17 at 13:42

The problem is that you're returning a reference to local array. Instead, let the caller allocate the buffer. I've also fixed some other problems in the code:

#define MAX_BUFFER_LENGTH (sizeof(unsigned int) * CHAR_BIT + 1)

char *to_bit_string(unsigned int n, char *buf) {
    unsigned int mask = UINT_MAX - (UINT_MAX >> 1);
    char *tmp;

    for (tmp = buf; mask; mask >>= 1, tmp++) {
        *tmp = n & mask ? '1': '0';
    }

    *tmp = 0;
    return buf;
}

First of all, we use unsigned int instead of signed int here, because signed ints would be converted to unsigned ints when used in conjunction with unsigned int. Second, unsigned ints can have varying number of bits; so we use sizeof(unsigned int) * CHAR_BIT + 1 to get the absolute maximum of the number of bits. Third, we use UINT_MAX - (UINT_MAX >> 1) as a handy way to get a value that has only the most-significant bit set, no matter how many value bits the number has. Fourth: instead of indices, we use a moving pointer. Fifth - we remember to null-terminate the string.

Usage:

char the_bits[MAX_BUFFER_LENGTH];
puts(to_bit_string(0xDEADBEEF, the_bits));

Output

11011110101011011011111011101111

score 0 · Answer 3 · answered Aug 20 '17 at 11:54

A bit modified code - the caller should provide buff to accommodate the string

char *showBits(unsigned int dec, char *buf) {
    unsigned int mask = 1u << 31;
    int count = 0;
    while (mask>0) {
        if ((dec & mask) == 0) {
            buf[count] = '0';
        }
        else {
            buf[count] = '1';
        }
        count++;
        mask = mask >> 1;
    }
    buf[count] = '\0';
    return buf;
}

C - Pointer points to random values

3 Answers3