one element array as name of struct typedef

[Ron Peterson (012ED25E)]

I ran into something like the following while looking into how the GNU
MP library implements its mpz_t type.

typedef struct {
int len;
char *buf;
} foo[1];

This is an interesting technique. I'm unfamiliar with declaring the
name of a typedef as a one element array. Is this part of the C
standard? Is it portable? Does this technique have a name?

[Mark Bluemel]

Ron Peterson (012ED25E) wrote:

I ran into something like the following while looking into how the GNU
MP library implements its mpz_t type.

typedef struct {
int len;
char *buf;
} foo[1];

This is an interesting technique. I'm unfamiliar with declaring the
name of a typedef as a one element array. Is this part of the C
standard? Is it portable? Does this technique have a name?

Hmmm.... I think you're mistaken in what this means.

My reading (which could easily be incorrect) is that it makes "foo" a
typedef for a single dimension, single element, array of such structures.

I'm trying to work out what the value of such a technique would be.

[Richard Tobin]

In article <fb**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

>typedef struct {
int len;
char *buf;
} foo[1];

>I'm trying to work out what the value of such a technique would be.

My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. If it had been

typedef struct {...} foo;

you would have to use &foo all over the place, and it it had been

typedef struct {...} *foo;

you would have to allocate the data as well as declaring a variable.

-- Richard
--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Ravishankar S]

I ran into something like the following while looking into how the GNU
MP library implements its mpz_t type.

typedef struct {
int len;
char *buf;
} foo[1];

This is an interesting technique. I'm unfamiliar with declaring the
name of a typedef as a one element array. Is this part of the C
standard? Is it portable? Does this technique have a name?

typeof(foo) == array of the given struct of 1 element

so the actual array may be declared or defined as:

foo fooarray; /* Note: No dimension info required */

the technique is useful when a pointer to an array (i mean entire array, not
just pointer to element data type) is required.
read C FAQ. Ther is a entire chapter devoted to pointers and array.

[Ravishankar S]

"Richard Tobin" <ri*****@cogsci.ed.ac.ukwrote in message
news:fb***********@pc-news.cogsci.ed.ac.uk...

In article <fb**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

typedef struct {
int len;
char *buf;
} foo[1];

I'm trying to work out what the value of such a technique would be.

My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. If it had been

typedef struct {...} foo;

No. The typedef is similar to , say..

typedef unsigned int length_t;

Do we use &length_t anywhere ? the length_t is the *name* of a *type*.

similarly with foo. could have been named better as "foo_array_type"

[Army1987]

On Tue, 04 Sep 2007 12:17:34 +0100, Mark Bluemel wrote:

Ron Peterson (012ED25E) wrote:

>I ran into something like the following while looking into how the GNU
MP library implements its mpz_t type.

typedef struct {
int len;
char *buf;
} foo[1];

This is an interesting technique. I'm unfamiliar with declaring the
name of a typedef as a one element array. Is this part of the C
standard? Is it portable? Does this technique have a name?

Hmmm.... I think you're mistaken in what this means.

My reading (which could easily be incorrect) is that it makes "foo" a
typedef for a single dimension, single element, array of such structures.

I'm trying to work out what the value of such a technique would be.

On glibc, jmp_buf is declared as an array with one element.
--
Army1987 (Replace "NOSPAM" with "email")
No-one ever won a game by resigning. -- S. Tartakower

[Richard Tobin]

In article <fb**********@news4.fe.internet.bosch.com>,
Ravishankar S <s.***********@de.bosch.comwrote:

>My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. If it had been

typedef struct {...} foo;

>No. The typedef is similar to , say..

Sorry, I just made a mistake in the line you snipped. What I should
have said was:

If it had been

typedef struct {...} mpz_t;

than after declaring

mpz_t x;

you would have to use &x all over the place.

Declaring the type as a single-element array is a way of hiding from
the user the fact that it's a structure and needs to have its address
passed to the library functions.

-- Richard
--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Ron Peterson (012ED25E)]

On Sep 4, 7:50 am, [e-mail] (Richard Tobin) wrote:

In article <fbjese$[e-mail]>,
Mark Bluemel <[e-mail]:

typedef struct {
int len;
char *buf;
} foo[1];

I'm trying to work out what the value of such a technique would be.

My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. If it had been

typedef struct {...} foo;

you would have to use &foo all over the place, and it it had been

typedef struct {...} *foo;

