Speicher allokieren wann, wo wie lange

McBsp

Hi

hab ein grundlegendes Verständnis-Problem. Am besten ich schreib ein kleines Beispiel (ob das Bsp. Sinn macht oder nicht spielt keine Rolle):

int erg; /*globale Variable*/
void power(int base, int n);

void main()
{
int i; /*automatische Variable*/

for(i=0; i<10;++i)
printf("%d %d %d \n", i, power(2,i));
}

void power(int base, int n)
{
int i,p;

p=1;
for(i=0; i <= n; ++i)
erg = p * base;
}

Meine Frage wann wird für die einzelnen Variablen Speicherplatz reserviert?
Wird für globale Variablen (erg) bereits zur Kompilierzeit Speicher reserviert?
Wann wird für automatische Variablen (i,p) Speicher reserviert, wie lange und wo (auf dem Stack??)?
Wird bereits bei der Definition einer Variablen Speicher reserviert oder erst bei der Initialisierung?

Thanks

c.rackwitz

int erg; // definition; hier
void power(int base, int n); // prototyp; hier nicht

void main()
{
  int i;  // definition; hier

  for(i=0; i<10;++i)
    printf("%d %d %d \n", i, power(2,i));
}

void power(int base, int n) // funktionskopf; bei jedem aufruf
{
  int i,p; // definitionen; hier

  p=1;
  for(i=0; i <= n; ++i)
    erg = p * base;
}

fuer autovariablen wird auf dem stack reserviert, und zwar fuer jeden aufruf der funktion so lange die funktion laeuft.
fuer globale variablen weiss ich es nicht sicher, aber meine vermutung waere, dass die im datensegment liegen (also zur compile time "alloziiert werden").

bei der definition wird speicher reserviert, bei deklarationen nicht. die initialisierung spielt keine rolle.

Konfusius

soviel ich weiß macht der standard darüber keine aussage. er sagt lediglich, wo eine variable sichtbar ist. zb

int funktion (int x)
{
  // nur x sichtbar

  int y;

  // x und y sichtbar

  for(;;)
  {
    // nur x und y sichtbar

    int z;

    // x, y und z sichtbar
  }

  // x und y sichtbar
}

in der regel wird der compiler den speicher auf dem stack allozieren, sobald die variable sichtbar wird und den speicher wieder freigeben, sobald der sichtbarkeitsbereich verlassen wird.

häufig optimieren compiler das aber auch. in der obigen funktion würde ein optimierender compiler den speicher für die variablen y und z warscheinlich schon ganz zu beginn der funktion allozieren und erst ganz am ende wieder freigeben. das ist nämlich schneller und kürzer.

c.rackwitz

ausser sichtbarkeit gibt es noch "extent":

void bar(int *bararg)
{
    printf("%d", *bararg); // fooarg nicht sichtbar, existiert aber dennoch; muss mit pointer angesprochen werden
}
void foo(int fooarg)
{
    bar(&fooarg);
}