Pourquoi ne puis-je pas créer un tableau dont la taille est déterminée par une variable globale?

Pourquoi le tableau n’est-il pas initialisé par la size variable globale?

 #include int size = 5; int main() { int a[size] = {1, 2, 3, 4, 5}; printf("%d", a[0]); return 0; } 

L’erreur de compilation est montrée comme

object de taille variable ne peut pas être initialisé

Selon moi, le tableau devrait être initialisé par size .

Et quelle serait la réponse si je persiste à utiliser la variable globale (si cela est possible)?

    En C99, 6.7.8 / 3:

    Le type de l’entité à initialiser doit être un tableau de taille inconnue ou un type d’object qui n’est pas un type de tableau de longueur variable.

    6.6 / 2:

    Une expression constante peut être évaluée pendant la traduction plutôt que pendant l’exécution

    6.6 / 6:

    Une expression constante entière doit avoir un type entier et ne contenir que des opérandes constantes entières, des constantes d’énumération, des constantes de caractère, des expressions sizeof dont les résultats sont des constantes entières et des constantes flottantes constituant les opérandes immédiats des envois.

    6.7.5.2/4:

    Si la taille est une expression constante entière et que le type d’élément a une taille constante connue, le type de tableau n’est pas un type de tableau de longueur variable; sinon, le type de tableau est un type de tableau de longueur variable.

    a a a type de tableau de longueur variable, car size n’est pas une expression constante entière. Ainsi, il ne peut pas avoir de liste d’initialisation.

    En C90, il n’y a pas de VLA, le code est donc illégal pour cette raison.

    En C ++, il n’y a pas non plus de VLA, mais vous pouvez faire de size un const int . En effet, en C ++, vous pouvez utiliser des variables const int dans les ICE. En C, vous ne pouvez pas.

    Vraisemblablement, vous n’aviez pas l’intention d’avoir une longueur variable, vous avez donc besoin de:

     #define size 5 

    Si vous vouliez réellement avoir une longueur variable, je suppose que vous pourriez faire quelque chose comme ceci:

     int a[size]; int initlen = size; if (initlen > 5) initlen = 5; memcpy(a, (int[]){1,2,3,4,5}, initlen*sizeof(int)); 

    Ou peut-être:

     int a[size]; for (int i = 0; i < size && i < 5; ++i) { a[i] = i+1; } 

    Il est difficile de dire, cependant, que "devrait" arriver ici dans le cas où size! = 5. Cela n'a pas vraiment de sens de spécifier une valeur initiale de taille fixe pour un tableau de longueur variable.

    Vous n’avez pas besoin d’indiquer au compilateur la taille du tableau si vous atsortingbuez un initialiseur. Le compilateur déterminera la taille en fonction du nombre d’éléments avec lesquels vous l’initialisez.

     int a[] = {1,2,3,4,5}; 

    Ensuite, vous pouvez même laisser le compilateur vous dire la taille en obtenant la taille totale du tableau en octets sizeof(a) et en le divisant par la taille d’un élément sizeof(a[0]) :

     int size = sizeof(a) / sizeof(a[0]); 

    Le compilateur ne peut pas supposer que la valeur de size est toujours égale à 5 au moment où main () prend le contrôle. Si vous voulez une vraie constante dans un projet C à l’ancienne, utilisez:

     #define size 5 

    size est une variable, et C ne vous permet pas de déclarer ( edit: C99 vous permet de les déclarer, mais ne les initialisez pas comme vous le faites) des tableaux de taille variable. Si vous voulez créer un tableau dont la taille est une variable, utilisez malloc ou faites-en une taille constante.

    Il semble que votre compilateur n’est pas conforme à C99 … en parlant de quel compilateur utilisez-vous? Si c’est gcc, vous devez passer le commutateur ‘-std = c99’ …. si vous utilisez un compilateur antérieur à C99, cette instruction est illégale, si c’est le cas, procédez comme suit:

     int main() { 
        int a [5] = {1,2,3,4,5}; 
        printf ("% d", a [0]); 
        retourne 0; 
     }
    

    Dans les compilateurs standard antérieurs à C99, utilisez une constante au lieu d’une variable.

    Edit: Vous pouvez en savoir plus sur la norme C99 ici … et ici ….

    Le compilateur doit connaître la taille du tableau tout en le déclarant. Parce que la taille d’un tableau ne change pas après sa déclaration. Si vous mettez la taille du tableau dans une variable, vous pouvez imaginer que la valeur de cette variable changera lors de l’exécution du programme. Dans ce cas, le compilateur sera obligé d’allouer de la mémoire supplémentaire à ce tableau. Dans ce cas, cela n’est pas possible car le tableau est une structure de données statique allouée sur la stack. J’espère que cela aidera.

     #include /* int size=5; */ #define size 5 /* use this instead*/ /*OR*/ int a[size]={1,2,3,4,5}; /* this*/ int main() { int a[size]={1,2,3,4,5}; printf("%d",a[0]); return 0; } 

    int size signifie que size est une variable et que C n’autorise pas les tableaux de size variable .

    J’utilise VS2008 où en utilisant

     const int size=5; 

    permet

     int a[size]={1,2,3,4,5};