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(b uff) + 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******** ******@snowston e.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(b uff) + 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(bu ff) + 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*******@btin ternet.comwrote :

>"Adam" <ne**@snowstone .org.ukwrote in message
news:48******* *******@snowsto ne.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_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."
-- 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(b uff) + 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(b uff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

ptr = answer;
}

int main(void)
{
char *listofptrs;

foo(&listofptrs );

printf("5) %s",listofptr s[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(b uff) + 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",listofptr s[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(b uff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

*ptr = answer;
}

int main(void)
{
char **listofptrs;

foo(&listofptrs );

printf("5) %s",listofptr s[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(b uff) + 1);
strcpy(answer[i], buff);
}

printf(answer[2]);

ptr = answer;
}

int main(void)
{
char *listofptrs;

foo(&listofptrs );

printf("5) %s",listofptr s[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" <defaultuse...@ yahoo.comwrote:

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" <defaultuse...@ yahoo.comwrote:

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