why char array is empty in C

Question

my code as following:

char* int2str(int val);

void main(){
 char *s = int2str(1001);
 printf("----s=%s\n",s);
}

char* int2str(int val){
  char turnStr[10];
  sprintf(turnStr, "%d", val);
  //printf("turnStr=%s\n",turnStr);
  return turnStr;
}

The above code print out empty string, but when I uncommented the line:printf("turnStr=%s\n",turnStr) It was able to print out the right string. I knew the stack space can not return when the function was over, but I'm confused about when I added printf("turnStr=%s\n",turnStr), it could print out the string.

Answer 1

Wonderful!

The basic problem is that you returned the address of something on the stack, and it was changed by something else. I tried a recent gcc and it didn't even return the stack pointer, so I tried gcc 4.4.5 and reproduced your behavior.

I tried changing main to:

void main(){
 char *s = int2str(1001);
 printf("----s=%s\n",s);
 s = int2str(1002);
 printf("----s=%s\n",s);
}

and the second printf() output 1002.

I think what is happening is that printf has some local variables that were placed in the same location as your array and that aren't used if you have previously invoked printf().

Note that it didn't print as empty but as garbage. That garbage might start with a NUL, or not.

In any case, everyone else is right that you shouldn't do this. There are a number of solutions, including:

1. dynamic memory allocation (which means you need to free it)
2. passing in a buffer (adds parameters ... you should pass in the length)
3. using a static buffer (problematic for threading or multiple uses)
4. returning a structure by value containing the text (can copy more than it should, which could cause performance issues, and you have to save the structure in the caller)
5. eliminating this function altogether (which might not be a good solution depending on what you are doing)

Answer 2

You're returning a reference to local variable char turnStr[10]. When function exits, the memory used by that reference is cleaned up. So in main() you're left with a dangling pointer: char *s points to memory that is no longer valid.

Answer 3

The char array is stored on the stack frame of the int2str function. That means that while the function is still running, the memory on the stack is stable and usable. That's why you can print out the string. However, once you return from the function, there's no guarantee that the memory will be maintained and it can be cleared out or reused like you witnessed.

Answer 4

Returning reference (pointer) to the local object is an Undefined Behaviour. Many modern compilers emit the warning and assign this pointer with the NULL - for example gcc. Another problem you have with this code is another UB. Your char array is not long enough to accommodate the string

how to sort it out (an example):

char* int2str(int val);

void main(){
 char *s = int2str(1001);
 printf("----s=%s\n",s);
}

char* int2str(int val){
  static char turnStr[20];
  sprintf(turnStr, "%d", val);
  //printf("turnStr=%s\n",turnStr);
  return turnStr;
}

https://godbolt.org/z/F3cx3E

Answer 5

For starters according to the C Standard the function main without parameters shall be declared like

int main( void )

that is its return type shall be int.

Your program has undefined behavior because the returned pointer from the function int2str points to a local array with the automatic storage duration that will not be alive after exiting the function. So the pointer will have an invalid value. The memory occupied by the local array can be overwritten by a call of any other function (for example by a call of printf within main).

So you have to allocate dynamically memory for the destination string. To use a local array with static storage duration within the function is not a good idea because calling the function several times will lead that previous result strings will be overwritten.

Pay attention to that for example the value of INT_MIN (the user of the function can pass any valid integer value) can be equal to -2147483648 that requires a character array of 12 elements to store the string that represents such a number.

To calculate the required size of the string you can use a call of the C function snprintf with the second argument equal to 0.

Here is a demonstrative program.

#include <stdio.h>
#include <stdlib.h>

char * int2str( int x )
{
    int n = snprintf( NULL, 0, "%d", x );

    char *s = malloc( n + 1 );

    if ( s )
    {
        snprintf( s, n + 1, "%d", x );
    }

    return s;
}

int main(void) 
{
    char *s = int2str( 1001 );

    if ( s ) puts( s );

    free( s );

    return 0;
}

Its output is

1001