How come C allow structure members to be addressed like an array ?

[pereges]

#include <stdio.h>

typedef struct
{
double x, y, z;
}vector;

int main(void)
{
int i;
vector v;
double *cord;

v.x = 10;
v.y = 1;
v.z = 2;

cord = &v.x;

for(i = 0; i < 3; i++)
{
printf("%f\n", cord[i]);
}
return 0;
}

here's the output i get:
10.000000
1.000000
2.000000

which is the same as v

i don't how it happens as i was just trying some random ideas but
great stuff really. helped me to reduce some of my code to almost
1/3rd its size.

[Ben Bacarisse]

Ian Collins <ia******@hotma il.comwrites:

Tomás Ó hÉilidhe wrote:

>Others have explained the padding situation, but if you want re-
assurance, you might add a routine to the start of your code that
makes sure it's OK:

void EnsureItWorks(v oid)
{
Vector const v = { 99, 56, 42 };

if (99 == (&v.x)[0] &&
56 == (&v.x)[1] &&
42 == (&v.x)[2]) return;

(&v.x)[0] is guaranteed to be correct. The other two can be better
tested just by ensuring that

&v.x + 2 == &v.z

The value test could give a false positive if the padding between
elements happened to have the "right" value.

> puts("ERROR: There's padding in the Vector struct.");
exit(EXIT_FAILU RE);
}

int main(void) { EnsureItWorks() ; }

A very verbose way of writing

int main()
{
assert( sizeof(vector)= =sizeof(double) *3);
}

Except the structure can have padding at the end and still be suitable.

--
Ben.

[Ben Bacarisse]

Ian Collins <ia******@hotma il.comwrites:

viza wrote:

>Hi

On Sun, 15 Jun 2008 10:51:28 +1200, Ian Collins wrote:

>>Tomás Ó hÉilidhe wrote:

>>> if (99 == (&v.x)[0] &&
56 == (&v.x)[1] &&
42 == (&v.x)[2]) return;
puts("ERROR: There's padding in the Vector struct.");
exit(EXIT_FAILU RE);

>>A very verbose way of writing
assert( sizeof(vector)= =sizeof(double) *3);

The two are not equivalent and neither is perfect. Better is:

assert( offsetof(vector ,y) == sizeof(double)
&& offsetof(vector ,z) == sizeof(double)* 2 );

Why?

Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

Anyway, if offsetof(vector ,z) == sizeof(double)* 2, how can
offsetof(vector ,y) be anything other than sizeof(double)?

Agreed. I still prefer my address test, though.

By the way, This is all about making the best of a bad job. To the
OP: if you want to index things, make them an array as Keith Thompson
suggested. In addition to using #define to name the elements one
could also do:

typedef struct {
double v[3];
} vector;

enum { x, y, z };

vector point;

so that one can write point.v[x] and so on (even x[&point] if you
want to make your readers do a double-take!).

--
Ben.

[Ian Collins]

Ben Bacarisse wrote:

Ian Collins <ia******@hotma il.comwrites:

>viza wrote:

>>Hi

On Sun, 15 Jun 2008 10:51:28 +1200, Ian Collins wrote:
Tomás Ó hÉilidhe wrote:
if (99 == (&v.x)[0] &&
56 == (&v.x)[1] &&
42 == (&v.x)[2]) return;
puts("ERROR: There's padding in the Vector struct.");
exit(EXIT_FAILU RE);
A very verbose way of writing
assert( sizeof(vector)= =sizeof(double) *3);
The two are not equivalent and neither is perfect. Better is:

assert( offsetof(vector ,y) == sizeof(double)
&& offsetof(vector ,z) == sizeof(double)* 2 );

Why?

Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

OK, make it

assert( sizeof(vector[2])==sizeof(doubl e)*6 );

Or even a compile time assert:

const int n = 1/( sizeof(vector[2])==sizeof(doubl e)*6 );

>Anyway, if offsetof(vector ,z) == sizeof(double)* 2, how can
offsetof(vecto r,y) be anything other than sizeof(double)?

Agreed. I still prefer my address test, though.

