Flexible array member + variable length array

[Adam Warner]

Hi all,

With this structure that records the length of an array of pointers as its
first member:

struct array {
ptrdiff_t length;
void *ptr[];
};

How does one initialise this structure using a variable length array?

ptrdiff_t len=10;
{
struct array a[len+1];
...
}

It appears the above code will only work to reserve space for len pointers
if the sizeof length is the same as sizeof pointers to void and there is
no padding between length and the pointers to void. Is there portable C99
syntax that I have overlooked? (or will I have to create a VLA of type
void * and keep casting the first argument to ptrdiff_t?)

Thanks,
Adam

 

[Michael Mair]

Hi all,

With this structure that records the length of an array of pointers as its
first member:

struct array {
ptrdiff_t length;
void *ptr[];
};

How does one initialise this structure using a variable length array?

ptrdiff_t len=10;
{
struct array a[len+1];
...
}

It appears the above code will only work to reserve space for len pointers
if the sizeof length is the same as sizeof pointers to void and there is
no padding between length and the pointers to void. Is there portable C99
syntax that I have overlooked? (or will I have to create a VLA of type
void * and keep casting the first argument to ptrdiff_t?)

I am not sure what you are asking for. The example from the standard
runs like this:

(6.7.2.1)
"
17
EXAMPLE Assuming that all array members are aligned the same, after the
declarations:
struct s { int n; double d[]; };
struct ss { int n; double d[1]; };
the three expressions:
sizeof (struct s)
offsetof(struct s, d)
offsetof(struct ss, d)
have the same value. The structure struct s has a flexible array member
d.

18
If sizeof (double) is 8, then after the following code is executed:
struct s *s1;
struct s *s2;
s1 = malloc(sizeof (struct s) + 64);
s2 = malloc(sizeof (struct s) + 46);
and assuming that the calls to malloc succeed, the objects pointed to by
s1 and s2 behave as if the identifiers had been declared as:
struct { int n; double d[8]; } *s1;
struct { int n; double d[5]; } *s2;
"

Structures with flexible array members of course cannot be
put into arrays.


Cheers
Michael

 

[Shan]

Visit this page:

http://gcc.gnu.org/ml/gcc/2002-04/msg00026.html

Hope it helps.

Cheers
Shan

 

[Shan]

Visit this page:

http://gcc.gnu.org/ml/gcc/2002-04/msg00026.html

Hope it helps.

Cheers
Shan

Hi all,

With this structure that records the length of an array of pointers as its
first member:

struct array {
ptrdiff_t length;
void *ptr[];
};

How does one initialise this structure using a variable length array?

ptrdiff_t len=10;
{
struct array a[len+1];
...
}

It appears the above code will only work to reserve space for len pointers
if the sizeof length is the same as sizeof pointers to void and

there

is
no padding between length and the pointers to void. Is there

portable

C99
syntax that I have overlooked? (or will I have to create a VLA of type
void * and keep casting the first argument to ptrdiff_t?)

Thanks,
Adam

Sorry, i top posted by mistake....

 

[Adam Warner]

EXAMPLE Assuming that all array members are aligned the same, after the
declarations:
struct s { int n; double d[]; };
struct ss { int n; double d[1]; };
the three expressions:
sizeof (struct s)
offsetof(struct s, d)
offsetof(struct ss, d)
have the same value. The structure struct s has a flexible array member
d.

18
If sizeof (double) is 8, then after the following code is executed:
struct s *s1;
struct s *s2;
s1 = malloc(sizeof (struct s) + 64);
s2 = malloc(sizeof (struct s) + 46);
and assuming that the calls to malloc succeed, the objects pointed to by
s1 and s2 behave as if the identifiers had been declared as:
struct { int n; double d[8]; } *s1;
struct { int n; double d[5]; } *s2;
"

Structures with flexible array members of course cannot be
put into arrays.

Indeed. It looks like I was after alloca-style functionality (which is
non-standard) to duplicate the example above on the stack instead of the
heap.

Regards,
Adam

 

[Lawrence Kirby]

Hi all,

With this structure that records the length of an array of pointers as its
first member:

struct array {
ptrdiff_t length;
void *ptr[];
};

This is a structure containing a C99 flexible array member.

How does one initialise this structure using a variable length array?

You don't. Flexible array members and VLAs are different and unrelated
constructs. Flexible array members are designed to be allocated using
malloc() and friends, e.g.

struct array *p = malloc(sizeof *p + len * sizeof *p->ptr);

ptrdiff_t len=10;
{
struct array a[len+1];
...
}

You can't make arrays of structures containing flexible array members
because the size of each element is not known or fixed.

Lawrence

 

[S.Tobias]

Hi all,

With this structure that records the length of an array of pointers as its
first member:

