Thread: return value from function (out of scope)

Code:

char* getSomething() {
   char* str = "hello" ;
   return str ;
}

This is actually safe because the text is stored in memory for the duration of the program. Had you done this, though, that would not be the case:

Code:

char* getSomething() {
   char str[] = "hello" ;
   return str ;
}

In that case, it would be a local variable and could not be returned from the function.

At any rate, I would avoid returning malloc'ed memory as well, as this is a very common source of memory leaks. The best way, generally, is to have to user pass a buffer and buffer length to the function, ie:

Code:

char* foo(char* buffer, size_t max_length)
{
	char text[] = "baz";
	size_t length = strlen(text);
	if(length >= max_length)
		return NULL;
	strncpy(buffer, text, length);
	return buffer;
}

Originally Posted by itCbitC

The first one is to be avoided at all costs as str disappears the instant the function that contains it returns unless str is on the heap instead of on the stack.

Yes, when the stack is popped str is not visible anymore leaving you with a dangling pointer in the caller ie output now points to a non-existent location.

As long as str isn't on the stack ie a local variable.

Isn't this true with an ordinary variable. For eg.

Code:

int func(void)
{
int sum;
sum=32;
return sum;
}

Whenever the function is returned sum gets destroyed. So why is this only considered with pointers?

Originally Posted by BEN10

Whenever the function is returned sum gets destroyed. So why is this only considered with pointers?

Right. So the local variable is destroyed when the function goes out of scope. If you return a pointer to the local variable, one can then reason that the caller would get a copy of a pointer to a variable that no longer exists. In the case of buffer, the caller would get a pointer to the first element of an array that no longer exists.

Still I'm very much confused. I dont understand how does all this returning procedure works fine if the variable gets destroyed(even in simpler cases where no pointer is involved).

Originally Posted by jeanluca

Code:

char* getSomething() {
   char* str = "hello" ;
   return str ;
}

is str stored on the heap ? I would say it local -> stack!

itCbitC thnx for the tutorial!

The variable str itself is local and therefore stored on the stack. It disappears (is popped off the stack) at the end of the function. However, the value it stores and is returning to the caller is the address of the string literal "hello" which exists in the program's read-only data segment. This address will exist throughout the program's existence and is therefore safe to return using this function.

Originally Posted by BEN10

Still I'm very much confused. I dont understand how does all this returning procedure works fine if the variable gets destroyed(even in simpler cases where no pointer is involved).

Where pointers are not involved, the value/literal to be returned is copied from the stack frame of the callee into the stack frame of the caller. Storage is already allocated in the stack frame of the callee for the value being returned. Did you try to Google it?

[edit] Here's a link on stack howto [/edit]

Originally Posted by jeanluca

Hi All

Consider the following function

Code:

char* getSomething() {
   char* str = "hello" ;
   return str ;
}

which I can use as follows

Code:

   char* output = malloc( 6 * sizeof(*output) ) ;
   output = getSomething() ;

or

Code:

   char *output = getSomething() ;

I would say that the last usage should be avoided, right?

But an other problem might be char* str, because it goes out of scope when the function finishes, meaning the memory will be available again. Is this statement right ?

If so, it could then give problems when using 'output'. And in which situation can you return a pointer ?

Any comments on the above, because I have the feeling I don't really understand this stuff!

thnx a lot
LuCa

Note that the first use is bad, since you are only assigning a new value to the pointer, and not to the allocated memory.
The allocated memory's address is stored in the pointer and is lost once you assign another value to the pointer from the returned function, thus creating a memory leak.