(null) is printed after converting an integer 12345 to a string "54321" and then returning it to main function for printing

Question

I initially wrote a perfectly working C code for converting a positive integer (say 12345) to a string (i.e. "12345") and print it. The logic is simple: extracting the digits of the integer one-by-one by taking modulo 10 and reducing the integer by a factor of 10 each time (this occurs in the itos() function). The final string needs to hold the extracted digits in reverse order so as to match the original integer (cf. reverse() function).

#include <stdio.h>
#include <string.h>

char *reverse (char *s);
char *itos (int n);

int
main ()
{
  int n = 12345;
  char *s = itos (n);
  printf ("%s", s);
  return 1;
}

char *
itos (int n)
{
  int d = 0;
  char s[100];
  int i = 0;
  do
    {
      d = n % 10;
      s[i] = (d + '0');
      n = n / 10;
      i++;
    } while (n != 0);
  s[i] = '\0';
  return reverse(s);
}

char *
reverse (char *s)
{
  int i = 0;
  int j = strlen (s) - 1;
  char temp;
  while (i < j)
    {
      temp = s[i];
      s[i] = s[j];
      s[j] = temp;
      i++;
      j--;
    }
  return s;
}

You may compile it here. This works perfectly fine, but something strange happens if I return s instead of reverse(s) from the char* itos() function. That is:

#include <stdio.h>
#include <string.h>

char *itos (int n);

int
main ()
{
  int n = 12345;
  char *s = itos (n);
  printf ("%s", s);
  return 1;
}

char *
itos (int n)
{
  int d = 0;
  char s[100];
  int i = 0;
  do
    {
      d = n % 10;
      s[i] = (d + '0');
      n = n / 10;
      i++;
    } while (n != 0);
  s[i] = '\0';
  return s;
}

I'd have expected it to simply print the string "54321" instead of "12345". However, in the output screen, I simply get a (null). There might be a logical error in the char* itos() function, as in I might have done some illegal pointer operation, but I can't really locate the source of error.

I did try debugging by inserting print statements in several parts of the code. What I noticed is if I print the string s within the itos() function just before the return statement then it works fine and prints the string "54321". However, the print statement in the main() function still outputs a (null), which probably implies that there is some mismanagement of memory when the itos() function returns a character pointer to the main() function. Could someone please clarify?

Answer 1

Inside function itos you declared the variable s which is an array of 100 chars. This array is allocated somewhere after the start of the function and deallocated just before the function returns to its caller.

So when you put a printf inside itos, the variable s will still be a valid storage and this is why it worked as you intended. However as soon as itos returns, the memory reserved to the variable s should be considered deallocated thus can not be expected to still contain the data it had when itos was executing, creating undefined behavior if you rely on that.

Probably once deallocated, the memory pointed by s had its values modified, causing your function to not being able to proper convert the string back to a number.

Answer 2

char s[100] is only valid within itos. When the function returns, the memory becomes invalid, and accessing it through the pointer you returned is undefined behavior. You could instead allocate the memory dynamically, like this:

char* s = malloc(100);

When you do it this way, you need to free it when you're done with it (such as after the printf in main), like this:

free(s);

---

So, would defining a global character array be the way to go?

This would also work. Generally, it has its advantages and disadvantages over dynamically allocating the memory. For instance, it would occupy the memory at all times even if your function isn't using it. But to make up for it, the function runs faster because it doesn't have to dynamically allocate/delete the memory every time the function runs. But on the other hand it increases the startup time because it will zero-initialize the array. And of course you couldn't run it multiple times in parallel with one global array. But for this small program, none of those matter much.