Constants: how are they allocated?

Constants: how are they allocated?

[Justin Gombos]

When a constant is assigned to a variable, is the constant stored on the 
stack, or in the heap?

Re: Constants: how are they allocated?

[Chad Bremmon]

Justin Gombos wrote:
> 
> When a constant is assigned to a variable, is the constant stored on the
> stack, or in the heap?When a constant is assigned to a variable, the constant will not move or change. I believe that 
where the variable goes is compiler defined.  Common practice places non-dynamic variables on the 
stack.

Chad

Re: Constants: how are they allocated?

[Theodore E. Dennison]

Justin Gombos wrote:
> 
> When a constant is assigned to a variable, is the constant stored on the
> stack, or in the heap?

That depends on your compiler, and on how and where the constant was
declared.

Your compiler's docs (if they are any good) should shed light on this.

I know in VADS's case it LOOKS LIKE constants that aren't "static" are
meerly variables that the compiler won't let you update. They have
'ADDRESSes, and are stored in the same place a variable would be:
    On the heap if they are global to a package or the main routine.
    On the stack if they are in the body of a task or subprogram.

Constants that are static are meerly textually replaced by their value
at run-time.

If I remember correctly, DEC Ada handles constants quite differently.

-- 
T.E.D.          
                |  Work - mailto:dennison@escmail.orl.mmc.com  |
                |  Home - mailto:dennison@iag.net              |
                |  URL  - http://www.iag.net/~dennison         |

Re: Constants: how are they allocated?

[Theodore E. Dennison]

Robert A Duff wrote:
> 
> In article <4ml2s6$bis@dewey.csun.edu>,
> justin gombos <hbcsc096@csun.edu> wrote:
> >Oops.. I botched on the question.  Let me re-word it.  If a constant is
> >defined and allocated at runtime, where is it stored?  ie. in the case
> >that a constant is assigned to a function or expression containing
> >variables.
> 
> In most compilers, such constants are allocated just like variables.

Unless, of course, the constant is static (on some compilers). And of
course some compilers go a bit beyond the LRM definition of "static"
in deciding which constants to treat this way.

Again, this is all really implementation-defined.

-- 
T.E.D.          
                |  Work - mailto:dennison@escmail.orl.mmc.com  |
                |  Home - mailto:dennison@iag.net              |
                |  URL  - http://www.iag.net/~dennison         |

Re: Constants: how are they allocated?

[justin gombos]

Oops.. I botched on the question.  Let me re-word it.  If a constant is
defined and allocated at runtime, where is it stored?  ie. in the case
that a constant is assigned to a function or expression containing
variables. 

--
http://www.csun.edu/~hbcsc096/dt

Re: Constants: how are they allocated?

[Theodore E. Dennison]

justin gombos wrote:
> 
> Oops.. I botched on the question.  Let me re-word it.  If a constant is
> defined and allocated at runtime, where is it stored?  ie. in the case
> that a constant is assigned to a function or expression containing
> variables.

The answer is still the same. This is not something defined in the 
language's specification, so it is up to the compiler writer. Your
compiler's documentation may contain this information. No one here
can give you a definitive answer without knowing what Ada compiler
(vendor and platform) you are talking about.

-- 
T.E.D.          
                |  Work - mailto:dennison@escmail.orl.mmc.com  |
                |  Home - mailto:dennison@iag.net              |
                |  URL  - http://www.iag.net/~dennison         |

Re: Constants: how are they allocated?

[Robert A Duff]

In article <4ml2s6$bis@dewey.csun.edu>,
justin gombos <hbcsc096@csun.edu> wrote:
>Oops.. I botched on the question.  Let me re-word it.  If a constant is
>defined and allocated at runtime, where is it stored?  ie. in the case
>that a constant is assigned to a function or expression containing
>variables. 

In most compilers, such constants are allocated just like variables.
The fact that the thing is constant causes compile-time checks, and
might cause the optimizer to be more clever, but is unlikely to affect
storage allocation (I'm assuming the compiler doesn't know the value
here).

E.g if you put:

    X: constant Integer := Read_A_Value_From_The_Keyboard;

in a procedure, X will probably be allocated on the stack, just the same
as if X were not constant.

- Bob