variable tableau modifié à la portée de fichier en C

J'ai un code comme ceci:

static int a = 6;
static int b = 3;

static int Hello[a][b] =
{
    { 1,2,3},
    { 1,2,3},
    { 1,2,3},
    { 1,2,3},
    { 1,2,3},
    { 1,2,3}
};

mais quand je compile, il est dit d'erreur:

variable modifiée "Bonjour" à la portée du fichier

comment est-ce possible? et comment pourrais-je résoudre ce problème?

Double Possible de Variable tableau modifié à la portée de fichier

OriginalL'auteur | 2012-11-30

arrays c static

32

Vous ne pouvez pas avoir statique tableau dont la taille est donnée comme une variable

C'est pourquoi les constantes doivent être #defined:
```
#define a 6
```
Cette façon de préprocesseur va remplacer a avec 6, le rendre valide déclaration.

est a et b définis comme des int a = 6; int b = 3 au lieu de static int a = 6 œuvres?
Non, ce sera encore une variable. Utilisation #define. En C++ il y a const qui permettrait const int a = 6; de travail, mais même const n'est pas assez en C.
Pas sûr au sujet de la norme, mais gcc ne l'accepte pas.
Mes excuses. Vous avez tout à fait raison au sujet de gcc. Mon commutateurs sont sur "std=gnu99". En vertu de l' "std=c99" vous ne pouvez même pas const-decl les dimensions. Vous obtenez les deux mon-voter, ma réponse supprimé, et mes excuses, monsieur.

OriginalL'auteur zch
8

Réponse Simple variable modified array at file scope is not possible.

Détaillée :

faire de la compilation integral constant expression, puisque la longueur du tableau doit être spécifié au moment de la compilation.

comme ceci :
```
#define a 6
#define b 3
```
Ou, suivez standard c99. et de la compilation comme pour gcc.

gcc -Wall -std=c99 test.c -o test.out

Le problème ici est de longueur variable tableau à la fourniture de longueur ne peut pas être initialisé, donc vous obtenez cette erreur.

simplement
```
static int a =6;
static int b =3;

void any_func()
{
int Hello [a][b]; //no need of initialization no static array means no file scope.
}
```
Maintenant utiliser la boucle for ou une boucle pour remplir le tableau.

Pour plus d'info, juste une DÉMO :
```
#include <stdio.h>
static int a = 6; 
int main()
{
int Hello[a]={1,2,3,4,5,6}; //see here initialization of array Hello it's in function
                            //scope but still error
return 0;
}


root@Omkant:~/c# clang -std=c99 vararr.c -o vararr
vararr.c:8:11: error: variable-sized object may not be initialized
int Hello[a]={1,2,3,4,5,6};
          ^
1 error generated. 
```
Si vous éliminer l'électricité statique et de fournir l'initialisation il va générer d'erreur comme ci-dessus.

Mais si vous gardez statique ainsi que l'initialisation de l'faudra encore une erreur.

Mais si vous retirez de l'initialisation et de garder static l'erreur ci-dessous viendra.
```
error: variable length array declaration not allowed at file scope
static int Hello[a];
           ^     ~
1 error generated.
```
Afin de longueur variable déclaration de tableau non autorisé à la portée du fichier afin de le faire fonctionner ou de bloquer la portée à l'intérieur de n'importe quelle fonction (mais rappelez-vous rendant à la portée de la fonction doit supprimer l'initialisation)

NOTE : Depuis qu'il est C marqués afin de faire a et b comme const ne vous aidera pas, mais dans C++ const fonctionnera très bien.

C99 ne prend pas en charge VLA du fichier à-portée. il doit être en fonction de la portée ou plus petit. Il 'peut' utiliser const index des déclarations, y compris static const int a = 10; par exemple, à la portée de fichier.
Vraiment ? laissez-moi vérifier
Ses une pile-chose. Si ils sont encore pris en charge par votre compilateur C99, il n'est pas obligatoire qu'ils soient; la norme définit comment ils se comportent si votre C99 t les soutenir. Les implémentations de l'utilisation de la pile-mathématiques pour les mettre en œuvre. Vous ne pouvez pas le faire au niveau mondial (ou fichier) de données du segment de la compilation.
Mais quand je définis a dans main dans ce cas, ce n'est pas le travail, la compilation avec -std=c99 . maintenant a est sur la pile, donc quel est le problème maintenant , j'ai essayé avec gcc et clang
J'ai lu quelque part sur DONC en lui même posté la réponse , mais je suis maintenant moi-même face à cette avec -std=c99 et pas à la compilation, aucune idée ? allez éditer ma réponse aussi

OriginalL'auteur Omkant
1

Lors de l'utilisation de CLANG/LLVM les ouvrages suivants:
```
static const int a = 6;
static const int b = 3;

static int Hello[a][b] =
{
    { 1,2,3},
    { 1,2,3},
    { 1,2,3},
    { 1,2,3},
    { 1,2,3},
    { 1,2,3}
}; 
```
(À voir dans l'assembly généré, on doit utiliser Bonjour, de sorte qu'il ne sera pas optimisé)

Cependant, cela va générer une erreur si C99 mode est sélectionné (-std=c99),
il ne fera que générer un avertissement (Wgnu-pliage-constant) si -pédant est sélectionné.

GCC ne semble pas permettre cela (const est interprétée comme étant en lecture seule)

Voir l'explication dans ce fil:

"Initialiseur élément n'est pas constante d'erreur" pour aucune raison en Linux, GCC, la compilation de C

OriginalL'auteur PolarBear2015

Vous devez vous connecter pour publier un commentaire.