Thread: char* returning question

I have a few questions about functions returning char *:

Here I have two programs, the green how the program works without any problems:

Code:

char *func(void)
{
   char *returnstr;

   returnstr = (char *) malloc(100);

   //  put something into the string

   return(returnstr);
}

int main()
{
   char *str;

   str = func();
   printf("%s", str);

// I think I need to free() the str,
// but to free here something that was allocated 
// inside func() looks kind of weird, and alittle stupid
// so I'm not sure what do with the allocated memory...

   return(0);
}

And the red, the wrong way to return char *:

Code:

char *func(void)
{
   char returnstr[100]={0};

   //  put something into the string

   return(returnstr);
}

int main()
{
   printf("%s", func());

   return(0);
}

Can someone please explain to me what is the problem with the red code, and why do I have to work the way I did with in the green code?

Thank you.

The array goes out of scope when the function ends. This effectively destroys whatever it contains. Or as far as you're concerned it's unable to be used any way. Just like you can't assign arrays with the = sign, you can't return them.

But as to the issue, it's because the array goes out of scope and is destroyed.


Quzah.

I see, but what about the allocated memory do I really need the free() tagging along with the function??? It looks kind of weird?

Also, why can't I directly print to the screen the returned string (address)?

Yes. For every allocation, you need to free. Print what to the screen? The array's contents? Because it's already been destroyed.


Quzah.

No, I meant if I want to place this in the green code:

Code:

printf("%s", func());

You can, you'll just create a memory leak because you don't have a pointer to the string, so you can't free lit later.


Quzah.

Don't forget:

Code:

char *also_fine(void)
{
  static char a[] = "This is a string";

  return a;
}

Variables declared as static in a function are not allocated on the stack so the above function will work fine. It's not without its drawback too though.

char* a = malloc(4);
a = "abc";
free(a); // Needs this.
This is wrong - you're not freeing what you malloc'ed, that was lost with your assignment.
What you're freeing here is "abc".

Originally Posted by Tonto

If you need data, it's going to have to come from a safe place. What you could be doing, is passing a local pointer of main to a function (with preallocated memory on heap or stack) and then strcpy (not assign the pointer!) whatever stuff you generate in foo() or bar(), and then continue. Like this:

Code:

char* foobar(char* s)
{
	char a[] = "abc";
	strcpy(s, a); // Not assigning s to a, strcpy'ing!
	return s;
}

int main()
{
	char* s = malloc(64); // Needs allocation!
	printf("%s", foobar(s));
	return 0;
}

but basicly if I pass the s allocated string to the foobar function I don't need to return(s), since the string will be returned with all the changes inside the variable I just passed to it. In other words:

Code:

void foobar(char *s)
{
   strcpy(s, "hello world");
  // no return
}

main()
{
   char *s = (char *) malloc(100);

   foobar(s);
   printf("%s", s);
}