Returning a string array from a function

[Adam]

Hi,

I'd like to return an (arbitrary length) string array from a function so
that after calling the array I've got a list of strings I can access.

After much perusing of the internet I found a related answer here (by
Eric Sosman) which involved creating an array of pointers and using
that, so it looks something like:
void foo(char *sptr[], int items)
{
char buff[50];
while (--items >= 0)
{
sprintf (buff, "foo%d", items);
sptr[items] = malloc(strlen(buff) + 1);
if (sptr[items] == NULL)
exit(0);
strcpy (sptr[items], buff);
}
}

int main(void)
{
int total = 10;
char *p[total];

foo(p, total);

printf(p[1]);

return 0;
}
This works a treat (I can access my strings, e.g. the printf line) but
how would I do a similar thing if I don't know how long my list is going
to be? E.g. "total" only gets found out inside foo.

Thanks a lot,
Adam

--
Adam Richardson
Carpe Diem

[Malcolm McLean]

"Adam" <ne**@snowstone.org.ukwrote in message
news:48**************@snowstone.org.uk...

Hi,

I'd like to return an (arbitrary length) string array from a function so
that after calling the array I've got a list of strings I can access.

After much perusing of the internet I found a related answer here (by
Eric Sosman) which involved creating an array of pointers and using
that, so it looks something like:
void foo(char *sptr[], int items)
{
char buff[50];
while (--items >= 0)
{
sprintf (buff, "foo%d", items);
sptr[items] = malloc(strlen(buff) + 1);
if (sptr[items] == NULL)
exit(0);
strcpy (sptr[items], buff);
}
}

int main(void)
{
int total = 10;
char *p[total];

foo(p, total);

printf(p[1]);

return 0;
}
This works a treat (I can access my strings, e.g. the printf line) but
how would I do a similar thing if I don't know how long my list is going
to be? E.g. "total" only gets found out inside foo.

Thanks a lot,
Adam

char **foo(int items)
{
char **answer;
char buff[100];
int i;

answer = malloc(items * sizeof(char *));
if(!answer)
goto error_exit;
/* needed for clean up, mustn't have non-null garbage pointers */
for(i=0;i<items;i++)
answer[i] = 0;
for(i=0;i<items;i++)
{
sprintf(buff, "foo %d", i):
answer[i] = malloc(stren(buff) + 1);
if(!answer[i])
goto error_exit;
strcpy(answer[i], buff);
}
return answer;
error_exit:
if(answer)
for(i=0;i<items;i++)
free(answer[i]);
free(answer);
/* maybe print error message / terminate here */
return 0;
}

[Walter Roberson]

In article <Mt******************************@bt.com>,
Malcolm McLean <re*******@btinternet.comwrote:

>"Adam" <ne**@snowstone.org.ukwrote in message
news:48**************@snowstone.org.uk...

>I'd like to return an (arbitrary length) string array from a function so
that after calling the array I've got a list of strings I can access.

answer = malloc(items * sizeof(char *));
if(!answer)
goto error_exit;
/* needed for clean up, mustn't have non-null garbage pointers */

Hmmm. Adam's question didn't -sound- like textbook homework, that you
needed to use a goto to down-grade the code quality so as to
down-grade the marks of anyone who copied it literally.
--
I was very young in those days, but I was also rather dim.
-- Christopher Priest

[Adam]

In message <Wb******************************@comcast.com>, Eric Sosman
wrote:

Adam wrote:

I'd like to return an (arbitrary length) string array from a function so
that after calling the array I've got a list of strings I can access.

^^^^^ function

[snip discussion]

Thanks a lot for the helpful info. I'll go away and do some pondering
about the best course of action. :)

Are you using a C99 compiler?

Yep, GCC, -std=c99.

Thanks,
Adam

--
Adam Richardson
Carpe Diem

[Keith Thompson]

Adam <ne**@snowstone.org.ukwrites:

In message <Wb******************************@comcast.com>, Eric Sosman
wrote:

[...]

> Are you using a C99 compiler?

Yep, GCC, -std=c99.

Then you're using a compiler that implements most, but not all, of C99.
See <http://gcc.gnu.org/c99status.html>.

--
Keith Thompson (The_Other_Keith) 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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Adam]

