passing arg char[X][Y] to function expecting (char**)

[MackS]

I've come across the following difficulty, related to questions 6.12,
6.13 and 6.18 in the FAQ, which I am unable to overcome:

void fun(char **array_of_stri ngs, int num_elements);

int main(void)
{
char static_array_of _strings[NUM_STRINGS][MAX_STRING_LEN+ 1];

fun ((char**)&stati c_array_of_stri ngs, NUM_STRINGS);

return 0;
}

This code compiles but is wrong (I get a segmentation fault). How can I
correctly call fun on static_array_of _strings?

I can't modify the prototype of fun() because it also receives "true"
char** (in the sense of dynamically allocated arrays of strings, ie,
both the number of elements in the array as well as the length of each
string are unknown size at compile time).

How can I pass static_array_of _strings to it? The way I read FAQ 6.18
suggests this is impossible and the prototype of fun() would have to
modified to include MAX_STRING_LEN+ 1.
Thank you for any help,

Mack

[MackS]

Let me add that, in the mean time, the work-around I have found is

void fun(char **array_of_stri ngs, int num_elements);

int main(void)
{
char static_array_of _strings[NUM_STRINGS][MAX_STRING_LEN+ 1];

/* do other stuff * /

{
char* tmp_array_of_st rings[NUM_STRINGS];
int i = 0;
for (; i < NUM_STRINGS; i++)
tmp_array_of_st rings[i] = static_array_of _strings[i];

fun (tmp_array_of_s trings, NUM_STRINGS);

}

return 0;
}

Since fun() doesn't need to modify the (char*) pointers themselves,
this works. But is there a more elegant way of doing this?

Mack

[E. Robert Tisdale]

MackS wrote:

I've come across the following difficulty, related to questions 6.12,
6.13 and 6.18 in the FAQ, which I am unable to overcome:

void fun(char **array_of_stri ngs, int num_elements);
This is the same as

void fun(char* array_of_string s[], int num_elements);
int main(int argc, char* argv[]) {

char static_array_of _strings[NUM_STRINGS][MAX_STRING_LEN+ 1];

fun((char**)&st atic_array_of_s trings, NUM_STRINGS);
This should be something like

char* static_array_of _strings = {"s1", "s2", "s3"};
fun(static_arra y_of_strings, 3);
return 0;
}

This code compiles but is wrong (I get a segmentation fault).
How can I correctly call fun on static_array_of _strings?

I can't modify the prototype of fun() because it also receives "true"
char** (in the sense of dynamically allocated arrays of strings, ie,
both the number of elements in the array
as well as the length of each string
are unknown size at compile time).

How can I pass static_array_of _strings to it?
The way I read FAQ 6.18 suggests this is impossible
and the prototype of fun() would have to modified
to include MAX_STRING_LEN+ 1.

You can write

char* array_of_string s
= (char*)malloc(N UM_STRINGS*size of(char*));
for (size_t i = 0; i < NUM_STRINGS; ++i)
array_of_string s[i] = &(static_array_ of_strings[i][0]);
fun(array_of_st rings, NUM_STRINGS);
free((void*)arr ay_of_strings);

assuming that each array of char in static_array_of _strings
contains at least one '\0'.

If you have a C99 compiler, you could write a wrapper function:

void
fun2(size_t strings, size_t length,
char* static_array_of _strings[strings][length]) {
char* array_of_string s[strings];
for (size_t i = 0; i < strings; ++i)
array_of_string s[i] = &(static_array_ of_strings[i][0]);
fun(array_of_st rings, strings);
}

using variable size arrays.

[Keith Thompson]

"MackS" <ma***********@ hotmail.com> writes:

I've come across the following difficulty, related to questions 6.12,
6.13 and 6.18 in the FAQ, which I am unable to overcome:

void fun(char **array_of_stri ngs, int num_elements);

int main(void)
{
char static_array_of _strings[NUM_STRINGS][MAX_STRING_LEN+ 1];

fun ((char**)&stati c_array_of_stri ngs, NUM_STRINGS);

return 0;
}

This code compiles but is wrong (I get a segmentation fault). How can I
correctly call fun on static_array_of _strings?

fun() expects a pointer to an array of pointers.

static_array_of _strings is an array of array of characters; it
contains no pointers.

(Incidentally, the name "static_array_o f_strings" is a bit misleading,
since it isn't static in any of the senses that C uses the term.)

If you want an array of pointers for fun() to chew on, you're going to
have to build it yourself. The workaround you describe in your
followup is actually a good solution.

--
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.

[Keith Thompson]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:
[...]

char* array_of_string s
= (char*)malloc(N UM_STRINGS*size of(char*));
char *array_of_strin gs = malloc(NUM_STRI NGS * sizeof *array_of_strin gs);

[...] free((void*)arr ay_of_strings);
free(array_of_s trings);

The cast is useless.

[...] If you have a C99 compiler, you could write a wrapper function:

[...]

And if you don't, much of ERT's other code (which I haven't quoted)
won't compile (unless your compiler implements some C99 features as
extensions).

--
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.

[E. Robert Tisdale]

Keith Thompson wrote:

E. Robert Tisdale writes:

free((void*)arr ay_of_strings);
free(array_of_s trings);

The cast is useless.

cat main.c #include <stdlib.h>

int main(int argc, char* argv[]) {
const
char* p =(const char*)malloc(13 );
free(p);
return 0;
}
gcc -Wall -std=c99 -pedantic -o main main.c

main.c: In function `main':
main.c:6: warning: passing arg 1 of `free' \
discards qualifiers from pointer target type

If you have a C99 compiler,

And if you don't,

get one.

[CBFalconer]

MackS wrote:

I've come across the following difficulty, related to questions
6.12, 6.13 and 6.18 in the FAQ, which I am unable to overcome:

void fun(char **array_of_stri ngs, int num_elements);

int main(void)
{
char static_array_of _strings[NUM_STRINGS][MAX_STRING_LEN+ 1];

fun ((char**)&stati c_array_of_stri ngs, NUM_STRINGS);
return 0;
}

This code compiles but is wrong (I get a segmentation fault).
How can I correctly call fun on static_array_of _strings?
.... snip ...
How can I pass static_array_of _strings to it? The way I read FAQ
6.18 suggests this is impossible and the prototype of fun() would
have to modified to include MAX_STRING_LEN+ 1.

You can't. Fun is expecting a pointer to a pointer to a char. I
see no pointers in static_array_of _strings. (henceforth to be known
as sas)

If you don't need to modify the strings, you could use:

static const char *sas[] = {"string1",
"string2",
"string3",
"laststring "};

and call with fun(&sas, sizeof(sas)/sizeof(sas[0]));

If you do need to modify the strings, create the modifiable strings
and then gather pointers to them in sas.

char string1[MAX_STR_LEN] = "string1";
char string2[MAX_STR_LEN] = "string2";
char string3[MAX_STR_LEN] = "string3";
char laststring[MAX_STR_LEN] = "laststring ";

char *sas[] = {&string1, &string2, &string3, &laststring} ;

--
"If you want to post a followup via groups.google.c om, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson

[Christian Kandeler]

CBFalconer wrote:

char string1[MAX_STR_LEN] = "string1";
char string2[MAX_STR_LEN] = "string2";
char string3[MAX_STR_LEN] = "string3";
char laststring[MAX_STR_LEN] = "laststring ";

char *sas[] = {&string1, &string2, &string3, &laststring} ;

The address operators in the last initializer seem wrong to me. They
indicate that we have an array of pointers to arrays, which is not
compatible with the left hand side. I'm curious, though: If we wanted to
leave the right hand side as it is, what would the lhs need to look like? I
can't seem to figure it out.
Christian

[Christian Kandeler]

Christian Kandeler wrote:

char *sas[] = {&string1, &string2, &string3, &laststring} ;

[ ... ]
If we wanted to leave the right hand side as it is, what would the lhs
need to look like? I can't seem to figure it out.

Okay, I remembered there's cdecl. It looks like this:
char (*sas[])[MAX_STR_LEN]
According to the precedence rules, this makes perfect sense, but looking at
it, I never would have guessed that the outer brackets refer to the inner
arrays. I hope I'll never have to use such a construct.
Christian

[Keith Thompson]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:

Keith Thompson wrote:

E. Robert Tisdale writes:

free((void*)arr ay_of_strings);

free(array_of_s trings);
The cast is useless.

> cat main.c

#include <stdlib.h>

int main(int argc, char* argv[]) {
const
char* p =(const char*)malloc(13 );
free(p);
return 0;
}

> gcc -Wall -std=c99 -pedantic -o main main.c

main.c: In function `main':
main.c:6: warning: passing arg 1 of `free' \
discards qualifiers from pointer target type

So what? There was no const in the previous code; the cast in your
free((void*)arr ay_of_strings);
is indeed useless.

--
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.