Array of size zero!

[prashna]

Hi all,

I have seen a piece of code(while doing code review) which declared an
array of size 0.One of my friend told although it is not standard
C,some compilers will support this..I am very curious to know the use
of it..
The code was compiled using Diab C compiler.
Also the array was declared in structure like this

typedef struct someStruct
{
int i;
char array[0];
} someStruct;
Thanks
Regards

[jacob navia]

The standard way of writing this is:
typedef struct someStruct
{
int i;
char array[];
} someStruct;

Without the zero.
This is a flexible array and is supported by C99.

you allocate the structure with more than sizeof(int), to
allocate the size of the array

[xarax]

"prashna" <va******@redif fmail.com> wrote in message
news:d4******** *************** ***@posting.goo gle.com...

Hi all,

I have seen a piece of code(while doing code review) which declared an
array of size 0.One of my friend told although it is not standard
C,some compilers will support this..I am very curious to know the use
of it..
The code was compiled using Diab C compiler.
Also the array was declared in structure like this

typedef struct someStruct
{
int i;
char array[0];
} someStruct;
Thanks
Regards

I think the C99 variant of this is "char array[];". The
zero-length array thing is intended to get around the
problem of allocating a variable-length structure, where
the declared portion of the structure represents a fixed-length
"header" and the size of the variable-length portion is
calculated at run-time.

Some compilers have a non-standard extension that allows
an array length of zero specified, which is the same effect
as the C99 elided length specification.

For compilers that don't support either specification, the
infamous "struct hack" technique is used where the array
length is specified as 1, and size calculations for the
variable-length structure take into consideration the
presence of one element of the array in the structure length
returned by sizeof().

[Case -]

jacob navia wrote:

The standard way of writing this is:
typedef struct someStruct
{
int i;
char array[];
} someStruct;

Without the zero.
This is a flexible array and is supported by C99.

you allocate the structure with more than sizeof(int), to
allocate the size of the array

I geuss this is not correct because it assumes that
array[] starts right after i. As the FAQ tells us,
you should use the offsetof() macro, which can
calculate the byte offset of array in someStruct.
This macro should be defined in <stddef.h>. If not,
use the #definition in the FAQ.

Case

[Richard Delorme]

prashna a écrit :

Hi all,

I have seen a piece of code(while doing code review) which declared an
array of size 0.One of my friend told although it is not standard
C,some compilers will support this..I am very curious to know the use
of it..
The code was compiled using Diab C compiler.
Also the array was declared in structure like this

typedef struct someStruct
{
int i;
char array[0];
} someStruct;

It was a pre-C99 standard trial to have a flexible member array.
The struct could be allocated this way :
someStruct *s = malloc(sizeof (someStruct) + 42);
So, with a single malloc, you allocated the struct and the array objects
simultaneously.
In C99 a flexible array member should be declared :
struct someStruct {
int i;
char array[];
};

--
Richard

[Dan Pop]

In <40************ **********@drea der2.news.tisca li.nl> Case - <[e-mail]> writes:

jacob navia wrote:

The standard way of writing this is:
typedef struct someStruct
{
int i;
char array[];
} someStruct;

Without the zero.
This is a flexible array and is supported by C99.

you allocate the structure with more than sizeof(int), to
allocate the size of the array

I geuss this is not correct because it assumes that
array[] starts right after i.

Nonsense: no such assumption is needed at all.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Alex Fraser]

"Dan Pop" <Da*****@cern.c h> wrote in message
news:ca******** **@sunnews.cern .ch...

In <40************ **********@drea der2.news.tisca li.nl> Case - <[e-mail]> writes:

jacob navia wrote:

The standard way of writing this is:
typedef struct someStruct
{
int i;
char array[];
} someStruct;

Without the zero.
This is a flexible array and is supported by C99.

you allocate the structure with more than sizeof(int), to
allocate the size of the array

I geuss this is not correct because it assumes that
array[] starts right after i.

Nonsense: no such assumption is needed at all.

Right, but Jacob /is/ making that assumption. AIUI, this does not
necessarily allocate sufficient space for 10 elements in array:

struct someStruct *s = malloc(sizeof(i nt) + 10);

But, OTOH, this does:

struct someStruct *s = malloc(sizeof *s + 10);

(Assuming malloc() succeeds in both cases.)

