Pointers to Arrays

[kelvSYC]

I have a declaration of a pointer to an array of a struct as follows:

struct foo (*a)[];

And I have an array of a struct as follows:

struct foo b[];

However, a = &b returns an error (illegal assignment to constant).
Why is this? Is it because the dimensions to b are not defined?

--
I am only a mirage.

[Vijay Kumar R Zanvar]

"kelvSYC" <ke*****@no.ema il.shaw.ca> wrote in message
news:0910200322 12534304%ke**** *@no.email.shaw .ca...

I have a declaration of a pointer to an array of a struct as follows:

struct foo (*a)[];

The dimension, here, is not required. It is just a template
which is required by the compiler to know what /a/ is pointing
at.
And I have an array of a struct as follows:

struct foo b[];

Dimension is required. If you have b already defined somewhere
then use

extern struct foo[];
However, a = &b returns an error (illegal assignment to constant).
Why is this? Is it because the dimensions to b are not defined?

[Chris Torek]

In article <09************ ************@no .email.shaw.ca>
kelvSYC <kelvSYC> writes:

I have a declaration of a pointer to an array of a struct as follows:
struct foo (*a)[];
And I have an array of a struct as follows:
struct foo b[];
However, a = &b returns an error (illegal assignment to constant).
Why is this? Is it because the dimensions to b are not defined?

If so, that would be a compiler bug. But I suspect the above is
not *quite* what you have (although "array of unknown size" *is*
not very useful, hence not used much, hence one should suspect
compilers might be buggy in this area).

GCC (under -ansi -pedantic) is perfectly happy with the following,
which is not proof, but is some evidence that it is OK:

% cat /tmp/t.c
struct foo;
struct foo (*a)[];
extern struct foo b[];
void f(void) {
a = &b;
}
% cc -ansi -pedantic -W -Wall -O -c t.c
%

The variable "a" has type "pointer to array ? of struct foo", where
"?" represents "unknown size". (Some prefer to write this as
"pointer to array of ? `struct foo's".) Note that there is absolutely
nothing you can do with the variable "a" that you could not do more
simply with another variable:

struct foo *a1 = *a;

Now you can replace any occurrence of (*a)[i] with a1[i], and any
occurrence of *a with plain a1. The only thing the pointer in "a"
would give you that a1 would not is the ability to write a[h][i]
for some integer h, but with the size of the arrays to which "a"
points unspecified, so the only valid value for "h" is an integer
constant zero: a[0][i], which is the same as (*a)[i].
--
In-Real-Life: Chris Torek, Wind River Systems (BSD engineering)
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://67.40.109.61/torek/index.html (for the moment)
Reading email is like searching for food in the garbage, thanks to spammers.

[James Hu]

On 2003-10-10, kelvSYC <ke*****@no.ema il.shaw.ca> wrote:

I have a declaration of a pointer to an array of a struct as follows:
struct foo (*a)[];
And I have an array of a struct as follows:
struct foo b[];
However, a = &b returns an error (illegal assignment to constant).
Why is this? Is it because the dimensions to b are not defined?

In fact, both the declartions of a and b need to have dimensions, and
they need to be the same number.

This is needed so that b is the same type as what a is declared to be
pointing at.

-- James

[Dave Thompson]

On Fri, 10 Oct 2003 00:36:42 -0500, James Hu <jx*@despammed. com>
wrote:

On 2003-10-10, kelvSYC <ke*****@no.ema il.shaw.ca> wrote:

I have a declaration of a pointer to an array of a struct as follows:
struct foo (*a)[];
And I have an array of a struct as follows:
struct foo b[];
However, a = &b returns an error (illegal assignment to constant).
Why is this? Is it because the dimensions to b are not defined?
In fact, both the declartions of a and b need to have dimensions, and
they need to be the same number.

No they don't. If at file scope, the declaration of b is actually a
tentative definition; if not overridden, it allocates an array of one
element, initialized to appropriate zeros. But even if you add
'extern' to prevent this, array of unknown bound is compatible with
any fixed bound, and so AFAICT pointers to same can safely be assigned
or equivalent. In C99 this is also true at compile time for any VLA
bound, although it is UB if the actual runtime bounds disagree.
This is needed so that b is the same type as what a is declared to be
pointing at.

It appears to technically be a violation (UB) to *access* through a
pointer to array of the wrong bound, although in practice it will
almost certainly work as long as any element(s) actually accessed
is(are) within the actual array object. But if you convert (cast, or
assign or equivalent) back to pointer to correct bound it must work.

You won't be able to do arithmetic on, or (thus) subscript, the
pointer to unknown bound, of course.

- David.Thompson1 at worldnet.att.ne t

[James Hu]

On 2003-10-20, Dave Thompson <da************ *@worldnet.att. net> wrote:

On Fri, 10 Oct 2003 00:36:42 -0500, James Hu <jx*@despammed. com>
wrote:

In fact, both the declartions of a and b need to have dimensions, and
they need to be the same number.

No they don't. [...]

Thank you. I was actually straightened out after reading Chris Torek's
post.

-- James