In message <Wb******************************@comcast.com>, Eric Sosman
wrote:

Adam wrote:

I'd like to return an (arbitrary length) string array from a
function so that after calling the array I've got a list of strings
I can access.

[snip]

After much perusing of the internet I found a related answer here
(by Eric Sosman) which involved creating an array of pointers and
using that, so it looks something like:

void foo(char *sptr[], int items)
{
char buff[50];
while (--items >= 0)
{
sprintf (buff, "foo%d", items);
sptr[items] = malloc(strlen(buff) + 1);
if (sptr[items] == NULL)
exit(0);
strcpy (sptr[items], buff);
}
}
[but how can I do it without specifying "items"?]

[snip]

>
Another way is for foo() to allocate the sptr "array" by
itself, using malloc().

OK, I've been thinking a bit more about this and trying to come to terms
with pointers to pointers and malloc - neither of which I've used
before! However, I'm stuck.

Thanks to Malcolm, who's example I've butchered to try and get working
(I've removed the error-checking etc to try and get it down to
fundamentals, but I realise that's important):

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void foo(char **ptr)
{
char **answer;
char buff[100];
int i;
int items = 10;

answer = malloc(items * sizeof(char *));

for(i=0;i<items;i++)
{
sprintf(buff, "foo %d", i);
answer[i] = malloc(strlen(buff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

ptr = answer;
}

int main(void)
{
char *listofptrs;

foo(&listofptrs);

printf("5) %s",listofptrs[5]);

return 0;
}

answer[2] gets displayed OK, but everything goes nasty before
listofptrs[5] (and the compiler spouts warnings about the printf line
not being right).

On the face of it, since listofptrs[5] is a pointer to the string, I'd
have thought I ought to use *listofptrs[5] but I get an error about
misuse of "unary *".

I'm sure I'm doing something stupid wrong, but I can't work it out. Any
pointers welcome! ;)

Thanks,
Adam

--
Adam Richardson
Carpe Diem

[Default User]

Adam wrote:

OK, I've been thinking a bit more about this and trying to come to
terms with pointers to pointers and malloc - neither of which I've
used before! However, I'm stuck.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void foo(char **ptr)
{
char **answer;
char buff[100];
int i;
int items = 10;

answer = malloc(items * sizeof(char *));

for(i=0;i<items;i++)
{
sprintf(buff, "foo %d", i);
answer[i] = malloc(strlen(buff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

ptr = answer;

ptr is a local pointer. Nothing you do to it in foo() will be reflected
back in main().

}

int main(void)
{
char *listofptrs;

In spite of the name, listofptrs is a single pointer to char. NOT what
you want.

foo(&listofptrs);

printf("5) %s",listofptrs[5]);

listofptrs[5] would be at best a single char, not a string.

return 0;
}

I wouldn't do it this way for real, but here's a way with the least
amount of fiddling with your example that achieves the goal:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void foo(char ***ptr)
{
char **answer;
char buff[100];
int i;
int items = 10;

answer = malloc(items * sizeof(char *));

for(i=0;i<items;i++)
{
sprintf(buff, "foo %d", i);
answer[i] = malloc(strlen(buff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

*ptr = answer;
}

int main(void)
{
char **listofptrs;

foo(&listofptrs);

printf("5) %s",listofptrs[5]);

return 0;
}

Brian

[A. Bolmarcich]

On 2007-09-05, Adam <ne**@snowstone.org.ukwrote:

OK, I've been thinking a bit more about this and trying to come to terms
with pointers to pointers and malloc - neither of which I've used
before! However, I'm stuck.

Thanks to Malcolm, who's example I've butchered to try and get working
(I've removed the error-checking etc to try and get it down to
fundamentals, but I realise that's important):

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void foo(char **ptr)
{
char **answer;
char buff[100];
int i;
int items = 10;

answer = malloc(items * sizeof(char *));

for(i=0;i<items;i++)
{
sprintf(buff, "foo %d", i);
answer[i] = malloc(strlen(buff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

ptr = answer;
}

int main(void)
{
char *listofptrs;

foo(&listofptrs);

printf("5) %s",listofptrs[5]);

return 0;
}

answer[2] gets displayed OK, but everything goes nasty before
listofptrs[5] (and the compiler spouts warnings about the printf line
not being right).

On the face of it, since listofptrs[5] is a pointer to the string, I'd
have thought I ought to use *listofptrs[5] but I get an error about
misuse of "unary *".

[snip]

Given the declaration

char *listofptrs"

listofptrs[5] is a char. To have listofptrs[5] be a char*, you can use
the declaration

char **listofptrs

With that change to the declaration, you need to change

void foo(char **ptr)

to

void foo(char ***ptr)

and inside the function foo change

ptr = answer;

to

*ptr = answer;

[Adam]

On 5 Sep, 23:36, "Default User" <[e-mail]:

ptr is a local pointer. Nothing you do to it in foo() will be reflected
back in main().

Of course. I'd had a feeling there was something wrong with that
expression. If I'd nailed it down I might have solved my problem! :)

I wouldn't do it this way for real, but here's a way with the least

Any alternative suggestions are welcome :)

Thanks,
Adam

[Default User]

Adam wrote:

On 5 Sep, 23:36, "Default User" <[e-mail]:

ptr is a local pointer. Nothing you do to it in foo() will be
reflected back in main().

Of course. I'd had a feeling there was something wrong with that
expression. If I'd nailed it down I might have solved my problem! :)

I wouldn't do it this way for real, but here's a way with the least

Any alternative suggestions are welcome :)

It's poor practice to use a magic number defined in the worker
function. How would the caller know what the value of "items" is?

One thing to consider is whether you want to do all the allocating in a
separate function. The caller then has to deallocate it.

If you do, then you at least need to tell the caller how many items
have been indicated. Either a return value or another parameter is the
way to do that.

Brian

[Adam]

In message <5k************@mid.individual.net>, Default User wrote:

Adam wrote:

On 5 Sep, 23:36, "Default User" <[e-mail]:

ptr is a local pointer. Nothing you do to it in foo() will be
reflected back in main().

Of course. I'd had a feeling there was something wrong with that
expression. If I'd nailed it down I might have solved my problem! :)

I wouldn't do it this way for real, but here's a way with the least

Any alternative suggestions are welcome :)

It's poor practice to use a magic number defined in the worker
function. How would the caller know what the value of "items" is?

Sorry, I should have said - that's only for illustration. Assigning the
actual strings will be done by an OS-specific routine. Also, I need to
think about error checking and providing a function to free the memory.

Adam

--
Adam Richardson
Carpe Diem

[Antoninus Twink]

On 5 Sep 2007 at 22:36, Default User wrote:

ptr is a local pointer. Nothing you do to it in foo() will be reflected
back in main().

Gasp! Default Loser actually makes a post to clc with technical content,
rather than a moan about top-posting or an accusation of trolling!
*falls off chair in amazement*

[Adam]

[to recap, I'm trying to generate an artibrary list of strings in a
function for use in main()]

In message <81**************@snowstone.org.uk>, Adam wrote:

Sorry, I should have said - that's only for illustration. Assigning the
actual strings will be done by an OS-specific routine. Also, I need to
think about error checking and providing a function to free the memory.

OK, I've got my function working now but am still a bit uncertain about
my use of free, so here's my final attempt - I'd be grateful for any
comments :)

It's got some psuedo-code in it to replace the bits where my real
function has OS-specific bits. The return-value of the real function is
also a slightly more sophisticated error structure.
int create_list(char ***ptrlist)
{
char **list;
char *name;
int items, i, count = 0;

items = /* number determined by OS routine */ ;

/* Allocate space for a list of pointers long enough */
/* for all items + terminating "" */
list = malloc((items + 1) * sizeof(char *));
if (!list)
return 1;

while ( /* more items */ )
{
/* pointer to an item string written to "name" by OS routine here */

/* Allocate length of string + terminator */
list[count] = malloc(strlen(name) + 1);

if (!list[count])
{
/* Free already-allocated items */
for (i = 0; i < count; i++)
free(list[count]);

return 1;
}

if ( /* last item */ )
strcpy(list[count], ""); /* Terminate list with "" */
else
strcpy(list[count], name);

count++;
}

*ptrlist = list;

return 0;
}

void clear_list(char **ptrlist)
{
int i = 0;

/* Free the strings pointed to in the pointer list */
while(strcmp(ptrlist[i], ""))
{
free(ptrlist[i]);
i++;
}

/* Free the pointer list */
free(ptrlist);
}

int main(void)
{
char **listofptrs;
int i = 0;

create_list(&listofptrs); /* Create list */

/* Use list, e.g.: */
while(strcmp(ptrlist[i], ""))
{
printf(ptrlist[i]);
i++;
}

clear_list(listofptrs); /* Free memory */

return 0;
}
On an unrelated note, what's the best practice when it comes to using
"return"? Up until now I've always only had one return from a function,
but create_list has a few places where return is called...

Thanks a lot,
Adam

--
Adam Richardson
Carpe Diem

[Chris Dollin]

Adam wrote:

On an unrelated note, what's the best practice when it comes to using
"return"? Up until now I've always only had one return from a function,
but create_list has a few places where return is called...

I don't know what "best practice" is, but I do have opinions.

(a) If you have a local coding standard, stick to it unless it's
so horrible you're prepared to advocate for change.

(b) Code being /clear/ trumps any blind application of rules.

(c) If a function is so long that it's hard to see where any
extra returns are, that function is anyways too long. Fix
that first.

(d) Code being /clear/ trumps any blind application of rules.

(e) Code should say what it means and mean what it says.

(f) If a function has blank lines in it, it's too long, unless
it has a switch in it, in which case it /might/ be too long.

I freely write functions with multiple returns in them, because
I follow (b) and (c) and nobody has tried to impose an unsuitable (a).
For example I'd write (I'm not advocating this brace placement [1])

if (whatever)
{
thenWhatever();
return answerA;
}
else
{
elseWhatever();
return answerB;
}

rather than any sort of dance with a variable to hold the return
value. That's assuming, of course, that I can't write it like:

return whatever ? answerAafterThen : answerBafterElse;

which would be my preference, subject to (b).

[1] I don't lie well, do I.

--
Trumps Are Green And Sevens Hedgehog
"It took a very long time, much longer than the most generous estimates."
- James White, /Sector General/

[Ben Bacarisse]

Adam <ne**@snowstone.org.ukwrites:

[to recap, I'm trying to generate an artibrary list of strings in a
function for use in main()]

In message <81**************@snowstone.org.uk>, Adam wrote:

>Sorry, I should have said - that's only for illustration. Assigning the
actual strings will be done by an OS-specific routine. Also, I need to
think about error checking and providing a function to free the memory.

OK, I've got my function working now but am still a bit uncertain about
my use of free, so here's my final attempt - I'd be grateful for any
comments :)

Not quite right yet...

It's got some psuedo-code in it to replace the bits where my real
function has OS-specific bits. The return-value of the real function is
also a slightly more sophisticated error structure.
int create_list(char ***ptrlist)
{
char **list;
char *name;
int items, i, count = 0;

items = /* number determined by OS routine */ ;

/* Allocate space for a list of pointers long enough */
/* for all items + terminating "" */

It would be more idiomatic to use NULL for the final sentinel value
and even more idiomatic to return the number of strings and have no
sentinel. By using "" you are have to either allocate a space for
this short string, or you can use a pointer to a constant "" but both
of these are more complex than using NULL.

list = malloc((items + 1) * sizeof(char *));
if (!list)
return 1;

while ( /* more items */ )
{
/* pointer to an item string written to "name" by OS routine here */

/* Allocate length of string + terminator */
list[count] = malloc(strlen(name) + 1);

if (!list[count])
{
/* Free already-allocated items */
for (i = 0; i < count; i++)
free(list[count]);

Typo? You mean free(list[i]), yes?

Here you should probably also free(list) since it is not required
now. If you used NULL as a terminator, it would be already terminated
(the malloc just failed) and you could just call clear_list to throw
everything away!

>
return 1;
}

if ( /* last item */ )
strcpy(list[count], ""); /* Terminate list with "" */

I would prefer to see this outside the loop. It makes more sense to
me that way. Also, it is not clear if you will have make space for
this short string. If strlen(name) returns 0 on the last iteration
then you are OK.

else
strcpy(list[count], name);

count++;
}

*ptrlist = list;

return 0;
}

void clear_list(char **ptrlist)
{
int i = 0;

/* Free the strings pointed to in the pointer list */
while(strcmp(ptrlist[i], ""))

prtlist[i][0] == '\0' or even !*prtlist[0] are simpler and idiomatic
in C.

{
free(ptrlist[i]);
i++;
}

/* Free the pointer list */
free(ptrlist);
}

int main(void)
{
char **listofptrs;
int i = 0;

create_list(&listofptrs); /* Create list */

/* Use list, e.g.: */
while(strcmp(ptrlist[i], ""))

This test would be simpler with a NULL as the end marker.

{
printf(ptrlist[i]);
i++;
}

clear_list(listofptrs); /* Free memory */

return 0;
}
On an unrelated note, what's the best practice when it comes to using
"return"? Up until now I've always only had one return from a function,
but create_list has a few places where return is called...

Pass -- I'll leave that can of worms unopened!

--
Ben.

[Bart van Ingen Schenau]

Chris Dollin wrote:

Adam wrote:

>On an unrelated note, what's the best practice when it comes to using
"return"? Up until now I've always only had one return from a
function, but create_list has a few places where return is called...

I don't know what "best practice" is, but I do have opinions.

<snip>

(f) If a function has blank lines in it, it's too long, unless
it has a switch in it, in which case it /might/ be too long.

I don't agree on this one.
I regularly put blank lines between logical sections in my code such as
variable declarations (C90 style, at beginning of a block),
pre-condition checks and the code that does the actual work.

However, if you can split the actual work into multiple logical units,
then it is highly likely that your function is doing too much and is
therefor too long.

Bart v Ingen Schenau
--
a.c.l.l.c-c++ FAQ: http://www.comeaucomputing.com/learn/faq
c.l.c FAQ: http://www.eskimo.com/~scs/C-faq/top.html
c.l.c++ FAQ: http://www.parashift.com/c++-faq-lite/

[Army1987]

On Sat, 08 Sep 2007 16:25:07 +0100, Ben Bacarisse wrote:

> while(strcmp(ptrlist[i], ""))

This test would be simpler with a NULL as the end marker.

I agree that it is silly to use an empty string as a sentinel, but
how is while(ptrlist[i]) simpler than while(ptrlist[i][0])?
--
Army1987 (Replace "NOSPAM" with "email")
If you're sending e-mail from a Windows machine, turn off Microsoft's
stupid “Smart Quotes� feature. This is so you'll avoid sprinkling garbage
characters through your mail. -- Eric S. Raymond and Rick Moen

[CBFalconer]

Army1987 wrote:

Ben Bacarisse wrote:

>> while(strcmp(ptrlist[i], ""))

This test would be simpler with a NULL as the end marker.

I agree that it is silly to use an empty string as a sentinel,
but how is while(ptrlist[i]) simpler than while(ptrlist[i][0])?

The rest of the context seems to have been snipped, but on the
basis of the above it omits at least one level of indirection.
"while (ptrlist[i])" needs only to load ptrlist and i, add them,
and load from the result to test (which may all be one
instruction). "while (ptrlist[i][0])" needs to load from that
result before applying the test.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>
--
Posted via a free Usenet account from http://www.teranews.com

[Ben Bacarisse]

Army1987 <ar******@NOSPAM.itwrites:

On Sat, 08 Sep 2007 16:25:07 +0100, Ben Bacarisse wrote:

>> while(strcmp(ptrlist[i], ""))

This test would be simpler with a NULL as the end marker.

I agree that it is silly to use an empty string as a sentinel, but
how is while(ptrlist[i]) simpler than while(ptrlist[i][0])?

True. I forgot that I had already explained how to remove the strcmp
call!

Of course, it *is* simpler by almost any measure, but I won't argue
the point -- I know exactly what you mean. Once the function call has
been replaced the two test are essentially equivalent.

--
Ben.

[Adam]

On 8 Sep, 16:25, Ben Bacarisse <[e-mail]:

It would be more idiomatic to use NULL for the final sentinel value
and even more idiomatic to return the number of strings and have no
sentinel.

After a bit of exploration, I've altered the function to return the
number of strings.

[snip other helpful comments]

Thanks to all who provided advice, I've got my function working now
and have learned more about indirection and char arrays in the
process. :)

Adam