«

Hello everybody --

I always want the compiler to completely evaluate sizeof values. But I
gather that C99 allows the run-time environment to do some partial
evaluation of sizeof.

If this is so, then is there some C99-compliant mechanism I can use to
be sure that sizeof is evaluated always at compile time, never at run
time?

Thanks!

-- pete

On 12/17/2010 10:27 AM, pete wrote:
> Hello everybody --
>
> I always want the compiler to completely evaluate sizeof values. But I
> gather that C99 allows the run-time environment to do some partial
> evaluation of sizeof.
>
> If this is so, then is there some C99-compliant mechanism I can use to
> be sure that sizeof is evaluated always at compile time, never at run
> time?

No, because the size of a variable-length array (VLA) cannot be
determined until run time.

void func(int len) {
double vla[len]; // size unknown at compile time
size_t size = sizeof vla; // unknown at compile time
...

Aside from VLA's, though, everything that has a size at all has
a size that's an integer constant expression. There is no guarantee
that an ICE is "evaluated" at compile time, but they nearly always
are. Even if the "evaluation" occurs at run time, an ICE can be used
anywhere an plain integer constant can be.

--
Eric Sosman
lid

On Dec 17, 10:46*am, Eric Sosman <esos...@ieee-dot-org.invalid> wrote:
> On 12/17/2010 10:27 AM, pete wrote:
>
> > Hello everybody --
>
> > I always want the compiler to completely evaluate sizeof values. But I
> > gather that C99 allows the run-time environment to do some partial
> > evaluation of sizeof.
>
> > If this is so, then is there some C99-compliant mechanism I can use to
> > be sure that sizeof is evaluated always at compile time, never at run
> > time?
>
> * * *No, because the size of a variable-length array (VLA) cannot be
> determined until run time.
>
> * * * * void func(int len) {
> * * * * * * double vla[len]; * // size unknown at compile time
> * * * * * * size_t size = sizeof vla; *// unknown at compile time
> * * * * * * ...
>
> * * *Aside from VLA's, though, everything that has a size at all has
> a size that's an integer constant expression. *There is no guarantee
> that an ICE is "evaluated" at compile time, but they nearly always
> are. *Even if the "evaluation" occurs at run time, an ICE can be used
> anywhere an plain integer constant can be.
>
> --
> Eric Sosman
> esos...@ieee-dot-org.invalid

Ah, that's the answer! If I don't use VLAs, then sizeof should always
be known at compile time. Thanks, Eric.
--
pete
----------
patient: Doc, it hurts when I wiggle my VLAs.
doctor: Then don't wiggle the damn things!

On 2010-12-17, pete <> wrote:
> I always want the compiler to completely evaluate sizeof values. But I
> gather that C99 allows the run-time environment to do some partial
> evaluation of sizeof.
>
> If this is so, then is there some C99-compliant mechanism I can use to
> be sure that sizeof is evaluated always at compile time, never at run
> time?

Yes. Never call it on a VLA.

-s
--
Copyright 2010, all wrongs reversed. Peter Seebach / usenet-
http://www.seebs.net/log/ <-- lawsuits, religion, and funny pictures
http://en.wikipedia.org/wiki/Fair_Game_(Scientology) <-- get educated!
I am not speaking for my employer, although they do rent some of my opinions.