struct array {
ptrdiff_t length;
void *ptr[];
};

This is a structure containing a C99 flexible array member.

You don't. Flexible array members and VLAs are different and unrelated
constructs. Flexible array members are designed to be allocated using
malloc() and friends, e.g.

struct array *p = malloc(sizeof *p + len * sizeof *p->ptr);

Well, if an object was declared with the type struct with FAM, then
you actually could initialize it's leading members, couldn't you?
(Of course, declaring such objects would be against the purpose
of FAM.)
(Note: you cannot initialize FAM itself, even if the struct were
the first member of a suitable union, because FAM is ignored in
all contexts, except `sizeof', `.' and `->'.)

ptrdiff_t len=10;
{
struct array a[len+1];
...
}

You can't make arrays of structures containing flexible array members
because the size of each element is not known or fixed.

Would you please kindly elaborate on that?

Indeed, FAMs (flexible array members) and VLAs are different. FAMs are
described in 6.7.2.1p16. The size of a struct with a FAM is the
offset of the FAM, therefore such a struct is not an incomplete type.
It is not variably modified type either, because it does not contain a
VLA type (the definition of VM types is in 6.7.5p3).

The last place I looked was in array declarators, and all I found was
in 6.7.5.2p1:
# The element type shall not be an incomplete or function type.

I see nothing that would forbid to create arrays of structs with FAM.

+++

However, I tried this program with Comeau compiler in C99 mode:

struct flex
{
int i;
int tail[];
};

int main()
{
struct flex f;
int s = sizeof(struct flex);
struct flex a[5];
}

[...]
"t.c", line 11: error: type containing an unknown-size array is not allowed
struct flex a[5];
^

