Thread: return array

Originally Posted by mark707

first I tried to return the array name which is obviously its address. the compiler gave a warning but i recieved the correct output.

What was the warning? What do you understand of the warning?

Originally Posted by mark707

the second thing i tried was to declare the array as static. no warnings given and the output is correct.

This can work, but then it means that there will be pitfalls that must be avoided when calling the function more than once.

Originally Posted by mark707

the third approach is to have the function work with a global array.

This is a poor solution since it means that your function can only be used with a single array.

What was the warning? What do you understand of the warning?

It warned me about returning address of a local variable.

Originally Posted by mark707

It warned me about returning address of a local variable.

That means that you declared the array to be local to the function. As such, returning a pointer to the first element of the array is wrong: once the function returns, the array no longer exists. The fact that it worked for you does not mean that it is correct; the behaviour here is undefined.

One observation I make is that the number of tokens resulting from the split is likely to be unknown in advance. As such, you might make use of dynamic memory allocation. If so, then instead of declaring a local array, you would have a local pointer that you can return. The caller would be responsible for calling free.

Originally Posted by mark707

first I tried to return the array name which is obviously its address. the compiler gave a warning but i recieved the correct output.

As laserlight hinted, the compiler gives you a warning for a reason. Strictly speaking, any attempt to use a local array returned in this way gives undefined behaviour. The problem with undefined behaviour is that ANY result is permitted. One permitted result is giving you the result you expect. Another permitted result is crashing your program. Yet another permitted result is reformatting your hard drive. The problem is that your code may give behaviour you expect for you, but give some other behaviour for someone else (for example, someone using a different version of your compiler to build your code). Because ANY behaviour is correct. And it is the code that is incorrect.

Originally Posted by mark707

What is the best approach and is there another way I could do it.

There is no "best" approach in C. There are options. Your first option is a really bad one (because undefined behaviour is something to be avoided, except in very specific settings - and you have given no information to suggest you are working in such a setting).

You need to think about things more holistically though. The goal is to return data reliably from your function, for the caller to be able to use it.

What limitations can you reasonably expect the caller (or the programmer writing calling code, who may or may not be you) to accept?

What do you expect to happen if your function is called more than once? If your function is called twice, can it return the same data both times, or will it return something different?

If your function returns the same address each time, does it write different data to it on subsequent calls? If it does, can the caller be relied on to keep copy of older data in order to safely use it?

Imagine what a statement like this

Code:

   some_caller_function(your_function(), your_function());

will do if your_function() returns different data each time, or if the second call of you_function() returns the same address but writes different data to it. Can you rely on the caller to avoid this? Or not?

Code:

/* count_tokens: Computes the number of tokens in 's'. */
size_t count_tokens(const char *s);

/* copy_tokens: Splits 's' into multiple strings and assigns a pointer to each one in '*a'. Terminates with a null pointer. */
char **copy_tokens(char **a, char *s);

/* tokenise: Makes a copy of s, allocates the necessary storage for the array, stores each token in the array, and returns it (using both of the functions listed above). */
char **tokenise(const char *s);

If you have a complicated tokenisation process, as you may if you were writing a complicated line-parser for a shell, you could write a finite state machine in a generic manner that would allow you to use it with both count_tokens and copy_tokens, leading to a simple implementation for both of those functions.

The tokenise function really only requires two calls to malloc. If whitespace may be present before the tokens, you can allocate an extra pointer, store it in the first element, then return a pointer to the second element of the array. That will allow you to free the copy of 's' later on.