you would have to allocate the data as well as declaring a variable.

Yes. I was trying to emulate the way the MP library worked, and that
is how I discovered this. It lets you avoid ampersands, and
automatically allocates the structure. So you can do 'foo avar;', and
then pass avar to an initialization function, say, that would take
care of setting the values of 'len' and 'buf'. I rather like the
technique, I'm mostly just wondering if it's standard and portable.

[Mark Bluemel]

Richard Tobin wrote:

In article <fb**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

>>typedef struct {
int len;
char *buf;
} foo[1];

>I'm trying to work out what the value of such a technique would be.

My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. If it had been

typedef struct {...} foo;

you would have to use &foo all over the place, and it it had been

typedef struct {...} *foo;

you would have to allocate the data as well as declaring a variable.

And how is this worse than having to artificially use a "[0]" subscript
all the time?

Oh! Is it the case that the code which declares items of type "foo"
never actually work with their contents - effectively treating them as
opaque? Clever, I guess...

[Richard Tobin]

In article <fb**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

>And how is this worse than having to artificially use a "[0]" subscript
all the time?

You don't...

>Oh! Is it the case that the code which declares items of type "foo"
never actually work with their contents - effectively treating them as
opaque? Clever, I guess...

Exactly. This is code provided by a library.

A more common approach would be to declare the type as a pointer, and
require you to call a function to allocate the object. But this way
you can just declare it in the usual way. Unfortunately it looks as
if you would still have to do something explicit to free it, since it
contains a pointer to a buffer.

(I haven't used the library, I'm just inferring this from the definition.)

-- Richard
--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Bart van Ingen Schenau]

Ron Peterson (012ED25E) wrote:

I ran into something like the following while looking into how the GNU
MP library implements its mpz_t type.

typedef struct {
int len;
char *buf;
} foo[1];

This is an interesting technique. I'm unfamiliar with declaring the
name of a typedef as a one element array. Is this part of the C
standard? Is it portable? Does this technique have a name?

Yes, the semantics of this declaration are fully defined by the C
standard, and the technique is therefor portable.
I am not familiar with using it, so I can't tell if it has a name or
not.

Bart v Ingen Schenau
--
a.c.l.l.c-c++ FAQ: http://www.comeaucomputing.com/learn/faq
c.l.c FAQ: http://www.eskimo.com/~scs/C-faq/top.html
c.l.c++ FAQ: http://www.parashift.com/c++-faq-lite/

[Ron Peterson (012ED25E)]

On Sep 4, 12:19 pm, [e-mail] (Richard Tobin) wrote:

In article <fbjnhg$[e-mail]>,
Mark Bluemel <[e-mail]:

And how is this worse than having to artificially use a "[0]" subscript
all the time?

You don't...

Oh! Is it the case that the code which declares items of type "foo"
never actually work with their contents - effectively treating them as
opaque? Clever, I guess...

Exactly. This is code provided by a library.

A more common approach would be to declare the type as a pointer, and
require you to call a function to allocate the object. But this way
you can just declare it in the usual way. Unfortunately it looks as
if you would still have to do something explicit to free it, since it
contains a pointer to a buffer.

(I haven't used the library, I'm just inferring this from the definition.)

Yeah. GNU MP has you do:

mpz_t avar;
mpz_init( avar );
....do something with avar
mpz_clear( avar );

I think this seems cleaner than

struct astruct *avar = NULL;
avar = malloc( sizeof( struct astruct ) );
init_function( &avar );
...do something
clear_function( &avar );
free( avar );

....which, AFAIKT, is the least amount of code you'd have to write to
do the same thing without the clever one element array.

[Ron Peterson (012ED25E)]

On Sep 4, 2:57 pm, "Ron Peterson (012ED25E)" <[e-mail]>
wrote:

On Sep 4, 12:19 pm, [e-mail] (Richard Tobin) wrote:

In article <fbjnhg$[e-mail]>,
Mark Bluemel <[e-mail]:

>And how is this worse than having to artificially use a "[0]" subscript
>all the time?

You don't...

>Oh! Is it the case that the code which declares items of type "foo"
>never actually work with their contents - effectively treating them as
>opaque? Clever, I guess...

Exactly. This is code provided by a library.

A more common approach would be to declare the type as a pointer, and
require you to call a function to allocate the object. But this way
you can just declare it in the usual way. Unfortunately it looks as
if you would still have to do something explicit to free it, since it
contains a pointer to a buffer.