It seems to accept a declared object (`f') of type struct flex, but
rejects an array for some reason.

 

[Michael Mair]

On Thu, 03 Feb 2005 20:50:36 +1300, Adam Warner wrote:

Hi all,

With this structure that records the length of an array of pointers as its
first member:

struct array {
ptrdiff_t length;
void *ptr[];
};

This is a structure containing a C99 flexible array member.

How does one initialise this structure using a variable length array?

You don't. Flexible array members and VLAs are different and unrelated
constructs. Flexible array members are designed to be allocated using
malloc() and friends, e.g.

struct array *p = malloc(sizeof *p + len * sizeof *p->ptr);

Well, if an object was declared with the type struct with FAM, then
you actually could initialize it's leading members, couldn't you?
(Of course, declaring such objects would be against the purpose
of FAM.)
(Note: you cannot initialize FAM itself, even if the struct were
the first member of a suitable union, because FAM is ignored in
all contexts, except `sizeof', `.' and `->'.)

ptrdiff_t len=10;
{
struct array a[len+1];
...
}

You can't make arrays of structures containing flexible array members
because the size of each element is not known or fixed.

Would you please kindly elaborate on that?

Indeed, FAMs (flexible array members) and VLAs are different. FAMs are
described in 6.7.2.1p16. The size of a struct with a FAM is the
offset of the FAM, therefore such a struct is not an incomplete type.
It is not variably modified type either, because it does not contain a
VLA type (the definition of VM types is in 6.7.5p3).

The last place I looked was in array declarators, and all I found was
in 6.7.5.2p1:
# The element type shall not be an incomplete or function type.

I see nothing that would forbid to create arrays of structs with FAM.

+++

However, I tried this program with Comeau compiler in C99 mode:

struct flex
{
int i;
int tail[];
};

int main()
{
struct flex f;
int s = sizeof(struct flex);
struct flex a[5];
}

[...]
"t.c", line 11: error: type containing an unknown-size array is not allowed
struct flex a[5];
^

It seems to accept a declared object (`f') of type struct flex, but
rejects an array for some reason.

Because there is no guarantee that the alignment requirements hold
in the sense that there is padding at the end.
Example: Let sizeof(int)==4, sizeof(short)==2 and the alignment
requirements equal to the size of the type.
Hence,
struct s1 {
int i;
char c;
}
will have a size of 8, but
struct s2 {
int i;
char c;
short s[];
}
has as size of 6 as we assume that
sizeof(structs2)==offsetof(struct s2,s)
and offsetof(struct s2,s)==offsetof(struct s3,s)
with
struct s3 {
int i;
char c;
short s[1];
}
which follows from the (non-normative) example 6.7.2.1#17


Cheers
Michael

 

[S.Tobias]

Lawrence Kirby <[email protected]> wrote:

[snippage]

You can't make arrays of structures containing flexible array members
because the size of each element is not known or fixed.

Would you please kindly elaborate on that?

Indeed, FAMs (flexible array members) and VLAs are different. FAMs are
described in 6.7.2.1p16. The size of a struct with a FAM is the
offset of the FAM, therefore such a struct is not an incomplete type.
It is not variably modified type either, because it does not contain a
VLA type (the definition of VM types is in 6.7.5p3).

The last place I looked was in array declarators, and all I found was
in 6.7.5.2p1:
# The element type shall not be an incomplete or function type.

I see nothing that would forbid to create arrays of structs with FAM.

+++

However, I tried this program with Comeau compiler in C99 mode:
[snip code]

[...]
"t.c", line 11: error: type containing an unknown-size array is not allowed
struct flex a[5];
^

It seems to accept a declared object (`f') of type struct flex, but
rejects an array for some reason.

Thank you for answering, however I disagree with your POV.

Because there is no guarantee that the alignment requirements hold
in the sense that there is padding at the end.

But the Standard does not make any requirements for alignment
(it merely allows them); it's up to the implementation fulfill them.

Example: Let sizeof(int)==4, sizeof(short)==2 and the alignment
requirements equal to the size of the type.
Hence,
struct s1 {
int i;
char c;
}
will have a size of 8, but
struct s2 {
int i;
char c;
short s[];
}
has as size of 6 as we assume that
sizeof(structs2)==offsetof(struct s2,s)

Yes, but what's the point? On an architecture without alignment
this shouldn't be a problem, should it?

I think you use your logic in the wrong direction. My reasoning
would be that since the Standard doesn't forbid structs with FAM
being elements of an array, they are allowed. It means that on
an implementation with int alignment 4 bytes, the compiler must
provide padding bits so that sizeof(struct s2) == 8.

and offsetof(struct s2,s)==offsetof(struct s3,s)
with
struct s3 {
int i;
char c;
short s[1];
}
which follows from the (non-normative) example 6.7.2.1#17

No, the Standard is very clear that it does not guarantee this
(footnote 106; and the word "Assuming" in the example).

Note that 6.7.2.1p16 does not provide any recipe for building
struct s2 type; it uses words "an array of unspecified length",
which means it is up to the implementation to decide what length
should be the most suitable.

+++

I think it not wrong to imagine that a FAM is a "member" which
represents the bytes _after_ the body of the struct object
(ie. the FAM does not strictly belong to the struct).

===

For others' convenience, here's the full quote of 6.7.2.1p16:

# 16 As a special case, the last element of a structure with more
# than one named member may have an incomplete array type;
# this is called a flexible array member. With two exceptions,
# the flexible array member is ignored. First, the size of the
# structure shall be equal to the offset of the last element of
# an otherwise identical structure that replaces the flexible
# array member with an array of unspecified length.106) Second,
# when a . (or ->) operator has a left operand that is (a pointer
# to) a structure with a flexible array member and the right
# operand names that member, it behaves as if that member were
# replaced with the longest array (with the same element type)
# that would not make the structure larger than the object being
# accessed; the offset of the array shall remain that of the
# flexible array member, even if this would differ from that of
# the replacement array. If this array would have no elements, it
# behaves as if it had one element but the behavior is undefined
# if any attempt is made to access that element or to generate
# a pointer one past it.
#
# 106) The length is unspecified to allow for the fact that
# implementations may give array members different alignments
# according to their lengths.

 

[Kevin Bracey]

In message <[email protected]>

I think you use your logic in the wrong direction. My reasoning
would be that since the Standard doesn't forbid structs with FAM
being elements of an array, they are allowed. It means that on
an implementation with int alignment 4 bytes, the compiler must
provide padding bits so that sizeof(struct s2) == 8.

Wrong. 6.7.2.1p2:

"...the last member of a structure with more than one named member
may have incomplete array type; such a structure ... shall not be a
member of a structure or an element of an array."

This is precisely to cope with alignment issues. On our implementation,
int has alignment 4, and given

struct s1 {
int i;
char c;
};

struct s2 {
int i;
char c;
short s[];
};

struct s1 has size 8, and struct s2 has size 6 (because sizeof(struct s2)
must equal offsetof(struct s2, s)), just as Michael suggests. Thus any
struct s2s placed in an array would be misaligned. Fortunately, the standard
forbids this.

There is a Defect Report #282 about sizeof such a structure, but it's bogus
as far as I can see - they're suggesting that they have to put padding before
s[] to make s2 be size 8 for alignment, but what they've missed is that s2
does not have to meet alignment requirements, because of the array
restriction, so s2 can be left unpadded.

 

[S.Tobias]

In message <[email protected]>

I think you use your logic in the wrong direction. My reasoning
would be that since the Standard doesn't forbid structs with FAM
being elements of an array, they are allowed. It means that on

[snip]

Wrong. 6.7.2.1p2:

"...the last member of a structure with more than one named member
may have incomplete array type; such a structure ... shall not be a
member of a structure or an element of an array."

Shame on me having missed that part! Many thanks!