The reason being that padding after i in struct someStruct is not allowed
for.

Alex

[Dan Pop]

In <2j************ @uni-berlin.de> "Alex Fraser" <[e-mail] > writes:

"Dan Pop" <Da*****@cern.c h> wrote in message
news:ca******* ***@sunnews.cer n.ch...

In <40************ **********@drea der2.news.tisca li.nl> Case - <[e-mail]>writes:

>jacob navia wrote:
>> The standard way of writing this is:
>> typedef struct someStruct
>> {
>> int i;
>> char array[];
>> } someStruct;
>>
>> Without the zero.
>> This is a flexible array and is supported by C99.
>>
>> you allocate the structure with more than sizeof(int), to
>> allocate the size of the array
>>
>
>I geuss this is not correct because it assumes that
>array[] starts right after i.

Nonsense: no such assumption is needed at all.

Right, but Jacob /is/ making that assumption.

Where?!? He says more than sizeof(int), which might be misleading, but
not technically wrong.
AIUI, this does not
necessarily allocate sufficient space for 10 elements in array:

struct someStruct *s = malloc(sizeof(i nt) + 10);
It should, except for deliberately perverse implementations , but, in
theory, you're correct. OTOH, Jacob didn't say anywhere that this is
the right way of allocating memory for the structure, did he?
But, OTOH, this does:

struct someStruct *s = malloc(sizeof *s + 10);

(Assuming malloc() succeeds in both cases.)

The reason being that padding after i in struct someStruct is not allowed
for. ^^^

The reason being that padding after i in struct someStruct is
theoretically allowed. But, since it would merely waste memory, don't
expect to find it, until someone revives the DS9K project.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Emmanuel Delahaye]

In 'comp.lang.c', va******@rediff mail.com (prashna) wrote:

I have seen a piece of code(while doing code review) which declared an
array of size 0.One of my friend told although it is not standard
Wrong. It's a C99 feature.
C,some compilers will support this..I am very curious to know the use
of it..
The code was compiled using Diab C compiler.
Also the array was declared in structure like this

typedef struct someStruct
{
int i;
char array[0];
} someStruct;

It's used to do some linear mapping. It's a sort of trick... Not very good C
(outbounds-based technique), but it works and can be useful.

--
-ed- get my email here: http://marreduspam.com/ad672570
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=c99
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

[Alex Fraser]

"Dan Pop" <Da*****@cern.c h> wrote in message
news:ca******** **@sunnews.cern .ch...

In <2j************ @uni-berlin.de> "Alex Fraser" <[e-mail] > writes:

"Dan Pop" <Da*****@cern.c h> wrote in message
news:ca******* ***@sunnews.cer n.ch...

In <40************ **********@drea der2.news.tisca li.nl> Case -
<[e-mail]> writes:

>jacob navia wrote:
>> The standard way of writing this is:
>> typedef struct someStruct
>> {
>> int i;
>> char array[];
>> } someStruct; [snip] >> you allocate the structure with more than sizeof(int), to
>> allocate the size of the array
>
>I geuss this is not correct because it assumes that
>array[] starts right after i.

Nonsense: no such assumption is needed at all.
Right, but Jacob /is/ making that assumption.

Where?!? He says more than sizeof(int), which might be misleading, but
not technically wrong.

By fortunate vagueness, yes. That too is an assumption, but a reasonable
one, don't you think?

AIUI, this does not
necessarily allocate sufficient space for 10 elements in array:

struct someStruct *s = malloc(sizeof(i nt) + 10);

It should, except for deliberately perverse implementations , but, in
theory, you're correct. OTOH, Jacob didn't say anywhere that this is
the right way of allocating memory for the structure, did he?

See above.

But, OTOH, this does:

struct someStruct *s = malloc(sizeof *s + 10);

(Assuming malloc() succeeds in both cases.)

The reason being that padding after i in struct someStruct is not allowed
for. ^^^

(I wrote this as applying to the first sentence but it doesn't read that
way. Oops.)
The reason being that padding after i in struct someStruct is
theoretically allowed. But, since it would merely waste memory, don't
expect to find it, until someone revives the DS9K project.

Agreed, in this specific case it is extremely unlikely. But for some
combinations of types of i and/or array, it's almost "guaranteed " (eg struct
{int i, double array[]}).

Alex