(I haven't used the library, I'm just inferring this from the definition.)

Yeah. GNU MP has you do:

mpz_t avar;
mpz_init( avar );
...do something with avar
mpz_clear( avar );

I think this seems cleaner than

struct astruct *avar = NULL;
avar = malloc( sizeof( struct astruct ) );
init_function( &avar );
..do something
clear_function( &avar );
free( avar );

...which, AFAIKT, is the least amount of code you'd have to write to
do the same thing without the clever one element array.

whoops, forget the ampersands of course...

[Old Wolf]

On Sep 5, 6:57 am, "Ron Peterson (012ED25E)" <[e-mail]>
wrote:

Yeah. GNU MP has you do:

mpz_t avar;
mpz_init( avar );
...do something with avar
mpz_clear( avar );

I think this seems cleaner than

struct astruct *avar = NULL;
avar = malloc( sizeof( struct astruct ) );
init_function( &avar );
..do something
clear_function( &avar );
free( avar );

...which, AFAIKT, is the least amount of code you'd have to write to
do the same thing without the clever one element array.

You overlooked:
avar_t avar;
init_func(&avar);
......
clear_func(&avar);

which is no more complicated than the mpz variation. I
find the technique distasteful, as its only function
appears to be to obfuscate the code. Code which looks
like it passes objects by value, actually modifies the
objects.

[Keith Thompson]

Army1987 <ar******@NOSPAM.itwrites:

On Tue, 04 Sep 2007 12:17:34 +0100, Mark Bluemel wrote:

>Ron Peterson (012ED25E) wrote:

>>I ran into something like the following while looking into how the GNU
MP library implements its mpz_t type.

typedef struct {
int len;
char *buf;
} foo[1];

This is an interesting technique. I'm unfamiliar with declaring the
name of a typedef as a one element array. Is this part of the C
standard? Is it portable? Does this technique have a name?

Hmmm.... I think you're mistaken in what this means.

My reading (which could easily be incorrect) is that it makes "foo" a
typedef for a single dimension, single element, array of such structures.

I'm trying to work out what the value of such a technique would be.

On glibc, jmp_buf is declared as an array with one element.

The standard specifically requires jmp_buf to be an array type.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Richard Tobin]

In article <ln************@nuthaus.mib.org>,
Keith Thompson <ks***@mib.orgwrote:

>On glibc, jmp_buf is declared as an array with one element.

>The standard specifically requires jmp_buf to be an array type.

Because historically it was just an array of a few ints, into which
some registers were copied.

-- Richard

--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[James Antill]

On Tue, 04 Sep 2007 14:45:20 +0100, Mark Bluemel wrote:

Richard Tobin wrote:

>In article <fb**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

>>>typedef struct {
int len;
char *buf;
} foo[1];

>>I'm trying to work out what the value of such a technique would be.

My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. If it had been

typedef struct {...} foo;

you would have to use &foo all over the place, and it it had been

typedef struct {...} *foo;

you would have to allocate the data as well as declaring a variable.

And how is this worse than having to artificially use a "[0]" subscript
all the time?

Well you can use foo->len etc. which I've done before, although I don't
hide it in typedef's.

--
James Antill -- ja***@and.org
C String APIs use too much memory? ustr: length, ref count, size and
read-only/fixed. Ave. 44% overhead over strdup(), for 0-20B strings
http://www.and.org/ustr/

[Ben Pfaff]

ri*****@cogsci.ed.ac.uk (Richard Tobin) writes:

In article <fb**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

>>typedef struct {
int len;
char *buf;
} foo[1];

>>I'm trying to work out what the value of such a technique would be.

My guess is that it's a neat trick for having objects that are (in
effect) automatically passed by reference. [...]

For what it's worth, the canonical example of this technique is
the jmp_buf type declared in <setjmp.h>.
--
char a[]="\n .CJacehknorstu";int putchar(int);int main(void){unsigned long b[]
={0x67dffdff,0x9aa9aa6a,0xa77ffda9,0x7da6aa6a,0xa6 7f6aaa,0xaa9aa9f6,0x11f6},*p
=b,i=24;for(;p+=!*p;*p/=4)switch(0[p]&3)case 0:{return 0;for(p--;i--;i--)case+
2:{i++;if(i)break;else default:continue;if(0)case 1:putchar(a[i&15]);break;}}}