Lorsque la mémoire est allouée à des variables locales dans le C

Que les variables locales sont aussi appelés variables automatiques, et sont censés être alloué de la mémoire au moment de l'exécution, lorsque la fonction est accessible.

int main(){
    int a; //declaration 
    return 0;
}

int main(){
    int a[]; //compilation error, array_size missing
    return 0;
}

int main(){
    int a[2]; //declaration, but can't work without array_size, 
              //so at compile time it is checked!
    return 0;
}

Ma question est de savoir si c'est juste une règle de donner array_size dans la déclaration en C, ou que la mémoire est allouée au moment de la compilation pour array (encore variable locale)

Comment ça fonctionne?

Un tableau est une variable que par la programmation en C par K&R. pg no 161.

Comment pourrait éventuellement être une variable allouée au moment de la compilation?
Il n'y a pas tout les tableaux statiques dans ce code.
Par le compilateur, bien sûr. Je suis sûr qu'il alloue beaucoup. Oh.. tu parlais dans le programme en cours de compilation.. nm. =P
que serait un local fixe-longueur variable de tableau.
Nah. Le compilateur émet les instructions de lors de la compilation que le programme allouer de la mémoire lors de l'exécution.

OriginalL'auteur linuxD | 2013-03-13

  1. 7

    Lorsque vous déclarez une variable locale, la taille est connue à la compilation, mais d'allocation de mémoire se produit pendant le temps d'exécution.

    Donc dans votre exemple, le tableau sans taille est clairement un problème de compilateur, car il ne sait pas quelle est la taille d'inclure dans le code assembleur.

    Si vous ne connaissez pas la taille d'un tableau, vous pouvez toujours utiliser les types pointeur et malloc/free ou même alloca. Les deux premiers fonctionnent sur le tas, et alloca utilise la pile.

    L'exception notable de variables statiques. Le stockage est alloué à la compilation/lien temps déjà et ne peut pas être modifiée lors de l'exécution.

    Exemples:

    int main(int argc, const char *argv[])
{
    int a; //a is a sizeof(int) allocated on stack
}

int main(int argc, const char *argv[])
{
    int a[2]; //a is a sizeof(int)*2 allocated on stack
}

int main(int argc, const char *argv[])
{
    int *a; //a is a sizeof(int*) allocated on stack (pointer)
    a = alloca(sizeof(int)*4); //a points to an area with size of 4 integers
                               //data is allocated on stack
}

int main(int argc, const char *argv[])
{
    static int a; //a is allocated in data segment, keeps the value
}
    Que dire de la variable qui est déclarée à l'extérieur de main()?
    segment de données. même que static
    Je vous remercie pour votre réponse et pour parler statique, @Valeri Atamaniouk

    OriginalL'auteur Valeri Atamaniouk

  2. 1
    int main(){
    int a[2];
    return 0;
}

    Ici, int a[2]; est un définition d'une variable nommée a. a est un tableau de deux int.

    Ce qui se passe dans la pratique, c'est que le compilateur émet un code d'utilisation de l'espace sur la pile pour 2 adjacentes int objets (probablement 8 octets, mais la taille de int est jusqu'à la mise en œuvre). C'est en supposant bien sûr que l'objet n'est pas retiré par l'optimiseur parce que vous n'utilisez jamais.

    L'erreur de compilation que vous avez de l' int a[999999999]; est dû à une certaine limite appliquée par le compilateur, parce qu'il sait (ou en tout cas suppose) il n'y aura jamais assez de tapis pour qu'.

    Merci pour votre aide. Ce que nous appelons int a[2]={9,8,4}; une déclaration ou une définition.
    c'est une défaillance de la tentative d'une définition (trop d'éléments dans le {} liste). Être conscient que les définitions déclarations, mais ils sont le genre de déclarations que de créer les objets qu'ils déclarent.
    merci encore. Puis-je obtenir des détails à ce sujet les définitions sont les déclarations, un lien s'il vous plaît, parce que sa question fréquemment posée.
    stackoverflow.com/questions/3342215/declaration-and-definition

    OriginalL'auteur Steve Jessop

  3. 1

    Il y a une différence entre local et automatique variables en C. Une variable locale peut être automatique ou statique, qui détermine si la mémoire est alloué sur la pile, de façon permanente ou, lorsque le programme est exécuté.

    Avec ce code:

    int main(){
  int a[];    //compilation error, array_size missing
  return 0;
}

    C'est un incomplète tableau. L'erreur est parce que le compilateur ne sait pas combien de ints le programme aura besoin d'allouer.

    OriginalL'auteur teppic

  4. 0

    Comme sgar91 indiqué dans les commentaires, un tableau comme dans votre exemple est attribuée lorsqu'une fonction est appelée et doit être déterminé par la taille. Si vous avez besoin de tableaux dynamiques, vous devez allouer de la mémoire sur le tas.

    int *values = malloc(sizeof(int) * array_count);

    OriginalL'auteur Inisheer

  5. 0

    D'attribution automatique se produit lorsque vous déclarez une variable automatique, comme un argument de fonction ou un variable locale. L'espace d'une variable automatique est alloué lors de l'instruction composée contenant la déclaration est entré, et il est libéré lorsque cette instruction composée est sorti.

    OriginalL'auteur Rajeshirke

  6. 0

    C'est le point C, où les tableaux et les pointeurs ne sont pas les mêmes.

    Prenez cet exemple:

    int main(){
   int a[5];
   int * b = malloc(sizeof(int) * 5);

  printf("sizeof a = %d\n",sizeof a);
  printf("sizeof int[5] = %d\n",sizeof(int[5]));
  printf("sizeof b = %d\n",sizeof b);

  free(b);
  return 0;
}

    Ce sera de retour:

    sizeof a = 20
sizeof int[5] = 20
sizeof b = 4

    La variable a est interne déclaré en tant que int[5], un entier pointeur pointant sur un bloc de mémoire avec l'espace de 5 entiers.

    OriginalL'auteur flyingOwl

  7. 0

    Pour les variables locales, la mémoire qu'ils consomment est sur la pile. Cela signifie qu'ils doivent avoir une taille fixe connue au moment de la compilation, de sorte que lorsque la fonction est appelée, l'exacte quantité de mémoire nécessaire est ajoutée à la pile par la modification de la valeur du pointeur de pile. C'est pourquoi le tableau doit avoir une taille: le nombre d'octets sur la pile doit changer par un montant fixe lorsque la fonction est appelée.

    Appels à malloc() et similaire allouer de la mémoire dans le tas; la mémoire allouée dans cette voie au moment de l'exécution peut être de taille variable.

    OriginalL'auteur wilsonmichaelpatrick

  8. 0

    La taille du tableau doit être connu au moment de la compilation et vous pouvez passer de la taille, soit directement sur le tableau ou indirectement, de la mémoire est décidé au moment de la compilation, mais alloués au moment de l'exécution, à l'exception de
    pour la variable tableau de taille.

    OriginalL'auteur µtex