Compiler error for "wrong" sized type

[David White]

The size of a struct can be affected by compiler packing. Suppose you need it to be a
specific value for some reason (e.g., in firmware). How can you get the compiler to
generate an error for the wrong size rather than assert it at run-time? Here is one way,
but I don't know if it's guaranteed to work on any compiler:
1/(sizeof(struct my_struct) == correct_size);

For me, the above produces a compile-time divide-by-zero error for the wrong size. Is
there a better way?

DW

[Eric Sosman]

David White wrote:

Richard Heathfield wrote:

Well, I don't know about "better", but I like this:

char DetectWrongSize[(sizeof(struct my_struct) == correct_size) * 2 -
1];

If the struct is the wrong size, this will yield a negatively sized
array, which is illegal.

Thanks. That's an improvement. Unfortunately, our Hi-Tech compiler doesn't pick it up
because it treats an array size of -1 as unsigned!

DW

P.S. A colleague is terribly disappointed to learn that an array cannot have a negative
size. He thinks it should be allowed, with the valid index range extending from size+1 to
zero inclusive (e.g., -9 to 0 for a size of -10). I asked him what he would expect for a
sizeof of such an array, but he can't decide whether it should be positive or negative.

Wow! You're a colleague of Paul Dirac?

Hmmm: Dirac's ideas could revolutionize memory management in
C-- (or would it be --C?). If "no memory at all" spontaneously
split into a chunk of allocated memory and a corresponding chunk
of unallocated anti-memory, a program could store data in the
allocated area without needing to call malloc(). Of course, one
would need to be careful: pointer aliasing could cause the memory
and anti-memory to come together and undergo mutual annihilation,
with the resulting, er, Gamma ray constituting an implementation-
defined signal. The task of keeping the allocation separated
from the anti-allocation is probably best left to Maxwell's Nasal
Demon.

--
Eric Sosman
es*****@acm-dot-org.invalid
--
Eric Sosman
es*****@acm-dot-org.invalid

[Kenneth Brody]

David White wrote:
[...]

P.S. A colleague is terribly disappointed to learn that an array cannot
have a negative size. He thinks it should be allowed, with the valid
index range extending from size+1 to zero inclusive (e.g., -9 to 0 for
a size of -10). I asked him what he would expect for a sizeof of such
an array, but he can't decide whether it should be positive or negative.

http://astronomy.swin.edu.au/~pbourk...ry/minus1.html

--
+-------------------------+--------------------+-----------------------------+
| Kenneth J. Brody | www.hvcomputer.com | |
| kenbrody/at\spamcop.net | www.fptech.com | #include <std_disclaimer .h> |
+-------------------------+--------------------+-----------------------------+
Don't e-mail me at: <mailto:Th***** ********@gmail. com>

[tedu]

David White wrote:

Richard Heathfield wrote:

Well, I don't know about "better", but I like this:

char DetectWrongSize[(sizeof(struct my_struct) == correct_size) * 2 -
1];

If the struct is the wrong size, this will yield a negatively sized
array, which is illegal.

Thanks. That's an improvement. Unfortunately, our Hi-Tech compiler doesn't pick it up
because it treats an array size of -1 as unsigned!

does it allow multiple case statements with the same value?

switch (0) {
case sizeof(struct my_struct) == correct_size:
case 0:
}

[S.Tobias]

tedu <tu@zeitbombe.o rg> wrote:

David White wrote:

Richard Heathfield wrote:

> Well, I don't know about "better", but I like this:
>
> char DetectWrongSize[(sizeof(struct my_struct) == correct_size) * 2 -
> 1];
>
> If the struct is the wrong size, this will yield a negatively sized
> array, which is illegal.

Thanks. That's an improvement. Unfortunately, our Hi-Tech compiler doesn't pick it up
because it treats an array size of -1 as unsigned!

does it allow multiple case statements with the same value?

switch (0) {
case sizeof(struct my_struct) == correct_size:
case 0:
}

Nit: a label reqires a following statement; make it:
switch (0) {
case sizeof(struct my_struct) == correct_size: ;
case 0: ;
}

(Otherwise it's a nice trick, I liked it.)

--
Stan Tobias
mailx `echo si***@FamOuS.Be dBuG.pAlS.INVALID | sed s/[[:upper:]]//g`

[Harald van Dijk]

S.Tobias wrote:

tedu <tu@zeitbombe.o rg> wrote:

David White wrote:

Richard Heathfield wrote:
> Well, I don't know about "better", but I like this:
>
> char DetectWrongSize[(sizeof(struct my_struct) == correct_size) * 2 -
> 1];
>
> If the struct is the wrong size, this will yield a negatively sized
> array, which is illegal.

Thanks. That's an improvement. Unfortunately, our Hi-Tech compiler doesn't pick it up
because it treats an array size of -1 as unsigned!

does it allow multiple case statements with the same value?

switch (0) {
case sizeof(struct my_struct) == correct_size:
case 0:
}

Nit: a label reqires a following statement; make it:
switch (0) {
case sizeof(struct my_struct) == correct_size: ;
case 0: ;
}

(Otherwise it's a nice trick, I liked it.)

"case 0: ;" is a statement, so the first semicolon isn't necessary. The
second indeed is though.

[David White]

"tedu" <tu@zeitbombe.o rg> wrote in message
news:11******** **************@ j33g2000cwa.goo glegroups.com.. .

does it allow multiple case statements with the same value?
I don't know. I'll find out next week.
switch (0) {
case sizeof(struct my_struct) == correct_size:
case 0:
}

Good idea. Incidentally, I had a problem with this rule once. I allowed two
different characters in encoded text to have the same meaning, e.g.,
#define TOKEN_CHAR '#'
#define ALT_TOKEN_CHAR 't'

Since they have the same meaning, the switch that processed them looked like
this:
switch(ch)
{
....
case TOKEN_CHAR:
case ALT_TOKEN_CHAR:
/* process */
break;
....
}

But in some cases I didn't want to allow both characters, so I did this:
#define TOKEN_CHAR '#'
#define ALT_TOKEN_CHAR '#'

The switch then wouldn't compile, but it could have, since there's no clash.

DW