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.

[EventHelix.com]

On Jun 14, 5:37*pm, pereges <Brol...@gmail. comwrote:

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

This is not portable but at the low level there is no difference
between a structure containing three doubles and an array of three
doubles in this case.

You cannot assume this, as some implementation might introduce pads
for byte alignment in structures.

The following articles should help:

http://www.eventhelix.com/RealTimeMa...ranslation.htm
http://www.eventhelix.com/RealTimeMa...anslation2.htm
http://www.eventhelix.com/RealTimeMa...anslation3.htm

--
EventStudio 4.0 - http://www.Eventhelix.com/Eventstudio/
Sequence diagram based systems engineering tool

[Richard Tobin]

In article <a0************ *************** *******@34g2000 hsf.googlegroup s.com>,
EventHelix.com <ev********@gma il.comwrote:

>This is not portable but at the low level there is no difference
between a structure containing three doubles and an array of three
doubles in this case.

Fields in a struct are aligned in "an implementation-defined manner
appropriate to [their] type". The clear implication is that the
padding is a property of the type (rather than each individual
instance) and so it would be unreasonable for the padding of
successive members of the same type in a struct to be different from
that in an array - which is to say, there should be no padding between
fields of the same type.

Can anyone come up with a reason (other than perverseness) why an
implementation would not do this?

-- Richard
--
In the selection of the two characters immediately succeeding the numeral 9,
consideration shall be given to their replacement by the graphics 10 and 11 to
facilitate the adoption of the code in the sterling monetary area. (X3.4-1963)

[pereges]

one can solve this problem using a vector iterator function like below
but i am not sure if the solution is generic :

#include <stdio.h>

typedef struct
{
double x, y, z;

}vector;

double vector_iterator (vector *a, int i)
{
double ret;
if(i == 0)
ret = a->x;
if(i == 1)
ret = a->y;
if(i == 2)
ret = a->z;
return ret;
}

int main(void)
{
int i;
vector v;
double coord;

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

for(i = 0; i < 3; i++)
{
coord = vector_iterator (&v, i);
printf("%f\n", coord);
}
return 0;

}

[=?ISO-8859-1?Q?Tom=E1s_=D3_h=C9ilidhe?=]

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;

puts("ERROR: There's padding in the Vector struct.");

exit(EXIT_FAILU RE);
}

int main(void) { EnsureItWorks() ; }
(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!)

[badc0de4]

Tomás Ó hÉilidhe wrote:

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

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

*BANG*
(&v.x)[1] or (&v.x)[2] is a trap representation :)

puts("ERROR: There's padding in the Vector struct.");

exit(EXIT_FAILU RE);
}

[Ian Collins]

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;

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);
}

--
Ian Collins.

[viza]

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

viza

[Ian Collins]

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?

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

--
Ian Collins.

[Ian Collins]

Keith Thompson wrote:

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.

That why I suggested the compile time assert, it's unlikely, but worth
picking up as soon as possible.

--
Ian Collins.