typedef struct {
size_t length;
int foo;
char bar;
element_t array;
} fussbucket_t;

fussbucket_t sample;

sample.array[0] = (element_t) foo;
sample.array[1] = (element_t) bar;

To accommodate cases where sizeof(array) is "too large"
(whatever that means) to dangle off the bussbucket_t,

typedef struct {
size_t length;
int foo;
char bar;
union {
element_t array;
element_t *pointer;
} u;
} fussbucket_t;

fussbucket_t sample;
element_t longArray[A_BIG_NUMBER];

sample.u.array[0] = &longArray[0];

Hi,

[I'll post this here instead of c.l.c as I suspect folks here
are far more adept at "squeezing bytes" out of things (vs.
the "desktop jocks")]

While arguably not legitimate, the following is in the
*spirit* of the language (consider much of this pseudo-code):

D Yuniskis wrote:
Hi,

[I'll post this here instead of c.l.c as I suspect folks here
are far more adept at "squeezing bytes" out of things (vs.
the "desktop jocks")]


It's probably fair to say that the c.l.c. crowd are more concerned with
what is theoretically correct in C, while in c.a.e. we are more
concerned with practical working code.

While arguably not legitimate, the following is in the
*spirit* of the language (consider much of this pseudo-code):


Your code is inarguably not legitimate, and is not in the "spirit" of
any language I know of.

It would help enormously if you could give a short description of what
you are trying to do - it's very hard to guess from this post. Your
second "correction" post doesn't really help either - it is still
mangled code, and mixing in partial quotations from your first post with
partial corrections and smart-ass "sed" notation makes it even less clear.

Figure out what you are trying to do, and explain it in a post. Then
someone will probably be able to help you.

mvh.,

It's probably fair to say that the c.l.c. crowd are more concerned with
what is theoretically correct in C, while in c.a.e. we are more concerned
with practical working code.

Hi,

[I'll post this here instead of c.l.c as I suspect folks here
are far more adept at "squeezing bytes" out of things (vs.
the "desktop jocks")]

While arguably not legitimate, the following is in the
*spirit* of the language (consider much of this pseudo-code):

typedef struct {
size_t length;
int foo;
char bar;
element_t array;
} fussbucket_t;

fussbucket_t sample;

sample.array[0] = (element_t) foo;
sample.array[1] = (element_t) bar;

ASSERT(sample.array == sample.array[0]);

To accommodate cases where sizeof(array) is "too large"
(whatever that means) to dangle off the bussbucket_t,
you could optionally store a pointer to the array in
place of array[0]. E.g.,

typedef struct {
size_t length;
int foo;
char bar;
union {
element_t array;
element_t *pointer;
} u;
} fussbucket_t;

fussbucket_t sample;
element_t longArray[A_BIG_NUMBER];

sample.u.array[0] = &longArray[0];

If sizeof(element_t) is smaller than sizeof(element_t *),
then you can cheat and pack a few element_t's into the
union. I.e., as if:

struct {
size_t length;
int foo;
char bar;
union {
element_t array[sizeof(element_t *)/sizeof(element_t)];
element_t *pointer;
} u;
}

I *think* this may be portable -- I haven't even checked the
syntax to see if I've shot myself in the foot before I even got
started!

D Yuniskis wrote:

typedef struct {
size_t length;
int fu;
char baz;
element_t array;
} fussbucket_t;

fussbucket_t sample;

sample.array[0] = (element_t) foo;
sample.array[1] = (element_t) bar;

You can only index array types and pointer types. What is the type of
element_t?

ASSERT(sample.array == sample.array[0]);

That is true if array is a multidimensional array, but not, in general,
otherwise.

To accommodate cases where sizeof(array) is "too large"
(whatever that means) to dangle off the bussbucket_t,
you could optionally store a pointer to the array in
place of array[0]. E.g.,

typedef struct {
size_t length;
int fu;
char baz;
union {
element_t array;
element_t *pointer;
} u;
} fussbucket_t;

fussbucket_t sample;
element_t longArray[A_BIG_NUMBER];

sample.u.array[0] = &longArray[0];

If sizeof(element_t) is smaller than sizeof(element_t *),
then you can cheat and pack a few element_t's into the
union. I.e., as if:

struct {
size_t length;
int fu;
char baz;
union {
element_t array[sizeof(element_t *)/sizeof(element_t)];
element_t *pointer;
} u;
}

I *think* this may be portable -- I haven't even checked the
syntax to see if I've shot myself in the foot before I even got
started!

That works if sizeof(element_t*) >= sizeof(element_t).

Of course, that is true only for small types.

In the general case, if that is not true,
you have declared an array of zero elements, which isn't allowed
in that part of the declaration.

You could make it work by using a max() macro:
element_t
array[max(sizeof(element_t),sizeof(element_t*))/sizeof(element_t)];

which guarantees at least one item in array. Unfortunately, you cannot
use the standard preprocessor for selecting different code, depending on
which is greater.

Agreed. Not only working but also maintainable. The sample code posted was
anything but that.

Chris Burrows wrote:
Agreed. Not only working but also maintainable. The sample code posted was
anything but that.

Perhaps you could suggest how this could be made *more*
maintainable? (keeping in mind that you don't want to
make it *brittle* in the process!)

The following should compile and "work". I can't imagine
how to change it to make it more "maintainable" :-(

A big thing that makes code maintainable is good comments.

[I've merged in some of the corrections I posted earlier
but have refrained from making all syntactic changes]

Thad Smith wrote:
D Yuniskis wrote:

snip
The risk only happens when sizeof(element_t) > sizeof(element_t *).
This is something that the developer has to safeguard against
as there is no way that I can "#error" at compile time. What
I have done is added a tiny executable to my makefile that
essentially compares the sizeof's, prints an error message
and returns a nonzero result code that causes the make(1) to
fail with the message that it displays.

I can think of no other way to enforce this requirement.

You could make it work by using a max() macro:
element_t
array[max(sizeof(element_t),sizeof(element_t*))/sizeof(element_t)];

This is only legal in newer C (C99?). E.g.,
you couldn't put such a declaration in file scope... (?)

which guarantees at least one item in array. Unfortunately, you
cannot use the standard preprocessor for selecting different code,
depending on which is greater.

Exactly. An unfortunate consequence of sizeof not being valid
in the preprocessor (though I have found many compilers that
*will* recognize its use there).

There is also a hazard that can bite a sloppy coder if
sizeof(element_t *) mod sizeof(element_t) != 0. But,
you can't protect against incompetence (I guess
I could provide a macro to simplify accessing the array
elements while avoiding this hazard).

Chris Burrows wrote:
Agreed. Not only working but also maintainable. The sample code posted
was anything but that.

Perhaps you could suggest how this could be made *more*
maintainable? (keeping in mind that you don't want to
make it *brittle* in the process!)

"D Yuniskis" <not.going.to.be at (no spam) seen.com> wrote in message
news:hc76jv$n5q$1 at (no spam) aioe.org...
Chris Burrows wrote:
Agreed. Not only working but also maintainable. The sample code posted
was anything but that.

Perhaps you could suggest how this could be made *more*
maintainable? (keeping in mind that you don't want to
make it *brittle* in the process!)

Some more information is required first. AFAICS you have proposed a solution
without clearly describing the problem domain that it is attempting to
address.

What exactly are you trying to achieve?

What alternative solutions have you rejected and why?

Have some particular real-world circumstances driven you to devise such an
obscure approach or is this just an intellectual exercise?