How to get array size from a pointer?

[ggnguser]

It's part of a test and I'm stumped. There is a function

void foo(char **x)

The function signature is given and cannot be changed, so no passing
of other values. The test case involves defining this variable:

char *y[] = { /* bunch of stuff */ }

and calling

foo(y)

In the above, "bunch of stuff" is a series of triplets, two strings
followed by a null string (""). However, the last triplet ends with an
integer 0. This seems that it's supposed to signify the end of the
array. However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever). So in effect, one cannot
test for it as a sentry value because it's actually the same as the
preceding triplets.

How then, can the function foo() determine the bounds of the array?
Knowing the bounds of the particular test case is not sufficient since
the actual test suite may have arrays of varying size.

[Richard Heathfield]

gg******@gmail. com said:

It's part of a test and I'm stumped. There is a function

void foo(char **x)

The function signature is given and cannot be changed, so no passing
of other values. The test case involves defining this variable:

char *y[] = { /* bunch of stuff */ }

and calling

foo(y)

In the above, "bunch of stuff" is a series of triplets, two strings
followed by a null string (""). However, the last triplet ends with an
integer 0. This seems that it's supposed to signify the end of the
array. However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever). So in effect, one cannot
test for it as a sentry value because it's actually the same as the
preceding triplets.

How then, can the function foo() determine the bounds of the array?
Knowing the bounds of the particular test case is not sufficient since
the actual test suite may have arrays of varying size.

Your English description of the array contents is confusing. I suggest you
show us the actual initialisation code - i.e. replace /* bunch of stuff */
with the actual bunch of actual stuff.
--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[lawrence.jones]

gg******@gmail. com <gg******@gmail .comwrote:

>
However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever).

No. An empty string is like an empty box; a null pointer is no box at
all.
--
Larry Jones

Rats. I can't tell my gum from my Silly Putty. -- Calvin

[Keith Thompson]

"Bartc" <[e-mail] rites:

<vi******@gmail .comwrote in message
news:31******** *************** ***********@r37 g2000prr.google groups.com...

>On Oct 8, 4:22 pm, "Bartc" <[e-mail] mwrote:

[...]

>>Any empty string is not necessarily NULL.

An empty string is _never_ NULL.

I missed where the OP mentioned the null string "", and assumed that
NULL was also being used to signify an empty string.

However NULL to represent an empty string can be a useful technique
(although not recognised by standard functions), hence my comment.

[...]

Sure, you can use a null pointer to represent an empty string. You
can also use the number 42, or the string "this is an empty string",
to represent an empty string. You can use anything you like to
represent anything you like, as long as you're consistent about it.

But a null pointer *is not* an empty string, and it doesn't point to
an empty string. And, in my opinion, using a null pointer to
represent an empty string is a bad idea; it's too easy to accidentally
pass it to a function that doesn't know about your convention, and it
loses you the ability to distinguish between an empty string and the
absence of a string.

Finally, strings are not pointers. A pointer can point to a string; a
pointer cannot be a string.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[lovecreatesbeauty]

On Oct 9, 12:48 am, Keith Thompson <[e-mail] rote:

>
But a null pointer *is not* an empty string, and it doesn't point to
an empty string. And, in my opinion, using a null pointer to
represent an empty string is a bad idea; it's too easy to accidentally
pass it to a function that doesn't know about your convention, and it
loses you the ability to distinguish between an empty string and the
absence of a string.

Finally, strings are not pointers. A pointer can point to a string; a
pointer cannot be a string.

Yes. In my opinion, the null/empty string is this string: ""; the null
pointer is this value: NULL.

[Keith Thompson]

"lo************ ***@gmail.c0m" <lo************ ***@gmail.comwr ites:

On Oct 9, 12:48 am, Keith Thompson <[e-mail] rote:

>But a null pointer *is not* an empty string, and it doesn't point to
an empty string. And, in my opinion, using a null pointer to
represent an empty string is a bad idea; it's too easy to accidentally
pass it to a function that doesn't know about your convention, and it
loses you the ability to distinguish between an empty string and the
absence of a string.

Finally, strings are not pointers. A pointer can point to a string; a
pointer cannot be a string.

Yes. In my opinion, the null/empty string is this string: ""; the null
pointer is this value: NULL.

