Discussion :

[_kal_]

Bonjour,

J'ai eu un cours d'amphi dernierement ou le prof expliquait que, depuis la norme de 99, il est possible de déclarer un tableau de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int f(int n)
{
    int t[n];
    ...
}

Cependant, cela est accepté car ici n est une variable locale. Si nous avions utilisé une variable de classe statique, alors cela aurait été refusé à la compilation. Je lui ai demandé pourquoi, mais je n'ai pas vraiment compris son explication (il est parti dans un délire avec la pile....)

De retour chez moi, je test donc un petit programme avec une variable globale:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int m = 5;
void f()
{
        int t[m];
        int i;
        for (i = 0 ; i < m ; i++)
        {
                t[i] = i;
                printf("t[%d] = %d\n", i , t[i]);
        }
}
main()
{
        f();
}

Et ça marche... :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
kal@vaio ~ $ ./test
t[0] = 0
t[1] = 1
t[2] = 2
t[3] = 3
t[4] = 4

Y a t il quelqu'un pour m'expliquer réellement ce qu'il se passe depuis cette norme de 99 ?

[Skyounet]

Ce que ton prof a voulu texpliquer c'est que en C89 tu ne peux pas faire cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void fonction(int n) {
    int tab[n];
...
}

Essaye et tu aura une erreur a la compilation (ou un warning)
IL faut passer pas des allocations dynamiques sinon.

En revanche en C99 tu peux le faire.

Ton exemple ne montre rien du tout tu as juste une variable globale.

[_kal_]

Tu n'as pas compris ce que je demandais.

Effectivement, depuis C99, on peux faire cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void fonction(int n) {
    int tab[n];
...
}

En ravanche, il m'as dit qu'en C99; cela ne fonctionnait pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int m = 5;
void f()
{
        int t[m]; 
...
}

Info ou intox ?

[Skyounet]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int m = 5;
 
void fonction(void) {
        int tab[m];
        tab[0] = 1;
}
 
int main(void) {
        fonction();
        return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
skyrunner@seymour:~$ gcc -Wall -ansi -pedantic test.c -o test
test.c: In function `fonction':
test.c:4: attention : ISO C90 interdit le tableau « tab » de taille variable

En gros en C90 tu dois utiliser malloc ou des #define

[HanLee]

Je lui ai demandé pourquoi, mais je n'ai pas vraiment compris son explication (il est parti dans un délire avec la pile....)

C'est pas un "délire"...

[loufoque]

En gros en C90 tu dois utiliser malloc ou des #define

On parle de C99, pas de C90.
Tu es hors sujet.
Si tu veux utiliser C99 avec gcc, remplace -ansi par -std=c99.

En ravanche, il m'as dit qu'en C99; cela ne fonctionnait pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int m = 5;
void f()
{
        int t[m];
...
}

Info ou intox ?

S'il a dit ça il s'est apparemment trompé.
J'ai moi-même pu constater que les profs d'informatique dans les premières années d'université (du moins ceux que j'ai eus) font des erreurs.

[Skyounet]

En gros en C90 tu dois utiliser malloc ou des #define

On parle de C99, pas de C90.
Tu es hors sujet.
Si tu veux utiliser C99 avec gcc, remplace -ansi par -std=c99.

Qu'est ce tu baves, j'ai rien compris.

Je lui dis simplement qu'en C89 (j'ai ecris C90 il me semble que c'est la meme chose mais pas sur du tout) tu dois utiliser malloc ou des #define pour des tableau de tailles variables.

[gl]

Qu'est ce tu baves, j'ai rien compris.

Je lui dis simplement qu'en C89 (j'ai ecris C90 il me semble que c'est la meme chose mais pas sur du tout) tu dois utiliser malloc ou des #define pour des tableau de tailles variables.

Oui, mais le posteur original pose la question sur la norme C99 et non C90 (ou C89).

[gl]

Si nous avions utilisé une variable de classe statique, alors cela aurait été refusé à la compilation. Je lui ai demandé pourquoi, mais je n'ai pas vraiment compris son explication (il est parti dans un délire avec la pile....)

As-tu bien compris la restriction dont-il parlait ?
Parce que a ma connaissance, la variable contenant la taille du tableau peut etre globale ou static sans souci.

Par contre, un tableau dont la taille est une variable (VLA) ne peut pas etre static ou extern, ni membre d'une structure ou d'une union :

All declarations of variably modified (VM) types have to be at either block scope or function prototype scope. Array objects declared with the static or extern storage-class specifier cannot have a variable length array (VLA) type. However, an object declared with the static storageclass specifier can have a VM type (that is, a pointer to a VLA type). Finally, all identifiers declared with a VM type have to be ordinary identifiers and cannot, therefore, be members of structures or unions.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
extern int n;
int A[n];                                       // invalid: file scope VLA
extern int (*p2)[n];                       // invalid: file scope VM
int B[100];                                   // valid: file scope but not VM
 
void fvla(int m, int C[m][m]);        // valid: VLA with prototype scope
 
void fvla(int m, int C[m][m])         // valid: adjusted to auto pointer to VLA
{
   typedef int VLA[m][m];             // valid: block scope typedef VLA
   struct tag 
   {
      int (*y)[n];                           // invalid: y not ordinary identifier
      int z[n];                               // invalid: z not ordinary identifier
   };
   int D[m];                                // valid: auto VLA
   static int E[m];                        // invalid: static block scope VLA
   extern int F[m];                      // invalid: F has linkage and is VLA
   int (*s)[m];                            // valid: auto pointer to VLA
   extern int (*r)[m];                  // invalid: r has linkage and points to VLA
   static int (*q)[m] = &B;           // valid: q is a static block pointer to VLA
}

[Skyounet]

Qu'est ce tu baves, j'ai rien compris.

Je lui dis simplement qu'en C89 (j'ai ecris C90 il me semble que c'est la meme chose mais pas sur du tout) tu dois utiliser malloc ou des #define pour des tableau de tailles variables.

Oui, mais le posteur original pose la question sur la norme C99 et non C90 (ou C89).

Hi hi autant pour moi, désolé...

[loufoque]

[En C89/90] tu dois utiliser malloc ou des #define pour des tableau de tailles variables.

malloc travaille avec des pointeurs, pas des tableaux.
et #define n'a rien de variable.

[_kal_]

S'il a dit ça il s'est apparemment trompé.
J'ai moi-même pu constater que les profs d'informatique dans les premières années d'université (du moins ceux que j'ai eus) font des erreurs.

Yep, deuxième année d'université... Enfin bon heureusement que j'ai pris le soin de vérifier et que le forum soit là

Qu'est ce tu baves, j'ai rien compris.

Je lui dis simplement qu'en C89 (j'ai ecris C90 il me semble que c'est la meme chose mais pas sur du tout) tu dois utiliser malloc ou des #define pour des tableau de tailles variables.

Oui, mais le posteur original pose la question sur la norme C99 et non C90 (ou C89).

+1, apparemment t'as eu du mal à comprendre

As-tu bien compris la restriction dont-il parlait ?
Parce que a ma connaissance, la variable contenant la taille du tableau peut etre globale ou static sans souci.

Par contre, un tableau dont la taille est une variable (VLA) ne peut pas etre static ou extern, ni membre d'une structure ou d'une union

Oui j'ai bien compris, et donc mon prof s'était effectivement trompé dans son explication :o

Merci tout le monde