A function returning string or pointer

[svata]

Hello to all,

as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.

I read some articles, some other posts and come to this solution:
char *read_name(void ){
static char item_name[11];
char *p_item_name;

printf("Enter the description: ");
if (fgets(item_nam e, sizeof(item_nam e), stdin) != NULL){
/* if the input contains a new line */
if (( p_item_name = strchr(item_nam e, '\n')) != NULL ){
*p_item_name = '\0'; /* get rid of new line */
}
else {
while(getchar() != '\n'){ /* get rid of the rest in the buffer */
;
}
}
}
return item_name; /* return string in the form of character array */
}

Are there other solutions? What are the pros and cons using
array/pointer?

svata

[loic-dev]

Hello Svata,

as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.

I read some articles, some other posts and come to this solution:

<snip>

Are there other solutions? What are the pros and cons using
array/pointer?

Your code is fine, especially if the item_name read should be truncated
to 10 characters (this limit could be defined as constant, BTW, to make
code change easier).

Cheers,
Loic.

[Chris Dollin]

svata wrote:

Hello to all,

as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.

You /must not/ return a pointer to an array which is a local
non-static variable of the function.

I read some articles, some other posts and come to this solution:

char *read_name(void ){
static char item_name[11];

(fx:snip)

return item_name; /* return string in the form of character array */
}

So you /must not/ do this. The variable `item_name` evaporates when
the function returns, so the pointer to it isn't pointing anywhere
and any use of it gets you undefined behaviour -- which is a Very
Bad Thing.

You must return a pointer to store which will outlive the function
call: for example:

* a static array, usually a bad idea because different uses of the
function will share that array.

* mallocated store (which the using code will have to free)

* store passed in as an argument (so it's the caller's problem)

* mix as desired (carefully)

--
Chris "hantwig efferko VOOM!" Dollin
Meaning precedes definition.

[Chris Dollin]

lo******@gmx.ne t wrote:

Hello Svata,

>as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.

I read some articles, some other posts and come to this solution:

<snip>

>Are there other solutions? What are the pros and cons using
array/pointer?

Your code is fine,

Not so, as my reply to svata explains.

--
Chris "hantwig efferko VOOM!" Dollin
"People are part of the design. It's dangerous to forget that." /Star Cops/

[Chris Dollin]

Chris Dollin, the complete idiot, wrote:

svata wrote:

>Hello to all,

as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.

You /must not/ return a pointer to an array which is a local
non-static variable of the function.

>I read some articles, some other posts and come to this solution:

char *read_name(void ){
static char item_name[11];

(fx:snip)

> return item_name; /* return string in the form of character array */
}

So you /must not/ do this.

OK, OK, I'm blind. I read it three times and didn't see `static`.
As soon as I posted, I saw it.

Sorry sorry sorry. Egg egg egg. Time to go hone.

You must return a pointer to store which will outlive the function
call: for example:

* a static array, usually a bad idea because different uses of the
function will share that array.

So you were OK to do what you did, except there's a gotcha you
need to beware of.

--
Chris "hantwig efferko VOOM!" Dollin
"Life is full of mysteries. Consider this one of them." Sinclair, /Babylon 5/

[Stephen Sprunk]

"svata" <sv******@centr um.czwrote in message
news:11******** **************@ h54g2000cwb.goo glegroups.com.. .

as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng)
or
a pointer to this array.

I read some articles, some other posts and come to this solution:

....

Are there other solutions? What are the pros and cons using
array/pointer?

Returning a pointer to a static buffer is a common technique. However,
that has the problem that your callers need to be aware of that, and
they'll likely need to strdup() the results if they want to call the
function frequently. It also means the function is not reentrant, which
can kill you if you try to call that function from multiple threads,
signal handlers, etc.

malloc()ing a new buffer for each call is also done at times. That
solves the above problems, but it means that the caller needs to know to
free() the strings you return when they're done with them, or they'll
end up with a memory leak.

The last common option is to require the caller to provide a buffer (and
its size!) for you; you just put the string into their buffer. By
requiring the caller to do the malloc(), it makes it easier for them to
see they need to do a free(). Or they might use a local array, if they
know how big to make it.

The question in all cases is what to do if the buffer isn't big enough
for the input. If you _know_ that a certain size will never be
exceeded, you can go with that, but such "knowledge" usually turns out
to be incorrect after several maintenance/release cycles. You'll need
to spend as much time figuring out this problem as you are deciding who
allocates the buffer where.