Yes -- but it's not a matter of opinion.

[news.motzarella .org was having problems, which seem to have been
cleared up; sorry if this appears twice.]

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Nate Eldredge]

"gg******@gmail .com" <gg******@gmail .comwrites:

It's part of a test and I'm stumped. There is a function

void foo(char **x)

The function signature is given and cannot be changed, so no passing
of other values. The test case involves defining this variable:

char *y[] = { /* bunch of stuff */ }

and calling

foo(y)

In the above, "bunch of stuff" is a series of triplets, two strings
followed by a null string (""). However, the last triplet ends with an
integer 0. This seems that it's supposed to signify the end of the
array.

If I understand right, then an appropriate initializer for y would be
something like

char *y[] = { "foo", "bar", "", "baz", "qux", "", "xyzzy", "plugh", 0 };

However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever). So in effect, one cannot
test for it as a sentry value because it's actually the same as the
preceding triplets.

Well, this may or may not be the case. But it's irrelevant to the
problem at hand. I think what you may be overlooking is that an empty
string is not represented by a NULL pointer (which can be got by
assigning the integer 0 to a pointer), but by a (non-NULL) pointer to
a null character ('\0'). (Or, if you prefer, an array of chars of
which the first is '\0'.) So if I write

char *s = "";

then the following expressions are all true:

s != NULL;
*s == '\0';
s[0] = '\0';

Based on this, you could also understand why

char t[30] = "hello";
strcat(t, s);

would leave t unchanged, while strcat(t, NULL) would crash. (If
you're confused, try writing your own version of strcat and see what
it would do in each case.)

In a sense, the point isn't whether the NULL pointer and the null
character '\0' are represented by the same bits (the C standard makes
no guarantee one way or the other). The issue is whether you're
looking at the pointer itself or the thing it points to.

This is complicated somewhat by the fact that some people write their
code in such a way that passing NULL where a string is expected has
the same effect as passing an empty string. But this is something
that they have to do explicitly. (You could modify your version of
strcat to do this if you want.) In the situation at hand, this is
exactly the opposite of what you want; the distinction between the two
is the information you need.

How then, can the function foo() determine the bounds of the array?
Knowing the bounds of the particular test case is not sufficient since
the actual test suite may have arrays of varying size.

Hopefully this discussion is enough of a hint. If not, post again.

By the way, if by "test" you mean this is part of an exam for a
course, don't forget to properly credit this post as a source of
information.

[Bartc]

"Keith Thompson" <ks***@mib.orgw rote in message
news:ln******** ****@nuthaus.mi b.org...

"Bartc" <[e-mail] rites:

><vi******@gmai l.comwrote in message
news:31******* *************** ************@r3 7g2000prr.googl egroups.com...

>>On Oct 8, 4:22 pm, "Bartc" <[e-mail] mwrote:

[...]

>>>Any empty string is not necessarily NULL.

An empty string is _never_ NULL.

I missed where the OP mentioned the null string "", and assumed that
NULL was also being used to signify an empty string.

However NULL to represent an empty string can be a useful technique
(although not recognised by standard functions), hence my comment.

[...]

Sure, you can use a null pointer to represent an empty string. You
can also use the number 42, or the string "this is an empty string",
to represent an empty string. You can use anything you like to
represent anything you like, as long as you're consistent about it.

I quite like this other quote in this thread:

<la************ @siemens.comwro te in message
news:5q******** ****@jones.home ip.net...

gg******@gmail. com <gg******@gmail .comwrote:
No. An empty string is like an empty box; a null pointer is no box at
all.

If you go to your drawer to get some socks, the absence of a drawer will
tell you you have no socks, just as well as an empty drawer. And you don't
have to open the drawer to find out.

>
But a null pointer *is not* an empty string, and it doesn't point to
an empty string. And, in my opinion, using a null pointer to
represent an empty string is a bad idea; it's too easy to accidentally
pass it to a function that doesn't know about your convention, and it
loses you the ability to distinguish between an empty string and the
absence of a string.

Well I used null pointers for empty strings before, outside of C. In C, that
would be problematic because standard functions tend to crash when you pass
null pointers. But I do still sometimes use null pointers this way, it just
needs some care.

--
Bartc

[CBFalconer]

"gg******@gmail .com" wrote:

