Best practice: string manipulation functions

Hi,
I am fairly new to C coding and have a question regarding the best practice when using functions to manipulate strings. Basically I would like to know should I write a function like:

char *manipulate(char *str)
{

static char outstr[1024];

< Insert function code >

return outstr;

}

or is it better to write:

char *manipulate(char *outstr, char *str)
{

< Insert function code >

return outstr;

}

I was just curious to know if I should be using one method or the other as a best practice from point of view of performance and or style.

Thanks in advance for any feedback.

I suppose it depends on what you need to do with it. If you need to return the modified string, you'll need to allocate it dynamicly, or use an internal static buffer. If you pass a buffer to store the modified string in, you'll also want to pass the size of the buffer, so that you don't run merrily along and trash your memory as you walk off the end of it.

But really, it depends on what you're actually doing with the string.

Quzah.

It's really personal preference IMO. Each has its pros and cons.

In the first style the calling function doesn't have to worry about declaring the buffer. However, you can't do something like printf("%s:%s\n", manipulate("foo"), manipulate("bar")); because the static buffer will get overwritten by the second call to manipulate().

In the second style you can do the printf() type things, but the calling function has to declare the buffers used by manipulate(). Also, your second method is a little dangerous in that manipulate() has no idea how big outstr is so you might be risking a buffer overflow. I'd rewrite it as char *manipulate(char *outstr, int size, char *str) where size is the size of outstr if you decide to go that route.

A third style would be to have manipulate() dynamically allocate memory for the buffer, but then the calling function has to worry about free()'ing that memory and I personally think it's best for a function to provide its own clean-up whenever possible.

Being consistent I think is the most important part. You don't want half your functions to work one way and the other half to work the other.

The second way is far more intuitive, and easier to debug if you have problems. You should pass in the size of the buffer as well in your second function though, so you dont overwrite it by accident.

While the first method is technically correct, you will start to have problems when the function is called repeatedly. Especially if it is called from different threads. Picture this:

Code:

---

char *pstr1, *pstr2;
pstr1 = manipulate();
pstr2 = manipulate();
// now pstr1 and pstr2 both point to the same location in memory.  If you make
// a change to one, it will change the other.  This can cause you major headaches.

---

Thanks for all of the help, I think it is clear that the second method is probably the method of choice to use.

Thanks for the tip about passing the size inside the function call as well.