Printable View
what is the correct way of declaring a function that return an array of characters?
Also how do return array of characters from within a local function?
I tried use a pointer to the variable that was declared in the location function, sometimes, it gave incorrect result. maybe because of the lifetime of the local variable.
Code:char *f ( char somearray[])
{
}
You can return an array with a pointer as long as it's not a local variable. If it is, you can make it static and it will be ok because the lifetime is like a global. You can also dynamically allocate an array and pass it back with a pointer, but then you'll have to free it later.
You don't.
Pass the char* buffer & size of the buffer to the function and write to those parameters.
Local arrays you create in a function disappear when the function returns. You'd have to allocate it with malloc() if you want a local variable to survive a function return, but then someone else has to delete it with free(). The method I showed above is the standard safer way to do it.Code:char* func( char* buf, int size )
{
char str[] = "Hello World";
if ( size > strlen( str ) )
{
return strncpy( buf, str, (size - 1) );
}
return NULL; /* Error! buf isn't big enough. */
}
You can return a char* pointer like above, or better might be to return an int (0 for success, otherwise the buffer size required)...
Oops, forgot about the static option. But then of course your code wouldn't be multithread safe...Quote:
Originally Posted by robwhit
[QUOTE=cpjust;695015]You don't.
Pass the char* buffer & size of the buffer to the function and write to those parameters.
it is okay to do like this, but just what if we don want make changes to pointer which is passed as the function argument (buf).Code:char* func( char* buf, int size )
{
char str[] = "Hello World";
if ( size > strlen( str ) )
{
return strncpy( buf, str, (size - 1) );
}
return NULL; /* Error! buf isn't big enough. */
}
I think using malloc() and add one more arqument to the function prototype.
so later on I can free the space claimed in the function.
what do you think? is it good? m not so sure at all.
then make a copy of it.Quote:
Originally Posted by whichet
yeah, like that.Quote:
Originally Posted by whichet
That's like using a public toilet without flushing. You're forcing other people to clean up your mess. ;)Quote:
Originally Posted by whichet
If the person calling the function already has an array that they can use for the buffer, they can pass that to the function and then there's no call to malloc() and no need to call free() since the array is on the stack.
Or if they need the buffer to live longer, they can do the malloc() themselves and obviously they'd need to free it somewhere down the road too; but at least they have the option of using malloc() or using an array.
Which of course makes a big problem for the calling function if it does not know beforehead the target size of the buffer... So it should guess the size to be allocated - try to pass the allocated array to the child function, and when it fails due to unsuffitient buffer size - to reallocate the buffer with bigger size... Too much overhead.Quote:
Originally Posted by cpjust
In that case, you can do what some Win32 API does. Pass a NULL buffer and 0 size and the function should return the required size.
Or you can make the function smart by taking a char** and if that char** is NULL and size == 0, then allocate memory in the char** argument.
Or you can just take a char*, but the callee casts a char** to char* and passes it (the buffer being NULL) and size == 0 and the function will re-cast the char* to char** and allocate a buffer. Seems a bit more complex, but it hides the extra char** argument with a simple char*, as if the callee must pass a buffer.
Or you can combine the first and second.
Not just the Win32 API. Some POSIX and GNU functions do this as well. I can't think of any at the moment except for tmpnam(), which sort of does.Quote:
In that case, you can do what some Win32 API does. Pass a NULL buffer and 0 size and the function should return the required size.
Your second option sounds pretty convoluted . . . . :)
Sounds a bit similar to the strtol() type of functions.Quote:
Originally Posted by dwks
No, strtol() is like the first option:
No casting involved . . . .Quote:
Or you can make the function smart by taking a char** and if that char** is NULL and size == 0, then allocate memory in the char** argument.
Kinda up to the programmer to use whatever you deem best. If the function takes char**, then you need to do an extra & when passing the argument, so you won't pass char**. But if you take char*, then you won't need it, but eh... whatever syntax you feel is better.
But the first and maybe second are the best I think.
I took that as the second option. The first one was using the Win32 approach with passing the buffer and size.Quote:
Originally Posted by dwks