>
It's part of a test and I'm stumped. There is a function

void foo(char **x)

The function signature is given and cannot be changed, so no passing
of other values. The test case involves defining this variable:

char *y[] = { /* bunch of stuff */ }

and calling

foo(y)

In the above, "bunch of stuff" is a series of triplets, two strings
followed by a null string (""). However, the last triplet ends with an
integer 0. This seems that it's supposed to signify the end of the
array. However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever). So in effect, one cannot
test for it as a sentry value because it's actually the same as the
preceding triplets.

Maybe "bunch of stuff" is that, but y is not. y is an array of
pointers to char, and those pointers also point to char arrays that
are not writeable. The arrays are strings, with a '\0' terminal
char. The last string is an empty string, and is used to mark the
end of the array.

Now consider what foo is. It appears, from your definition, to be
a function that returns void (i.e. nothing). It also requires a
parameter, x, which is a pointer to a char pointer.

Combining those things, the call to foo(y) cannot possibly do
anything.

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home .att.net>
Try the download section.

[Nick Keighley]

On 9 Oct, 01:27, CBFalconer <cbfalco...@yah oo.comwrote:

"ggngu...@gmail .com" wrote:

It's part of a test and I'm stumped. There is a function

void foo(char **x)

The function signature is given and cannot be changed, so no passing
of other values. The test case involves defining this variable:

char *y[] = { /* bunch of stuff */ }

and calling

foo(y)

In the above, "bunch of stuff" is a series of triplets, two strings
followed by a null string (""). However, the last triplet ends with an
integer 0. This seems that it's supposed to signify the end of the
array. However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever). So in effect, one cannot
test for it as a sentry value because it's actually the same as the
preceding triplets.

Maybe "bunch of stuff" is that, but y is not. *y is an array of
pointers to char, and those pointers also point to char arrays that
are not writeable. *The arrays are strings, with a '\0' terminal
char. *The last string is an empty string, and is used to mark the
end of the array.

Now consider what foo is. *It appears, from your definition, to be
a function that returns void (i.e. nothing). *It also requires a
parameter, x, which is a pointer to a char pointer.

Combining those things, the call to foo(y) cannot possibly do
anything.

--
*[mail]: Chuck F (cbfalconer at maineline dot net)
*[page]: <http://cbfalconer.home .att.net>
* * * * * * Try the download section.- Hide quoted text -

- Show quoted text -

On 9 Oct, 01:27, CBFalconer <cbfalco...@yah oo.comwrote:

<snip>

Now consider what foo is. It appears, from your definition, to be
a function that returns void (i.e. nothing). It also requires a
parameter, x, which is a pointer to a char pointer.

Combining those things, the call to foo(y) cannot possibly do
anything.

i/o?

--
Nick Keighley

[Nate Eldredge]

CBFalconer <cb********@yah oo.comwrites:

"gg******@gmail .com" wrote:

>>
It's part of a test and I'm stumped. There is a function

void foo(char **x)

The function signature is given and cannot be changed, so no passing
of other values. The test case involves defining this variable:

char *y[] = { /* bunch of stuff */ }

and calling

foo(y)

In the above, "bunch of stuff" is a series of triplets, two strings
followed by a null string (""). However, the last triplet ends with an
integer 0. This seems that it's supposed to signify the end of the
array. However, it appears to me that 0 is the same binary value as
for the empty string (NUL, \0, whatever). So in effect, one cannot
test for it as a sentry value because it's actually the same as the
preceding triplets.

Maybe "bunch of stuff" is that, but y is not. y is an array of
pointers to char, and those pointers also point to char arrays that
are not writeable. The arrays are strings, with a '\0' terminal
char. The last string is an empty string, and is used to mark the
end of the array.

Now consider what foo is. It appears, from your definition, to be
a function that returns void (i.e. nothing). It also requires a
parameter, x, which is a pointer to a char pointer.

Combining those things, the call to foo(y) cannot possibly do
anything.

Um? Here are some possible definitions for foo that do things.

void foo(char **x) { x[3] = "Hi mom!"; }
void foo(char **x) { while (*x) puts(*x++); }
void foo(char **x) { errno = EDOOFUS; }
void foo(char **x) { longjmp(somewhe re); }
void foo(char **x) { abort(); }