Fair enough, but the simplified offsetof (or sizeof) test has the
(small) advantage of not requiring an instance of vector to test.
Saying that, the address test could be evaluated at compile time, so the
vector would be eliminated by an optimiser.

--
Ian Collins.

[Keith Thompson]

Ian Collins <ia******@hotma il.comwrites:

Ben Bacarisse wrote:

>Ian Collins <ia******@hotma il.comwrites:

>>viza wrote:
Hi

On Sun, 15 Jun 2008 10:51:28 +1200, Ian Collins wrote:
Tomás Ó hÉilidhe wrote:
> if (99 == (&v.x)[0] &&
> 56 == (&v.x)[1] &&
> 42 == (&v.x)[2]) return;
> puts("ERROR: There's padding in the Vector struct.");
> exit(EXIT_FAILU RE);
A very verbose way of writing
assert( sizeof(vector)= =sizeof(double) *3);
The two are not equivalent and neither is perfect. Better is:

assert( offsetof(vector ,y) == sizeof(double)
&& offsetof(vector ,z) == sizeof(double)* 2 );

Why?

Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

OK, make it

assert( sizeof(vector[2])==sizeof(doubl e)*6 );

Or even a compile time assert:

const int n = 1/( sizeof(vector[2])==sizeof(doubl e)*6 );

I think that this:

sizeof(vector) == sizeof(double) * 3

would suffice. An array of two thingies must have twice the size of a
single thingie, for any applicable value of "thingie".

[snip]

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

[vippstar]

On Jun 15, 5:27 am, Keith Thompson <[e-mail] rote:

Ian Collins <[e-mail] mwrites:

Ben Bacarisse wrote:

Ian Collins <[e-mail] mwrites:

>viza wrote:
Hi

>>On Sun, 15 Jun 2008 10:51:28 +1200, Ian Collins wrote:
Tomás Ó hÉilidhe wrote:
if (99 == (&v.x)[0] &&
56 == (&v.x)[1] &&
42 == (&v.x)[2]) return;
puts("ERROR: There's padding in the Vector struct.");
exit(EXIT_FAILU RE);
A very verbose way of writing
assert( sizeof(vector)= =sizeof(double) *3);
The two are not equivalent and neither is perfect. Better is:

>>assert( offsetof(vector ,y) == sizeof(double)
&& offsetof(vector ,z) == sizeof(double)* 2 );

>Why?

Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

OK, make it

assert( sizeof(vector[2])==sizeof(doubl e)*6 );

Or even a compile time assert:

const int n = 1/( sizeof(vector[2])==sizeof(doubl e)*6 );

I think that this:

sizeof(vector) == sizeof(double) * 3

would suffice. An array of two thingies must have twice the size of a
single thingie, for any applicable value of "thingie".

vector is not an array, it's a struct.
This:
struct vector { double x, y, z; };
sizeof(struct vector)
Needs not to evaluate to sizeof (double) * 3.
If it were a vector (array), then yes, it is guaranteed and you are
correct.
But vector is a struct.

Thomas: Please change your name to ASCII.

[Ian Collins]

Keith Thompson wrote:

Ian Collins <ia******@hotma il.comwrites:

>Ben Bacarisse wrote:

>>Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

OK, make it

assert( sizeof(vector[2])==sizeof(doubl e)*6 );

Or even a compile time assert:

const int n = 1/( sizeof(vector[2])==sizeof(doubl e)*6 );

I think that this:

sizeof(vector) == sizeof(double) * 3

would suffice. An array of two thingies must have twice the size of a
single thingie, for any applicable value of "thingie".

It would, my last suggestion was pointless. It would still fail if
there were padding at the end of the struct. I would still use the one
above, the chances of padding at the end but not in the middle are slim.

--
Ian Collins.

[Richard Heathfield]

vi******@gmail. com said:

<snip>

Thomas: Please change your name to ASCII.

Won't that get rather confusing?

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

[Keith Thompson]

vi******@gmail. com writes:

On Jun 15, 5:27 am, Keith Thompson <[e-mail] rote:

>Ian Collins <[e-mail] mwrites:

Ben Bacarisse wrote:
Ian Collins <[e-mail] mwrites:

>>viza wrote:
Hi

>>>On Sun, 15 Jun 2008 10:51:28 +1200, Ian Collins wrote:
Tomás Ó hÉilidhe wrote:
> if (99 == (&v.x)[0] &&
> 56 == (&v.x)[1] &&
> 42 == (&v.x)[2]) return;
> puts("ERROR: There's padding in the Vector struct.");
> exit(EXIT_FAILU RE);
A very verbose way of writing
assert( sizeof(vector)= =sizeof(double) *3);
The two are not equivalent and neither is perfect. Better is:

>>>assert( offsetof(vector ,y) == sizeof(double)
&& offsetof(vector ,z) == sizeof(double)* 2 );

>>Why?

>Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

OK, make it

assert( sizeof(vector[2])==sizeof(doubl e)*6 );

Or even a compile time assert:

const int n = 1/( sizeof(vector[2])==sizeof(doubl e)*6 );

I think that this:

sizeof(vector) == sizeof(double) * 3

would suffice. An array of two thingies must have twice the size of a
single thingie, for any applicable value of "thingie".

vector is not an array, it's a struct.
This:
struct vector { double x, y, z; };
sizeof(struct vector)
Needs not to evaluate to sizeof (double) * 3.
If it were a vector (array), then yes, it is guaranteed and you are
correct.
But vector is a struct.

Yes, I understand that. But vector[2] is an array type. My point
was that this:
assert(sizeof(v ector[2]) == sizeof(double) * 6);
is equivalent to this:
assert(sizeof(v ector) == sizeof(double) * 3);

In both cases, the asserted expression isn't guaranted to be true --
which is the whole point of the assert().

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

[Keith Thompson]

Ian Collins <ia******@hotma il.comwrites:

Keith Thompson wrote:

>Ian Collins <ia******@hotma il.comwrites:

>>Ben Bacarisse wrote:

>>>Tomás's code is over complex (one test is enough) and could fail in
unusual cases (see my other posting) and your test will be thrown if
there is padding at the end of the struct.

OK, make it

assert( sizeof(vector[2])==sizeof(doubl e)*6 );

Or even a compile time assert:

const int n = 1/( sizeof(vector[2])==sizeof(doubl e)*6 );

I think that this:

sizeof(vector) == sizeof(double) * 3

would suffice. An array of two thingies must have twice the size of a
single thingie, for any applicable value of "thingie".

It would, my last suggestion was pointless. It would still fail if
there were padding at the end of the struct. I would still use the one
above, the chances of padding at the end but not in the middle are slim.

I'd say the chances of padding at the end are higher than the chances
of padding in the middle.

Consider
struct foo { char a; char b; char c; };

It's plausible that sizeof(struct foo) == 4, with a padding byte at
the end.

This is less likely to happen for a struct containing doubles, though.

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

[Joachim Schmitz]

Antoninus Twink wrote:

On 14 Jun 2008 at 22:34, Tomás Ó hÉilidhe wrote:

> Vector const v = { 99, 56, 42 };

if (99 == (&v.x)[0] &&
56 == (&v.x)[1] &&
42 == (&v.x)[2]) return;

Holy crap, are you trying to follow the CBF anti-style rules?

>(I know that floating-point arithmetic isn't exact but as far as I
know it's exact for integer values... but I'm open to correction!)

It's nothing to do with integer values. Just passing around a
floating-point value won't magically change its bits.

In

double a=42;
double b=42.422242;
double c=1./3;
assert(a == 42);
assert(b == 42.422242);
assert(c == 1./3);

all the asserts will succeed.

I think you're missing the point. Tomás wantes to check whether it is safe
to assume that struct {double a;double; double c;} can be interpreted as
double[3], i.e. whether there are any padding bytes in the struct that would
prevent that.
And it seems on anything but a DS9K it is save to assume that no padding
bytes are between the members (of equal typr), but it is very well possible
that there are some after the last member.

Bye, Jojo
Bye, Jojo