S

--
Stephen Sprunk "God does not play dice." --Albert Einstein
CCIE #3723 "God is an inveterate gambler, and He throws the
K5SSS dice at every possible opportunity." --Stephen Hawking

--
Posted via a free Usenet account from http://www.teranews.com

[goose]

svata wrote:

Hello to all,

as a result from my previous post I'm busy with splitting code into
functions.
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.

I read some articles, some other posts and come to this solution:
char *read_name(void ){
static char item_name[11];
char *p_item_name;

printf("Enter the description: ");
if (fgets(item_nam e, sizeof(item_nam e), stdin) != NULL){
/* if the input contains a new line */
if (( p_item_name = strchr(item_nam e, '\n')) != NULL ){
*p_item_name = '\0'; /* get rid of new line */
}
else {
while(getchar() != '\n'){ /* get rid of the rest in the buffer */
;
}
}
}
return item_name; /* return string in the form of character array */
}

Are there other solutions? What are the pros and cons using
array/pointer?

Stephen below suggests the caller supplying the buffer
(and length). It is sometimes desirable for the caller
to repeatedly call the function each time receiving as
much of the data as can fit in the buffer.

e.g.

int foo (char *buf, int length)
{
/* copy data_to_be_retu rned into buf, not exceeding length */
return 0;
}
....
char buf[20];
int length = foo (buf, sizeof buf);
while (length) {
length = foo (buf, sizeof buf);
/* Use the data here */
}

You can also make the called function behave differently
depending on the argument supplied, supplying a NULL pointer
for the buffer would return the length needed (hard to do with
the above example). This has the disadvantage of seriously
confusing the reader, so comment clearly in header, etc.

e.g.

int foo (char *buf)
{
/* process and store data to be returned in a static buffer */
if (!buf) {
return length_of_data_ to_be_returned;
} else {
memcpy (buf, data_to_be_retu rned, length_of_data_ to_be_returned) ;
}
return 0;
}
....
int length = foo (NULL);
char *buf = malloc (length);
if (!buf) {
/* error!!! */
} else {
foo (buf);
}
....
free (buf);
Basically, every solution will have pros and cons, and
it's up to you to choose which is best for the situation.
There is no "one-good-way" that can be applied to all
situations; be thankful that you've got such a variety
of methods available :-)

goose,
hth

[Eric Sosman]

svata wrote On 11/13/06 09:44,:

[...]
The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or
a pointer to this array.
[...]

Others have addressed your immediate question. I'd like
to draw your attention to two other issues:

printf("Enter the description: ");
if (fgets(item_nam e, sizeof(item_nam e), stdin) != NULL){

Question 12.4 in the comp.lang.c Frequently Asked Questions
list http://www.c-faq.com/ explains why you'd be well-advised to
insert fflush(stdout); between these two lines.

/* if the input contains a new line */
if (( p_item_name = strchr(item_nam e, '\n')) != NULL ){
*p_item_name = '\0'; /* get rid of new line */
}
else {
while(getchar() != '\n'){ /* get rid of the rest in the buffer */
;
}

A good effort, but it overlooks one possibility: What does
getchar() return at end-of-input (or I/O error)? What will
this code do if that happens?

--
Er*********@sun .com

[Old Wolf]

svata wrote:

Hello to all,

as a result from my previous post I'm busy with splitting code into
functions. The one problem ( out of many ) I encounter is how to
properly use/code a function which returns either array of
characters(stri ng) or a pointer to this array.

I prefer making the caller pass in a buffer and a buffer size, and
then the function fills in the buffer and returns the length filled in.
(Or returns a status code and passes the length back via a
pointer parameter, etc.)

This way, the function is not tied to any particular memory
management scheme, and can be called from various places in
your code without having to waste any memory or perform any
acrobatics.

It is also common to allow the function to accept NULL as the
buffer, in which case it will return the size of buffer required, and
then the caller can allocate space if necessary and call the
function again.

[Keith Thompson]

"svata" <sv******@centr um.czwrites:
[...]

The one problem ( out of many ) I encounter is how to properly
use/code a function which returns either array of characters(stri ng) or

[...]

Are there other solutions? What are the pros and cons using
array/pointer?

See the comp.lang.c FAQ, <http://www.c-faq.com/>, particularly
questions 7.5a and 7.5b.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.